GZ/nwyj/WebContent/admin/scripts/dojo/dijit/dijit.js.uncompressed.js

/*
 * Copyright (c) 2004-2007, The Dojo Foundation All Rights Reserved.
 * 
 * Licensed under the Academic Free License version 2.1 or above OR the modified
 * BSD license. For more information on Dojo licensing, see:
 * 
 * http://dojotoolkit.org/book/dojo-book-0-9/introduction/licensing
 */

/*
 * This is a compiled version of Dojo, built for deployment and not for
 * development. To get an editable version, please visit:
 * 
 * http://dojotoolkit.org
 * 
 * for documentation and information on getting the source.
 */

if (!dojo._hasResource["dijit._base.focus"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._base.focus"] = true;
	dojo.provide("dijit._base.focus");

	// summary:
	// These functions are used to query or set the focus and selection.
	//
	// Also, they trace when widgets become actived/deactivated,
	// so that the widget can fire _onFocus/_onBlur events.
	// "Active" here means something similar to "focused", but
	// "focus" isn't quite the right word because we keep track of
	// a whole stack of "active" widgets. Example: Combobutton --> Menu -->
	// MenuItem. The onBlur event for Combobutton doesn't fire due to focusing
	// on the Menu or a MenuItem, since they are considered part of the
	// Combobutton widget. It only happens when focus is shifted
	// somewhere completely different.

	dojo.mixin(dijit, {
		// _curFocus: DomNode
		// Currently focused item on screen
		_curFocus : null,

		// _prevFocus: DomNode
		// Previously focused item on screen
		_prevFocus : null,

		isCollapsed : function() {
			// summary: tests whether the current selection is empty
			var _window = dojo.global;
			var _document = dojo.doc;
			if (_document.selection) { // IE
				return !_document.selection.createRange().text; // Boolean
			} else if (_window.getSelection) {
				var selection = _window.getSelection();
				if (dojo.isString(selection)) { // Safari
					return !selection; // Boolean
				} else { // Mozilla/W3
					return selection.isCollapsed || !selection.toString(); // Boolean
				}
			}
		},

		getBookmark : function() {
			// summary: Retrieves a bookmark that can be used with
			// moveToBookmark to return to the same range
			var bookmark, selection = dojo.doc.selection;
			if (selection) { // IE
				var range = selection.createRange();
				if (selection.type.toUpperCase() == 'CONTROL') {
					bookmark = range.length ? dojo._toArray(range) : null;
				} else {
					bookmark = range.getBookmark();
				}
			} else {
				if (dojo.global.getSelection) {
					selection = dojo.global.getSelection();
					if (selection) {
						var range = selection.getRangeAt(0);
						bookmark = range.cloneRange();
					}
				} else {
					console
							.debug("No idea how to store the current selection for this browser!");
				}
			}
			return bookmark; // Array
		},

		moveToBookmark : function(/* Object */bookmark) {
			// summary: Moves current selection to a bookmark
			// bookmark: this should be a returned object from
			// dojo.html.selection.getBookmark()
			var _document = dojo.doc;
			if (_document.selection) { // IE
				var range;
				if (dojo.isArray(bookmark)) {
					range = _document.body.createControlRange();
					dojo.forEach(bookmark, range.addElement);
				} else {
					range = _document.selection.createRange();
					range.moveToBookmark(bookmark);
				}
				range.select();
			} else { // Moz/W3C
				var selection = dojo.global.getSelection
						&& dojo.global.getSelection();
				if (selection && selection.removeAllRanges) {
					selection.removeAllRanges();
					selection.addRange(bookmark);
				} else {
					console
							.debug("No idea how to restore selection for this browser!");
				}
			}
		},

		getFocus : function(/* Widget */menu, /* Window */openedForWindow) {
			// summary:
			// Returns the current focus and selection.
			// Called when a popup appears (either a top level menu or a
			// dialog),
			// or when a toolbar/menubar receives focus
			//
			// menu:
			// the menu that's being opened
			//
			// openedForWindow:
			// iframe in which menu was opened
			//
			// returns:
			// a handle to restore focus/selection

			return {
				// Node to return focus to
				node : menu && dojo.isDescendant(dijit._curFocus, menu.domNode)
						? dijit._prevFocus
						: dijit._curFocus,

				// Previously selected text
				bookmark : !dojo.withGlobal(openedForWindow || dojo.global,
						dijit.isCollapsed) ? dojo.withGlobal(openedForWindow
								|| dojo.global, dijit.getBookmark) : null,

				openedForWindow : openedForWindow
			}; // Object
		},

		focus : function(/* Object || DomNode */handle) {
			// summary:
			// Sets the focused node and the selection according to argument.
			// To set focus to an iframe's content, pass in the iframe itself.
			// handle:
			// object returned by get(), or a DomNode

			if (!handle) {
				return;
			}

			var node = "node" in handle ? handle.node : handle, // because
																// handle is
																// either
																// DomNode or a
																// composite
																// object
			bookmark = handle.bookmark, openedForWindow = handle.openedForWindow;

			// Set the focus
			// Note that for iframe's we need to use the <iframe> to follow the
			// parentNode chain,
			// but we need to set focus to iframe.contentWindow
			if (node) {
				var focusNode = (node.tagName.toLowerCase() == "iframe")
						? node.contentWindow
						: node;
				if (focusNode && focusNode.focus) {
					try {
						// Gecko throws sometimes if setting focus is
						// impossible,
						// node not displayed or something like that
						focusNode.focus();
					} catch (e) {/* quiet */
					}
				}
				dijit._onFocusNode(node);
			}

			// set the selection
			// do not need to restore if current selection is not empty
			// (use keyboard to select a menu item)
			if (bookmark
					&& dojo.withGlobal(openedForWindow || dojo.global,
							dijit.isCollapsed)) {
				if (openedForWindow) {
					openedForWindow.focus();
				}
				try {
					dojo.withGlobal(openedForWindow || dojo.global,
							moveToBookmark, null, [bookmark]);
				} catch (e) {
					/*
					 * squelch IE internal error, see
					 * http://trac.dojotoolkit.org/ticket/1984
					 */
				}
			}
		},

		// List of currently active widgets (focused widget and it's ancestors)
		_activeStack : [],

		registerWin : function(/* Window? */targetWindow) {
			// summary:
			// Registers listeners on the specified window (either the main
			// window or an iframe) to detect when the user has clicked
			// somewhere.
			// Anyone that creates an iframe should call this function.

			if (!targetWindow) {
				targetWindow = window;
			}

			dojo.connect(targetWindow.document, "onmousedown", null, function(
							evt) {
						dijit._justMouseDowned = true;
						setTimeout(function() {
									dijit._justMouseDowned = false;
								}, 0);
						dijit._onTouchNode(evt.target || evt.srcElement);
					});
			// dojo.connect(targetWindow, "onscroll", ???);

			// Listen for blur and focus events on targetWindow's body
			var body = targetWindow.document.body
					|| targetWindow.document.getElementsByTagName("body")[0];
			if (body) {
				if (dojo.isIE) {
					body.attachEvent('onactivate', function(evt) {
								if (evt.srcElement.tagName.toLowerCase() != "body") {
									dijit._onFocusNode(evt.srcElement);
								}
							});
					body.attachEvent('ondeactivate', function(evt) {
								dijit._onBlurNode(evt.srcElement);
							});
				} else {
					body.addEventListener('focus', function(evt) {
								dijit._onFocusNode(evt.target);
							}, true);
					body.addEventListener('blur', function(evt) {
								dijit._onBlurNode(evt.target);
							}, true);
				}
			}
			body = null; // prevent memory leak (apparent circular reference
							// via closure)
		},

		_onBlurNode : function(/* DomNode */node) {
			// summary:
			// Called when focus leaves a node.
			// Usually ignored, _unless_ it *isn't* follwed by touching another
			// node,
			// which indicates that we tabbed off the last field on the page,
			// in which case every widget is marked inactive
			dijit._prevFocus = dijit._curFocus;
			dijit._curFocus = null;

			var w = dijit.getEnclosingWidget(node);
			if (w && w._setStateClass) {
				w._focused = false;
				w._setStateClass();
			}
			if (dijit._justMouseDowned) {
				// the mouse down caused a new widget to be marked as active;
				// this blur event
				// is coming late, so ignore it.
				return;
			}

			// if the blur event isn't followed by a focus event then mark all
			// widgets as inactive.
			if (dijit._clearActiveWidgetsTimer) {
				clearTimeout(dijit._clearActiveWidgetsTimer);
			}
			dijit._clearActiveWidgetsTimer = setTimeout(function() {
						delete dijit._clearActiveWidgetsTimer;
						dijit._setStack([]);
					}, 100);
		},

		_onTouchNode : function(/* DomNode */node) {
			// summary
			// Callback when node is focused or mouse-downed

			// ignore the recent blurNode event
			if (dijit._clearActiveWidgetsTimer) {
				clearTimeout(dijit._clearActiveWidgetsTimer);
				delete dijit._clearActiveWidgetsTimer;
			}

			// compute stack of active widgets (ex: ComboButton --> Menu -->
			// MenuItem)
			var newStack = [];
			try {
				while (node) {
					if (node.dijitPopupParent) {
						node = dijit.byId(node.dijitPopupParent).domNode;
					} else if (node.tagName
							&& node.tagName.toLowerCase() == "body") {
						// is this the root of the document or just the root of
						// an iframe?
						if (node === dojo.body()) {
							// node is the root of the main document
							break;
						}
						// otherwise, find the iframe this node refers to (can't
						// access it via parentNode,
						// need to do this trick instead) and continue tracing
						// up the document
						node = dojo.query("iframe").filter(function(iframe) {
									return iframe.contentDocument.body === node;
								})[0];
					} else {
						var id = node.getAttribute
								&& node.getAttribute("widgetId");
						if (id) {
							newStack.unshift(id);
						}
						node = node.parentNode;
					}
				}
			} catch (e) { /* squelch */
			}

			dijit._setStack(newStack);
		},

		_onFocusNode : function(/* DomNode */node) {
			// summary
			// Callback when node is focused
			if (node && node.tagName && node.tagName.toLowerCase() == "body") {
				return;
			}
			dijit._onTouchNode(node);
			if (node == dijit._curFocus) {
				return;
			}
			dijit._prevFocus = dijit._curFocus;
			dijit._curFocus = node;
			dojo.publish("focusNode", [node]);

			// handle focus/blur styling
			var w = dijit.getEnclosingWidget(node);
			if (w && w._setStateClass) {
				w._focused = true;
				w._setStateClass();
			}
		},

		_setStack : function(newStack) {
			// summary
			// The stack of active widgets has changed. Send out appropriate
			// events and record new stack

			var oldStack = dijit._activeStack;
			dijit._activeStack = newStack;

			// compare old stack to new stack to see how many elements they have
			// in common
			for (var nCommon = 0; nCommon < Math.min(oldStack.length,
					newStack.length); nCommon++) {
				if (oldStack[nCommon] != newStack[nCommon]) {
					break;
				}
			}

			// for all elements that have gone out of focus, send blur event
			for (var i = oldStack.length - 1; i >= nCommon; i--) {
				var widget = dijit.byId(oldStack[i]);
				if (widget) {
					dojo.publish("widgetBlur", [widget]);
					if (widget._onBlur) {
						widget._onBlur();
					}
				}
			}

			// for all element that have come into focus, send focus event
			for (var i = nCommon; i < newStack.length; i++) {
				var widget = dijit.byId(newStack[i]);
				if (widget) {
					dojo.publish("widgetFocus", [widget]);
					if (widget._onFocus) {
						widget._onFocus();
					}
				}
			}
		}
	});

	// register top window and all the iframes it contains
	dojo.addOnLoad(dijit.registerWin);

}

if (!dojo._hasResource["dijit._base.manager"]) { // _hasResource checks added
													// by build. Do not use
													// _hasResource directly in
													// your code.
	dojo._hasResource["dijit._base.manager"] = true;
	dojo.provide("dijit._base.manager");

	dojo.declare("dijit.WidgetSet", null, {
				constructor : function() {
					// summary:
					// A set of widgets indexed by id
					this._hash = {};
				},

				add : function(/* Widget */widget) {
					if (this._hash[widget.id]) {
						throw new Error("Tried to register widget with id=="
								+ widget.id
								+ " but that id is already registered");
					}
					this._hash[widget.id] = widget;
				},

				remove : function(/* String */id) {
					delete this._hash[id];
				},

				forEach : function(/* Function */func) {
					for (var id in this._hash) {
						func(this._hash[id]);
					}
				},

				filter : function(/* Function */filter) {
					var res = new dijit.WidgetSet();
					this.forEach(function(widget) {
								if (filter(widget)) {
									res.add(widget);
								}
							});
					return res; // dijit.WidgetSet
				},

				byId : function(/* String */id) {
					return this._hash[id];
				},

				byClass : function(/* String */cls) {
					return this.filter(function(widget) {
								return widget.declaredClass == cls;
							}); // dijit.WidgetSet
				}
			});

	// registry: list of all widgets on page
	dijit.registry = new dijit.WidgetSet();

	dijit._widgetTypeCtr = {};

	dijit.getUniqueId = function(/* String */widgetType) {
		// summary
		// Generates a unique id for a given widgetType

		var id;
		do {
			id = widgetType
					+ "_"
					+ (dijit._widgetTypeCtr[widgetType] !== undefined
							? ++dijit._widgetTypeCtr[widgetType]
							: dijit._widgetTypeCtr[widgetType] = 0);
		} while (dijit.byId(id));
		return id; // String
	};

	if (dojo.isIE) {
		// Only run this for IE because we think it's only necessary in that
		// case,
		// and because it causes problems on FF. See bug #3531 for details.
		dojo.addOnUnload(function() {
					dijit.registry.forEach(function(widget) {
								widget.destroy();
							});
				});
	}

	dijit.byId = function(/* String|Widget */id) {
		// summary:
		// Returns a widget by its id, or if passed a widget, no-op (like
		// dojo.byId())
		return (dojo.isString(id)) ? dijit.registry.byId(id) : id; // Widget
	};

	dijit.byNode = function(/* DOMNode */node) {
		// summary:
		// Returns the widget as referenced by node
		return dijit.registry.byId(node.getAttribute("widgetId")); // Widget
	};

	dijit.getEnclosingWidget = function(/* DOMNode */node) {
		// summary:
		// Returns the widget whose dom tree contains node or null if
		// the node is not contained within the dom tree of any widget
		while (node) {
			if (node.getAttribute && node.getAttribute("widgetId")) {
				return dijit.registry.byId(node.getAttribute("widgetId"));
			}
			node = node.parentNode;
		}
		return null;
	};

}

if (!dojo._hasResource["dijit._base.place"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._base.place"] = true;
	dojo.provide("dijit._base.place");

	// ported from dojo.html.util

	dijit.getViewport = function() {
		// summary
		// Returns the dimensions and scroll position of the viewable area of a
		// browser window

		var _window = dojo.global;
		var _document = dojo.doc;

		// get viewport size
		var w = 0, h = 0;
		if (dojo.isMozilla) {
			// mozilla
			// _window.innerHeight includes the height taken by the scroll bar
			// clientHeight is ideal but has DTD issues:
			// #4539: FF reverses the roles of body.clientHeight/Width and
			// documentElement.clientHeight/Width based on the DTD!
			// check DTD to see whether body or documentElement returns the
			// viewport dimensions using this algorithm:
			var minw, minh, maxw, maxh;
			if (_document.body.clientWidth > _document.documentElement.clientWidth) {
				minw = _document.documentElement.clientWidth;
				maxw = _document.body.clientWidth;
			} else {
				maxw = _document.documentElement.clientWidth;
				minw = _document.body.clientWidth;
			}
			if (_document.body.clientHeight > _document.documentElement.clientHeight) {
				minh = _document.documentElement.clientHeight;
				maxh = _document.body.clientHeight;
			} else {
				maxh = _document.documentElement.clientHeight;
				minh = _document.body.clientHeight;
			}
			w = (maxw > _window.innerWidth) ? minw : maxw;
			h = (maxh > _window.innerHeight) ? minh : maxh;
		} else if (!dojo.isOpera && _window.innerWidth) {
			// in opera9, dojo.body().clientWidth should be used, instead
			// of window.innerWidth/document.documentElement.clientWidth
			// so we have to check whether it is opera
			w = _window.innerWidth;
			h = _window.innerHeight;
		} else if (dojo.isIE && _document.documentElement
				&& _document.documentElement.clientHeight) {
			w = _document.documentElement.clientWidth;
			h = _document.documentElement.clientHeight;
		} else if (dojo.body().clientWidth) {
			// IE5, Opera
			w = dojo.body().clientWidth;
			h = dojo.body().clientHeight;
		}

		// get scroll position
		var scroll = dojo._docScroll();

		return {
			w : w,
			h : h,
			l : scroll.x,
			t : scroll.y
		}; // object
	};

	dijit.placeOnScreen = function(
			/* DomNode */node,
			/* Object */pos,
			/* Object */corners,
			/* boolean? */tryOnly) {
		// summary:
		// Keeps 'node' in the visible area of the screen while trying to
		// place closest to pos.x, pos.y. The input coordinates are
		// expected to be the desired document position.
		//
		// Set which corner(s) you want to bind to, such as
		//		
		// placeOnScreen(node, {x: 10, y: 20}, ["TR", "BL"])
		//		
		// The desired x/y will be treated as the topleft(TL)/topright(TR) or
		// BottomLeft(BL)/BottomRight(BR) corner of the node. Each corner is
		// tested
		// and if a perfect match is found, it will be used. Otherwise, it goes
		// through
		// all of the specified corners, and choose the most appropriate one.
		//		
		// NOTE: node is assumed to be absolutely or relatively positioned.

		var choices = dojo.map(corners, function(corner) {
					return {
						corner : corner,
						pos : pos
					};
				});

		return dijit._place(node, choices);
	}

	dijit._place = function(/* DomNode */node, /* Array */choices, /* Function */
			layoutNode) {
		// summary:
		// Given a list of spots to put node, put it at the first spot where it
		// fits,
		// of if it doesn't fit anywhere then the place with the least overflow
		// choices: Array
		// Array of elements like: {corner: 'TL', pos: {x: 10, y: 20} }
		// Above example says to put the top-left corner of the node at (10,20)
		// layoutNode: Function(node, orient)
		// for things like tooltip, they are displayed differently (and have
		// different dimensions)
		// based on their orientation relative to the parent. This adjusts the
		// popup based on orientation.

		// get {x: 10, y: 10, w: 100, h:100} type obj representing position of
		// viewport over document
		var view = dijit.getViewport();

		// This won't work if the node is inside a <div style="position:
		// relative">,
		// so reattach it to document.body. (Otherwise, the positioning will be
		// wrong
		// and also it might get cutoff)
		if (!node.parentNode
				|| String(node.parentNode.tagName).toLowerCase() != "body") {
			dojo.body().appendChild(node);
		}

		var best = null;
		for (var i = 0; i < choices.length; i++) {
			var corner = choices[i].corner;
			var pos = choices[i].pos;

			// configure node to be displayed in given position relative to
			// button
			// (need to do this in order to get an accurate size for the node,
			// because
			// a tooltips size changes based on position, due to triangle)
			if (layoutNode) {
				layoutNode(corner);
			}

			// get node's size
			var oldDisplay = node.style.display;
			var oldVis = node.style.visibility;
			node.style.visibility = "hidden";
			node.style.display = "";
			var mb = dojo.marginBox(node);
			node.style.display = oldDisplay;
			node.style.visibility = oldVis;

			// coordinates and size of node with specified corner placed at pos,
			// and clipped by viewport
			var startX = (corner.charAt(1) == 'L' ? pos.x : Math.max(view.l,
					pos.x - mb.w)), startY = (corner.charAt(0) == 'T'
					? pos.y
					: Math.max(view.t, pos.y - mb.h)), endX = (corner.charAt(1) == 'L'
					? Math.min(view.l + view.w, startX + mb.w)
					: pos.x), endY = (corner.charAt(0) == 'T' ? Math.min(view.t
							+ view.h, startY + mb.h) : pos.y), width = endX
					- startX, height = endY - startY, overflow = (mb.w - width)
					+ (mb.h - height);

			if (best == null || overflow < best.overflow) {
				best = {
					corner : corner,
					aroundCorner : choices[i].aroundCorner,
					x : startX,
					y : startY,
					w : width,
					h : height,
					overflow : overflow
				};
			}
			if (overflow == 0) {
				break;
			}
		}

		node.style.left = best.x + "px";
		node.style.top = best.y + "px";
		return best;
	}

	dijit.placeOnScreenAroundElement = function(
			/* DomNode */node,
			/* DomNode */aroundNode,
			/* Object */aroundCorners,
			/* Function */layoutNode) {

		// summary
		// Like placeOnScreen, except it accepts aroundNode instead of x,y
		// and attempts to place node around it. Uses margin box dimensions.
		//
		// aroundCorners
		// specify Which corner of aroundNode should be
		// used to place the node => which corner(s) of node to use (see the
		// corners parameter in dijit.placeOnScreen)
		// e.g. {'TL': 'BL', 'BL': 'TL'}
		//
		// layoutNode: Function(node, orient)
		// for things like tooltip, they are displayed differently (and have
		// different dimensions)
		// based on their orientation relative to the parent. This adjusts the
		// popup based on orientation.

		// get coordinates of aroundNode
		aroundNode = dojo.byId(aroundNode);
		var oldDisplay = aroundNode.style.display;
		aroundNode.style.display = "";
		// #3172: use the slightly tighter border box instead of marginBox
		var aroundNodeW = aroundNode.offsetWidth; // mb.w;
		var aroundNodeH = aroundNode.offsetHeight; // mb.h;
		var aroundNodePos = dojo.coords(aroundNode, true);
		aroundNode.style.display = oldDisplay;

		// Generate list of possible positions for node
		var choices = [];
		for (var nodeCorner in aroundCorners) {
			choices.push({
						aroundCorner : nodeCorner,
						corner : aroundCorners[nodeCorner],
						pos : {
							x : aroundNodePos.x
									+ (nodeCorner.charAt(1) == 'L'
											? 0
											: aroundNodeW),
							y : aroundNodePos.y
									+ (nodeCorner.charAt(0) == 'T'
											? 0
											: aroundNodeH)
						}
					});
		}

		return dijit._place(node, choices, layoutNode);
	}

}

if (!dojo._hasResource["dijit._base.window"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._base.window"] = true;
	dojo.provide("dijit._base.window");

	dijit.getDocumentWindow = function(doc) {
		// summary
		// Get window object associated with document doc

		// With Safari, there is not way to retrieve the window from the
		// document, so we must fix it.
		if (dojo.isSafari && !doc._parentWindow) {
			/*
			 * This is a Safari specific function that fix the reference to the
			 * parent window from the document object.
			 */
			var fix = function(win) {
				win.document._parentWindow = win;
				for (var i = 0; i < win.frames.length; i++) {
					fix(win.frames[i]);
				}
			}
			fix(window.top);
		}

		// In some IE versions (at least 6.0), document.parentWindow does not
		// return a
		// reference to the real window object (maybe a copy), so we must fix it
		// as well
		// We use IE specific execScript to attach the real window reference to
		// document._parentWindow for later use
		if (dojo.isIE && window !== document.parentWindow && !doc._parentWindow) {
			/*
			 * In IE 6, only the variable "window" can be used to connect events
			 * (others may be only copies).
			 */
			doc.parentWindow.execScript("document._parentWindow = window;",
					"Javascript");
			// to prevent memory leak, unset it after use
			// another possibility is to add an onUnload handler which seems
			// overkill to me (liucougar)
			var win = doc._parentWindow;
			doc._parentWindow = null;
			return win; // Window
		}

		return doc._parentWindow || doc.parentWindow || doc.defaultView; // Window
	}

}

if (!dojo._hasResource["dijit._base.popup"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._base.popup"] = true;
	dojo.provide("dijit._base.popup");

	dijit.popup = new function() {
		// summary:
		// This class is used to show/hide widgets as popups.
		//

		var stack = [], beginZIndex = 1000, idGen = 1;

		this.open = function(/* Object */args) {
			// summary:
			// Popup the widget at the specified position
			//
			// args: Object
			// popup: Widget
			// widget to display,
			// parent: Widget
			// the button etc. that is displaying this popup
			// around: DomNode
			// DOM node (typically a button); place popup relative to this node
			// orient: Object
			// structure specifying possible positions of popup relative to
			// "around" node
			// onCancel: Function
			// callback when user has canceled the popup by
			// 1. hitting ESC or
			// 2. by using the popup widget's proprietary cancel mechanism (like
			// a cancel button in a dialog);
			// ie: whenever popupWidget.onCancel() is called, args.onCancel is
			// called
			// onClose: Function
			// callback whenever this popup is closed
			// onExecute: Function
			// callback when user "executed" on the popup/sub-popup by selecting
			// a menu choice, etc. (top menu only)
			//
			// examples:
			// 1. opening at the mouse position
			// dijit.popup.open({popup: menuWidget, x: evt.pageX, y:
			// evt.pageY});
			// 2. opening the widget as a dropdown
			// dijit.popup.open({parent: this, popup: menuWidget, around:
			// this.domNode, onClose: function(){...} });
			//
			// Note that whatever widget called dijit.popup.open() should also
			// listen to it's own _onBlur callback
			// (fired from _base/focus.js) to know that focus has moved
			// somewhere else and thus the popup should be closed.

			var widget = args.popup, orient = args.orient || {
				'BL' : 'TL',
				'TL' : 'BL'
			}, around = args.around, id = (args.around && args.around.id)
					? (args.around.id + "_dropdown")
					: ("popup_" + idGen++);

			// make wrapper div to hold widget and possibly hold iframe behind
			// it.
			// we can't attach the iframe as a child of the widget.domNode
			// because
			// widget.domNode might be a <table>, <ul>, etc.
			var wrapper = dojo.doc.createElement("div");
			wrapper.id = id;
			wrapper.className = "dijitPopup";
			wrapper.style.zIndex = beginZIndex + stack.length;
			wrapper.style.visibility = "hidden";
			if (args.parent) {
				wrapper.dijitPopupParent = args.parent.id;
			}
			dojo.body().appendChild(wrapper);

			widget.domNode.style.display = "";
			wrapper.appendChild(widget.domNode);

			var iframe = new dijit.BackgroundIframe(wrapper);

			// position the wrapper node
			var best = around ? dijit.placeOnScreenAroundElement(wrapper,
					around, orient, widget.orient ? dojo
							.hitch(widget, "orient") : null) : dijit
					.placeOnScreen(wrapper, args, orient == 'R' ? ['TR', 'BR',
									'TL', 'BL'] : ['TL', 'BL', 'TR', 'BR']);

			wrapper.style.visibility = "visible";
			// TODO: use effects to fade in wrapper

			var handlers = [];

			// Compute the closest ancestor popup that's *not* a child of
			// another popup.
			// Ex: For a TooltipDialog with a button that spawns a tree of
			// menus, find the popup of the button.
			function getTopPopup() {
				for (var pi = stack.length - 1; pi > 0
						&& stack[pi].parent === stack[pi - 1].widget; pi--);
				return stack[pi];
			}

			// provide default escape and tab key handling
			// (this will work for any widget, not just menu)
			handlers.push(dojo.connect(wrapper, "onkeypress", this, function(
							evt) {
						if (evt.keyCode == dojo.keys.ESCAPE && args.onCancel) {
							args.onCancel();
						} else if (evt.keyCode == dojo.keys.TAB) {
							dojo.stopEvent(evt);
							var topPopup = getTopPopup();
							if (topPopup && topPopup.onCancel) {
								topPopup.onCancel();
							}
						}
					}));

			// watch for cancel/execute events on the popup and notify the
			// caller
			// (for a menu, "execute" means clicking an item)
			if (widget.onCancel) {
				handlers.push(dojo.connect(widget, "onCancel", null,
						args.onCancel));
			}

			handlers.push(dojo.connect(widget, widget.onExecute
							? "onExecute"
							: "onChange", null, function() {
						var topPopup = getTopPopup();
						if (topPopup && topPopup.onExecute) {
							topPopup.onExecute();
						}
					}));

			stack.push({
						wrapper : wrapper,
						iframe : iframe,
						widget : widget,
						parent : args.parent,
						onExecute : args.onExecute,
						onCancel : args.onCancel,
						onClose : args.onClose,
						handlers : handlers
					});

			if (widget.onOpen) {
				widget.onOpen(best);
			}

			return best;
		};

		this.close = function(/* Widget */popup) {
			// summary:
			// Close specified popup and any popups that it parented
			while (dojo.some(stack, function(elem) {
						return elem.widget == popup;
					})) {
				var top = stack.pop(), wrapper = top.wrapper, iframe = top.iframe, widget = top.widget, onClose = top.onClose;

				if (widget.onClose) {
					widget.onClose();
				}
				dojo.forEach(top.handlers, dojo.disconnect);

				// #2685: check if the widget still has a domNode so ContentPane
				// can change its URL without getting an error
				if (!widget || !widget.domNode) {
					return;
				}
				dojo.style(widget.domNode, "display", "none");
				dojo.body().appendChild(widget.domNode);
				iframe.destroy();
				dojo._destroyElement(wrapper);

				if (onClose) {
					onClose();
				}
			}
		};
	}();

	dijit._frames = new function() {
		// summary: cache of iframes
		var queue = [];

		this.pop = function() {
			var iframe;
			if (queue.length) {
				iframe = queue.pop();
				iframe.style.display = "";
			} else {
				if (dojo.isIE) {
					var html = "<iframe src='javascript:\"\"'"
							+ " style='position: absolute; left: 0px; top: 0px;"
							+ "z-index: -1; filter:Alpha(Opacity=\"0\");'>";
					iframe = dojo.doc.createElement(html);
				} else {
					var iframe = dojo.doc.createElement("iframe");
					iframe.src = 'javascript:""';
					iframe.className = "dijitBackgroundIframe";
				}
				iframe.tabIndex = -1; // Magic to prevent iframe from getting
										// focus on tab keypress - as style
										// didnt work.
				dojo.body().appendChild(iframe);
			}
			return iframe;
		};

		this.push = function(iframe) {
			iframe.style.display = "";
			if (dojo.isIE) {
				iframe.style.removeExpression("width");
				iframe.style.removeExpression("height");
			}
			queue.push(iframe);
		}
	}();

	// fill the queue
	if (dojo.isIE && dojo.isIE < 7) {
		dojo.addOnLoad(function() {
					var f = dijit._frames;
					dojo.forEach([f.pop()], f.push);
				});
	}

	dijit.BackgroundIframe = function(/* DomNode */node) {
		// summary:
		// For IE z-index schenanigans. id attribute is required.
		//
		// description:
		// new dijit.BackgroundIframe(node)
		// Makes a background iframe as a child of node, that fills
		// area (and position) of node

		if (!node.id) {
			throw new Error("no id");
		}
		if ((dojo.isIE && dojo.isIE < 7)
				|| (dojo.isFF && dojo.isFF < 3 && dojo.hasClass(dojo.body(),
						"dijit_a11y"))) {
			var iframe = dijit._frames.pop();
			node.appendChild(iframe);
			if (dojo.isIE) {
				iframe.style.setExpression("width", "document.getElementById('"
								+ node.id + "').offsetWidth");
				iframe.style.setExpression("height",
						"document.getElementById('" + node.id
								+ "').offsetHeight");
			}
			this.iframe = iframe;
		}
	};

	dojo.extend(dijit.BackgroundIframe, {
				destroy : function() {
					// summary: destroy the iframe
					if (this.iframe) {
						dijit._frames.push(this.iframe);
						delete this.iframe;
					}
				}
			});

}

if (!dojo._hasResource["dijit._base.scroll"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._base.scroll"] = true;
	dojo.provide("dijit._base.scroll");

	dijit.scrollIntoView = function(/* DomNode */node) {
		// summary
		// Scroll the passed node into view, if it is not.

		// don't rely on that node.scrollIntoView works just because the
		// function is there
		// it doesnt work in Konqueror or Opera even though the function is
		// there and probably
		// not safari either
		// dont like browser sniffs implementations but sometimes you have to
		// use it
		if (dojo.isIE) {
			// only call scrollIntoView if there is a scrollbar for this menu,
			// otherwise, scrollIntoView will scroll the window scrollbar
			if (dojo.marginBox(node.parentNode).h <= node.parentNode.scrollHeight) { // PORT
																						// was
																						// getBorderBox
				node.scrollIntoView(false);
			}
		} else if (dojo.isMozilla) {
			node.scrollIntoView(false);
		} else {
			var parent = node.parentNode;
			var parentBottom = parent.scrollTop + dojo.marginBox(parent).h; // PORT
																			// was
																			// getBorderBox
			var nodeBottom = node.offsetTop + dojo.marginBox(node).h;
			if (parentBottom < nodeBottom) {
				parent.scrollTop += (nodeBottom - parentBottom);
			} else if (parent.scrollTop > node.offsetTop) {
				parent.scrollTop -= (parent.scrollTop - node.offsetTop);
			}
		}
	};

}

if (!dojo._hasResource["dijit._base.sniff"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._base.sniff"] = true;
	dojo.provide("dijit._base.sniff");

	// ported from dojo.html.applyBrowserClass (style.js)

	// summary:
	// Applies pre-set class names based on browser & version to the
	// top-level HTML node. Simply doing a require on this module will
	// establish this CSS. Modified version of Morris' CSS hack.
	(function() {
		var d = dojo;
		var ie = d.isIE;
		var opera = d.isOpera;
		var maj = Math.floor;
		var classes = {
			dj_ie : ie,
			// dj_ie55: ie == 5.5,
			dj_ie6 : maj(ie) == 6,
			dj_ie7 : maj(ie) == 7,
			dj_iequirks : ie && d.isQuirks,
			// NOTE: Opera not supported by dijit
			dj_opera : opera,
			dj_opera8 : maj(opera) == 8,
			dj_opera9 : maj(opera) == 9,
			dj_khtml : d.isKhtml,
			dj_safari : d.isSafari,
			dj_gecko : d.isMozilla
		}; // no dojo unsupported browsers

		for (var p in classes) {
			if (classes[p]) {
				var html = dojo.doc.documentElement; // TODO browser-specific
														// DOM magic needed?
				if (html.className) {
					html.className += " " + p;
				} else {
					html.className = p;
				}
			}
		}
	})();

}

if (!dojo._hasResource["dijit._base.bidi"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._base.bidi"] = true;
	dojo.provide("dijit._base.bidi");

	// summary: applies a class to the top of the document for right-to-left
	// stylesheet rules

	dojo.addOnLoad(function() {
				if (!dojo._isBodyLtr()) {
					dojo.addClass(dojo.body(), "dijitRtl");
				}
			});

}

if (!dojo._hasResource["dijit._base.typematic"]) { // _hasResource checks added
													// by build. Do not use
													// _hasResource directly in
													// your code.
	dojo._hasResource["dijit._base.typematic"] = true;
	dojo.provide("dijit._base.typematic");

	dijit.typematic = {
		// summary:
		// These functions are used to repetitively call a user specified
		// callback
		// method when a specific key or mouse click over a specific DOM node is
		// held down for a specific amount of time.
		// Only 1 such event is allowed to occur on the browser page at 1 time.

		_fireEventAndReload : function() {
			this._timer = null;
			this._callback(++this._count, this._node, this._evt);
			this._currentTimeout = (this._currentTimeout < 0)
					? this._initialDelay
					: ((this._subsequentDelay > 1)
							? this._subsequentDelay
							: Math.round(this._currentTimeout
									* this._subsequentDelay));
			this._timer = setTimeout(dojo.hitch(this, "_fireEventAndReload"),
					this._currentTimeout);
		},

		trigger : function(/* Event */evt, /* Object */_this, /* DOMNode */node, /* Function */
				callback, /* Object */obj, /* Number */subsequentDelay, /* Number */
				initialDelay) {
			// summary:
			// Start a timed, repeating callback sequence.
			// If already started, the function call is ignored.
			// This method is not normally called by the user but can be
			// when the normal listener code is insufficient.
			// Parameters:
			// evt: key or mouse event object to pass to the user callback
			// _this: pointer to the user's widget space.
			// node: the DOM node object to pass the the callback function
			// callback: function to call until the sequence is stopped called
			// with 3 parameters:
			// count: integer representing number of repeated calls (0..n) with
			// -1 indicating the iteration has stopped
			// node: the DOM node object passed in
			// evt: key or mouse event object
			// obj: user space object used to uniquely identify each typematic
			// sequence
			// subsequentDelay: if > 1, the number of milliseconds until the
			// 3->n events occur
			// or else the fractional time multiplier for the next event's
			// delay, default=0.9
			// initialDelay: the number of milliseconds until the 2nd event
			// occurs, default=500ms
			if (obj != this._obj) {
				this.stop();
				this._initialDelay = initialDelay || 500;
				this._subsequentDelay = subsequentDelay || 0.90;
				this._obj = obj;
				this._evt = evt;
				this._node = node;
				this._currentTimeout = -1;
				this._count = -1;
				this._callback = dojo.hitch(_this, callback);
				this._fireEventAndReload();
			}
		},

		stop : function() {
			// summary:
			// Stop an ongoing timed, repeating callback sequence.
			if (this._timer) {
				clearTimeout(this._timer);
				this._timer = null;
			}
			if (this._obj) {
				this._callback(-1, this._node, this._evt);
				this._obj = null;
			}
		},

		addKeyListener : function(/* DOMNode */node, /* Object */keyObject, /* Object */
				_this, /* Function */callback, /* Number */subsequentDelay, /* Number */
				initialDelay) {
			// summary: Start listening for a specific typematic key.
			// keyObject: an object defining the key to listen for.
			// key: (mandatory) the keyCode (number) or character (string) to
			// listen for.
			// ctrlKey: desired ctrl key state to initiate the calback sequence:
			// pressed (true)
			// released (false)
			// either (unspecified)
			// altKey: same as ctrlKey but for the alt key
			// shiftKey: same as ctrlKey but for the shift key
			// See the trigger method for other parameters.
			// Returns an array of dojo.connect handles
			return [dojo.connect(node, "onkeypress", this, function(evt) {
				if (evt.keyCode == keyObject.keyCode
						&& (!keyObject.charCode || keyObject.charCode == evt.charCode)
						&& (keyObject.ctrlKey === undefined || keyObject.ctrlKey == evt.ctrlKey)
						&& (keyObject.altKey === undefined || keyObject.altKey == evt.ctrlKey)
						&& (keyObject.shiftKey === undefined || keyObject.shiftKey == evt.ctrlKey)) {
					dojo.stopEvent(evt);
					dijit.typematic.trigger(keyObject, _this, node, callback,
							keyObject, subsequentDelay, initialDelay);
				} else if (dijit.typematic._obj == keyObject) {
					dijit.typematic.stop();
				}
			}), dojo.connect(node, "onkeyup", this, function(evt) {
						if (dijit.typematic._obj == keyObject) {
							dijit.typematic.stop();
						}
					})];
		},

		addMouseListener : function(/* DOMNode */node, /* Object */_this, /* Function */
				callback, /* Number */subsequentDelay, /* Number */initialDelay) {
			// summary: Start listening for a typematic mouse click.
			// See the trigger method for other parameters.
			// Returns an array of dojo.connect handles
			var dc = dojo.connect;
			return [dc(node, "mousedown", this, function(evt) {
						dojo.stopEvent(evt);
						dijit.typematic.trigger(evt, _this, node, callback,
								node, subsequentDelay, initialDelay);
					}), dc(node, "mouseup", this, function(evt) {
						dojo.stopEvent(evt);
						dijit.typematic.stop();
					}), dc(node, "mouseout", this, function(evt) {
						dojo.stopEvent(evt);
						dijit.typematic.stop();
					}), dc(node, "mousemove", this, function(evt) {
						dojo.stopEvent(evt);
					}), dc(node, "dblclick", this, function(evt) {
						dojo.stopEvent(evt);
						if (dojo.isIE) {
							dijit.typematic.trigger(evt, _this, node, callback,
									node, subsequentDelay, initialDelay);
							setTimeout(dijit.typematic.stop, 50);
						}
					})];
		},

		addListener : function(/* Node */mouseNode, /* Node */keyNode, /* Object */
				keyObject, /* Object */_this, /* Function */callback, /* Number */
				subsequentDelay, /* Number */initialDelay) {
			// summary: Start listening for a specific typematic key and
			// mouseclick.
			// This is a thin wrapper to addKeyListener and addMouseListener.
			// mouseNode: the DOM node object to listen on for mouse events.
			// keyNode: the DOM node object to listen on for key events.
			// See the addMouseListener and addKeyListener methods for other
			// parameters.
			// Returns an array of dojo.connect handles
			return this.addKeyListener(keyNode, keyObject, _this, callback,
					subsequentDelay, initialDelay).concat(this
							.addMouseListener(mouseNode, _this, callback,
									subsequentDelay, initialDelay));
		}
	};

}

if (!dojo._hasResource["dijit._base.wai"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._base.wai"] = true;
	dojo.provide("dijit._base.wai");

	dijit.wai = {
		onload : function() {
			// summary:
			// Function that detects if we are in high-contrast mode or not,
			// and sets up a timer to periodically confirm the value.
			// figure out the background-image style property
			// and apply that to the image.src property.
			// description:
			// This must be a named function and not an anonymous
			// function, so that the widget parsing code can make sure it
			// registers its onload function after this function.
			// DO NOT USE "this" within this function.

			// create div for testing if high contrast mode is on or images are
			// turned off
			var div = document.createElement("div");
			div.id = "a11yTestNode";
			div.style.cssText = 'border: 1px solid;'
					+ 'border-color:red green;' + 'position: absolute;'
					+ 'height: 5px;' + 'top: -999px;'
					+ 'background-image: url("'
					+ dojo.moduleUrl("dijit", "form/templates/blank.gif")
					+ '");';
			dojo.body().appendChild(div);

			// test it
			function check() {
				var cs = dojo.getComputedStyle(div);
				if (cs) {
					var bkImg = cs.backgroundImage;
					var needsA11y = (cs.borderTopColor == cs.borderRightColor)
							|| (bkImg != null && (bkImg == "none" || bkImg == "url(invalid-url:)"));
					dojo[needsA11y ? "addClass" : "removeClass"](dojo.body(),
							"dijit_a11y");
				}
			}
			check();
			if (dojo.isIE) {
				setInterval(check, 4000);
			}
		}
	};

	// Test if computer is in high contrast mode.
	// Make sure the a11y test runs first, before widgets are instantiated.
	if (dojo.isIE || dojo.isMoz) { // NOTE: checking in Safari messes things up
		dojo._loaders.unshift(dijit.wai.onload);
	}

	dojo.mixin(dijit, {
		hasWaiRole : function(/* Element */elem) {
			// Summary: Return true if elem has a role attribute and false if
			// not.
			if (elem.hasAttribute) {
				return elem.hasAttribute("role");
			} else {
				return elem.getAttribute("role") ? true : false;
			}
		},

		getWaiRole : function(/* Element */elem) {
			// Summary: Return the role of elem or an empty string if
			// elem does not have a role.
			var value = elem.getAttribute("role");
			if (value) {
				var prefixEnd = value.indexOf(":");
				return prefixEnd == -1 ? value : value.substring(prefixEnd + 1);
			} else {
				return "";
			}
		},

		setWaiRole : function(/* Element */elem, /* String */role) {
			// Summary: Set the role on elem. On Firefox 2 and below, "wairole:"
			// is
			// prepended to the provided role value.
			if (dojo.isFF && dojo.isFF < 3) {
				elem.setAttribute("role", "wairole:" + role);
			} else {
				elem.setAttribute("role", role);
			}
		},

		removeWaiRole : function(/* Element */elem) {
			// Summary: Removes the role attribute from elem.
			elem.removeAttribute("role");
		},

		hasWaiState : function(/* Element */elem, /* String */state) {
			// Summary: Return true if elem has a value for the given state and
			// false if it does not.
			// On Firefox 2 and below, we check for an attribute in namespace
			// "http://www.w3.org/2005/07/aaa" with a name of the given state.
			// On all other browsers, we check for an attribute called
			// "aria-"+state.
			if (dojo.isFF && dojo.isFF < 3) {
				return elem.hasAttributeNS("http://www.w3.org/2005/07/aaa",
						state);
			} else {
				if (elem.hasAttribute) {
					return elem.hasAttribute("aria-" + state);
				} else {
					return elem.getAttribute("aria-" + state) ? true : false;
				}
			}
		},

		getWaiState : function(/* Element */elem, /* String */state) {
			// Summary: Return the value of the requested state on elem
			// or an empty string if elem has no value for state.
			// On Firefox 2 and below, we check for an attribute in namespace
			// "http://www.w3.org/2005/07/aaa" with a name of the given state.
			// On all other browsers, we check for an attribute called
			// "aria-"+state.
			if (dojo.isFF && dojo.isFF < 3) {
				return elem.getAttributeNS("http://www.w3.org/2005/07/aaa",
						state);
			} else {
				var value = elem.getAttribute("aria-" + state);
				return value ? value : "";
			}
		},

		setWaiState : function(/* Element */elem, /* String */state, /* String */
				value) {
			// Summary: Set state on elem to value.
			// On Firefox 2 and below, we set an attribute in namespace
			// "http://www.w3.org/2005/07/aaa" with a name of the given state.
			// On all other browsers, we set an attribute called
			// "aria-"+state.
			if (dojo.isFF && dojo.isFF < 3) {
				elem.setAttributeNS("http://www.w3.org/2005/07/aaa", "aaa:"
								+ state, value);
			} else {
				elem.setAttribute("aria-" + state, value);
			}
		},

		removeWaiState : function(/* Element */elem, /* String */state) {
			// Summary: Removes the given state from elem.
			// On Firefox 2 and below, we remove the attribute in namespace
			// "http://www.w3.org/2005/07/aaa" with a name of the given state.
			// On all other browsers, we remove the attribute called
			// "aria-"+state.
			if (dojo.isFF && dojo.isFF < 3) {
				elem.removeAttributeNS("http://www.w3.org/2005/07/aaa", state);
			} else {
				elem.removeAttribute("aria-" + state);
			}
		}
	});

}

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

}

if (!dojo._hasResource["dojo.date.stamp"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dojo.date.stamp"] = true;
	dojo.provide("dojo.date.stamp");

	// Methods to convert dates to or from a wire (string) format using
	// well-known conventions

	dojo.date.stamp.fromISOString = function(/* String */formattedString, /* Number? */
			defaultTime) {
		// summary:
		// Returns a Date object given a string formatted according to a subset
		// of the ISO-8601 standard.
		//
		// description:
		// Accepts a string formatted according to a profile of ISO8601 as
		// defined by
		// RFC3339 (http://www.ietf.org/rfc/rfc3339.txt), except that partial
		// input is allowed.
		// Can also process dates as specified by
		// http://www.w3.org/TR/NOTE-datetime
		// The following combinations are valid:
		// * dates only
		// yyyy
		// yyyy-MM
		// yyyy-MM-dd
		// * times only, with an optional time zone appended
		// THH:mm
		// THH:mm:ss
		// THH:mm:ss.SSS
		// * and "datetimes" which could be any combination of the above
		// timezones may be specified as Z (for UTC) or +/- followed by a time
		// expression HH:mm
		// Assumes the local time zone if not specified. Does not validate.
		// Improperly formatted
		// input may return null. Arguments which are out of bounds will be
		// handled
		// by the Date constructor (e.g. January 32nd typically gets resolved to
		// February 1st)
		//
		// formattedString:
		// A string such as 2005-06-30T08:05:00-07:00 or 2005-06-30 or T08:05:00
		//
		// defaultTime:
		// Used for defaults for fields omitted in the formattedString.
		// Uses 1970-01-01T00:00:00.0Z by default.

		if (!dojo.date.stamp._isoRegExp) {
			dojo.date.stamp._isoRegExp =
			// TODO: could be more restrictive and check for 00-59, etc.
			/^(?:(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(.\d+)?)?((?:[+-](\d{2}):(\d{2}))|Z)?)?$/;
		}

		var match = dojo.date.stamp._isoRegExp.exec(formattedString);
		var result = null;

		if (match) {
			match.shift();
			match[1] && match[1]--; // Javascript Date months are 0-based
			match[6] && (match[6] *= 1000); // Javascript Date expects
											// fractional seconds as
											// milliseconds

			if (defaultTime) {
				// mix in defaultTime. Relatively expensive, so use || operators
				// for the fast path of defaultTime === 0
				defaultTime = new Date(defaultTime);
				dojo.map(
						["FullYear", "Month", "Date", "Hours", "Minutes",
								"Seconds", "Milliseconds"], function(prop) {
							return defaultTime["get" + prop]();
						}).forEach(function(value, index) {
							if (match[index] === undefined) {
								match[index] = value;
							}
						});
			}
			result = new Date(match[0] || 1970, match[1] || 0, match[2] || 0,
					match[3] || 0, match[4] || 0, match[5] || 0, match[6] || 0);

			var offset = 0;
			var zoneSign = match[7] && match[7].charAt(0);
			if (zoneSign != 'Z') {
				offset = ((match[8] || 0) * 60) + (Number(match[9]) || 0);
				if (zoneSign != '-') {
					offset *= -1;
				}
			}
			if (zoneSign) {
				offset -= result.getTimezoneOffset();
			}
			if (offset) {
				result.setTime(result.getTime() + offset * 60000);
			}
		}

		return result; // Date or null
	}

	dojo.date.stamp.toISOString = function(/* Date */dateObject, /* Object? */
			options) {
		// summary:
		// Format a Date object as a string according a subset of the ISO-8601
		// standard
		//
		// description:
		// When options.selector is omitted, output follows RFC3339
		// (http://www.ietf.org/rfc/rfc3339.txt)
		// The local time zone is included as an offset from GMT, except when
		// selector=='time' (time without a date)
		// Does not check bounds.
		//
		// dateObject:
		// A Date object
		//
		// object {selector: string, zulu: boolean, milliseconds: boolean}
		// selector- "date" or "time" for partial formatting of the Date object.
		// Both date and time will be formatted by default.
		// zulu- if true, UTC/GMT is used for a timezone
		// milliseconds- if true, output milliseconds

		var _ = function(n) {
			return (n < 10) ? "0" + n : n;
		}
		options = options || {};
		var formattedDate = [];
		var getter = options.zulu ? "getUTC" : "get";
		var date = "";
		if (options.selector != "time") {
			date = [dateObject[getter + "FullYear"](),
					_(dateObject[getter + "Month"]() + 1),
					_(dateObject[getter + "Date"]())].join('-');
		}
		formattedDate.push(date);
		if (options.selector != "date") {
			var time = [_(dateObject[getter + "Hours"]()),
					_(dateObject[getter + "Minutes"]()),
					_(dateObject[getter + "Seconds"]())].join(':');
			var millis = dateObject[getter + "Milliseconds"]();
			if (options.milliseconds) {
				time += "." + (millis < 100 ? "0" : "") + _(millis);
			}
			if (options.zulu) {
				time += "Z";
			} else if (options.selector != "time") {
				var timezoneOffset = dateObject.getTimezoneOffset();
				var absOffset = Math.abs(timezoneOffset);
				time += (timezoneOffset > 0 ? "-" : "+")
						+ _(Math.floor(absOffset / 60)) + ":"
						+ _(absOffset % 60);
			}
			formattedDate.push(time);
		}
		return formattedDate.join('T'); // String
	}

}

if (!dojo._hasResource["dojo.parser"]) { // _hasResource checks added by
											// build. Do not use _hasResource
											// directly in your code.
	dojo._hasResource["dojo.parser"] = true;
	dojo.provide("dojo.parser");

	dojo.parser = new function() {

		var d = dojo;

		function val2type(/* Object */value) {
			// summary:
			// Returns name of type of given value.

			if (d.isString(value)) {
				return "string";
			}
			if (typeof value == "number") {
				return "number";
			}
			if (typeof value == "boolean") {
				return "boolean";
			}
			if (d.isFunction(value)) {
				return "function";
			}
			if (d.isArray(value)) {
				return "array";
			} // typeof [] == "object"
			if (value instanceof Date) {
				return "date";
			} // assume timestamp
			if (value instanceof d._Url) {
				return "url";
			}
			return "object";
		}

		function str2obj(/* String */value, /* String */type) {
			// summary:
			// Convert given string value to given type
			switch (type) {
				case "string" :
					return value;
				case "number" :
					return value.length ? Number(value) : NaN;
				case "boolean" :
					// for checked/disabled value might be "" or "checked".
					// interpret as true.
					return typeof value == "boolean" ? value : !(value
							.toLowerCase() == "false");
				case "function" :
					if (d.isFunction(value)) {
						// IE gives us a function, even when we say something
						// like onClick="foo"
						// (in which case it gives us an invalid function
						// "function(){ foo }").
						// Therefore, convert to string
						value = value.toString();
						value = d.trim(value.substring(value.indexOf('{') + 1,
								value.length - 1));
					}
					try {
						if (value.search(/[^\w\.]+/i) != -1) {
							// TODO: "this" here won't work
							value = d.parser._nameAnonFunc(new Function(value),
									this);
						}
						return d.getObject(value, false);
					} catch (e) {
						return new Function();
					}
				case "array" :
					return value.split(/\s*,\s*/);
				case "date" :
					switch (value) {
						case "" :
							return new Date(""); // the NaN of dates
						case "now" :
							return allGetServerTime(); // current date
						default :
							return d.date.stamp.fromISOString(value);
					}
				case "url" :
					return d.baseUrl + value;
				default :
					return d.fromJson(value);
			}
		}

		var instanceClasses = {
		// map from fully qualified name (like "dijit.Button") to structure like
		// { cls: dijit.Button, params: {label: "string", disabled: "boolean"} }
		};

		function getClassInfo(/* String */className) {
			// className:
			// fully qualified name (like "dijit.Button")
			// returns:
			// structure like
			// {
			// cls: dijit.Button,
			// params: { label: "string", disabled: "boolean"}
			// }

			if (!instanceClasses[className]) {
				// get pointer to widget class
				var cls = d.getObject(className);
				if (!d.isFunction(cls)) {
					throw new Error("Could not load class '"
							+ className
							+ "'. Did you spell the name correctly and use a full path, like 'dijit.form.Button'?");
				}
				var proto = cls.prototype;

				// get table of parameter names & types
				var params = {};
				for (var name in proto) {
					if (name.charAt(0) == "_") {
						continue;
					} // skip internal properties
					var defVal = proto[name];
					params[name] = val2type(defVal);
				}

				instanceClasses[className] = {
					cls : cls,
					params : params
				};
			}
			return instanceClasses[className];
		}

		this._functionFromScript = function(script) {
			var preamble = "";
			var suffix = "";
			var argsStr = script.getAttribute("args");
			if (argsStr) {
				d.forEach(argsStr.split(/\s*,\s*/), function(part, idx) {
							preamble += "var " + part + " = arguments[" + idx
									+ "]; ";
						});
			}
			var withStr = script.getAttribute("with");
			if (withStr && withStr.length) {
				d.forEach(withStr.split(/\s*,\s*/), function(part) {
							preamble += "with(" + part + "){";
							suffix += "}";
						});
			}
			return new Function(preamble + script.innerHTML + suffix);
		}

		this.instantiate = function(/* Array */nodes) {
			// summary:
			// Takes array of nodes, and turns them into class instances and
			// potentially calls a layout method to allow them to connect with
			// any children
			var thelist = [];
			d.forEach(nodes, function(node) {
				if (!node) {
					return;
				}
				var type = node.getAttribute("dojoType");
				if ((!type) || (!type.length)) {
					return;
				}
				var clsInfo = getClassInfo(type);
				var clazz = clsInfo.cls;
				var ps = clazz._noScript || clazz.prototype._noScript;

				// read parameters (ie, attributes).
				// clsInfo.params lists expected params like {"checked":
				// "boolean", "n": "number"}
				var params = {};
				var attributes = node.attributes;
				for (var name in clsInfo.params) {
					var item = attributes.getNamedItem(name);
					if (!item
							|| (!item.specified && (!dojo.isIE || name
									.toLowerCase() != "value"))) {
						continue;
					}
					var value = item.value;
					// Deal with IE quirks for 'class' and 'style'
					switch (name) {
						case "class" :
							value = node.className;
							break;
						case "style" :
							value = node.style && node.style.cssText; // FIXME:
																		// Opera?
					}
					var _type = clsInfo.params[name];
					params[name] = str2obj(value, _type);
				}

				// Process <script type="dojo/*"> script tags
				// <script type="dojo/method" event="foo"> tags are added to
				// params, and passed to
				// the widget on instantiation.
				// <script type="dojo/method"> tags (with no event) are executed
				// after instantiation
				// <script type="dojo/connect" event="foo"> tags are
				// dojo.connected after instantiation
				if (!ps) {
					var connects = [], // functions to connect after
										// instantiation
					calls = []; // functions to call after instantiation

					d.query("> script[type^='dojo/']", node).orphan().forEach(
							function(script) {
								var event = script.getAttribute("event"), type = script
										.getAttribute("type"), nf = d.parser
										._functionFromScript(script);
								if (event) {
									if (type == "dojo/connect") {
										connects.push({
													event : event,
													func : nf
												});
									} else {
										params[event] = nf;
									}
								} else {
									calls.push(nf);
								}
							});
				}

				var markupFactory = clazz["markupFactory"];
				if (!markupFactory && clazz["prototype"]) {
					markupFactory = clazz.prototype["markupFactory"];
				}
				// create the instance
				var instance = markupFactory ? markupFactory(params, node,
						clazz) : new clazz(params, node);
				thelist.push(instance);

				// map it to the JS namespace if that makes sense
				var jsname = node.getAttribute("jsId");
				if (jsname) {
					d.setObject(jsname, instance);
				}

				// process connections and startup functions
				if (!ps) {
					dojo.forEach(connects, function(connect) {
								dojo.connect(instance, connect.event, null,
										connect.func);
							});
					dojo.forEach(calls, function(func) {
								func.call(instance);
							});
				}
			});

			// Call startup on each top level instance if it makes sense (as for
			// widgets). Parent widgets will recursively call startup on their
			// (non-top level) children
			d.forEach(thelist, function(instance) {
						if (instance
								&& (instance.startup)
								&& ((!instance.getParent) || (!instance
										.getParent()))) {
							instance.startup();
						}
					});
			return thelist;
		};

		this.parse = function(/* DomNode? */rootNode) {
			// summary:
			// Search specified node (or root node) recursively for class
			// instances,
			// and instantiate them Searches for
			// dojoType="qualified.class.name"
			var list = d.query('[dojoType]', rootNode);
			// go build the object instances
			var instances = this.instantiate(list);
			return instances;
		};
	}();

	// Register the parser callback. It should be the first callback
	// after the a11y test.

	(function() {
		var parseRunner = function() {
			if (djConfig["parseOnLoad"] == true) {
				dojo.parser.parse();
			}
		};

		// FIXME: need to clobber cross-dependency!!
		if (dojo.exists("dijit.wai.onload")
				&& (dijit.wai.onload === dojo._loaders[0])) {
			dojo._loaders.splice(1, 0, parseRunner);
		} else {
			dojo._loaders.unshift(parseRunner);
		}
	})();

	// TODO: ported from 0.4.x Dojo. Can we reduce this?
	dojo.parser._anonCtr = 0;
	dojo.parser._anon = {}; // why is this property required?
	dojo.parser._nameAnonFunc = function(/* Function */anonFuncPtr, /* Object */
			thisObj) {
		// summary:
		// Creates a reference to anonFuncPtr in thisObj with a completely
		// unique name. The new name is returned as a String.
		var jpn = "$joinpoint";
		var nso = (thisObj || dojo.parser._anon);
		if (dojo.isIE) {
			var cn = anonFuncPtr["__dojoNameCache"];
			if (cn && nso[cn] === anonFuncPtr) {
				return anonFuncPtr["__dojoNameCache"];
			}
		}
		var ret = "__" + dojo.parser._anonCtr++;
		while (typeof nso[ret] != "undefined") {
			ret = "__" + dojo.parser._anonCtr++;
		}
		nso[ret] = anonFuncPtr;
		return ret; // String
	}

}

if (!dojo._hasResource["dijit._Widget"]) { // _hasResource checks added by
											// build. Do not use _hasResource
											// directly in your code.
	dojo._hasResource["dijit._Widget"] = true;
	dojo.provide("dijit._Widget");

	dojo.declare("dijit._Widget", null, {
		// summary:
		// The foundation of dijit widgets.
		//
		// id: String
		// a unique, opaque ID string that can be assigned by users or by the
		// system. If the developer passes an ID which is known not to be
		// unique, the specified ID is ignored and the system-generated ID is
		// used instead.
		id : "",

		// lang: String
		// Language to display this widget in (like en-us).
		// Defaults to brower's specified preferred language (typically the
		// language of the OS)
		lang : "",

		// dir: String
		// Bi-directional support, as defined by the HTML DIR attribute. Either
		// left-to-right "ltr" or right-to-left "rtl".
		dir : "",

		// class: String
		// HTML class attribute
		"class" : "",

		// style: String
		// HTML style attribute
		style : "",

		// title: String
		// HTML title attribute
		title : "",

		// srcNodeRef: DomNode
		// pointer to original dom node
		srcNodeRef : null,

		// domNode: DomNode
		// this is our visible representation of the widget! Other DOM
		// Nodes may by assigned to other properties, usually through the
		// template system's dojoAttachPonit syntax, but the domNode
		// property is the canonical "top level" node in widget UI.
		domNode : null,

		// attributeMap: Object
		// A map of attributes and attachpoints -- typically standard HTML
		// attributes -- to set
		// on the widget's dom, at the "domNode" attach point, by default.
		// Other node references can be specified as properties of 'this'
		attributeMap : {
			id : "",
			dir : "",
			lang : "",
			"class" : "",
			style : "",
			title : ""
		}, // TODO: add on* handlers?

		// ////////// INITIALIZATION METHODS
		// ///////////////////////////////////////

		postscript : function(params, srcNodeRef) {
			this.create(params, srcNodeRef);
		},

		create : function(params, srcNodeRef) {
			// summary:
			// To understand the process by which widgets are instantiated, it
			// is critical to understand what other methods create calls and
			// which of them you'll want to override. Of course, adventurous
			// developers could override create entirely, but this should
			// only be done as a last resort.
			//
			// Below is a list of the methods that are called, in the order
			// they are fired, along with notes about what they do and if/when
			// you should over-ride them in your widget:
			//			
			// postMixInProperties:
			// a stub function that you can over-ride to modify
			// variables that may have been naively assigned by
			// mixInProperties
			// # widget is added to manager object here
			// buildRendering
			// Subclasses use this method to handle all UI initialization
			// Sets this.domNode. Templated widgets do this automatically
			// and otherwise it just uses the source dom node.
			// postCreate
			// a stub function that you can over-ride to modify take
			// actions once the widget has been placed in the UI

			// store pointer to original dom tree
			this.srcNodeRef = dojo.byId(srcNodeRef);

			// For garbage collection. An array of handles returned by
			// Widget.connect()
			// Each handle returned from Widget.connect() is an array of handles
			// from dojo.connect()
			this._connects = [];

			// _attaches: String[]
			// names of all our dojoAttachPoint variables
			this._attaches = [];

			// mixin our passed parameters
			if (this.srcNodeRef && (typeof this.srcNodeRef.id == "string")) {
				this.id = this.srcNodeRef.id;
			}
			if (params) {
				dojo.mixin(this, params);
			}
			this.postMixInProperties();

			// generate an id for the widget if one wasn't specified
			// (be sure to do this before buildRendering() because that function
			// might
			// expect the id to be there.
			if (!this.id) {
				this.id = dijit.getUniqueId(this.declaredClass.replace(/\./g,
						"_"));
			}
			dijit.registry.add(this);

			this.buildRendering();

			// Copy attributes listed in attributeMap into the [newly created]
			// DOM for the widget.
			// The placement of these attributes is according to the property
			// mapping in attributeMap.
			// Note special handling for 'style' and 'class' attributes which
			// are lists and can
			// have elements from both old and new structures, and some
			// attributes like "type"
			// cannot be processed this way as they are not mutable.
			if (this.domNode) {
				for (var attr in this.attributeMap) {
					var mapNode = this[this.attributeMap[attr] || "domNode"];
					var value = this[attr];
					if (typeof value != "object"
							&& (value !== "" || (params && params[attr]))) {
						switch (attr) {
							case "class" :
								dojo.addClass(mapNode, value);
								break;
							case "style" :
								if (mapNode.style.cssText) {
									mapNode.style.cssText += "; " + value;// FIXME:
																			// Opera
								} else {
									mapNode.style.cssText = value;
								}
								break;
							default :
								mapNode.setAttribute(attr, value);
						}
					}
				}
			}

			if (this.domNode) {
				this.domNode.setAttribute("widgetId", this.id);
			}
			this.postCreate();

			// If srcNodeRef has been processed and removed from the DOM (e.g.
			// TemplatedWidget) then delete it to allow GC.
			if (this.srcNodeRef && !this.srcNodeRef.parentNode) {
				delete this.srcNodeRef;
			}
		},

		postMixInProperties : function() {
			// summary
			// Called after the parameters to the widget have been read-in,
			// but before the widget template is instantiated.
			// Especially useful to set properties that are referenced in the
			// widget template.
		},

		buildRendering : function() {
			// summary:
			// Construct the UI for this widget, setting this.domNode.
			// Most widgets will mixin TemplatedWidget, which overrides this
			// method.
			this.domNode = this.srcNodeRef || dojo.doc.createElement('div');
		},

		postCreate : function() {
			// summary:
			// Called after a widget's dom has been setup
		},

		startup : function() {
			// summary:
			// Called after a widget's children, and other widgets on the page,
			// have been created.
			// Provides an opportunity to manipulate any children before they
			// are displayed
			// This is useful for composite widgets that need to control or
			// layout sub-widgets
			// Many layout widgets can use this as a wiring phase
		},

		// ////////// DESTROY FUNCTIONS ////////////////////////////////

		destroyRecursive : function(/* Boolean */finalize) {
			// summary:
			// Destroy this widget and it's descendants. This is the generic
			// "destructor" function that all widget users should call to
			// cleanly discard with a widget. Once a widget is destroyed, it's
			// removed from the manager object.
			// finalize: Boolean
			// is this function being called part of global environment
			// tear-down?

			this.destroyDescendants();
			this.destroy();
		},

		destroy : function(/* Boolean */finalize) {
			// summary:
			// Destroy this widget, but not its descendants
			// finalize: Boolean
			// is this function being called part of global environment
			// tear-down?
			this.uninitialize();
			dojo.forEach(this._connects, function(array) {
						dojo.forEach(array, dojo.disconnect);
					});
			this.destroyRendering(finalize);
			dijit.registry.remove(this.id);
		},

		destroyRendering : function(/* Boolean */finalize) {
			// summary:
			// Destroys the DOM nodes associated with this widget
			// finalize: Boolean
			// is this function being called part of global environment
			// tear-down?

			if (this.bgIframe) {
				this.bgIframe.destroy();
				delete this.bgIframe;
			}

			if (this.domNode) {
				dojo._destroyElement(this.domNode);
				delete this.domNode;
			}

			if (this.srcNodeRef) {
				dojo._destroyElement(this.srcNodeRef);
				delete this.srcNodeRef;
			}
		},

		destroyDescendants : function() {
			// summary:
			// Recursively destroy the children of this widget and their
			// descendants.

			// TODO: should I destroy in the reverse order, to go bottom up?
			dojo.forEach(this.getDescendants(), function(widget) {
						widget.destroy();
					});
		},

		uninitialize : function() {
			// summary:
			// stub function. Over-ride to implement custom widget tear-down
			// behavior.
			return false;
		},

		// //////////////// MISCELLANEOUS METHODS ///////////////////

		toString : function() {
			// summary:
			// returns a string that represents the widget. When a widget is
			// cast to a string, this method will be used to generate the
			// output. Currently, it does not implement any sort of reversable
			// serialization.
			return '[Widget ' + this.declaredClass + ', '
					+ (this.id || 'NO ID') + ']'; // String
		},

		getDescendants : function() {
			// summary:
			// return all the descendant widgets
			var list = dojo.query('[widgetId]', this.domNode);
			return list.map(dijit.byNode); // Array
		},

		nodesWithKeyClick : ["input", "button"],

		connect : function(
				/* Object|null */obj,
				/* String */event,
				/* String|Function */method) {

			// summary:
			// Connects specified obj/event to specified method of this object
			// and registers for disconnect() on widget destroy.
			// Special event: "ondijitclick" triggers on a click or enter-down
			// or space-up
			// Similar to dojo.connect() but takes three arguments rather than
			// four.
			var handles = [];
			if (event == "ondijitclick") {
				var w = this;
				// add key based click activation for unsupported nodes.
				if (!this.nodesWithKeyClick[obj.nodeName]) {
					handles.push(dojo.connect(obj, "onkeydown", this, function(
									e) {
								if (e.keyCode == dojo.keys.ENTER) {
									return (dojo.isString(method))
											? w[method](e)
											: method.call(w, e);
								} else if (e.keyCode == dojo.keys.SPACE) {
									// stop space down as it causes IE to scroll
									// the browser window
									dojo.stopEvent(e);
								}
							}));
					handles.push(dojo.connect(obj, "onkeyup", this,
							function(e) {
								if (e.keyCode == dojo.keys.SPACE) {
									return dojo.isString(method)
											? w[method](e)
											: method.call(w, e);
								}
							}));
				}
				event = "onclick";
			}
			handles.push(dojo.connect(obj, event, this, method));

			// return handles for FormElement and ComboBox
			this._connects.push(handles);
			return handles;
		},

		disconnect : function(/* Object */handles) {
			// summary:
			// Disconnects handle created by this.connect.
			// Also removes handle from this widget's list of connects
			for (var i = 0; i < this._connects.length; i++) {
				if (this._connects[i] == handles) {
					dojo.forEach(handles, dojo.disconnect);
					this._connects.splice(i, 1);
					return;
				}
			}
		},

		isLeftToRight : function() {
			// summary:
			// Checks the DOM to for the text direction for bi-directional
			// support
			// description:
			// This method cannot be used during widget construction because the
			// widget
			// must first be connected to the DOM tree. Parent nodes are
			// searched for the
			// 'dir' attribute until one is found, otherwise left to right mode
			// is assumed.
			// See HTML spec, DIR attribute for more information.

			if (typeof this._ltr == "undefined") {
				this._ltr = dojo.getComputedStyle(this.domNode).direction != "rtl";
			}
			return this._ltr; // Boolean
		},

		isFocusable : function() {
			// summary:
			// Return true if this widget can currently be focused
			// and false if not
			return this.focus
					&& (dojo.style(this.domNode, "display") != "none");
		}
	});

}

if (!dojo._hasResource["dojo.string"]) { // _hasResource checks added by
											// build. Do not use _hasResource
											// directly in your code.
	dojo._hasResource["dojo.string"] = true;
	dojo.provide("dojo.string");

	dojo.string.pad = function(/* String */text, /* int */size, /* String? */ch, /* boolean? */
			end) {
		// summary:
		// Pad a string to guarantee that it is at least 'size' length by
		// filling with the character 'c' at either the start or end of the
		// string. Pads at the start, by default.
		// text: the string to pad
		// size: length to provide padding
		// ch: character to pad, defaults to '0'
		// end: adds padding at the end if true, otherwise pads at start

		var out = String(text);
		if (!ch) {
			ch = '0';
		}
		while (out.length < size) {
			if (end) {
				out += ch;
			} else {
				out = ch + out;
			}
		}
		return out; // String
	};

	dojo.string.substitute = function( /* String */template,
			/* Object or Array */map,
			/* Function? */transform,
			/* Object? */thisObject) {
		// summary:
		// Performs parameterized substitutions on a string. Throws an
		// exception if any parameter is unmatched.
		// description:
		// For example,
		// | dojo.string.substitute("File '${0}' is not found in directory
		// '${1}'.",["foo.html","/temp"]);
		// | dojo.string.substitute("File '${name}' is not found in directory
		// '${info.dir}'.",{name: "foo.html", info: {dir: "/temp"}});
		// both return
		// "File 'foo.html' is not found in directory '/temp'."
		// template:
		// a string with expressions in the form ${key} to be replaced or
		// ${key:format} which specifies a format function. NOTE syntax has
		// changed from %{key}
		// map: where to look for substitutions
		// transform:
		// a function to process all parameters before substitution takes
		// place, e.g. dojo.string.encodeXML
		// thisObject:
		// where to look for optional format function; default to the global
		// namespace

		return template.replace(/\$\{([^\s\:\}]+)(?:\:([^\s\:\}]+))?\}/g,
				function(match, key, format) {
					var value = dojo.getObject(key, false, map);
					if (format) {
						value = dojo.getObject(format, false, thisObject)(value);
					}
					if (transform) {
						value = transform(value, key);
					}
					return value.toString();
				}); // string
	};

	dojo.string.trim = function(/* String */str) {
		// summary: trims whitespaces from both sides of the string
		// description:
		// This version of trim() was taken from Steven Levithan's blog:
		// http://blog.stevenlevithan.com/archives/faster-trim-javascript.
		// The short yet good-performing version of this function is
		// dojo.trim(), which is part of the base.
		str = str.replace(/^\s+/, '');
		for (var i = str.length - 1; i > 0; i--) {
			if (/\S/.test(str.charAt(i))) {
				str = str.substring(0, i + 1);
				break;
			}
		}
		return str; // String
	};

}

if (!dojo._hasResource["dijit._Templated"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._Templated"] = true;
	dojo.provide("dijit._Templated");

	dojo.declare("dijit._Templated", null, {
		// summary:
		// mixin for widgets that are instantiated from a template

		// templateNode: DomNode
		// a node that represents the widget template. Pre-empts both
		// templateString and templatePath.
		templateNode : null,

		// templateString String:
		// a string that represents the widget template. Pre-empts the
		// templatePath. In builds that have their strings "interned", the
		// templatePath is converted to an inline templateString, thereby
		// preventing a synchronous network call.
		templateString : null,

		// templatePath: String
		// Path to template (HTML file) for this widget
		templatePath : null,

		// widgetsInTemplate Boolean:
		// should we parse the template to find widgets that might be
		// declared in markup inside it? false by default.
		widgetsInTemplate : false,

		// containerNode DomNode:
		// holds child elements. "containerNode" is generally set via a
		// dojoAttachPoint assignment and it designates where children of
		// the src dom node will be placed
		containerNode : null,

		// skipNodeCache Boolean:
		// if using a cached widget template node poses issues for a
		// particular widget class, it can set this property to ensure
		// that its template is always re-built from a string
		_skipNodeCache : false,

		// method over-ride
		buildRendering : function() {
			// summary:
			// Construct the UI for this widget from a template, setting
			// this.domNode.

			// Lookup cached version of template, and download to cache if it
			// isn't there already. Returns either a DomNode or a string,
			// depending on
			// whether or not the template contains ${foo} replacement
			// parameters.
			var cached = dijit._Templated.getCachedTemplate(this.templatePath,
					this.templateString, this._skipNodeCache);

			var node;
			if (dojo.isString(cached)) {
				var className = this.declaredClass, _this = this;
				// Cache contains a string because we need to do property
				// replacement
				// do the property replacement
				var tstr = dojo.string.substitute(cached, this, function(value,
								key) {
							if (key.charAt(0) == '!') {
								value = _this[key.substr(1)];
							}
							if (typeof value == "undefined") {
								throw new Error(className + " template:" + key);
							} // a debugging aide
							if (!value) {
								return "";
							}

							// Substitution keys beginning with ! will skip the
							// transform step,
							// in case a user wishes to insert unescaped markup,
							// e.g. ${!foo}
							return key.charAt(0) == "!" ? value :
									// Safer substitution, see heading
									// "Attribute values" in
									// http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.3.2
									value.toString().replace(/"/g, "&quot;"); // TODO:
																				// add
																				// &amp?
																				// use
																				// encodeXML
																				// method?
						}, this);

				node = dijit._Templated._createNodesFromText(tstr)[0];
			} else {
				// if it's a node, all we have to do is clone it
				node = cached.cloneNode(true);
			}

			// recurse through the node, looking for, and attaching to, our
			// attachment points which should be defined on the template node.
			this._attachTemplateNodes(node);

			var source = this.srcNodeRef;
			if (source && source.parentNode) {
				source.parentNode.replaceChild(node, source);
			}

			this.domNode = node;
			if (this.widgetsInTemplate) {
				var childWidgets = dojo.parser.parse(node);
				this._attachTemplateNodes(childWidgets, function(n, p) {
							return n[p];
						});
			}

			this._fillContent(source);
		},

		_fillContent : function(/* DomNode */source) {
			// summary:
			// relocate source contents to templated container node
			// this.containerNode must be able to receive children, or
			// exceptions will be thrown
			var dest = this.containerNode;
			if (source && dest) {
				while (source.hasChildNodes()) {
					dest.appendChild(source.firstChild);
				}
			}
		},

		_attachTemplateNodes : function(rootNode, getAttrFunc) {
			// summary:
			// map widget properties and functions to the handlers specified in
			// the dom node and it's descendants. This function iterates over
			// all
			// nodes and looks for these properties:
			// * dojoAttachPoint
			// * dojoAttachEvent
			// * waiRole
			// * waiState
			// rootNode: DomNode|Array[Widgets]
			// the node to search for properties. All children will be searched.
			// getAttrFunc: function?
			// a function which will be used to obtain property for a given
			// DomNode/Widget

			getAttrFunc = getAttrFunc || function(n, p) {
				return n.getAttribute(p);
			};

			var nodes = dojo.isArray(rootNode)
					? rootNode
					: (rootNode.all || rootNode.getElementsByTagName("*"));
			var x = dojo.isArray(rootNode) ? 0 : -1;
			for (; x < nodes.length; x++) {
				var baseNode = (x == -1) ? rootNode : nodes[x];
				if (this.widgetsInTemplate && getAttrFunc(baseNode, 'dojoType')) {
					continue;
				}
				// Process dojoAttachPoint
				var attachPoint = getAttrFunc(baseNode, "dojoAttachPoint");
				if (attachPoint) {
					var point, points = attachPoint.split(/\s*,\s*/);
					while (point = points.shift()) {
						if (dojo.isArray(this[point])) {
							this[point].push(baseNode);
						} else {
							this[point] = baseNode;
						}
					}
				}

				// Process dojoAttachEvent
				var attachEvent = getAttrFunc(baseNode, "dojoAttachEvent");
				if (attachEvent) {
					// NOTE: we want to support attributes that have the form
					// "domEvent: nativeEvent; ..."
					var event, events = attachEvent.split(/\s*,\s*/);
					var trim = dojo.trim;
					while (event = events.shift()) {
						if (event) {
							var thisFunc = null;
							if (event.indexOf(":") != -1) {
								// oh, if only JS had tuple assignment
								var funcNameArr = event.split(":");
								event = trim(funcNameArr[0]);
								thisFunc = trim(funcNameArr[1]);
							} else {
								event = trim(event);
							}
							if (!thisFunc) {
								thisFunc = event;
							}
							this.connect(baseNode, event, thisFunc);
						}
					}
				}

				// waiRole, waiState
				var role = getAttrFunc(baseNode, "waiRole");
				if (role) {
					dijit.setWaiRole(baseNode, role);
				}
				var values = getAttrFunc(baseNode, "waiState");
				if (values) {
					dojo.forEach(values.split(/\s*,\s*/), function(stateValue) {
								if (stateValue.indexOf('-') != -1) {
									var pair = stateValue.split('-');
									dijit.setWaiState(baseNode, pair[0],
											pair[1]);
								}
							});
				}

			}
		}
	});

	// key is either templatePath or templateString; object is either string or
	// DOM tree
	dijit._Templated._templateCache = {};

	dijit._Templated.getCachedTemplate = function(templatePath, templateString,
			alwaysUseString) {
		// summary:
		// static method to get a template based on the templatePath or
		// templateString key
		// templatePath: String
		// the URL to get the template from. dojo.uri.Uri is often passed as
		// well.
		// templateString: String?
		// a string to use in lieu of fetching the template from a URL
		// Returns:
		// Either string (if there are ${} variables that need to be replaced)
		// or just
		// a DOM tree (if the node can be cloned directly)

		// is it already cached?
		var tmplts = dijit._Templated._templateCache;
		var key = templateString || templatePath;
		var cached = tmplts[key];
		if (cached) {
			return cached;
		}

		// If necessary, load template string from template path
		if (!templateString) {
			templateString = dijit._Templated._sanitizeTemplateString(dojo
					._getText(templatePath));
		}

		templateString = dojo.string.trim(templateString);

		if (templateString.match(/\$\{([^\}]+)\}/g) || alwaysUseString) {
			// there are variables in the template so all we can do is cache the
			// string
			return (tmplts[key] = templateString); // String
		} else {
			// there are no variables in the template so we can cache the DOM
			// tree
			return (tmplts[key] = dijit._Templated
					._createNodesFromText(templateString)[0]); // Node
		}
	};

	dijit._Templated._sanitizeTemplateString = function(/* String */tString) {
		// summary:
		// Strips <?xml ...?> declarations so that external SVG and XML
		// documents can be added to a document without worry. Also, if the
		// string
		// is an HTML document, only the part inside the body tag is returned.
		if (tString) {
			tString = tString.replace(
					/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
					"");
			var matches = tString.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
			if (matches) {
				tString = matches[1];
			}
		} else {
			tString = "";
		}
		return tString; // String
	};

	if (dojo.isIE) {
		dojo.addOnUnload(function() {
					var cache = dijit._Templated._templateCache;
					for (var key in cache) {
						var value = cache[key];
						if (!isNaN(value.nodeType)) { // isNode equivalent
							dojo._destroyElement(value);
						}
						delete cache[key];
					}
				});
	}

	(function() {
		var tagMap = {
			cell : {
				re : /^<t[dh][\s\r\n>]/i,
				pre : "<table><tbody><tr>",
				post : "</tr></tbody></table>"
			},
			row : {
				re : /^<tr[\s\r\n>]/i,
				pre : "<table><tbody>",
				post : "</tbody></table>"
			},
			section : {
				re : /^<(thead|tbody|tfoot)[\s\r\n>]/i,
				pre : "<table>",
				post : "</table>"
			}
		};

		// dummy container node used temporarily to hold nodes being created
		var tn;

		dijit._Templated._createNodesFromText = function(/* String */text) {
			// summary:
			// Attempts to create a set of nodes based on the structure of the
			// passed text.

			if (!tn) {
				tn = dojo.doc.createElement("div");
				tn.style.display = "none";
				dojo.body().appendChild(tn);
			}
			var tableType = "none";
			var rtext = text.replace(/^\s+/, "");
			for (var type in tagMap) {
				var map = tagMap[type];
				if (map.re.test(rtext)) {
					tableType = type;
					text = map.pre + text + map.post;
					break;
				}
			}

			tn.innerHTML = text;
			if (tn.normalize) {
				tn.normalize();
			}

			var tag = {
				cell : "tr",
				row : "tbody",
				section : "table"
			}[tableType];
			var _parent = (typeof tag != "undefined") ? tn
					.getElementsByTagName(tag)[0] : tn;

			var nodes = [];
			while (_parent.firstChild) {
				nodes.push(_parent.removeChild(_parent.firstChild));
			}
			tn.innerHTML = "";
			return nodes; // Array
		}
	})();

	// These arguments can be specified for widgets which are used in templates.
	// Since any widget can be specified as sub widgets in template, mix it
	// into the base widget class. (This is a hack, but it's effective.)
	dojo.extend(dijit._Widget, {
				dojoAttachEvent : "",
				dojoAttachPoint : "",
				waiRole : "",
				waiState : ""
			})

}

if (!dojo._hasResource["dijit._Container"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dijit._Container"] = true;
	dojo.provide("dijit._Container");

	dojo.declare("dijit._Contained", null, {
				// summary
				// Mixin for widgets that are children of a container widget

				getParent : function() {
					// summary:
					// returns the parent widget of this widget, assuming the
					// parent
					// implements dijit._Container
					for (var p = this.domNode.parentNode; p; p = p.parentNode) {
						var id = p.getAttribute && p.getAttribute("widgetId");
						if (id) {
							var parent = dijit.byId(id);
							return parent.isContainer ? parent : null;
						}
					}
					return null;
				},

				_getSibling : function(which) {
					var node = this.domNode;
					do {
						node = node[which + "Sibling"];
					} while (node && node.nodeType != 1);
					if (!node) {
						return null;
					} // null
					var id = node.getAttribute("widgetId");
					return dijit.byId(id);
				},

				getPreviousSibling : function() {
					// summary:
					// returns null if this is the first child of the parent,
					// otherwise returns the next element sibling to the "left".

					return this._getSibling("previous");
				},

				getNextSibling : function() {
					// summary:
					// returns null if this is the last child of the parent,
					// otherwise returns the next element sibling to the
					// "right".

					return this._getSibling("next");
				}
			});

	dojo.declare("dijit._Container", null, {
				// summary
				// Mixin for widgets that contain a list of children like
				// SplitContainer

				isContainer : true,

				addChild : function(/* Widget */widget, /* int? */insertIndex) {
					// summary:
					// Process the given child widget, inserting it's dom node
					// as
					// a child of our dom node

					if (insertIndex === undefined) {
						insertIndex = "last";
					}
					var refNode = this.containerNode || this.domNode;
					if (insertIndex && typeof insertIndex == "number") {
						var children = dojo.query("> [widgetid]", refNode);
						if (children && children.length >= insertIndex) {
							refNode = children[insertIndex - 1];
							insertIndex = "after";
						}
					}
					dojo.place(widget.domNode, refNode, insertIndex);

					// If I've been started but the child widget hasn't been
					// started,
					// start it now. Make sure to do this after widget has been
					// inserted into the DOM tree, so it can see that it's being
					// controlled by me,
					// so it doesn't try to size itself.
					if (this._started && !widget._started) {
						widget.startup();
					}
				},

				removeChild : function(/* Widget */widget) {
					// summary:
					// removes the passed widget instance from this widget but
					// does
					// not destroy it
					var node = widget.domNode;
					node.parentNode.removeChild(node); // detach but don't
														// destroy
				},

				_nextElement : function(node) {
					do {
						node = node.nextSibling;
					} while (node && node.nodeType != 1);
					return node;
				},

				_firstElement : function(node) {
					node = node.firstChild;
					if (node && node.nodeType != 1) {
						node = this._nextElement(node);
					}
					return node;
				},

				getChildren : function() {
					// summary:
					// Returns array of children widgets
					return dojo.query("> [widgetId]",
							this.containerNode || this.domNode)
							.map(dijit.byNode); // Array
				},

				hasChildren : function() {
					// summary:
					// Returns true if widget has children
					var cn = this.containerNode || this.domNode;
					return !!this._firstElement(cn); // Boolean
				},

				_getSiblingOfChild : function(/* Widget */child, /* int */dir) {
					// summary:
					// get the next or previous widget sibling of child
					// dir:
					// if 1, get the next sibling
					// if -1, get the previous sibling
					var node = child.domNode;
					var which = (dir > 0 ? "nextSibling" : "previousSibling");
					do {
						node = node[which];
					} while (node
							&& (node.nodeType != 1 || !dijit.byNode(node)));
					return node ? dijit.byNode(node) : null;
				}
			});

	dojo.declare("dijit._KeyNavContainer", [dijit._Container], {

				// summary:
				// A _Container with keyboard navigation of its children.
				// To use this mixin, call connectKeyNavHandlers() in
				// postCreate() and call startupKeyNavChildren() in startup().

				/*
				 * ===== // focusedChild: Widget // The currently focused child
				 * widget, or null if there isn't one focusedChild: null, =====
				 */

				_keyNavCodes : {},

				connectKeyNavHandlers : function(/* Array */prevKeyCodes, /* Array */
						nextKeyCodes) {
					// summary:
					// Call in postCreate() to attach the keyboard handlers
					// to the container.
					// preKeyCodes: Array
					// Key codes for navigating to the previous child.
					// nextKeyCodes: Array
					// Key codes for navigating to the next child.

					var keyCodes = this._keyNavCodes = {};
					var prev = dojo.hitch(this, this.focusPrev);
					var next = dojo.hitch(this, this.focusNext);
					dojo.forEach(prevKeyCodes, function(code) {
								keyCodes[code] = prev
							});
					dojo.forEach(nextKeyCodes, function(code) {
								keyCodes[code] = next
							});
					this.connect(this.domNode, "onkeypress",
							"_onContainerKeypress");
					if (dojo.isIE) {
						this.connect(this.domNode, "onactivate",
								"_onContainerFocus");
						this.connect(this.domNode, "ondeactivate",
								"_onContainerBlur");
					} else {
						this.connect(this.domNode, "onfocus",
								"_onContainerFocus");
						this
								.connect(this.domNode, "onblur",
										"_onContainerBlur");
					}
				},

				startupKeyNavChildren : function() {
					// summary:
					// Call in startup() to set child tabindexes to -1
					dojo.forEach(this.getChildren(), dojo.hitch(this,
									"_setTabIndexMinusOne"));
				},

				addChild : function(/* Widget */widget, /* int? */insertIndex) {
					// summary: Add a child to our _Container
					dijit._KeyNavContainer.superclass.addChild.apply(this,
							arguments);
					this._setTabIndexMinusOne(widget);
				},

				focus : function() {
					// summary: Default focus() implementation: focus the first
					// child.
					this.focusFirstChild();
				},

				focusFirstChild : function() {
					// summary: Focus the first focusable child in the
					// container.
					this.focusChild(this._getFirstFocusableChild());
				},

				focusNext : function() {
					// summary: Focus the next widget or focal node (for widgets
					// with multiple focal nodes) within this container.
					if (this.focusedChild && this.focusedChild.hasNextFocalNode
							&& this.focusedChild.hasNextFocalNode()) {
						this.focusedChild.focusNext();
						return;
					}
					var child = this._getNextFocusableChild(this.focusedChild,
							1);
					if (child.getFocalNodes) {
						this.focusChild(child, child.getFocalNodes()[0]);
					} else {
						this.focusChild(child);
					}
				},

				focusPrev : function() {
					// summary: Focus the previous widget or focal node (for
					// widgets
					// with multiple focal nodes) within this container.
					if (this.focusedChild && this.focusedChild.hasPrevFocalNode
							&& this.focusedChild.hasPrevFocalNode()) {
						this.focusedChild.focusPrev();
						return;
					}
					var child = this._getNextFocusableChild(this.focusedChild,
							-1);
					if (child.getFocalNodes) {
						var nodes = child.getFocalNodes();
						this.focusChild(child, nodes[nodes.length - 1]);
					} else {
						this.focusChild(child);
					}
				},

				focusChild : function(/* Widget */widget, /* Node? */node) {
					// summary: Focus widget. Optionally focus 'node' within
					// widget.
					if (widget) {
						if (this.focusedChild && widget !== this.focusedChild) {
							this._onChildBlur(this.focusedChild);
						}
						this.focusedChild = widget;
						if (node && widget.focusFocalNode) {
							widget.focusFocalNode(node);
						} else {
							widget.focus();
						}
					}
				},

				_setTabIndexMinusOne : function(/* Widget */widget) {
					if (widget.getFocalNodes) {
						dojo.forEach(widget.getFocalNodes(), function(node) {
									node.setAttribute("tabIndex", -1);
								});
					} else {
						(widget.focusNode || widget.domNode).setAttribute(
								"tabIndex", -1);
					}
				},

				_onContainerFocus : function(evt) {
					this.domNode.setAttribute("tabIndex", -1);
					if (evt.target === this.domNode) {
						this.focusFirstChild();
					} else {
						var widget = dijit.getEnclosingWidget(evt.target);
						if (widget && widget.isFocusable()) {
							this.focusedChild = widget;
						}
					}
				},

				_onContainerBlur : function(evt) {
					if (this.tabIndex) {
						this.domNode.setAttribute("tabIndex", this.tabIndex);
					}
				},

				_onContainerKeypress : function(evt) {
					if (evt.ctrlKey || evt.altKey) {
						return;
					}
					var func = this._keyNavCodes[evt.keyCode];
					if (func) {
						func();
						dojo.stopEvent(evt);
					}
				},

				_onChildBlur : function(/* Widget */widget) {
					// summary:
					// Called when focus leaves a child widget to go
					// to a sibling widget.
				},

				_getFirstFocusableChild : function() {
					return this._getNextFocusableChild(null, 1);
				},

				_getNextFocusableChild : function(child, dir) {
					if (child) {
						child = this._getSiblingOfChild(child, dir);
					}
					var children = this.getChildren();
					for (var i = 0; i < children.length; i++) {
						if (!child) {
							child = children[(dir > 0)
									? 0
									: (children.length - 1)];
						}
						if (child.isFocusable()) {
							return child;
						}
						child = this._getSiblingOfChild(child, dir);
					}
				}
			});

}

if (!dojo._hasResource["dijit.layout._LayoutWidget"]) { // _hasResource checks
														// added by build. Do
														// not use _hasResource
														// directly in your
														// code.
	dojo._hasResource["dijit.layout._LayoutWidget"] = true;
	dojo.provide("dijit.layout._LayoutWidget");

	dojo.declare("dijit.layout._LayoutWidget", [dijit._Widget,
					dijit._Container, dijit._Contained], {
				// summary
				// Mixin for widgets that contain a list of children like
				// SplitContainer.
				// Widgets which mixin this code must define layout() to lay out
				// the children

				isLayoutContainer : true,

				postCreate : function() {
					dojo.addClass(this.domNode, "dijitContainer");
				},

				startup : function() {
					// summary:
					// Called after all the widgets have been instantiated and
					// their
					// dom nodes have been inserted somewhere under
					// document.body.
					//
					// Widgets should override this method to do any
					// initialization
					// dependent on other widgets existing, and then call
					// this superclass method to finish things off.
					//
					// startup() in subclasses shouldn't do anything
					// size related because the size of the widget hasn't been
					// set yet.

					if (this._started) {
						return;
					}
					this._started = true;

					if (this.getChildren) {
						dojo.forEach(this.getChildren(), function(child) {
									child.startup();
								});
					}

					// If I am a top level widget
					if (!this.getParent || !this.getParent()) {
						// Do recursive sizing and layout of all my descendants
						// (passing in no argument to resize means that it has
						// to glean the size itself)
						this.resize();

						// since my parent isn't a layout container, and my
						// style is width=height=100% (or something similar),
						// then I need to watch when the window resizes, and
						// size myself accordingly
						// (passing in no argument to resize means that it has
						// to glean the size itself)
						this.connect(window, 'onresize', function() {
									this.resize();
								});
					}
				},

				resize : function(args) {
					// summary:
					// Explicitly set this widget's size (in pixels),
					// and then call layout() to resize contents (and maybe
					// adjust child widgets)
					//	
					// args: Object?
					// {w: int, h: int, l: int, t: int}

					var node = this.domNode;

					// set margin box size, unless it wasn't specified, in which
					// case use current size
					if (args) {
						dojo.marginBox(node, args);

						// set offset of the node
						if (args.t) {
							node.style.top = args.t + "px";
						}
						if (args.l) {
							node.style.left = args.l + "px";
						}
					}
					// If either height or width wasn't specified by the user,
					// then query node for it.
					// But note that setting the margin box and then immediately
					// querying dimensions may return
					// inaccurate results, so try not to depend on it.
					var mb = dojo.mixin(dojo.marginBox(node), args || {});

					// Save the size of my content box.
					this._contentBox = dijit.layout.marginBox2contentBox(node,
							mb);

					// Callback for widget to adjust size of it's children
					this.layout();
				},

				layout : function() {
					// summary
					// Widgets override this method to size & position their
					// contents/children.
					// When this is called this._contentBox is guaranteed to be
					// set (see resize()).
					//
					// This is called after startup(), and also when the
					// widget's size has been
					// changed.
				}
			});

	dijit.layout.marginBox2contentBox = function(/* DomNode */node, /* Object */
			mb) {
		// summary:
		// Given the margin-box size of a node, return it's content box size.
		// Functions like dojo.contentBox() but is more reliable since it
		// doesn't have
		// to wait for the browser to compute sizes.
		var cs = dojo.getComputedStyle(node);
		var me = dojo._getMarginExtents(node, cs);
		var pb = dojo._getPadBorderExtents(node, cs);
		return {
			l : dojo._toPixelValue(node, cs.paddingLeft),
			t : dojo._toPixelValue(node, cs.paddingTop),
			w : mb.w - (me.w + pb.w),
			h : mb.h - (me.h + pb.h)
		};
	};

	(function() {
		var capitalize = function(word) {
			return word.substring(0, 1).toUpperCase() + word.substring(1);
		};

		var size = function(widget, dim) {
			// size the child
			widget.resize ? widget.resize(dim) : dojo.marginBox(widget.domNode,
					dim);

			// record child's size, but favor our own numbers when we have them.
			// the browser lies sometimes
			dojo.mixin(widget, dojo.marginBox(widget.domNode));
			dojo.mixin(widget, dim);
		};

		dijit.layout.layoutChildren = function(/* DomNode */container, /* Object */
				dim, /* Object[] */children) {
			/**
			 * summary Layout a bunch of child dom nodes within a parent dom
			 * node container: parent node dim: {l, t, w, h} object specifying
			 * dimensions of container into which to place children children: an
			 * array like [ {domNode: foo, layoutAlign: "bottom" }, {domNode:
			 * bar, layoutAlign: "client"} ]
			 */

			// copy dim because we are going to modify it
			dim = dojo.mixin({}, dim);

			dojo.addClass(container, "dijitLayoutContainer");

			// Move "client" elements to the end of the array for layout. a11y
			// dictates that the author
			// needs to be able to put them in the document in tab-order, but
			// this algorithm requires that
			// client be last.
			children = dojo.filter(children, function(item) {
						return item.layoutAlign != "client";
					}).concat(dojo.filter(children, function(item) {
						return item.layoutAlign == "client";
					}));

			// set positions/sizes
			dojo.forEach(children, function(child) {
						var elm = child.domNode, pos = child.layoutAlign;

						// set elem to upper left corner of unused space; may
						// move it later
						var elmStyle = elm.style;
						elmStyle.left = dim.l + "px";
						elmStyle.top = dim.t + "px";
						elmStyle.bottom = elmStyle.right = "auto";

						dojo.addClass(elm, "dijitAlign" + capitalize(pos));

						// set size && adjust record of remaining space.
						// note that setting the width of a <div> may affect
						// it's height.
						if (pos == "top" || pos == "bottom") {
							size(child, {
										w : dim.w
									});
							dim.h -= child.h;
							if (pos == "top") {
								dim.t += child.h;
							} else {
								elmStyle.top = dim.t + dim.h + "px";
							}
						} else if (pos == "left" || pos == "right") {
							size(child, {
										h : dim.h
									});
							dim.w -= child.w;
							if (pos == "left") {
								dim.l += child.w;
							} else {
								elmStyle.left = dim.l + dim.w + "px";
							}
						} else if (pos == "client") {
							size(child, dim);
						}
					});
		};

	})();

}

if (!dojo._hasResource["dijit.form._FormWidget"]) { // _hasResource checks added
													// by build. Do not use
													// _hasResource directly in
													// your code.
	dojo._hasResource["dijit.form._FormWidget"] = true;
	dojo.provide("dijit.form._FormWidget");

	dojo.declare("dijit.form._FormWidget", [dijit._Widget, dijit._Templated], {
		/*
		 * Summary: FormElement widgets correspond to native HTML elements such
		 * as <input> or <button> or <select>. Each FormElement represents a
		 * single input value, and has a (possibly hidden) <input> element, to
		 * which it serializes its input value, so that form submission (either
		 * normal submission or via FormBind?) works as expected.
		 * 
		 * All these widgets should have these attributes just like native HTML
		 * input elements. You can set them during widget construction, but
		 * after that they are read only.
		 * 
		 * They also share some common methods.
		 */

		// baseClass: String
		// Root CSS class of the widget (ex: dijitTextBox), used to add CSS
		// classes of widget
		// (ex: "dijitTextBox dijitTextBoxInvalid dijitTextBoxFocused
		// dijitTextBoxInvalidFocused")
		// See _setStateClass().
		baseClass : "",

		// value: String
		// Corresponds to the native HTML <input> element's attribute.
		value : "",

		// name: String
		// Name used when submitting form; same as "name" attribute or plain
		// HTML elements
		name : "",

		// id: String
		// Corresponds to the native HTML <input> element's attribute.
		// Also becomes the id for the widget.
		id : "",

		// alt: String
		// Corresponds to the native HTML <input> element's attribute.
		alt : "",

		// type: String
		// Corresponds to the native HTML <input> element's attribute.
		type : "text",

		// tabIndex: Integer
		// Order fields are traversed when user hits the tab key
		tabIndex : "0",

		// disabled: Boolean
		// Should this widget respond to user input?
		// In markup, this is specified as "disabled='disabled'", or just
		// "disabled".
		disabled : false,

		// intermediateChanges: Boolean
		// Fires onChange for each value change or only on demand
		intermediateChanges : false,

		// These mixins assume that the focus node is an INPUT, as many but not
		// all _FormWidgets are.
		// Don't attempt to mixin the 'type', 'name' attributes here
		// programatically -- they must be declared
		// directly in the template as read by the parser in order to function.
		// IE is known to specifically
		// require the 'name' attribute at element creation time.
		attributeMap : dojo.mixin(dojo
						.clone(dijit._Widget.prototype.attributeMap), {
					id : "focusNode",
					tabIndex : "focusNode",
					alt : "focusNode"
				}),

		setDisabled : function(/* Boolean */disabled) {
			// summary:
			// Set disabled state of widget.

			this.domNode.disabled = this.disabled = disabled;
			if (this.focusNode) {
				this.focusNode.disabled = disabled;
			}
			if (disabled) {
				// reset those, because after the domNode is disabled, we can no
				// longer receive
				// mouse related events, see #4200
				this._hovering = false;
				this._active = false;
			}
			dijit.setWaiState(this.focusNode || this.domNode, "disabled",
					disabled);
			this._setStateClass();
		},

		_onMouse : function(/* Event */event) {
			// summary:
			// Sets _hovering, _active, and stateModifier properties depending
			// on mouse state,
			// then calls setStateClass() to set appropriate CSS classes for
			// this.domNode.
			//
			// To get a different CSS class for hover, send onmouseover and
			// onmouseout events to this method.
			// To get a different CSS class while mouse button is depressed,
			// send onmousedown to this method.

			var mouseNode = event.target;
			if (mouseNode && mouseNode.getAttribute) {
				this.stateModifier = mouseNode.getAttribute("stateModifier")
						|| "";
			}

			if (!this.disabled) {
				switch (event.type) {
					case "mouseenter" :
					case "mouseover" :
						this._hovering = true;
						break;

					case "mouseout" :
					case "mouseleave" :
						this._hovering = false;
						break;

					case "mousedown" :
						this._active = true;
						// set a global event to handle mouseup, so it fires
						// properly
						// even if the cursor leaves the button
						var self = this;
						// #2685: use this.connect and disconnect so destroy
						// works properly
						var mouseUpConnector = this.connect(dojo.body(),
								"onmouseup", function() {
									self._active = false;
									self._setStateClass();
									self.disconnect(mouseUpConnector);
								});
						break;
				}
				this._setStateClass();
			}
		},

		isFocusable : function() {
			return !this.disabled
					&& (dojo.style(this.domNode, "display") != "none");
		},

		focus : function() {
			dijit.focus(this.focusNode);
		},

		_setStateClass : function() {
			// summary
			// Update the visual state of the widget by setting the css classes
			// on this.domNode
			// (or this.stateNode if defined) by combining this.baseClass with
			// various suffixes that represent the current widget state(s).
			//
			// In the case where a widget has multiple
			// states, it sets the class based on all possible
			// combinations. For example, an invalid form widget that is being
			// hovered
			// will be "dijitInput dijitInputInvalid dijitInputHover
			// dijitInputInvalidHover".
			//
			// For complex widgets with multiple regions, there can be various
			// hover/active states,
			// such as "Hover" or "CloseButtonHover" (for tab buttons).
			// This is controlled by a stateModifier="CloseButton" attribute on
			// the close button node.
			//
			// The widget may have one or more of the following states,
			// determined
			// by this.state, this.checked, this.valid, and this.selected:
			// Error - ValidationTextBox sets this.state to "Error" if the
			// current input value is invalid
			// Checked - ex: a checkmark or a ToggleButton in a checked state,
			// will have this.checked==true
			// Selected - ex: currently selected tab will have
			// this.selected==true
			//
			// In addition, it may have at most one of the following states,
			// based on this.disabled and flags set in _onMouse (this._active,
			// this._hovering, this._focused):
			// Disabled - if the widget is disabled
			// Active - if the mouse (or space/enter key?) is being pressed down
			// Focused - if the widget has focus
			// Hover - if the mouse is over the widget
			//
			// (even if multiple af the above conditions are true we only pick
			// the first matching one)

			// Get original (non state related, non baseClass related) class
			// specified in template
			if (!("staticClass" in this)) {
				this.staticClass = (this.stateNode || this.domNode).className;
			}

			// Compute new set of classes
			var classes = [this.baseClass];

			function multiply(modifier) {
				classes = classes.concat(dojo.map(classes, function(c) {
							return c + modifier;
						}));
			}

			if (this.checked) {
				multiply("Checked");
			}
			if (this.state) {
				multiply(this.state);
			}
			if (this.selected) {
				multiply("Selected");
			}

			// Only one of these four can be applied.
			// Active trumps Focused, Focused trumps Hover, and Disabled trumps
			// all.
			if (this.disabled) {
				multiply("Disabled");
			} else if (this._active) {
				multiply(this.stateModifier + "Active");
			} else {
				if (this._focused) {
					multiply("Focused");
				}
				if ((this.stateModifier || !this._focused) && this._hovering) {
					multiply(this.stateModifier + "Hover");
				}
			}
			(this.stateNode || this.domNode).className = this.staticClass + " "
					+ classes.join(" ");
		},

		onChange : function(newValue) {
			// summary: callback when value is changed
		},

		postCreate : function() {
			this.setValue(this.value, null); // null reserved for initial
												// value
			this.setDisabled(this.disabled);
			this._setStateClass();
		},

		setValue : function(/* anything */newValue, /* Boolean, optional */
				priorityChange) {
			// summary: set the value of the widget.
			this._lastValue = newValue;
			dijit.setWaiState(this.focusNode || this.domNode, "valuenow", this
							.forWaiValuenow());
			if (priorityChange === undefined) {
				priorityChange = true;
			} // setValue with value only should fire onChange
			if (this._lastValueReported == undefined && priorityChange === null) { // don't
																					// report
																					// the
																					// initial
																					// value
				this._lastValueReported = newValue;
			}
			if ((this.intermediateChanges || priorityChange)
					&& ((newValue && newValue.toString)
							? newValue.toString()
							: newValue) !== ((this._lastValueReported && this._lastValueReported.toString)
							? this._lastValueReported.toString()
							: this._lastValueReported)) {
				this._lastValueReported = newValue;
				this.onChange(newValue);
			}
		},

		getValue : function() {
			// summary: get the value of the widget.
			return this._lastValue;
		},

		undo : function() {
			// summary: restore the value to the last value passed to onChange
			this.setValue(this._lastValueReported, false);
		},

		_onKeyPress : function(e) {
			if (e.keyCode == dojo.keys.ESCAPE && !e.shiftKey && !e.ctrlKey
					&& !e.altKey) {
				var v = this.getValue();
				var lv = this._lastValueReported;
				// Equality comparison of objects such as dates are done by
				// reference so
				// two distinct objects are != even if they have the same data.
				// So use
				// toStrings in case the values are objects.
				if ((typeof lv != "undefined")
						&& ((v !== null && v.toString) ? v.toString() : null) !== lv
								.toString()) {
					this.undo();
					dojo.stopEvent(e);
					return false;
				}
			}
			return true;
		},

		forWaiValuenow : function() {
			// summary: returns a value, reflecting the current state of the
			// widget,
			// to be used for the ARIA valuenow.
			// This method may be overridden by subclasses that want
			// to use something other than this.getValue() for valuenow
			return this.getValue();
		}
	});

}

if (!dojo._hasResource["dijit.dijit"]) { // _hasResource checks added by
											// build. Do not use _hasResource
											// directly in your code.
	dojo._hasResource["dijit.dijit"] = true;
	dojo.provide("dijit.dijit");

	// All the stuff in _base (these are the function that are guaranteed
	// available without an explicit dojo.require)

	// And some other stuff that we tend to pull in all the time anyway

}