Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo._base.html"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo._base.html"] = true;

dojo.require("dojo._base.lang");

dojo.provide("dojo._base.html");

// FIXME: need to add unit tests for all the semi-public methods

try{

	document.execCommand("BackgroundImageCache", false, true);

}catch(e){

	// sane browsers don't have cache "issues"

}

// =============================

// DOM Functions

// =============================

/*=====

dojo.byId = function(id, doc){

	//	summary:

	//		similar to other library's "$" function, takes a

	//		string representing a DOM id or a DomNode

	//		and returns the corresponding DomNode. If a Node is

	//		passed, this function is a no-op. Returns a

	//		single DOM node or null, working around several

	//		browser-specific bugs to do so.

	//	id: String|DOMNode

	//	 	DOM id or DOM Node

	//	doc: DocumentElement

	//		Document to work in. Defaults to the current value of

	//		dojo.doc.  Can be used to retreive

	//		node references from other documents.

=====*/

if(dojo.isIE || dojo.isOpera){

	dojo.byId = function(id, doc){

		if(dojo.isString(id)){

			var _d = doc || dojo.doc;

			var te = _d.getElementById(id);

			// attributes.id.value is better than just id in case the

			// user has a name=id inside a form

			if(te && te.attributes.id.value == id){

				return te;

			}else{

				var eles = _d.all[id];

				if(!eles){ return; }

				if(!eles.length){ return eles; }

				// if more than 1, choose first with the correct id

				var i=0;

				while((te=eles[i++])){

					if(te.attributes.id.value == id){ return te; }

				}

			}

		}else{

			return id; // DomNode

		}

	}

}else{

	dojo.byId = function(id, doc){

		if(dojo.isString(id)){

			return (doc || dojo.doc).getElementById(id);

		}else{

			return id; // DomNode

		}

	}

}

/*=====

}

=====*/

