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

	dojo.require("dojo.fx");

	dojo.require("dijit._Widget");
	dojo.require("dijit._Templated");
	dojo.require("dijit._Container");
	dojo.require("dojo.cookie");

	dojo.declare("dijit._TreeNode", [dijit._Widget, dijit._Templated,
					dijit._Container, dijit._Contained], {
				// summary
				// Single node within a tree

				// item: dojo.data.Item
				// the dojo.data entry this tree represents
				item : null,

				isTreeNode : true,

				// label: String
				// Text of this tree node
				label : "",

				isExpandable : null, // show expando node

				isExpanded : false,

				// state: String
				// dynamic loading-related stuff.
				// When an empty folder node appears, it is "UNCHECKED" first,
				// then after dojo.data query it becomes "LOADING" and, finally
				// "LOADED"
				state : "UNCHECKED",

				templateString : "<div class=\"dijitTreeNode dijitTreeExpandLeaf dijitTreeChildrenNo\" waiRole=\"presentation\"\n\t><span dojoAttachPoint=\"expandoNode\" class=\"dijitTreeExpando\" waiRole=\"presentation\"\n\t></span\n\t><span dojoAttachPoint=\"expandoNodeText\" class=\"dijitExpandoText\" waiRole=\"presentation\"\n\t></span\n\t>\n\t<div dojoAttachPoint=\"contentNode\" class=\"dijitTreeContent\" waiRole=\"presentation\">\n\t\t<div dojoAttachPoint=\"iconNode\" class=\"dijitInline dijitTreeIcon\" waiRole=\"presentation\"></div>\n\t\t<span dojoAttachPoint=\"labelNode\" class=\"dijitTreeLabel\" wairole=\"treeitem\" tabindex=\"-1\"></span>\n\t</div>\n</div>\n",

				postCreate : function() {
					// set label, escaping special characters
					this.setLabelNode(this.label);

					// set expand icon for leaf
					this._setExpando();

					// set icon and label class based on item
					this._updateItemClasses(this.item);

					if (this.isExpandable) {
						dijit.setWaiState(this.labelNode, "expanded",
								this.isExpanded);
					}
				},

				markProcessing : function() {
					// summary: visually denote that tree is loading data, etc.
					this.state = "LOADING";
					this._setExpando(true);
				},

				unmarkProcessing : function() {
					// summary: clear markup from markProcessing() call
					this._setExpando(false);
				},

				_updateItemClasses : function(item) {
					// summary: set appropriate CSS classes for item (used to
					// allow for item updates to change respective CSS)
					this.iconNode.className = "dijitInline dijitTreeIcon "
							+ this.tree.getIconClass(item);
					this.labelNode.className = "dijitTreeLabel "
							+ this.tree.getLabelClass(item);
				},

				_updateLayout : function() {
					// summary: set appropriate CSS classes for this.domNode
					var parent = this.getParent();
					if (parent && parent.isTree && parent._hideRoot) {
						/*
						 * if we are hiding the root node then make every first
						 * level child look like a root node
						 */
						dojo.addClass(this.domNode, "dijitTreeIsRoot");
					} else {
						dojo.toggleClass(this.domNode, "dijitTreeIsLast", !this
										.getNextSibling());
					}
				},

				_setExpando : function(/* Boolean */processing) {
					// summary: set the right image for the expando node

					// apply the appropriate class to the expando node
					var styles = ["dijitTreeExpandoLoading",
							"dijitTreeExpandoOpened", "dijitTreeExpandoClosed",
							"dijitTreeExpandoLeaf"];
					var idx = processing ? 0 : (this.isExpandable
							? (this.isExpanded ? 1 : 2)
							: 3);
					dojo.forEach(styles, function(s) {
								dojo.removeClass(this.expandoNode, s);
							}, this);
					dojo.addClass(this.expandoNode, styles[idx]);

					// provide a non-image based indicator for images-off mode
					this.expandoNodeText.innerHTML = processing
							? "*"
							: (this.isExpandable
									? (this.isExpanded ? "-" : "+")
									: "*");
				},

				expand : function() {
					// summary: show my children
					if (this.isExpanded) {
						return;
					}
					// cancel in progress collapse operation
					if (this._wipeOut.status() == "playing") {
						this._wipeOut.stop();
					}

					this.isExpanded = true;
					dijit.setWaiState(this.labelNode, "expanded", "true");
					dijit.setWaiRole(this.containerNode, "group");

					this._setExpando();

					this._wipeIn.play();
				},

				collapse : function() {
					if (!this.isExpanded) {
						return;
					}

					// cancel in progress expand operation
					if (this._wipeIn.status() == "playing") {
						this._wipeIn.stop();
					}

					this.isExpanded = false;
					dijit.setWaiState(this.labelNode, "expanded", "false");
					this._setExpando();

					this._wipeOut.play();
				},

				setLabelNode : function(label) {
					this.labelNode.innerHTML = "";
					this.labelNode.appendChild(document.createTextNode(label));
				},

				_setChildren : function(/* Object[] */childrenArray) {
					// summary:
					// Sets the children of this node.
					// Sets this.isExpandable based on whether or not there are
					// children
					// Takes array of objects like: {label: ...} (_TreeNode
					// options basically)
					// See parameters of _TreeNode for details.

					this.destroyDescendants();

					this.state = "LOADED";
					var nodeMap = {};
					if (childrenArray && childrenArray.length > 0) {
						this.isExpandable = true;
						if (!this.containerNode) { // maybe this node was
													// unfolderized and still
													// has container
							this.containerNode = this.tree.containerNodeTemplate
									.cloneNode(true);
							this.domNode.appendChild(this.containerNode);
						}

						// Create _TreeNode widget for each specified tree node
						dojo.forEach(childrenArray, function(childParams) {
									var child = new dijit._TreeNode(dojo.mixin(
											{
												tree : this.tree,
												label : this.tree
														.getLabel(childParams.item)
											}, childParams));
									this.addChild(child);
									var identity = this.tree.store
											.getIdentity(childParams.item);
									nodeMap[identity] = child;
									if (this.tree.persist) {
										if (this.tree._openedItemIds[identity]) {
											this.tree._expandNode(child);
										}
									}
								}, this);

						// note that updateLayout() needs to be called on each
						// child after
						// _all_ the children exist
						dojo.forEach(this.getChildren(), function(child, idx) {
									child._updateLayout();
								});
					} else {
						this.isExpandable = false;
					}

					if (this._setExpando) {
						// change expando to/form dot or + icon, as appropriate
						this._setExpando(false);
					}

					if (this.isTree && this._hideRoot) {
						// put first child in tab index if one exists.
						var fc = this.getChildren()[0];
						var tabnode = fc ? fc.labelNode : this.domNode;
						tabnode.setAttribute("tabIndex", "0");
					}

					// create animations for showing/hiding the children (if
					// children exist)
					if (this.containerNode && !this._wipeIn) {
						this._wipeIn = dojo.fx.wipeIn({
									node : this.containerNode,
									duration : 150
								});
						this._wipeOut = dojo.fx.wipeOut({
									node : this.containerNode,
									duration : 150
								});
					}

					return nodeMap;
				},

				_addChildren : function(/* object[] */childrenArray) {
					// summary:
					// adds the children to this node.
					// Takes array of objects like: {label: ...} (_TreeNode
					// options basically)

					// See parameters of _TreeNode for details.
					var nodeMap = {};
					if (childrenArray && childrenArray.length > 0) {
						dojo.forEach(childrenArray, function(childParams) {
							var child = new dijit._TreeNode(dojo.mixin({
												tree : this.tree,
												label : this.tree
														.getLabel(childParams.item)
											}, childParams));
							this.addChild(child);
							nodeMap[this.tree.store
									.getIdentity(childParams.item)] = child;
						}, this);

						dojo.forEach(this.getChildren(), function(child, idx) {
									child._updateLayout();
								});
					}

					return nodeMap;
				},

				deleteNode : function(/* treeNode */node) {
					node.destroy();

					var children = this.getChildren();
					if (children.length == 0) {
						this.isExpandable = false;
						this.collapse();
					}

					dojo.forEach(children, function(child) {
								child._updateLayout();
							});
				},

				makeExpandable : function() {
					// summary
					// if this node wasn't already showing the expando node,
					// turn it into one and call _setExpando()
					this.isExpandable = true;
					this._setExpando(false);
				}
			});

	dojo.declare("dijit.Tree", dijit._TreeNode, {
		// summary
		// This widget displays hierarchical data from a store. A query is
		// specified
		// to get the "top level children" from a data store, and then those
		// items are
		// queried for their children and so on (but lazily, as the user clicks
		// the expand node).
		//
		// Thus in the default mode of operation this widget is technically a
		// forest, not a tree,
		// in that there can be multiple "top level children". However, if you
		// specify label,
		// then a special top level node (not corresponding to any item in the
		// datastore) is
		// created, to father all the top level children.

		// store: String||dojo.data.Store
		// The store to get data to display in the tree
		store : null,

		// query: String
		// query to get top level node(s) of tree (ex: {type:'continent'})
		query : null,

		// childrenAttr: String
		// one ore more attributes that holds children of a tree node
		childrenAttr : ["children"],

		templateString : "<div class=\"dijitTreeContainer\" style=\"\" waiRole=\"tree\"\n\tdojoAttachEvent=\"onclick:_onClick,onkeypress:_onKeyPress\">\n\t<div class=\"dijitTreeNode  dijitTreeIsRoot dijitTreeExpandLeaf dijitTreeChildrenNo\" waiRole=\"presentation\"\n\t\tdojoAttachPoint=\"rowNode\"\n\t\t><span dojoAttachPoint=\"expandoNode\" class=\"dijitTreeExpando\" waiRole=\"presentation\"\n\t\t></span\n\t\t><span dojoAttachPoint=\"expandoNodeText\" class=\"dijitExpandoText\" waiRole=\"presentation\"\n\t\t></span\n\t\t>\n\t\t<div dojoAttachPoint=\"contentNode\" class=\"dijitTreeContent\" waiRole=\"presentation\">\n\t\t\t<div dojoAttachPoint=\"iconNode\" class=\"dijitInline dijitTreeIcon\" waiRole=\"presentation\"></div>\n\t\t\t<span dojoAttachPoint=\"labelNode\" class=\"dijitTreeLabel\" wairole=\"treeitem\" tabindex=\"0\"></span>\n\t\t</div>\n\t</div>\n</div>\n",

		isExpandable : true,

		isTree : true,

		// persist: Boolean
		// enables/disables use of cookies for state saving.
		persist : true,

		// dndController: String
		// class name to use as as the dnd controller
		dndController : null,

		// parameters to pull off of the tree and pass on to the dndController
		// as its params
		dndParams : ["onDndDrop", "itemCreator", "onDndCancel",
				"checkAcceptance", "checkItemAcceptance"],

		// declare the above items so they can be pulled from the tree's markup
		onDndDrop : null,
		itemCreator : null,
		onDndCancel : null,
		checkAcceptance : null,
		checkItemAcceptance : null,

		_publish : function(/* String */topicName, /* Object */message) {
			// summary:
			// Publish a message for this widget/topic
			dojo.publish(this.id, [dojo.mixin({
								tree : this,
								event : topicName
							}, message || {})]);
		},

		postMixInProperties : function() {
			this.tree = this;
			this.lastFocused = this.labelNode;

			this._itemNodeMap = {};

			this._hideRoot = !this.label;

			if (!this.store.getFeatures()['dojo.data.api.Identity']) {
				throw new Error("dijit.tree requires access to a store supporting the dojo.data Identity api");
			}

			if (!this.cookieName) {
				this.cookieName = this.id + "SaveStateCookie";
			}

			// if the store supports Notification, subscribe to the notification
			// events
			if (this.store.getFeatures()['dojo.data.api.Notification']) {
				this.connect(this.store, "onNew", "_onNewItem");
				this.connect(this.store, "onDelete", "_onDeleteItem");
				this.connect(this.store, "onSet", "_onSetItem");
			}
		},

		postCreate : function() {
			// load in which nodes should be opened automatically
			if (this.persist) {
				var cookie = dojo.cookie(this.cookieName);
				this._openedItemIds = {};
				if (cookie) {
					dojo.forEach(cookie.split(','), function(item) {
								this._openedItemIds[item] = true;
							}, this);
				}
			}

			// make template for container node (we will clone this and insert
			// it into
			// any nodes that have children)
			var div = document.createElement('div');
			div.style.display = 'none';
			div.className = "dijitTreeContainer";
			dijit.setWaiRole(div, "presentation");
			this.containerNodeTemplate = div;

			if (this._hideRoot) {
				this.rowNode.style.display = "none";
			}

			this.inherited("postCreate", arguments);

			// load top level children
			this._expandNode(this);

			if (this.dndController) {
				if (dojo.isString(this.dndController)) {
					this.dndController = dojo.getObject(this.dndController);
				}
				var params = {};
				for (var i = 0; i < this.dndParams.length; i++) {
					if (this[this.dndParams[i]]) {
						params[this.dndParams[i]] = this[this.dndParams[i]];
					}
				}
				this.dndController = new this.dndController(this, params);
			}

			this.connect(this.domNode, dojo.isIE ? "onactivate" : "onfocus",
					"_onTreeFocus");
		},

		// //////////// Data store related functions //////////////////////

		mayHaveChildren : function(/* dojo.data.Item */item) {
			// summary
			// User overridable function to tell if an item has or may have
			// children.
			// Controls whether or not +/- expando icon is shown.
			// (For efficiency reasons we may not want to check if an element
			// has
			// children until user clicks the expando node)

			return dojo.some(this.childrenAttr, function(attr) {
						return this.store.hasAttribute(item, attr);
					}, this);
		},

		getItemChildren : function(/* dojo.data.Item */parentItem, /* function(items) */
				onComplete) {
			// summary
			// User overridable function that return array of child items of
			// given parent item,
			// or if parentItem==null then return top items in tree
			var store = this.store;
			if (parentItem == null) {
				// get top level nodes
				store.fetch({
							query : this.query,
							onComplete : onComplete
						});
			} else {
				// get children of specified node
				var childItems = [];
				for (var i = 0; i < this.childrenAttr.length; i++) {
					childItems = childItems.concat(store.getValues(parentItem,
							this.childrenAttr[i]));
				}
				// count how many items need to be loaded
				var _waitCount = 0;
				dojo.forEach(childItems, function(item) {
							if (!store.isItemLoaded(item)) {
								_waitCount++;
							}
						});

				if (_waitCount == 0) {
					// all items are already loaded. proceed..
					onComplete(childItems);
				} else {
					// still waiting for some or all of the items to load
					function onItem(item) {
						if (--_waitCount == 0) {
							// all nodes have been loaded, send them to the tree
							onComplete(childItems);
						}
					}
					dojo.forEach(childItems, function(item) {
								if (!store.isItemLoaded(item)) {
									store.loadItem({
												item : item,
												onItem : onItem
											});
								}
							});
				}
			}
		},

		getItemParentIdentity : function(/* dojo.data.Item */item, /* Object */
				parentInfo) {
			// summary
			// User overridable function, to return id of parent (or null if top
			// level).
			// It's called with args from dojo.store.onNew
			return this.store.getIdentity(parentInfo.item); // String
		},

		getLabel : function(/* dojo.data.Item */item) {
			// summary: user overridable function to get the label for a tree
			// node (given the item)
			return this.store.getLabel(item); // String
		},

		getIconClass : function(/* dojo.data.Item */item) {
			// summary: user overridable function to return CSS class name to
			// display icon
		},

		getLabelClass : function(/* dojo.data.Item */item) {
			// summary: user overridable function to return CSS class name to
			// display label
		},

		_onLoadAllItems : function(/* _TreeNode */node, /* dojo.data.Item[] */
				items) {
			// sumary: callback when all the children of a given node have been
			// loaded
			var childParams = dojo.map(items, function(item) {
						return {
							item : item,
							isExpandable : this.mayHaveChildren(item)
						};
					}, this);

			dojo.mixin(this._itemNodeMap, node._setChildren(childParams));

			this._expandNode(node);
		},

		// ///////// Keyboard and Mouse handlers ////////////////////

		_onKeyPress : function(/* Event */e) {
			// summary: translates keypress events into commands for the
			// controller
			if (e.altKey) {
				return;
			}
			var treeNode = dijit.getEnclosingWidget(e.target);
			if (!treeNode) {
				return;
			}

			// Note: On IE e.keyCode is not 0 for printables so check
			// e.charCode.
			// In dojo charCode is universally 0 for non-printables.
			if (e.charCode) { // handle printables (letter navigation)
				// Check for key navigation.
				var navKey = e.charCode;
				if (!e.altKey && !e.ctrlKey && !e.shiftKey && !e.metaKey) {
					navKey = (String.fromCharCode(navKey)).toLowerCase();
					this._onLetterKeyNav({
								node : treeNode,
								key : navKey
							});
					dojo.stopEvent(e);
				}
			} else { // handle non-printables (arrow keys)
				var map = this._keyHandlerMap;
				if (!map) {
					// setup table mapping keys to events
					map = {};
					map[dojo.keys.ENTER] = "_onEnterKey";
					map[dojo.keys.LEFT_ARROW] = "_onLeftArrow";
					map[dojo.keys.RIGHT_ARROW] = "_onRightArrow";
					map[dojo.keys.UP_ARROW] = "_onUpArrow";
					map[dojo.keys.DOWN_ARROW] = "_onDownArrow";
					map[dojo.keys.HOME] = "_onHomeKey";
					map[dojo.keys.END] = "_onEndKey";
					this._keyHandlerMap = map;
				}
				if (this._keyHandlerMap[e.keyCode]) {
					this[this._keyHandlerMap[e.keyCode]]({
								node : treeNode,
								item : treeNode.item
							});
					dojo.stopEvent(e);
				}
			}
		},

		_onEnterKey : function(/* Object */message) {
			this._publish("execute", {
						item : message.item,
						node : message.node
					});
			this.onClick(message.item, message.node);
		},

		_onDownArrow : function(/* Object */message) {
			// summary: down arrow pressed; get next visible node, set focus
			// there
			var returnNode = this._navToNextNode(message.node);
			if (returnNode && returnNode.isTreeNode) {
				returnNode.tree.focusNode(returnNode);
				return returnNode;
			}
		},

		_onUpArrow : function(/* Object */message) {
			// summary: up arrow pressed; move to previous visible node

			var nodeWidget = message.node;
			var returnWidget = nodeWidget;

			// if younger siblings
			var previousSibling = nodeWidget.getPreviousSibling();
			if (previousSibling) {
				nodeWidget = previousSibling;
				// if the previous nodeWidget is expanded, dive in deep
				while (nodeWidget.isExpandable && nodeWidget.isExpanded
						&& nodeWidget.hasChildren()) {
					returnWidget = nodeWidget;
					// move to the last child
					var children = nodeWidget.getChildren();
					nodeWidget = children[children.length - 1];
				}
			} else {
				// if this is the first child, return the parent
				// unless the parent is the root of a tree with a hidden root
				var parent = nodeWidget.getParent();
				if (!(this._hideRoot && parent === this)) {
					nodeWidget = parent;
				}
			}

			if (nodeWidget && nodeWidget.isTreeNode) {
				returnWidget = nodeWidget;
			}

			if (returnWidget && returnWidget.isTreeNode) {
				returnWidget.tree.focusNode(returnWidget);
				return returnWidget;
			}
		},

		_onRightArrow : function(/* Object */message) {
			// summary: right arrow pressed; go to child node
			var nodeWidget = message.node;
			var returnWidget = nodeWidget;

			// if not expanded, expand, else move to 1st child
			if (nodeWidget.isExpandable && !nodeWidget.isExpanded) {
				this._expandNode(nodeWidget);
			} else if (nodeWidget.hasChildren()) {
				nodeWidget = nodeWidget.getChildren()[0];
			}

			if (nodeWidget && nodeWidget.isTreeNode) {
				returnWidget = nodeWidget;
			}

			if (returnWidget && returnWidget.isTreeNode) {
				returnWidget.tree.focusNode(returnWidget);
				return returnWidget;
			}
		},

		_onLeftArrow : function(/* Object */message) {
			// summary: left arrow pressed; go to parent

			var node = message.node;
			var returnWidget = node;

			// if not collapsed, collapse, else move to parent
			if (node.isExpandable && node.isExpanded) {
				this._collapseNode(node);
			} else {
				node = node.getParent();
			}
			if (node && node.isTreeNode) {
				returnWidget = node;
			}

			if (returnWidget && returnWidget.isTreeNode) {
				returnWidget.tree.focusNode(returnWidget);
				return returnWidget;
			}
		},

		_onHomeKey : function() {
			// summary: home pressed; get first visible node, set focus there
			var returnNode = this._navToRootOrFirstNode();
			if (returnNode) {
				returnNode.tree.focusNode(returnNode);
				return returnNode;
			}
		},

		_onEndKey : function(/* Object */message) {
			// summary: end pressed; go to last visible node

			var returnWidget = message.node.tree;

			var lastChild = returnWidget;
			while (lastChild.isExpanded) {
				var c = lastChild.getChildren();
				lastChild = c[c.length - 1];
				if (lastChild.isTreeNode) {
					returnWidget = lastChild;
				}
			}

			if (returnWidget && returnWidget.isTreeNode) {
				returnWidget.tree.focusNode(returnWidget);
				return returnWidget;
			}
		},

		_onLetterKeyNav : function(message) {
			// summary: letter key pressed; search for node starting with first
			// char = key
			var node = startNode = message.node;
			var key = message.key;
			do {
				node = this._navToNextNode(node);
				// check for last node, jump to first node if necessary
				if (!node) {
					node = this._navToRootOrFirstNode();
				}
			} while (node !== startNode
					&& (node.label.charAt(0).toLowerCase() != key));
			if (node && node.isTreeNode) {
				// no need to set focus if back where we started
				if (node !== startNode) {
					node.tree.focusNode(node);
				}
				return node;
			}
		},

		_onClick : function(/* Event */e) {
			// summary: translates click events into commands for the controller
			// to process
			var domElement = e.target;

			// find node
			var nodeWidget = dijit.getEnclosingWidget(domElement);
			if (!nodeWidget || !nodeWidget.isTreeNode) {
				return;
			}

			if (domElement == nodeWidget.expandoNode
					|| domElement == nodeWidget.expandoNodeText) {
				// expando node was clicked
				if (nodeWidget.isExpandable) {
					this._onExpandoClick({
								node : nodeWidget
							});
				}
			} else {
				this._publish("execute", {
							item : nodeWidget.item,
							node : nodeWidget
						});
				this.onClick(nodeWidget.item, nodeWidget);
				this.focusNode(nodeWidget);
			}
			dojo.stopEvent(e);
		},

		_onExpandoClick : function(/* Object */message) {
			// summary: user clicked the +/- icon; expand or collapse my
			// children.
			var node = message.node;
			if (node.isExpanded) {
				this._collapseNode(node);
			} else {
				this._expandNode(node);
			}
		},

		onClick : function(/* dojo.data */item, /* TreeNode */node) {
			// summary: user overridable function for executing a tree item
		},

		_navToNextNode : function(node) {
			// summary: get next visible node
			var returnNode;
			// if this is an expanded node, get the first child
			if (node.isExpandable && node.isExpanded && node.hasChildren()) {
				returnNode = node.getChildren()[0];
			} else {
				// find a parent node with a sibling
				while (node && node.isTreeNode) {
					returnNode = node.getNextSibling();
					if (returnNode) {
						break;
					}
					node = node.getParent();
				}
			}
			return returnNode;
		},

		_navToRootOrFirstNode : function() {
			// summary: get first visible node
			if (!this._hideRoot) {
				return this;
			} else {
				var returnNode = this.getChildren()[0];
				if (returnNode && returnNode.isTreeNode) {
					return returnNode;
				}
			}
		},

		_collapseNode : function(/* _TreeNode */node) {
			// summary: called when the user has requested to collapse the node

			if (node.isExpandable) {
				if (node.state == "LOADING") {
					// ignore clicks while we are in the process of loading data
					return;
				}
				if (this.lastFocused) {
					// are we collapsing a descendant with focus?
					if (dojo.isDescendant(this.lastFocused.domNode,
							node.domNode)) {
						this.focusNode(node);
					} else {
						// clicking the expando node might have erased focus
						// from
						// the current item; restore it
						this.focusNode(this.lastFocused);
					}
				}
				node.collapse();
				if (this.persist && node.item) {
					delete this._openedItemIds[this.store
							.getIdentity(node.item)];
					this._saveState();
				}
			}
		},

		_expandNode : function(/* _TreeNode */node) {
			// summary: called when the user has requested to expand the node

			// clicking the expando node might have erased focus from the
			// current item; restore it
			var t = node.tree;
			if (t.lastFocused) {
				t.focusNode(t.lastFocused);
			}

			if (!node.isExpandable) {
				return;
			}

			var store = this.store;
			var getValue = this.store.getValue;

			switch (node.state) {
				case "LOADING" :
					// ignore clicks while we are in the process of loading data
					return;

				case "UNCHECKED" :
					// need to load all the children, and then expand
					node.markProcessing();
					var _this = this;
					var onComplete = function(childItems) {
						node.unmarkProcessing();
						_this._onLoadAllItems(node, childItems);
					};
					this.getItemChildren(node.item, onComplete);
					break;

				default :
					// data is already loaded; just proceed
					if (node.expand) { // top level Tree doesn't have expand()
										// method
						node.expand();
						if (this.persist && node.item) {
							this._openedItemIds[this.store
									.getIdentity(node.item)] = true;
							this._saveState();
						}
					}
					break;
			}
		},

		// //////////////// Miscellaneous functions ////////////////

		blurNode : function() {
			// summary
			// Removes focus from the currently focused node (which must be
			// visible).
			// Usually not called directly (just call focusNode() on another
			// node instead)
			var node = this.lastFocused;
			if (!node) {
				return;
			}
			var labelNode = node.labelNode;
			dojo.removeClass(labelNode, "dijitTreeLabelFocused");
			labelNode.setAttribute("tabIndex", "-1");
			this.lastFocused = null;
		},

		focusNode : function(/* _tree.Node */node) {
			// summary
			// Focus on the specified node (which must be visible)

			// set focus so that the label will be voiced using screen readers
			node.labelNode.focus();
		},

		_onBlur : function() {
			// summary:
			// We've moved away from the whole tree. The currently "focused"
			// node
			// (see focusNode above) should remain as the lastFocused node so we
			// can
			// tab back into the tree. Just change CSS to get rid of the dotted
			// border
			// until that time
			if (this.lastFocused) {
				var labelNode = this.lastFocused.labelNode;
				dojo.removeClass(labelNode, "dijitTreeLabelFocused");
			}
		},

		_onTreeFocus : function(evt) {
			var node = dijit.getEnclosingWidget(evt.target);
			if (node != this.lastFocused) {
				this.blurNode();
			}
			var labelNode = node.labelNode;
			// set tabIndex so that the tab key can find this node
			labelNode.setAttribute("tabIndex", "0");
			dojo.addClass(labelNode, "dijitTreeLabelFocused");
			this.lastFocused = node;
		},

		// ////////////// Events from data store //////////////////////////

		_onNewItem : function(/* Object */item, parentInfo) {
			// summary: callback when new item has been added to the store.

			var loadNewItem; // should new item be displayed in tree?

			if (parentInfo) {
				var parent = this._itemNodeMap[this.getItemParentIdentity(item,
						parentInfo)];

				// If new item's parent item not in tree view yet, can safely
				// ignore.
				// Also, if a query of specified parent wouldn't return this
				// item, then ignore.
				if (!parent
						|| dojo
								.indexOf(this.childrenAttr,
										parentInfo.attribute) == -1) {
					return;
				}
			}

			var childParams = {
				item : item,
				isExpandable : this.mayHaveChildren(item)
			};
			if (parent) {
				if (!parent.isExpandable) {
					parent.makeExpandable();
				}
				if (parent.state == "LOADED" || parent.isExpanded) {
					var childrenMap = parent._addChildren([childParams]);
				}
			} else {
				// top level node
				var childrenMap = this._addChildren([childParams]);
			}

			if (childrenMap) {
				dojo.mixin(this._itemNodeMap, childrenMap);
				// this._itemNodeMap[this.store.getIdentity(item)]=child;
			}
		},

		_onDeleteItem : function(/* Object */item) {
			// summary: delete event from the store
			// since the object has just been deleted, we need to
			// use the name directly
			var identity = this.store.getIdentity(item);
			var node = this._itemNodeMap[identity];

			if (node) {
				var parent = node.getParent();
				parent.deleteNode(node);
				this._itemNodeMap[identity] = null;
			}
		},

		_onSetItem : function(/* Object */item) {
			// summary: set data event on an item in the store
			var identity = this.store.getIdentity(item);
			node = this._itemNodeMap[identity];

			if (node) {
				node.setLabelNode(this.getLabel(item));
				node._updateItemClasses(item);
			}
		},

		_saveState : function() {
			// summary: create and save a cookie with the currently expanded
			// nodes identifiers
			if (!this.persist) {
				return;
			}
			var ary = [];
			for (var id in this._openedItemIds) {
				ary.push(id);
			}
			dojo.cookie(this.cookieName, ary.join(","));
		}
	});

}