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

	dojo.require("dijit._tree.dndSelector");
	dojo.require("dojo.dnd.Manager");

	dojo.declare("dijit._tree.dndSource", dijit._tree.dndSelector, {
		// summary: a Source object, which can be used as a DnD source, or a DnD
		// target

		// object attributes (for markup)
		isSource : true,
		copyOnly : false,
		skipForm : false,
		accept : ["text"],

		constructor : function(node, params) {
			// summary: a constructor of the Source
			// node: Node: node or node's id to build the source on
			// params: Object: a dict of parameters, recognized parameters are:
			// isSource: Boolean: can be used as a DnD source, if true; assumed
			// to be "true" if omitted
			// accept: Array: list of accepted types (text strings) for a
			// target; assumed to be ["text"] if omitted
			// horizontal: Boolean: a horizontal container, if true, vertical
			// otherwise or when omitted
			// copyOnly: Boolean: always copy items, if true, use a state of
			// Ctrl key otherwise
			// skipForm: Boolean: don't start the drag operation, if clicked on
			// form elements
			// the rest of parameters are passed to the selector
			if (!params) {
				params = {};
			}
			dojo.mixin(this, params);
			this.isSource = typeof params.isSource == "undefined"
					? true
					: params.isSource;
			var type = params.accept instanceof Array
					? params.accept
					: ["text"];
			this.accept = null;
			if (type.length) {
				this.accept = {};
				for (var i = 0; i < type.length; ++i) {
					this.accept[type[i]] = 1;
				}
			}

			// class-specific variables
			this.isDragging = false;
			this.mouseDown = false;
			this.targetAnchor = null;
			this.targetBox = null;
			this.before = true;

			// states
			this.sourceState = "";
			if (this.isSource) {
				dojo.addClass(this.node, "dojoDndSource");
			}
			this.targetState = "";
			if (this.accept) {
				dojo.addClass(this.node, "dojoDndTarget");
			}
			if (this.horizontal) {
				dojo.addClass(this.node, "dojoDndHorizontal");
			}
			// set up events
			this.topics = [
					dojo.subscribe("/dnd/source/over", this, "onDndSourceOver"),
					dojo.subscribe("/dnd/start", this, "onDndStart"),
					dojo.subscribe("/dnd/drop", this, "onDndDrop"),
					dojo.subscribe("/dnd/cancel", this, "onDndCancel")];
		},

		startup : function() {
		},

		// methods
		checkAcceptance : function(source, nodes) {
			// summary: checks, if the target can accept nodes from this source
			// source: Object: the source which provides items
			// nodes: Array: the list of transferred items
			return true; // Boolean
		},
		copyState : function(keyPressed) {
			// summary: Returns true, if we need to copy items, false to move.
			// It is separated to be overwritten dynamically, if needed.
			// keyPressed: Boolean: the "copy" was pressed
			return this.copyOnly || keyPressed; // Boolean
		},
		destroy : function() {
			// summary: prepares the object to be garbage-collected
			this.inherited("destroy", arguments);
			dojo.forEach(this.topics, dojo.unsubscribe);
			this.targetAnchor = null;
		},

		// markup methods
		markupFactory : function(params, node) {
			params._skipStartup = true;
			return new dijit._tree.dndSource(node, params);
		},

		// mouse event processors
		onMouseMove : function(e) {
			// summary: event processor for onmousemove
			// e: Event: mouse event
			if (this.isDragging && this.targetState == "Disabled") {
				return;
			}
			this.inherited("onMouseMove", arguments);
			var m = dojo.dnd.manager();
			if (this.isDragging) {
				// calculate before/after

				if (this.allowBetween) { // not implemented yet for tree
											// since it has no concept of order
					var before = false;
					if (this.current) {
						if (!this.targetBox
								|| this.targetAnchor != this.current) {
							this.targetBox = {
								xy : dojo.coords(this.current, true),
								w : this.current.offsetWidth,
								h : this.current.offsetHeight
							};
						}
						if (this.horizontal) {
							before = (e.pageX - this.targetBox.xy.x) < (this.targetBox.w / 2);
						} else {
							before = (e.pageY - this.targetBox.xy.y) < (this.targetBox.h / 2);
						}
					}
					if (this.current != this.targetAnchor
							|| before != this.before) {
						this._markTargetAnchor(before);
						m.canDrop(!this.current || m.source != this
								|| !(this.current.id in this.selection));
					}
				}
			} else {
				if (this.mouseDown && this.isSource) {
					var n = this.getSelectedNodes();
					var nodes = [];
					for (var i in n) {
						nodes.push(n[i]);
					}
					if (nodes.length) {
						m.startDrag(this, nodes, this.copyState(dojo.dnd
										.getCopyKeyState(e)));
					}
				}
			}
		},

		onMouseDown : function(e) {
			// summary: event processor for onmousedown
			// e: Event: mouse event
			this.mouseDown = true;
			this.mouseButton = e.button;
			this.inherited("onMouseDown", arguments);
		},

		onMouseUp : function(e) {
			// summary: event processor for onmouseup
			// e: Event: mouse event
			if (this.mouseDown) {
				this.mouseDown = false;
				this.inherited("onMouseUp", arguments);
			}
		},

		onMouseOver : function(e) {
			// summary: event processor for onmouseover
			// e: Event: mouse event
			var n = e.relatedTarget;
			while (n) {
				if (n == this.node) {
					break;
				}
				try {
					n = n.parentNode;
				} catch (x) {
					n = null;
				}
			}
			if (!n) {
				this._changeState("Container", "Over");
				this.onOverEvent();
			}
			n = this._getChildByEvent(e);
			if (this.current == n) {
				return;
			}
			if (this.current) {
				this._removeItemClass(this.current, "Over");
			}
			if (n) {
				this._addItemClass(n, "Over");
				if (this.isDragging) {
					var m = dojo.dnd.manager();
					if (this.checkItemAcceptance(n, m.source)) {
						m
								.canDrop(this.targetState != "Disabled"
										&& (!this.current || m.source != this || !(this.current.id in this.selection)));
					} else {
						m.canDrop(false);
					}
				}
			} else {
				if (this.isDragging) {
					var m = dojo.dnd.manager();
					if (m.source
							&& this.checkAcceptance(m.source, m.source
											.getSelectedNodes())) {
						m
								.canDrop(this.targetState != "Disabled"
										&& (!this.current || m.source != this || !(this.current.id in this.selection)));
					} else {
						m.canDrop(false);
					}
				}
			}
			this.current = n;
		},

		checkItemAcceptance : function(node, source) {
			// summary: stub funciton to be overridden if one wants to check for
			// the ability to drop at the node/item level
			return true;
		},

		// topic event processors
		onDndSourceOver : function(source) {
			// summary: topic event processor for /dnd/source/over, called when
			// detected a current source
			// source: Object: the source which has the mouse over it
			if (this != source) {
				this.mouseDown = false;
				if (this.targetAnchor) {
					this._unmarkTargetAnchor();
				}
			} else if (this.isDragging) {
				var m = dojo.dnd.manager();
				m
						.canDrop(this.targetState != "Disabled"
								&& (!this.current || m.source != this || !(this.current.id in this.selection)));
			}
		},
		onDndStart : function(source, nodes, copy) {
			// summary: topic event processor for /dnd/start, called to initiate
			// the DnD operation
			// source: Object: the source which provides items
			// nodes: Array: the list of transferred items
			// copy: Boolean: copy items, if true, move items otherwise

			if (this.isSource) {
				this._changeState("Source", this == source ? (copy
								? "Copied"
								: "Moved") : "");
			}
			var accepted = this.checkAcceptance(source, nodes);

			this._changeState("Target", accepted ? "" : "Disabled");

			if (accepted) {
				dojo.dnd.manager().overSource(this);
			}

			this.isDragging = true;
		},

		itemCreator : function(nodes) {
			var items = []

			for (var i = 0; i < nodes.length; i++) {
				items.push({
							"name" : nodes[i].textContent,
							"id" : nodes[i].id
						});
			}

			return items;
		},

		onDndDrop : function(source, nodes, copy) {
			// summary: topic event processor for /dnd/drop, called to finish
			// the DnD operation
			// source: Object: the source which provides items
			// nodes: Array: the list of transferred items
			// copy: Boolean: copy items, if true, move items otherwise

			if (this.containerState == "Over") {
				this.isDragging = false;
				var target = this.current;
				var items = this.itemCreator(nodes, target);
				if (!target || target == this.tree.domNode) {
					for (var i = 0; i < items.length; i++) {
						this.tree.store.newItem(items[i], null);
					}
				} else {
					for (var i = 0; i < items.length; i++) {
						pInfo = {
							parent : dijit.getEnclosingWidget(target).item,
							attribute : "children"
						};
						var newItem = this.tree.store.newItem(items[i], pInfo);
						console.log("newItem:", newItem);
					}
				}
			}
			this.onDndCancel();
		},
		onDndCancel : function() {
			// summary: topic event processor for /dnd/cancel, called to cancel
			// the DnD operation
			if (this.targetAnchor) {
				this._unmarkTargetAnchor();
				this.targetAnchor = null;
			}
			this.before = true;
			this.isDragging = false;
			this.mouseDown = false;
			delete this.mouseButton;
			this._changeState("Source", "");
			this._changeState("Target", "");
		},

		// utilities

		onOverEvent : function() {
			// summary: this function is called once, when mouse is over our
			// container
			this.inherited("onOverEvent", arguments);
			dojo.dnd.manager().overSource(this);
		},
		onOutEvent : function() {
			// summary: this function is called once, when mouse is out of our
			// container
			this.inherited("onOutEvent", arguments);
			dojo.dnd.manager().outSource(this);
		},
		_markTargetAnchor : function(before) {
			// summary: assigns a class to the current target anchor based on
			// "before" status
			// before: Boolean: insert before, if true, after otherwise
			if (this.current == this.targetAnchor && this.before == before) {
				return;
			}
			if (this.targetAnchor) {
				this._removeItemClass(this.targetAnchor, this.before
								? "Before"
								: "After");
			}
			this.targetAnchor = this.current;
			this.targetBox = null;
			this.before = before;
			if (this.targetAnchor) {
				this._addItemClass(this.targetAnchor, this.before
								? "Before"
								: "After");
			}
		},
		_unmarkTargetAnchor : function() {
			// summary: removes a class of the current target anchor based on
			// "before" status
			if (!this.targetAnchor) {
				return;
			}
			this._removeItemClass(this.targetAnchor, this.before
							? "Before"
							: "After");
			this.targetAnchor = null;
			this.targetBox = null;
			this.before = true;
		},
		_markDndStatus : function(copy) {
			// summary: changes source's state based on "copy" status
			this._changeState("Source", copy ? "Copied" : "Moved");
		}
	});

	dojo.declare("dijit._tree.dndTarget", dijit._tree.dndSource, {
				// summary: a Target object, which can be used as a DnD target

				constructor : function(node, params) {
					// summary: a constructor of the Target --- see the Source
					// constructor for details
					this.isSource = false;
					dojo.removeClass(this.node, "dojoDndSource");
				},

				// markup methods
				markupFactory : function(params, node) {
					params._skipStartup = true;
					return new dijit._tree.dndTarget(node, params);
				}
			});

}