(function(){

	/*

	dojo.createElement = function(obj, parent, position){

		// TODO: need to finish this!

	}

	*/

	var _destroyContainer = null;

	dojo._destroyElement = function(/*String||DomNode*/node){

		// summary:

		//		removes node from its parent, clobbers it and all of its

		//		children.

		//	node:

		//		the element to be destroyed, either as an ID or a reference

		node = dojo.byId(node);

		try{

			if(!_destroyContainer){

				_destroyContainer = document.createElement("div");

			}

			_destroyContainer.appendChild(node.parentNode ? node.parentNode.removeChild(node) : node);

			// NOTE: see http://trac.dojotoolkit.org/ticket/2931. This may be a bug and not a feature

			_destroyContainer.innerHTML = "";

		}catch(e){

			/* squelch */

		}

	};

	dojo.isDescendant = function(/*DomNode|String*/node, /*DomNode|String*/ancestor){

		//	summary:

		//		Returns true if node is a descendant of ancestor

		//	node: id or node reference to test

		//	ancestor: id or node reference of potential parent to test against

		try{

			node = dojo.byId(node);

			ancestor = dojo.byId(ancestor);

			while(node){

				if(node === ancestor){

					return true; // Boolean

				}

				node = node.parentNode;

			}

		}catch(e){ return -1; /* squelch */ }

		return false; // Boolean

	};

	dojo.setSelectable = function(/*DomNode|String*/node, /*Boolean*/selectable){

		//	summary: enable or disable selection on a node

		//	node:

		//		id or reference to node

		//	selectable:

		node = dojo.byId(node);

		if(dojo.isMozilla){

			node.style.MozUserSelect = selectable ? "" : "none";

		}else if(dojo.isKhtml){

			node.style.KhtmlUserSelect = selectable ? "auto" : "none";

		}else if(dojo.isIE){

			node.unselectable = selectable ? "" : "on";

			dojo.query("*", node).forEach(function(descendant){

				descendant.unselectable = selectable ? "" : "on";

			});

		}

		//FIXME: else?  Opera?

	};

	var _insertBefore = function(/*Node*/node, /*Node*/ref){

		ref.parentNode.insertBefore(node, ref);

		return true;	//	boolean

	}

	var _insertAfter = function(/*Node*/node, /*Node*/ref){

		//	summary:

		//		Try to insert node after ref

		var pn = ref.parentNode;

		if(ref == pn.lastChild){

			pn.appendChild(node);

		}else{

			return _insertBefore(node, ref.nextSibling);	//	boolean

		}

		return true;	//	boolean

	}

	dojo.place = function(/*String|DomNode*/node, /*String|DomNode*/refNode, /*String|Number*/position){

		//	summary:

		//		attempt to insert node in relation to ref based on position

		//	node:

		//		id or reference to node to place relative to refNode

		//	refNode:

		//		id or reference of node to use as basis for placement

		//	position:

		//		string noting the position of node relative to refNode or a

		//		number indicating the location in the childNodes collection of

		//		refNode. Accepted string values are:

		//			* before

		//			* after

		//			* first

		//			* last

		//		"first" and "last" indicate positions as children of refNode.

		// FIXME: need to write tests for this!!!!

		if(!node || !refNode || position === undefined){

			return false;	//	boolean

		}

		node = dojo.byId(node);

		refNode = dojo.byId(refNode);

		if(typeof position == "number"){

			var cn = refNode.childNodes;

			if((position == 0 && cn.length == 0) ||

				cn.length == position){

				refNode.appendChild(node); return true;

			}

			if(position == 0){

				return _insertBefore(node, refNode.firstChild);

			}

			return _insertAfter(node, cn[position-1]);

		}

		switch(position.toLowerCase()){

			case "before":

				return _insertBefore(node, refNode);	//	boolean

			case "after":

				return _insertAfter(node, refNode);		//	boolean

			case "first":

				if(refNode.firstChild){

					return _insertBefore(node, refNode.firstChild);	//	boolean

				}else{

					refNode.appendChild(node);

					return true;	//	boolean

				}

				break;

			default: // aka: last

				refNode.appendChild(node);

				return true;	//	boolean

		}

	}

	// Box functions will assume this model.

	// On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode.

	// Can be set to change behavior of box setters.

	// can be either:

	//	"border-box"

	//	"content-box" (default)

	dojo.boxModel = "content-box";

	// We punt per-node box mode testing completely.

	// If anybody cares, we can provide an additional (optional) unit

	// that overrides existing code to include per-node box sensitivity.

	// Opera documentation claims that Opera 9 uses border-box in BackCompat mode.

	// but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box.

	// IIRC, earlier versions of Opera did in fact use border-box.

	// Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault.

	if(dojo.isIE /*|| dojo.isOpera*/){

		var _dcm = document.compatMode;

		// client code may have to adjust if compatMode varies across iframes

		dojo.boxModel = (_dcm=="BackCompat")||(_dcm=="QuirksMode")||(dojo.isIE<6) ? "border-box" : "content-box";

	}

	// =============================

	// Style Functions

	// =============================

	// getComputedStyle drives most of the style code.

	// Wherever possible, reuse the returned object.

	//

	// API functions below that need to access computed styles accept an

	// optional computedStyle parameter.

	//

	// If this parameter is omitted, the functions will call getComputedStyle themselves.

	//

	// This way, calling code can access computedStyle once, and then pass the reference to

	// multiple API functions.

	//

	// This is a faux declaration to take pity on the doc tool

/*=====

	dojo.getComputedStyle = function(node){

		//	summary:

		//		Returns a "computed style" object.

		//	description:

		//		get "computed style" object which can be used to gather

		//		information about the current state of the rendered node.

		//

		//		Note that this may behave differently on different browsers.

		//		Values may have different formats and value encodings across

		//		browsers.

		//

		//		Use the dojo.style() method for more consistent (pixelized)

		//		return values.

		//	node: DOMNode

		//		a reference to a DOM node. Does NOT support taking an

		//		ID string for speed reasons.

		//	example:

		//	|	dojo.getComputedStyle(dojo.byId('foo')).borderWidth;

		return; // CSS2Properties

	}

=====*/

	var gcs, dv = document.defaultView;

	if(dojo.isSafari){

		gcs = function(/*DomNode*/node){

			var s = dv.getComputedStyle(node, null);

			if(!s && node.style){

				node.style.display = "";

				s = dv.getComputedStyle(node, null);

			}

			return s || {};

		};

	}else if(dojo.isIE){

		gcs = function(node){

			return node.currentStyle;

		};

	}else{

		gcs = function(node){

			return dv.getComputedStyle(node, null);

		};

	}

	dojo.getComputedStyle = gcs;

	if(!dojo.isIE){

		dojo._toPixelValue = function(element, value){

			// style values can be floats, client code may want

			// to round for integer pixels.

			return parseFloat(value) || 0;

		}

	}else{

		dojo._toPixelValue = function(element, avalue){

			if(!avalue){ return 0; }

			// on IE7, medium is usually 4 pixels

			if(avalue=="medium"){ return 4; }

			// style values can be floats, client code may

			// want to round this value for integer pixels.

			if(avalue.slice && (avalue.slice(-2)=='px')){ return parseFloat(avalue); }

			with(element){

				var sLeft = style.left;

				var rsLeft = runtimeStyle.left;

				runtimeStyle.left = currentStyle.left;

				try{

					// 'avalue' may be incompatible with style.left, which can cause IE to throw

					// this has been observed for border widths using "thin", "medium", "thick" constants

					// those particular constants could be trapped by a lookup

					// but perhaps there are more

					style.left = avalue;

					avalue = style.pixelLeft;

				}catch(e){

					avalue = 0;

				}

				style.left = sLeft;

				runtimeStyle.left = rsLeft;

			}

			return avalue;

		}

	}

	// FIXME: there opacity quirks on FF that we haven't ported over. Hrm.

	/*=====

	dojo._getOpacity = function(node){

			//	summary:

			//		Returns the current opacity of the passed node as a

			//		floating-point value between 0 and 1.

			//	node: DomNode

			//		a reference to a DOM node. Does NOT support taking an

			//		ID string for speed reasons.

			//	return: Number between 0 and 1

	}

	=====*/

	dojo._getOpacity = (dojo.isIE ? function(node){

			try{

				return (node.filters.alpha.opacity / 100); // Number

			}catch(e){

				return 1; // Number

			}

		} : function(node){

			return dojo.getComputedStyle(node).opacity;

		}

	);

	/*=====

	dojo._setOpacity = function(node, opacity){

			//	summary:

			//		set the opacity of the passed node portably. Returns the

			//		new opacity of the node.

			//	node: DOMNode

			//		a reference to a DOM node. Does NOT support taking an

			//		ID string for performance reasons.

			//	opacity: Number

			//		A Number between 0 and 1. 0 specifies transparent.

			//	return: Number between 0 and 1

	}

	=====*/

	dojo._setOpacity = (dojo.isIE ? function(/*DomNode*/node, /*Number*/opacity){

			if(opacity == 1){

				// on IE7 Alpha(Filter opacity=100) makes text look fuzzy so remove it altogether (bug #2661)

				node.style.cssText = node.style.cssText.replace(/FILTER:[^;]*;/i, "");

				if(node.nodeName.toLowerCase() == "tr"){

					dojo.query("> td", node).forEach(function(i){

						i.style.cssText = i.style.cssText.replace(/FILTER:[^;]*;/i, "");

					});

				}

			}else{

				var o = "Alpha(Opacity="+(opacity*100)+")";

				node.style.filter = o;

			}

			if(node.nodeName.toLowerCase() == "tr"){

				dojo.query("> td", node).forEach(function(i){

					i.style.filter = o;

				});

			}

			return opacity;

		} : function(node, opacity){

			return node.style.opacity = opacity;

		}

	);

	var _pixelNamesCache = {

		width: true, height: true, left: true, top: true

	};

	var _toStyleValue = function(node, type, value){

		type = type.toLowerCase();

		if(_pixelNamesCache[type] === true){

			return dojo._toPixelValue(node, value)

		}else if(_pixelNamesCache[type] === false){

			return value;

		}else{

			if(dojo.isOpera && type == "cssText"){

				// FIXME: add workaround for #2855 here

			}

			if(

				(type.indexOf("margin") >= 0) ||

				// (type.indexOf("border") >= 0) ||

				(type.indexOf("padding") >= 0) ||

				(type.indexOf("width") >= 0) ||

				(type.indexOf("height") >= 0) ||

				(type.indexOf("max") >= 0) ||

				(type.indexOf("min") >= 0) ||

				(type.indexOf("offset") >= 0)

			){

				_pixelNamesCache[type] = true;

				return dojo._toPixelValue(node, value)

			}else{

				_pixelNamesCache[type] = false;

				return value;

			}

		}

	}

	// public API

	dojo.style = function(/*DomNode|String*/ node, /*String*/style, /*String?*/value){

		//	summary:

		//		gets or sets a style property on node. If 2 arguments are

		//		passed, acts as a getter. If value is passed, acts as a setter

		//		for the property.

		//	node:

		//		id or reference to node to get/set style for

		//	style:

		//		the style property to set in DOM-accessor format

		//		("borderWidth", not "border-width").

		//	value:

		//		optional. If passed, sets value on the node for style, handling

		//		cross-browser concerns.

		var n=dojo.byId(node), args=arguments.length, op=(style=="opacity");

		if(args==3){

			return op ? dojo._setOpacity(n, value) : n.style[style] = value; /*Number*/

		}

		if(args==2 && op){

			return dojo._getOpacity(n);

		}

		var s = dojo.getComputedStyle(n);

		return (args == 1) ? s : _toStyleValue(n, style, s[style]); /* CSS2Properties||String||Number */

	}

	// =============================

	// Box Functions

	// =============================

	dojo._getPadExtents = function(/*DomNode*/n, /*Object*/computedStyle){

		//	summary:

		// 		Returns object with special values specifically useful for node

		// 		fitting.

		// 			l/t = left/top padding (respectively)

		// 			w = the total of the left and right padding

		// 			h = the total of the top and bottom padding

		//		If 'node' has position, l/t forms the origin for child nodes.

		//		The w/h are used for calculating boxes.

		//		Normally application code will not need to invoke this

		//		directly, and will use the ...box... functions instead.

		var

			s=computedStyle||gcs(n),

			px=dojo._toPixelValue,

			l=px(n, s.paddingLeft),

			t=px(n, s.paddingTop);

		return {

			l: l,

			t: t,

			w: l+px(n, s.paddingRight),

			h: t+px(n, s.paddingBottom)

		};

	}

	dojo._getBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){

		//	summary:

		//		returns an object with properties useful for noting the border

		//		dimensions.

		// 			l/t = the sum of left/top border (respectively)

		//			w = the sum of the left and right border

		//			h = the sum of the top and bottom border

		//		The w/h are used for calculating boxes.

		//		Normally application code will not need to invoke this

		//		directly, and will use the ...box... functions instead.

		var

			ne='none',

			px=dojo._toPixelValue,

			s=computedStyle||gcs(n),

			bl=(s.borderLeftStyle!=ne ? px(n, s.borderLeftWidth) : 0),

			bt=(s.borderTopStyle!=ne ? px(n, s.borderTopWidth) : 0);

		return {

			l: bl,

			t: bt,

			w: bl + (s.borderRightStyle!=ne ? px(n, s.borderRightWidth) : 0),

			h: bt + (s.borderBottomStyle!=ne ? px(n, s.borderBottomWidth) : 0)

		};

	}

	dojo._getPadBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){

		//	summary:

		//		returns object with properties useful for box fitting with

		//		regards to padding.

		//			l/t = the sum of left/top padding and left/top border (respectively)

		//			w = the sum of the left and right padding and border

		//			h = the sum of the top and bottom padding and border

		//		The w/h are used for calculating boxes.

		//		Normally application code will not need to invoke this

		//		directly, and will use the ...box... functions instead.

		var

			s=computedStyle||gcs(n),

			p=dojo._getPadExtents(n, s),

			b=dojo._getBorderExtents(n, s);

		return {

			l: p.l + b.l,

			t: p.t + b.t,

			w: p.w + b.w,

			h: p.h + b.h

		};

	}

	dojo._getMarginExtents = function(n, computedStyle){

		//	summary:

		//		returns object with properties useful for box fitting with

		//		regards to box margins (i.e., the outer-box).

		//			l/t = marginLeft, marginTop, respectively

		//			w = total width, margin inclusive

		//			h = total height, margin inclusive

		//		The w/h are used for calculating boxes.

		//		Normally application code will not need to invoke this

		//		directly, and will use the ...box... functions instead.

		var

			s=computedStyle||gcs(n),

			px=dojo._toPixelValue,

			l=px(n, s.marginLeft),

			t=px(n, s.marginTop),

			r=px(n, s.marginRight),

			b=px(n, s.marginBottom);

		if (dojo.isSafari && (s.position != "absolute")){

			// FIXME: Safari's version of the computed right margin

			// is the space between our right edge and the right edge

			// of our offsetParent.

			// What we are looking for is the actual margin value as

			// determined by CSS.

			// Hack solution is to assume left/right margins are the same.

			r = l;

		}

		return {

			l: l,

			t: t,

			w: l+r,

			h: t+b

		};

	}

	// Box getters work in any box context because offsetWidth/clientWidth

	// are invariant wrt box context

	//

	// They do *not* work for display: inline objects that have padding styles

	// because the user agent ignores padding (it's bogus styling in any case)

	//

	// Be careful with IMGs because they are inline or block depending on

	// browser and browser mode.

	// Although it would be easier to read, there are not separate versions of

	// _getMarginBox for each browser because:

	// 1. the branching is not expensive

	// 2. factoring the shared code wastes cycles (function call overhead)

	// 3. duplicating the shared code wastes bytes

	dojo._getMarginBox = function(/*DomNode*/node, /*Object*/computedStyle){

		// summary:

		//		returns an object that encodes the width, height, left and top

		//		positions of the node's margin box.

		var s = computedStyle||gcs(node), me = dojo._getMarginExtents(node, s);

		var	l = node.offsetLeft - me.l,	t = node.offsetTop - me.t;

		if(dojo.isMoz){

			// Mozilla:

			// If offsetParent has a computed overflow != visible, the offsetLeft is decreased

			// by the parent's border.

			// We don't want to compute the parent's style, so instead we examine node's

			// computed left/top which is more stable.

			var sl = parseFloat(s.left), st = parseFloat(s.top);

			if(!isNaN(sl) && !isNaN(st)){

				l = sl, t = st;

			}else{

				// If child's computed left/top are not parseable as a number (e.g. "auto"), we

				// have no choice but to examine the parent's computed style.

				var p = node.parentNode;

				if(p && p.style){

					var pcs = gcs(p);

					if(pcs.overflow != "visible"){

						var be = dojo._getBorderExtents(p, pcs);

						l += be.l, t += be.t;

					}

				}

			}

		}else if(dojo.isOpera){

			// On Opera, offsetLeft includes the parent's border

			var p = node.parentNode;

			if(p){

				var be = dojo._getBorderExtents(p);

				l -= be.l, t -= be.t;

			}

		}

		return {

			l: l,

			t: t,

			w: node.offsetWidth + me.w,

			h: node.offsetHeight + me.h

		};

	}

	dojo._getContentBox = function(node, computedStyle){

		// summary:

		//		Returns an object that encodes the width, height, left and top

		//		positions of the node's content box, irrespective of the

		//		current box model.

		// clientWidth/Height are important since the automatically account for scrollbars

		// fallback to offsetWidth/Height for special cases (see #3378)

		var s=computedStyle||gcs(node), pe=dojo._getPadExtents(node, s), be=dojo._getBorderExtents(node, s), w=node.clientWidth, h;

		if(!w){

			w=node.offsetWidth, h=node.offsetHeight;

		}else{

			h=node.clientHeight, be.w = be.h = 0;

		}

		// On Opera, offsetLeft includes the parent's border

		if(dojo.isOpera){ pe.l += be.l; pe.t += be.t; };

		return {

			l: pe.l,

			t: pe.t,

			w: w - pe.w - be.w,

			h: h - pe.h - be.h

		};

	}

	dojo._getBorderBox = function(node, computedStyle){

		var s=computedStyle||gcs(node), pe=dojo._getPadExtents(node, s), cb=dojo._getContentBox(node, s);

		return {

			l: cb.l - pe.l,

			t: cb.t - pe.t,

			w: cb.w + pe.w,

			h: cb.h + pe.h

		};

	}

	// Box setters depend on box context because interpretation of width/height styles

	// vary wrt box context.

	//

	// The value of dojo.boxModel is used to determine box context.

	// dojo.boxModel can be set directly to change behavior.

	//

	// Beware of display: inline objects that have padding styles

	// because the user agent ignores padding (it's a bogus setup anyway)

	//

	// Be careful with IMGs because they are inline or block depending on

	// browser and browser mode.

	//

	// Elements other than DIV may have special quirks, like built-in

	// margins or padding, or values not detectable via computedStyle.

	// In particular, margins on TABLE do not seems to appear

	// at all in computedStyle on Mozilla.

	dojo._setBox = function(/*DomNode*/node, /*Number?*/l, /*Number?*/t, /*Number?*/w, /*Number?*/h, /*String?*/u){

		//	summary:

		//		sets width/height/left/top in the current (native) box-model

		//		dimentions. Uses the unit passed in u.

		//	node: DOM Node reference. Id string not supported for performance reasons.

		//	l: optional. left offset from parent.

		//	t: optional. top offset from parent.

		//	w: optional. width in current box model.

		//	h: optional. width in current box model.

		//	u: optional. unit measure to use for other measures. Defaults to "px".

		u = u || "px";

		with(node.style){

			if(!isNaN(l)){ left = l+u; }

			if(!isNaN(t)){ top = t+u; }

			if(w>=0){ width = w+u; }

			if(h>=0){ height = h+u; }

		}

	}

	dojo._usesBorderBox = function(/*DomNode*/node){

		//	summary:

		//		True if the node uses border-box layout.

		// We could test the computed style of node to see if a particular box

		// has been specified, but there are details and we choose not to bother.

		var n = node.tagName;

		// For whatever reason, TABLE and BUTTON are always border-box by default.

		// If you have assigned a different box to either one via CSS then

		// box functions will break.

		return dojo.boxModel=="border-box" || n=="TABLE" || n=="BUTTON"; // boolean

	}

	dojo._setContentSize = function(/*DomNode*/node, /*Number*/widthPx, /*Number*/heightPx, /*Object*/computedStyle){

		//	summary:

		//		Sets the size of the node's contents, irrespective of margins,

		//		padding, or borders.

		var bb = dojo._usesBorderBox(node);

		if(bb){

			var pb = dojo._getPadBorderExtents(node, computedStyle);

			if(widthPx>=0){ widthPx += pb.w; }

			if(heightPx>=0){ heightPx += pb.h; }

		}

		dojo._setBox(node, NaN, NaN, widthPx, heightPx);

	}

	dojo._setMarginBox = function(/*DomNode*/node, 	/*Number?*/leftPx, /*Number?*/topPx,

													/*Number?*/widthPx, /*Number?*/heightPx,

													/*Object*/computedStyle){

		//	summary:

		//		sets the size of the node's margin box and palcement

		//		(left/top), irrespective of box model. Think of it as a

		//		passthrough to dojo._setBox that handles box-model vagaries for

		//		you.

		var s = computedStyle || dojo.getComputedStyle(node);

		// Some elements have special padding, margin, and box-model settings.

		// To use box functions you may need to set padding, margin explicitly.

		// Controlling box-model is harder, in a pinch you might set dojo.boxModel.

		var bb=dojo._usesBorderBox(node),

				pb=bb ? _nilExtents : dojo._getPadBorderExtents(node, s),

				mb=dojo._getMarginExtents(node, s);

		if(widthPx>=0){	widthPx = Math.max(widthPx - pb.w - mb.w, 0); }

		if(heightPx>=0){ heightPx = Math.max(heightPx - pb.h - mb.h, 0); }

		dojo._setBox(node, leftPx, topPx, widthPx, heightPx);

	}

	var _nilExtents = { l:0, t:0, w:0, h:0 };

	// public API

	dojo.marginBox = function(/*DomNode|String*/node, /*Object?*/box){

		//	summary:

		//		getter/setter for the margin-box of node.

		//	description:

		//		Returns an object in the expected format of box (regardless

		//		if box is passed). The object might look like:

		//			{ l: 50, t: 200, w: 300: h: 150 }

		//		for a node offset from its parent 50px to the left, 200px from

		//		the top with a margin width of 300px and a margin-height of

		//		150px.

		//	node:

		//		id or reference to DOM Node to get/set box for

		//	box:

		//		optional. If passed, denotes that dojo.marginBox() should

		//		update/set the margin box for node. Box is an object in the

		//		above format. All properties are optional if passed.

		var n=dojo.byId(node), s=gcs(n), b=box;

		return !b ? dojo._getMarginBox(n, s) : dojo._setMarginBox(n, b.l, b.t, b.w, b.h, s); // Object

	}

	dojo.contentBox = function(/*DomNode|String*/node, /*Object?*/box){

		//	summary:

		//		getter/setter for the content-box of node.

		//	description:

		//		Returns an object in the expected format of box (regardless if box is passed).

		//		The object might look like:

		//			{ l: 50, t: 200, w: 300: h: 150 }

		//		for a node offset from its parent 50px to the left, 200px from

		//		the top with a content width of 300px and a content-height of

		//		150px. Note that the content box may have a much larger border

		//		or margin box, depending on the box model currently in use and

		//		CSS values set/inherited for node.

		//	node:

		//		id or reference to DOM Node to get/set box for

		//	box:

		//		optional. If passed, denotes that dojo.contentBox() should

		//		update/set the content box for node. Box is an object in the

		//		above format. All properties are optional if passed.

		var n=dojo.byId(node), s=gcs(n), b=box;

		return !b ? dojo._getContentBox(n, s) : dojo._setContentSize(n, b.w, b.h, s); // Object

	}

	// =============================

	// Positioning

	// =============================

	var _sumAncestorProperties = function(node, prop){

		if(!(node = (node||0).parentNode)){return 0};

		var val, retVal = 0, _b = dojo.body();

		while(node && node.style){

			if(gcs(node).position == "fixed"){

				return 0;

			}

			val = node[prop];

			if(val){

				retVal += val - 0;

				// opera and khtml #body & #html has the same values, we only

				// need one value

				if(node == _b){ break; }

			}

			node = node.parentNode;

		}

		return retVal;	//	integer

	}

	dojo._docScroll = function(){

		var _b = dojo.body();

		var _w = dojo.global;

		var de = dojo.doc.documentElement;

		return {

			y: (_w.pageYOffset || de.scrollTop || _b.scrollTop || 0),

			x: (_w.pageXOffset || dojo._fixIeBiDiScrollLeft(de.scrollLeft) || _b.scrollLeft || 0)

		};

	};

	dojo._isBodyLtr = function(){

		//FIXME: could check html and body tags directly instead of computed style?  need to ignore case, accept empty values

		return !("_bodyLtr" in dojo) ?

			dojo._bodyLtr = dojo.getComputedStyle(dojo.body()).direction == "ltr" :

			dojo._bodyLtr; // Boolean

	}

	dojo._getIeDocumentElementOffset = function(){

		// summary

		// The following values in IE contain an offset:

		//     event.clientX

		//     event.clientY

		//     node.getBoundingClientRect().left

		//     node.getBoundingClientRect().top

		// But other position related values do not contain this offset, such as

		// node.offsetLeft, node.offsetTop, node.style.left and node.style.top.

		// The offset is always (2, 2) in LTR direction. When the body is in RTL

		// direction, the offset counts the width of left scroll bar's width.

		// This function computes the actual offset.

		//NOTE: assumes we're being called in an IE browser

		var de = dojo.doc.documentElement;

		if(dojo.isIE >= 7){

			return {x: de.getBoundingClientRect().left, y: de.getBoundingClientRect().top}; // Object

		}else{

			// IE 6.0

			return {x: dojo._isBodyLtr() || window.parent == window ?

				de.clientLeft : de.offsetWidth - de.clientWidth - de.clientLeft,

				y: de.clientTop}; // Object

		}

	};

	dojo._fixIeBiDiScrollLeft = function(/*Integer*/ scrollLeft){

		// In RTL direction, scrollLeft should be a negative value, but IE

		// returns a positive one. All codes using documentElement.scrollLeft

		// must call this function to fix this error, otherwise the position

		// will offset to right when there is a horizonal scrollbar.

		if(dojo.isIE && !dojo._isBodyLtr()){

			var de = dojo.doc.documentElement;

			return scrollLeft + de.clientWidth - de.scrollWidth; // Integer

		}

		return scrollLeft; // Integer

	}

	dojo._abs = function(/*DomNode*/node, /*Boolean?*/includeScroll){

		//	summary:

		//		Gets the absolute position of the passed element based on the

		//		document itself. Returns an object of the form:

		//			{ x: 100, y: 300 }

		//		if includeScroll is passed, the x and y values will include any

		//		document offsets that may affect the position relative to the

		//		viewport.

		// FIXME: need to decide in the brave-new-world if we're going to be

		// margin-box or border-box.

		var ownerDocument = node.ownerDocument;

		var ret = {

			x: 0,

			y: 0

		};

		var hasScroll = false;

		// targetBoxType == "border-box"

		var db = dojo.body();

		if(dojo.isIE){

			var client = node.getBoundingClientRect();

			var offset = dojo._getIeDocumentElementOffset();

			ret.x = client.left - offset.x;

			ret.y = client.top - offset.y;

		}else if(ownerDocument["getBoxObjectFor"]){

			// mozilla

			var bo = ownerDocument.getBoxObjectFor(node);

			ret.x = bo.x - _sumAncestorProperties(node, "scrollLeft");

			ret.y = bo.y - _sumAncestorProperties(node, "scrollTop");

		}else{

			if(node["offsetParent"]){

				hasScroll = true;

				var endNode;

				// in Safari, if the node is an absolutely positioned child of

				// the body and the body has a margin the offset of the child

				// and the body contain the body's margins, so we need to end

				// at the body

				// FIXME: getting contrary results to the above in latest WebKit.

				if(dojo.isSafari &&

					//(node.style.getPropertyValue("position") == "absolute") &&

					(gcs(node).position == "absolute") &&

					(node.parentNode == db)){

					endNode = db;

				}else{

					endNode = db.parentNode;

				}

				if(node.parentNode != db){

					var nd = node;

					if(dojo.isOpera || (dojo.isSafari >= 3)){ nd = db; }

					ret.x -= _sumAncestorProperties(nd, "scrollLeft");

					ret.y -= _sumAncestorProperties(nd, "scrollTop");

				}

				var curnode = node;

				do{

					var n = curnode["offsetLeft"];

					//FIXME: ugly hack to workaround the submenu in

					//popupmenu2 does not shown up correctly in opera.

					//Someone have a better workaround?

					if(!dojo.isOpera || n>0){

						ret.x += isNaN(n) ? 0 : n;

					}

					var m = curnode["offsetTop"];

					ret.y += isNaN(m) ? 0 : m;

					curnode = curnode.offsetParent;

				}while((curnode != endNode)&&curnode);

			}else if(node["x"]&&node["y"]){

				ret.x += isNaN(node.x) ? 0 : node.x;

				ret.y += isNaN(node.y) ? 0 : node.y;

			}

		}

		// account for document scrolling

		// if offsetParent is used, ret value already includes scroll position

		// so we may have to actually remove that value if !includeScroll

		if(hasScroll || includeScroll){

			var scroll = dojo._docScroll();

			var m = hasScroll ? (!includeScroll ? -1 : 0) : 1;

			ret.y += m*scroll.y;

			ret.x += m*scroll.x;

		}

		return ret; // object

	}

	// FIXME: need a setter for coords or a moveTo!!

	dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){

		//	summary:

		//		Returns an object that measures margin box width/height and

		//		absolute positioning data from dojo._abs(). Return value will

		//		be in the form:

		//			{ l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }

		//		does not act as a setter. If includeScroll is passed, the x and

		//		y params are affected as one would expect in dojo._abs().

		var n=dojo.byId(node), s=gcs(n), mb=dojo._getMarginBox(n, s);

		var abs = dojo._abs(n, includeScroll);

		mb.x = abs.x;

		mb.y = abs.y;

		return mb;

	}

})();

