1 files changed, 320 insertions, 0 deletions
diff --git a/js/dojo/dojox/fx/_base.js b/js/dojo/dojox/fx/_base.js
new file mode 100644
index 0000000..335b649
--- /dev/null
+++ b/js/dojo/dojox/fx/_base.js
@@ -0,0 +1,320 @@
+//>>built
+define("dojox/fx/_base", ["dojo/_base/array","dojo/_base/lang", "dojo/_base/fx", "dojo/fx", "dojo/dom", "dojo/dom-style",
+	    "dojo/dom-geometry", "dojo/_base/connect", "dojo/_base/html"],
+	function(arrayUtil, lang, baseFx, coreFx, dom, domStyle, domGeom, connectUtil, htmlUtil){
+// summary: Experimental and extended Animations beyond Dojo Core / Base functionality.
+//	Provides advanced Lines, Animations, and convenience aliases.
+var dojoxFx = lang.getObject("dojox.fx", true);
+/*
+lang.mixin(dojox.fx, {
+
+	// anim: Function
+	//	Alias of `dojo.anim` - the shorthand `dojo.animateProperty` with auto-play
+	anim: dojo.fx.anim,
+
+	// animateProperty: Function
+	//	Alias of `dojo.animateProperty` - animate any CSS property
+	animateProperty: dojox.fx.animateProperty,
+
+	// fadeTo: Function
+	//		Fade an element from an opacity to an opacity.
+	//		Omit `start:` property to detect. `end:` property is required.
+	//		Ultimately an alias to `dojo._fade`
+	fadeTo: dojo._fade,
+
+	// fadeIn: Function
+	//	Alias of `dojo.fadeIn` - Fade a node in.
+	fadeIn: dojo.fadeIn,
+	
+	// fadeOut: Function
+	//	Alias of `dojo.fadeOut` - Fades a node out.
+	fadeOut: dojo.fadeOut,
+
+	// combine: Function
+	//	Alias of `dojo.fx.combine` - Run an array of animations in parallel
+	combine: dojo.fx.combine,
+
+	// chain: Function
+	//	Alias of `dojo.fx.chain` - Run an array of animations in sequence
+	chain: dojo.fx.chain,
+
+	// slideTo: Function
+	//	Alias of `dojo.fx.slideTo` - Slide a node to a defined top/left coordinate
+	slideTo: dojo.fx.slideTo,
+
+	// wipeIn: Function
+	//	Alias of `dojo.fx.wipeIn` - Wipe a node to visible
+	wipeIn: dojo.fx.wipeIn,
+
+	// wipeOut: Function
+	//	Alias of `dojo.fx.wipeOut` - Wipe a node to non-visible
+	wipeOut: dojo.fx.wipeOut
+
+});
+*/
+
+dojoxFx.sizeTo = function(/* Object */args){
+	// summary:
+	//		Creates an animation that will size a node
+	//
+	// description:
+	//		Returns an animation that will size the target node
+	//		defined in args Object about it's center to
+	//		a width and height defined by (args.width, args.height),
+	//		supporting an optional method: chain||combine mixin
+	//		(defaults to chain).
+	//
+	//	- works best on absolutely or relatively positioned elements
+	//
+	// example:
+	//	|	// size #myNode to 400px x 200px over 1 second
+	//	|	dojo.fx.sizeTo({
+	//	|		node:'myNode',
+	//	|		duration: 1000,
+	//	|		width: 400,
+	//	|		height: 200,
+	//	|		method: "combine"
+	//	|	}).play();
+	//
+
+	var node = args.node = dom.byId(args.node),
+		abs = "absolute";
+
+	var method = args.method || "chain";
+	if(!args.duration){ args.duration = 500; } // default duration needed
+	if(method == "chain"){ args.duration = Math.floor(args.duration / 2); }
+	
+	var top, newTop, left, newLeft, width, height = null;
+
+	var init = (function(n){
+		return function(){
+			var cs = domStyle.getComputedStyle(n),
+				pos = cs.position,
+				w = cs.width,
+				h = cs.height
+			;
+			
+			top = (pos == abs ? n.offsetTop : parseInt(cs.top) || 0);
+			left = (pos == abs ? n.offsetLeft : parseInt(cs.left) || 0);
+			width = (w == "auto" ? 0 : parseInt(w));
+			height = (h == "auto" ? 0 : parseInt(h));
+			
+			newLeft = left - Math.floor((args.width - width) / 2);
+			newTop = top - Math.floor((args.height - height) / 2);
+
+			if(pos != abs && pos != 'relative'){
+				var ret = domStyle.coords(n, true);
+				top = ret.y;
+				left = ret.x;
+				n.style.position = abs;
+				n.style.top = top + "px";
+				n.style.left = left + "px";
+			}
+		}
+	})(node);
+
+	var anim1 = baseFx.animateProperty(lang.mixin({
+		properties: {
+			height: function(){
+				init();
+				return { end: args.height || 0, start: height };
+			},
+			top: function(){
+				return { start: top, end: newTop };
+			}
+		}
+	}, args));
+	var anim2 = baseFx.animateProperty(lang.mixin({
+		properties: {
+			width: function(){
+				return { start: width, end: args.width || 0 }
+			},
+			left: function(){
+				return { start: left, end: newLeft }
+			}
+		}
+	}, args));
+
+	var anim = coreFx[(args.method == "combine" ? "combine" : "chain")]([anim1, anim2]);
+	return anim; // dojo.Animation
+
+};
+
+dojoxFx.slideBy = function(/* Object */args){
+	// summary:
+	//		Returns an animation to slide a node by a defined offset.
+	//
+	// description:
+	//		Returns an animation that will slide a node (args.node) from it's
+	//		current position to it's current posision plus the numbers defined
+	//		in args.top and args.left. standard dojo.fx mixin's apply.
+	//
+	// example:
+	//	|	// slide domNode 50px down, and 22px left
+	//	|	dojox.fx.slideBy({
+	//	|		node: domNode, duration:400,
+	//	|		top: 50, left: -22
+	//	|	}).play();
+
+	var node = args.node = dom.byId(args.node),
+		top, left;
+
+	var init = (function(n){
+		return function(){
+			var cs = domStyle.getComputedStyle(n);
+			var pos = cs.position;
+			top = (pos == 'absolute' ? n.offsetTop : parseInt(cs.top) || 0);
+			left = (pos == 'absolute' ? n.offsetLeft : parseInt(cs.left) || 0);
+			if(pos != 'absolute' && pos != 'relative'){
+				var ret = domGeom.coords(n, true);
+				top = ret.y;
+				left = ret.x;
+				n.style.position = "absolute";
+				n.style.top = top + "px";
+				n.style.left = left + "px";
+			}
+		}
+	})(node);
+	init();
+	
+	var _anim = baseFx.animateProperty(lang.mixin({
+		properties: {
+			// FIXME: is there a way to update the _Line after creation?
+			// null start values allow chaining to work, animateProperty will
+			// determine them for us (except in ie6? -- ugh)
+			top: top + (args.top || 0),
+			left: left + (args.left || 0)
+		}
+	}, args));
+	connectUtil.connect(_anim, "beforeBegin", _anim, init);
+	return _anim; // dojo.Animation
+};
+
+dojoxFx.crossFade = function(/* Object */args){
+	// summary:
+	//		Returns an animation cross fading two element simultaneously
+	//
+	// args:
+	//	args.nodes: Array - two element array of domNodes, or id's
+	//
+	//	all other standard animation args mixins apply. args.node ignored.
+	//
+
+	// simple check for which node is visible, maybe too simple?
+	var node1 = args.nodes[0] = dom.byId(args.nodes[0]),
+		op1 = htmlUtil.style(node1,"opacity"),
+		node2 = args.nodes[1] = dom.byId(args.nodes[1]),
+		op2 = htmlUtil.style(node2, "opacity")
+	;
+	
+	var _anim = coreFx.combine([
+		baseFx[(op1 == 0 ? "fadeIn" : "fadeOut")](lang.mixin({
+			node: node1
+		},args)),
+		baseFx[(op1 == 0 ? "fadeOut" : "fadeIn")](lang.mixin({
+			node: node2
+		},args))
+	]);
+	return _anim; // dojo.Animation
+};
+
+dojoxFx.highlight = function(/*Object*/ args){
+	// summary:
+	//		Highlight a node
+	//
+	// description:
+	//		Returns an animation that sets the node background to args.color
+	//		then gradually fades back the original node background color
+	//
+	// example:
+	//	|	dojox.fx.highlight({ node:"foo" }).play();
+
+	var node = args.node = dom.byId(args.node);
+
+	args.duration = args.duration || 400;
+	
+	// Assign default color light yellow
+	var startColor = args.color || '#ffff99',
+		endColor = htmlUtil.style(node, "backgroundColor")
+	;
+
+	// safari "fix"
+	// safari reports rgba(0, 0, 0, 0) (black) as transparent color, while
+	// other browsers return "transparent", rendered as white by default by
+	// dojo.Color; now dojo.Color maps "transparent" to
+	// djConfig.transparentColor ([r, g, b]), if present; so we can use
+	// the color behind the effect node
+	if(endColor == "rgba(0, 0, 0, 0)"){
+		endColor = "transparent";
+	}
+
+	var anim = baseFx.animateProperty(lang.mixin({
+		properties: {
+			backgroundColor: { start: startColor, end: endColor }
+		}
+	}, args));
+
+	if(endColor == "transparent"){
+		connectUtil.connect(anim, "onEnd", anim, function(){
+			node.style.backgroundColor = endColor;
+		});
+	}
+
+	return anim; // dojo.Animation
+};
+
+ 
+dojoxFx.wipeTo = function(/*Object*/ args){
+	// summary:
+	//		Animate a node wiping to a specific width or height
+	//
+	// description:
+	//		Returns an animation that will expand the
+	//		node defined in 'args' object from it's current to
+	//		the height or width value given by the args object.
+	//
+	//		default to height:, so leave height null and specify width:
+	//		to wipeTo a width. note: this may be deprecated by a
+	//
+	//		Note that the final value should not include
+	//		units and should be an integer.  Thus a valid args object
+	//		would look something like this:
+	//
+	//		|	dojox.fx.wipeTo({ node: "nodeId", height: 200 }).play();
+	//
+	//		Node must have no margin/border/padding, so put another
+	//		node inside your target node for additional styling.
+
+	args.node = dom.byId(args.node);
+	var node = args.node, s = node.style;
+
+	var dir = (args.width ? "width" : "height"),
+		endVal = args[dir],
+		props = {}
+	;
+
+	props[dir] = {
+		// wrapped in functions so we wait till the last second to query (in case value has changed)
+		start: function(){
+			// start at current [computed] height, but use 1px rather than 0
+			// because 0 causes IE to display the whole panel
+			s.overflow = "hidden";
+			if(s.visibility == "hidden" || s.display == "none"){
+				s[dir] = "1px";
+				s.display = "";
+				s.visibility = "";
+				return 1;
+			}else{
+				var now = htmlUtil.style(node,dir);
+				return Math.max(now, 1);
+			}
+		},
+		end: endVal
+	};
+
+	var anim = baseFx.animateProperty(lang.mixin({ properties: props }, args));
+	return anim; // dojo.Animation
+};
+
+return dojoxFx;
+});