upgrade Dojo to 1.6.1

1 files changed, 533 insertions, 229 deletions

diff --git a/lib/dijit/tree/dndSource.js b/lib/dijit/tree/dndSource.js
index ef129d9cb..4fc4660cc 100644
--- a/lib/dijit/tree/dndSource.js
+++ b/lib/dijit/tree/dndSource.js
@@ -1,240 +1,544 @@
 /*
-	Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
 	Available via Academic Free License >= 2.1 OR the modified BSD license.
 	see: http://dojotoolkit.org/license for details
 */
 
 
-if(!dojo._hasResource["dijit.tree.dndSource"]){
-dojo._hasResource["dijit.tree.dndSource"]=true;
+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,{isSource:true,accept:["text","treeNode"],copyOnly:false,dragThreshold:5,betweenThreshold:0,constructor:function(_1,_2){
-if(!_2){
-_2={};
-}
-dojo.mixin(this,_2);
-this.isSource=typeof _2.isSource=="undefined"?true:_2.isSource;
-var _3=_2.accept instanceof Array?_2.accept:["text","treeNode"];
-this.accept=null;
-if(_3.length){
-this.accept={};
-for(var i=0;i<_3.length;++i){
-this.accept[_3[i]]=1;
-}
-}
-this.isDragging=false;
-this.mouseDown=false;
-this.targetAnchor=null;
-this.targetBox=null;
-this.dropPosition="";
-this._lastX=0;
-this._lastY=0;
-this.sourceState="";
-if(this.isSource){
-dojo.addClass(this.node,"dojoDndSource");
-}
-this.targetState="";
-if(this.accept){
-dojo.addClass(this.node,"dojoDndTarget");
-}
-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")];
-},checkAcceptance:function(_4,_5){
-return true;
-},copyState:function(_6){
-return this.copyOnly||_6;
-},destroy:function(){
-this.inherited("destroy",arguments);
-dojo.forEach(this.topics,dojo.unsubscribe);
-this.targetAnchor=null;
-},_onDragMouse:function(e){
-var m=dojo.dnd.manager(),_7=this.targetAnchor,_8=this.current,_9=this.currentWidget,_a=this.dropPosition;
-var _b="Over";
-if(_8&&this.betweenThreshold>0){
-if(!this.targetBox||_7!=_8){
-this.targetBox=dojo.position(_8,true);
-}
-if((e.pageY-this.targetBox.y)<=this.betweenThreshold){
-_b="Before";
-}else{
-if((e.pageY-this.targetBox.y)>=(this.targetBox.h-this.betweenThreshold)){
-_b="After";
-}
-}
-}
-if(_8!=_7||_b!=_a){
-if(_7){
-this._removeItemClass(_7,_a);
-}
-if(_8){
-this._addItemClass(_8,_b);
-}
-if(!_8){
-m.canDrop(false);
-}else{
-if(_9==this.tree.rootNode&&_b!="Over"){
-m.canDrop(false);
-}else{
-if(m.source==this&&(_8.id in this.selection)){
-m.canDrop(false);
-}else{
-if(this.checkItemAcceptance(_8,m.source,_b.toLowerCase())&&!this._isParentChildDrop(m.source,_8)){
-m.canDrop(true);
-}else{
-m.canDrop(false);
-}
-}
-}
-}
-this.targetAnchor=_8;
-this.dropPosition=_b;
-}
-},onMouseMove:function(e){
-if(this.isDragging&&this.targetState=="Disabled"){
-return;
-}
-this.inherited(arguments);
-var m=dojo.dnd.manager();
-if(this.isDragging){
-this._onDragMouse(e);
-}else{
-if(this.mouseDown&&this.isSource&&(Math.abs(e.pageX-this._lastX)>=this.dragThreshold||Math.abs(e.pageY-this._lastY)>=this.dragThreshold)){
-var n=this.getSelectedNodes();
-var _c=[];
-for(var i in n){
-_c.push(n[i]);
-}
-if(_c.length){
-m.startDrag(this,_c,this.copyState(dojo.isCopyKey(e)));
-}
-}
-}
-},onMouseDown:function(e){
-this.mouseDown=true;
-this.mouseButton=e.button;
-this._lastX=e.pageX;
-this._lastY=e.pageY;
-this.inherited("onMouseDown",arguments);
-},onMouseUp:function(e){
-if(this.mouseDown){
-this.mouseDown=false;
-this.inherited("onMouseUp",arguments);
-}
-},onMouseOut:function(){
-this.inherited(arguments);
-this._unmarkTargetAnchor();
-},checkItemAcceptance:function(_d,_e,_f){
-return true;
-},onDndSourceOver:function(_10){
-if(this!=_10){
-this.mouseDown=false;
-this._unmarkTargetAnchor();
-}else{
-if(this.isDragging){
-var m=dojo.dnd.manager();
-m.canDrop(false);
-}
-}
-},onDndStart:function(_11,_12,_13){
-if(this.isSource){
-this._changeState("Source",this==_11?(_13?"Copied":"Moved"):"");
-}
-var _14=this.checkAcceptance(_11,_12);
-this._changeState("Target",_14?"":"Disabled");
-if(this==_11){
-dojo.dnd.manager().overSource(this);
-}
-this.isDragging=true;
-},itemCreator:function(_15,_16,_17){
-return dojo.map(_15,function(_18){
-return {"id":_18.id,"name":_18.textContent||_18.innerText||""};
+
+
+/*=====
+dijit.tree.__SourceArgs = function(){
+	// summary:
+	//		A dict of parameters for Tree source configuration.
+	// isSource: Boolean?
+	//		Can be used as a DnD source. Defaults to true.
+	// accept: String[]
+	//		List of accepted types (text strings) for a target; defaults to
+	//		["text", "treeNode"]
+	// copyOnly: Boolean?
+	//		Copy items, if true, use a state of Ctrl key otherwise,
+	// dragThreshold: Number
+	//		The move delay in pixels before detecting a drag; 0 by default
+	// betweenThreshold: Integer
+	//		Distance from upper/lower edge of node to allow drop to reorder nodes
+	this.isSource = isSource;
+	this.accept = accept;
+	this.autoSync = autoSync;
+	this.copyOnly = copyOnly;
+	this.dragThreshold = dragThreshold;
+	this.betweenThreshold = betweenThreshold;
+}
+=====*/
+
+dojo.declare("dijit.tree.dndSource", dijit.tree._dndSelector, {
+	// summary:
+	//		Handles drag and drop operations (as a source or a target) for `dijit.Tree`
+
+	// isSource: [private] Boolean
+	//		Can be used as a DnD source.
+	isSource: true,
+
+	// accept: String[]
+	//		List of accepted types (text strings) for the Tree; defaults to
+	//		["text"]
+	accept: ["text", "treeNode"],
+
+	// copyOnly: [private] Boolean
+	//		Copy items, if true, use a state of Ctrl key otherwise
+	copyOnly: false,
+
+	// dragThreshold: Number
+	//		The move delay in pixels before detecting a drag; 5 by default
+	dragThreshold: 5,
+
+	// betweenThreshold: Integer
+	//		Distance from upper/lower edge of node to allow drop to reorder nodes
+	betweenThreshold: 0,
+
+	constructor: function(/*dijit.Tree*/ tree, /*dijit.tree.__SourceArgs*/ params){
+		// summary:
+		//		a constructor of the Tree DnD Source
+		// tags:
+		//		private
+		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", "treeNode"];
+		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;	// DOMNode corresponding to the currently moused over TreeNode
+		this.targetBox = null;	// coordinates of this.targetAnchor
+		this.dropPosition = "";	// whether mouse is over/after/before this.targetAnchor
+		this._lastX = 0;
+		this._lastY = 0;
+
+		// states
+		this.sourceState = "";
+		if(this.isSource){
+			dojo.addClass(this.node, "dojoDndSource");
+		}
+		this.targetState = "";
+		if(this.accept){
+			dojo.addClass(this.node, "dojoDndTarget");
+		}
+
+		// 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")
+		];
+	},
+
+	// methods
+	checkAcceptance: function(source, nodes){
+		// summary:
+		//		Checks if the target can accept nodes from this source
+		// source: dijit.tree.dndSource
+		//		The source which provides items
+		// nodes: DOMNode[]
+		//		Array of DOM nodes corresponding to nodes being dropped, dijitTreeRow nodes if
+		//		source is a dijit.Tree.
+		// tags:
+		//		extension
+		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" control key was pressed
+		// tags:
+		//		protected
+		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;
+	},
+
+	_onDragMouse: function(e){
+		// summary:
+		//		Helper method for processing onmousemove/onmouseover events while drag is in progress.
+		//		Keeps track of current drop target.
+
+		var m = dojo.dnd.manager(),
+			oldTarget = this.targetAnchor,			// the TreeNode corresponding to TreeNode mouse was previously over
+			newTarget = this.current,				// TreeNode corresponding to TreeNode mouse is currently over
+			oldDropPosition = this.dropPosition;	// the previous drop position (over/before/after)
+
+		// calculate if user is indicating to drop the dragged node before, after, or over
+		// (i.e., to become a child of) the target node
+		var newDropPosition = "Over";
+		if(newTarget && this.betweenThreshold > 0){
+			// If mouse is over a new TreeNode, then get new TreeNode's position and size
+			if(!this.targetBox || oldTarget != newTarget){
+				this.targetBox = dojo.position(newTarget.rowNode, true);
+			}
+			if((e.pageY - this.targetBox.y) <= this.betweenThreshold){
+				newDropPosition = "Before";
+			}else if((e.pageY - this.targetBox.y) >= (this.targetBox.h - this.betweenThreshold)){
+				newDropPosition = "After";
+			}
+		}
+
+		if(newTarget != oldTarget || newDropPosition != oldDropPosition){
+			if(oldTarget){
+				this._removeItemClass(oldTarget.rowNode, oldDropPosition);
+			}
+			if(newTarget){
+				this._addItemClass(newTarget.rowNode, newDropPosition);
+			}
+
+			// Check if it's ok to drop the dragged node on/before/after the target node.
+			if(!newTarget){
+				m.canDrop(false);
+			}else if(newTarget == this.tree.rootNode && newDropPosition != "Over"){
+				// Can't drop before or after tree's root node; the dropped node would just disappear (at least visually)
+				m.canDrop(false);
+			}else if(m.source == this && (newTarget.id in this.selection)){
+				// Guard against dropping onto yourself (TODO: guard against dropping onto your descendant, #7140)
+				m.canDrop(false);
+			}else if(this.checkItemAcceptance(newTarget.rowNode, m.source, newDropPosition.toLowerCase())
+					&& !this._isParentChildDrop(m.source, newTarget.rowNode)){
+				m.canDrop(true);
+			}else{
+				m.canDrop(false);
+			}
+
+			this.targetAnchor = newTarget;
+			this.dropPosition = newDropPosition;
+		}
+	},
+
+	onMouseMove: function(e){
+		// summary:
+		//		Called for any onmousemove events over the Tree
+		// e: Event
+		//		onmousemouse event
+		// tags:
+		//		private
+		if(this.isDragging && this.targetState == "Disabled"){ return; }
+		this.inherited(arguments);
+		var m = dojo.dnd.manager();
+		if(this.isDragging){
+			this._onDragMouse(e);
+		}else{
+			if(this.mouseDown && this.isSource &&
+				 (Math.abs(e.pageX-this._lastX)>=this.dragThreshold || Math.abs(e.pageY-this._lastY)>=this.dragThreshold)){
+				var nodes = this.getSelectedTreeNodes();
+				if(nodes.length){
+					if(nodes.length > 1){
+						//filter out all selected items which has one of their ancestor selected as well
+						var seen = this.selection, i = 0, r = [], n, p;
+						nextitem: while((n = nodes[i++])){
+							for(p = n.getParent(); p && p !== this.tree; p = p.getParent()){
+								if(seen[p.id]){ //parent is already selected, skip this node
+									continue nextitem;
+								}
+							}
+							//this node does not have any ancestors selected, add it
+							r.push(n);
+						}
+						nodes = r;
+					}
+					nodes = dojo.map(nodes, function(n){return n.domNode});
+					m.startDrag(this, nodes, this.copyState(dojo.isCopyKey(e)));
+				}
+			}
+		}
+	},
+
+	onMouseDown: function(e){
+		// summary:
+		//		Event processor for onmousedown
+		// e: Event
+		//		onmousedown event
+		// tags:
+		//		private
+		this.mouseDown = true;
+		this.mouseButton = e.button;
+		this._lastX = e.pageX;
+		this._lastY = e.pageY;
+		this.inherited(arguments);
+	},
+
+	onMouseUp: function(e){
+		// summary:
+		//		Event processor for onmouseup
+		// e: Event
+		//		onmouseup event
+		// tags:
+		//		private
+		if(this.mouseDown){
+			this.mouseDown = false;
+			this.inherited(arguments);
+		}
+	},
+
+	onMouseOut: function(){
+		// summary:
+		//		Event processor for when mouse is moved away from a TreeNode
+		// tags:
+		//		private
+		this.inherited(arguments);
+		this._unmarkTargetAnchor();
+	},
+
+	checkItemAcceptance: function(target, source, position){
+		// summary:
+		//		Stub function to be overridden if one wants to check for the ability to drop at the node/item level
+		// description:
+		//		In the base case, this is called to check if target can become a child of source.
+		//		When betweenThreshold is set, position="before" or "after" means that we
+		//		are asking if the source node can be dropped before/after the target node.
+		// target: DOMNode
+		//		The dijitTreeRoot DOM node inside of the TreeNode that we are dropping on to
+		//		Use dijit.getEnclosingWidget(target) to get the TreeNode.
+		// source: dijit.tree.dndSource
+		//		The (set of) nodes we are dropping
+		// position: String
+		//		"over", "before", or "after"
+		// tags:
+		//		extension
+		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 dijit.tree.dndSource / dojo.dnd.Source which has the mouse over it
+		// tags:
+		//		private
+		if(this != source){
+			this.mouseDown = false;
+			this._unmarkTargetAnchor();
+		}else if(this.isDragging){
+			var m = dojo.dnd.manager();
+			m.canDrop(false);
+		}
+	},
+	onDndStart: function(source, nodes, copy){
+		// summary:
+		//		Topic event processor for /dnd/start, called to initiate the DnD operation
+		// source: Object
+		//		The dijit.tree.dndSource / dojo.dnd.Source which is providing the items
+		// nodes: DomNode[]
+		//		The list of transferred items, dndTreeNode nodes if dragging from a Tree
+		// copy: Boolean
+		//		Copy items, if true, move items otherwise
+		// tags:
+		//		private
+
+		if(this.isSource){
+			this._changeState("Source", this == source ? (copy ? "Copied" : "Moved") : "");
+		}
+		var accepted = this.checkAcceptance(source, nodes);
+
+		this._changeState("Target", accepted ? "" : "Disabled");
+
+		if(this == source){
+			dojo.dnd.manager().overSource(this);
+		}
+
+		this.isDragging = true;
+	},
+
+	itemCreator: function(/*DomNode[]*/ nodes, target, /*dojo.dnd.Source*/ source){
+		// summary:
+		//		Returns objects passed to `Tree.model.newItem()` based on DnD nodes
+		//		dropped onto the tree.   Developer must override this method to enable
+		// 		dropping from external sources onto this Tree, unless the Tree.model's items
+		//		happen to look like {id: 123, name: "Apple" } with no other attributes.
+		// description:
+		//		For each node in nodes[], which came from source, create a hash of name/value
+		//		pairs to be passed to Tree.model.newItem().  Returns array of those hashes.
+		// returns: Object[]
+		//		Array of name/value hashes for each new item to be added to the Tree, like:
+		// |	[
+		// |		{ id: 123, label: "apple", foo: "bar" },
+		// |		{ id: 456, label: "pear", zaz: "bam" }
+		// |	]
+		// tags:
+		//		extension
+
+		// TODO: for 2.0 refactor so itemCreator() is called once per drag node, and
+		// make signature itemCreator(sourceItem, node, target) (or similar).
+
+		return dojo.map(nodes, function(node){
+			return {
+				"id": node.id,
+				"name": node.textContent || node.innerText || ""
+			};
+		}); // Object[]
+	},
+
+	onDndDrop: function(source, nodes, copy){
+		// summary:
+		//		Topic event processor for /dnd/drop, called to finish the DnD operation.
+		// description:
+		//		Updates data store items according to where node was dragged from and dropped
+		//		to.   The tree will then respond to those data store updates and redraw itself.
+		// source: Object
+		//		The dijit.tree.dndSource / dojo.dnd.Source which is providing the items
+		// nodes: DomNode[]
+		//		The list of transferred items, dndTreeNode nodes if dragging from a Tree
+		// copy: Boolean
+		//		Copy items, if true, move items otherwise
+		// tags:
+		//		protected
+		if(this.containerState == "Over"){
+			var tree = this.tree,
+				model = tree.model,
+				target = this.targetAnchor,
+				requeryRoot = false;	// set to true iff top level items change
+
+			this.isDragging = false;
+
+			// Compute the new parent item
+			var targetWidget = target;
+			var newParentItem;
+			var insertIndex;
+			newParentItem = (targetWidget && targetWidget.item) || tree.item;
+			if(this.dropPosition == "Before" || this.dropPosition == "After"){
+				// TODO: if there is no parent item then disallow the drop.
+				// Actually this should be checked during onMouseMove too, to make the drag icon red.
+				newParentItem = (targetWidget.getParent() && targetWidget.getParent().item) || tree.item;
+				// Compute the insert index for reordering
+				insertIndex = targetWidget.getIndexInParent();
+				if(this.dropPosition == "After"){
+					insertIndex = targetWidget.getIndexInParent() + 1;
+				}
+			}else{
+				newParentItem = (targetWidget && targetWidget.item) || tree.item;
+			}
+
+			// If necessary, use this variable to hold array of hashes to pass to model.newItem()
+			// (one entry in the array for each dragged node).
+			var newItemsParams;
+
+			dojo.forEach(nodes, function(node, idx){
+				// dojo.dnd.Item representing the thing being dropped.
+				// Don't confuse the use of item here (meaning a DnD item) with the
+				// uses below where item means dojo.data item.
+				var sourceItem = source.getItem(node.id);
+
+				// Information that's available if the source is another Tree
+				// (possibly but not necessarily this tree, possibly but not
+				// necessarily the same model as this Tree)
+				if(dojo.indexOf(sourceItem.type, "treeNode") != -1){
+					var childTreeNode = sourceItem.data,
+						childItem = childTreeNode.item,
+						oldParentItem = childTreeNode.getParent().item;
+				}
+
+				if(source == this){
+					// This is a node from my own tree, and we are moving it, not copying.
+					// Remove item from old parent's children attribute.
+					// TODO: dijit.tree.dndSelector should implement deleteSelectedNodes()
+					// and this code should go there.
+
+					if(typeof insertIndex == "number"){
+						if(newParentItem == oldParentItem && childTreeNode.getIndexInParent() < insertIndex){
+							insertIndex -= 1;
+						}
+					}
+					model.pasteItem(childItem, oldParentItem, newParentItem, copy, insertIndex);
+				}else if(model.isItem(childItem)){
+					// Item from same model
+					// (maybe we should only do this branch if the source is a tree?)
+					model.pasteItem(childItem, oldParentItem, newParentItem, copy, insertIndex);
+				}else{
+					// Get the hash to pass to model.newItem().  A single call to
+					// itemCreator() returns an array of hashes, one for each drag source node.
+					if(!newItemsParams){
+						newItemsParams = this.itemCreator(nodes, target.rowNode, source);
+					}
+
+					// Create new item in the tree, based on the drag source.
+					model.newItem(newItemsParams[idx], newParentItem, insertIndex);
+				}
+			}, this);
+
+			// Expand the target node (if it's currently collapsed) so the user can see
+			// where their node was dropped.   In particular since that node is still selected.
+			this.tree._expandNode(targetWidget);
+		}
+		this.onDndCancel();
+	},
+
+	onDndCancel: function(){
+		// summary:
+		//		Topic event processor for /dnd/cancel, called to cancel the DnD operation
+		// tags:
+		//		private
+		this._unmarkTargetAnchor();
+		this.isDragging = false;
+		this.mouseDown = false;
+		delete this.mouseButton;
+		this._changeState("Source", "");
+		this._changeState("Target", "");
+	},
+
+	// When focus moves in/out of the entire Tree
+	onOverEvent: function(){
+		// summary:
+		//		This method is called when mouse is moved over our container (like onmouseenter)
+		// tags:
+		//		private
+		this.inherited(arguments);
+		dojo.dnd.manager().overSource(this);
+	},
+	onOutEvent: function(){
+		// summary:
+		//		This method is called when mouse is moved out of our container (like onmouseleave)
+		// tags:
+		//		private
+		this._unmarkTargetAnchor();
+		var m = dojo.dnd.manager();
+		if(this.isDragging){
+			m.canDrop(false);
+		}
+		m.outSource(this);
+
+		this.inherited(arguments);
+	},
+
+	_isParentChildDrop: function(source, targetRow){
+		// summary:
+		//		Checks whether the dragged items are parent rows in the tree which are being
+		//		dragged into their own children.
+		//
+		// source:
+		//		The DragSource object.
+		//
+		// targetRow:
+		//		The tree row onto which the dragged nodes are being dropped.
+		//
+		// tags:
+		//		private
+
+		// If the dragged object is not coming from the tree this widget belongs to,
+		// it cannot be invalid.
+		if(!source.tree || source.tree != this.tree){
+			return false;
+		}
+
+
+		var root = source.tree.domNode;
+		var ids = source.selection;
+
+		var node = targetRow.parentNode;
+
+		// Iterate up the DOM hierarchy from the target drop row,
+		// checking of any of the dragged nodes have the same ID.
+		while(node != root && !ids[node.id]){
+			node = node.parentNode;
+		}
+
+		return node.id && ids[node.id];
+	},
+
+	_unmarkTargetAnchor: function(){
+		// summary:
+		//		Removes hover class of the current target anchor
+		// tags:
+		//		private
+		if(!this.targetAnchor){ return; }
+		this._removeItemClass(this.targetAnchor.rowNode, this.dropPosition);
+		this.targetAnchor = null;
+		this.targetBox = null;
+		this.dropPosition = null;
+	},
+
+	_markDndStatus: function(copy){
+		// summary:
+		//		Changes source's state based on "copy" status
+		this._changeState("Source", copy ? "Copied" : "Moved");
+	}
 });
-},onDndDrop:function(_19,_1a,_1b){
-if(this.containerState=="Over"){
-var _1c=this.tree,_1d=_1c.model,_1e=this.targetAnchor,_1f=false;
-this.isDragging=false;
-var _20=dijit.getEnclosingWidget(_1e);
-var _21;
-var _22;
-_21=(_20&&_20.item)||_1c.item;
-if(this.dropPosition=="Before"||this.dropPosition=="After"){
-_21=(_20.getParent()&&_20.getParent().item)||_1c.item;
-_22=_20.getIndexInParent();
-if(this.dropPosition=="After"){
-_22=_20.getIndexInParent()+1;
-}
-}else{
-_21=(_20&&_20.item)||_1c.item;
-}
-var _23;
-dojo.forEach(_1a,function(_24,idx){
-var _25=_19.getItem(_24.id);
-if(dojo.indexOf(_25.type,"treeNode")!=-1){
-var _26=_25.data,_27=_26.item,_28=_26.getParent().item;
-}
-if(_19==this){
-if(typeof _22=="number"){
-if(_21==_28&&_26.getIndexInParent()<_22){
-_22-=1;
-}
-}
-_1d.pasteItem(_27,_28,_21,_1b,_22);
-}else{
-if(_1d.isItem(_27)){
-_1d.pasteItem(_27,_28,_21,_1b,_22);
-}else{
-if(!_23){
-_23=this.itemCreator(_1a,_1e,_19);
-}
-_1d.newItem(_23[idx],_21,_22);
-}
-}
-},this);
-this.tree._expandNode(_20);
-}
-this.onDndCancel();
-},onDndCancel:function(){
-this._unmarkTargetAnchor();
-this.isDragging=false;
-this.mouseDown=false;
-delete this.mouseButton;
-this._changeState("Source","");
-this._changeState("Target","");
-},onOverEvent:function(){
-this.inherited(arguments);
-dojo.dnd.manager().overSource(this);
-},onOutEvent:function(){
-this._unmarkTargetAnchor();
-var m=dojo.dnd.manager();
-if(this.isDragging){
-m.canDrop(false);
-}
-m.outSource(this);
-this.inherited(arguments);
-},_isParentChildDrop:function(_29,_2a){
-if(!_29.tree||_29.tree!=this.tree){
-return false;
-}
-var _2b=_29.tree.domNode;
-var ids={};
-for(var x in _29.selection){
-ids[_29.selection[x].parentNode.id]=true;
-}
-var _2c=_2a.parentNode;
-while(_2c!=_2b&&(!_2c.id||!ids[_2c.id])){
-_2c=_2c.parentNode;
-}
-return _2c.id&&ids[_2c.id];
-},_unmarkTargetAnchor:function(){
-if(!this.targetAnchor){
-return;
-}
-this._removeItemClass(this.targetAnchor,this.dropPosition);
-this.targetAnchor=null;
-this.targetBox=null;
-this.dropPosition=null;
-},_markDndStatus:function(_2d){
-this._changeState("Source",_2d?"Copied":"Moved");
-}});
+
 }