// =============================

// (CSS) Class Functions

// =============================

dojo.hasClass = function(/*DomNode|String*/node, /*String*/classStr){

	//	summary:

	//		Returns whether or not the specified classes are a portion of the

	//		class list currently applied to the node.

	return ((" "+dojo.byId(node).className+" ").indexOf(" "+classStr+" ") >= 0);  // Boolean

};

dojo.addClass = function(/*DomNode|String*/node, /*String*/classStr){

	//	summary:

	//		Adds the specified classes to the end of the class list on the

	//		passed node.

	node = dojo.byId(node);

	var cls = node.className;

	if((" "+cls+" ").indexOf(" "+classStr+" ") < 0){

		node.className = cls + (cls ? ' ' : '') + classStr;

	}

};

dojo.removeClass = function(/*DomNode|String*/node, /*String*/classStr){

	// summary: Removes the specified classes from node.

	node = dojo.byId(node);

	var t = dojo.trim((" " + node.className + " ").replace(" " + classStr + " ", " "));

	if(node.className != t){ node.className = t; }

};

dojo.toggleClass = function(/*DomNode|String*/node, /*String*/classStr, /*Boolean?*/condition){

	//	summary:

	//		Adds a class to node if not present, or removes if present.

	//		Pass a boolean condition if you want to explicitly add or remove.

	//	condition:

	//		If passed, true means to add the class, false means to remove.

	if(condition === undefined){

		condition = !dojo.hasClass(node, classStr);

	}

	dojo[condition ? "addClass" : "removeClass"](node, classStr);

};