New build scripts

git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@5282 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261

source/web/scripts/ajax/dojo/src/dnd/DragAndDrop.js

@@ -0,0 +1,264 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+dojo.require("dojo.lang.common");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lang.declare");
+dojo.provide("dojo.dnd.DragAndDrop");
+
+// summary:
+//		Core "interfaces" for the participants in all DnD operations.
+//		Subclasses implement all of the actions outlined by these APIs, with
+//		most of the ones you probably care about being defined in
+//		HtmlDragAndDrop.js, which will be automatically included should you
+//		dojo.require("dojo.dnd.*");.
+//
+//		In addition to the various actor classes, a global manager will be
+//		created/installed at dojo.dnd.dragManager. This manager object is of
+//		type dojo.dnd.DragManager and will be replaced by environment-specific
+//		managers.
+//
+// 		The 3 object types involved in any Drag and Drop operation are:
+//			* DragSource
+//				This is the item that can be selected for dragging. Drag
+//				sources can have "types" to help mediate whether or not various
+//				DropTargets will accept (or reject them). Most dragging actions
+//				are handled by the DragObject which the DragSource generates
+//				from its onDragStart method.
+//			* DragObject
+//				This, along with the manger, does most of the hard work of DnD.
+//				Implementations may rely on DragObject instances to implement
+//				"shadowing", "movement", or other kinds of DnD variations that
+//				affect the visual representation of the drag operation.
+//			* DropTarget
+//				Represents some section of the screen that can accept drag
+//				and drop events. DropTargets keep a list of accepted types
+//				which is checked agains the types of the respective DragSource
+//				objects that pass over it. DropTargets may implement behaviors
+//				that respond to drop events to take application-level actions.
+
+dojo.declare("dojo.dnd.DragSource", null, {
+	// String: 
+	//		what kind of drag source are we? Used to determine if we can be
+	//		dropped on a given DropTarget
+	type: "",
+
+	onDragEnd: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		//		stub handler that is called when dragging finishes.
+	},
+
+	onDragStart: function(/*dojo.dnd.DragEvent*/evt){ // dojo.dnd.DragObject
+		// summary:
+		//		stub handler that is called when dragging starts. Subclasses
+		//		should ensure that onDragStart *always* returns a
+		//		dojo.dnd.DragObject instance.
+	},
+
+	onSelected: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		//		This function gets called when the DOM element was selected for
+		//		dragging by the HtmlDragAndDropManager.
+	},
+
+	unregister: function(){
+		// summary: remove this drag source from the manager
+		dojo.dnd.dragManager.unregisterDragSource(this);
+	},
+
+	reregister: function(){
+		// summary: add this drag source to the manager
+		dojo.dnd.dragManager.registerDragSource(this);
+	}
+});
+
+dojo.declare("dojo.dnd.DragObject", null, {
+	// String: 
+	//		what kind of drag object are we? Used to determine if we can be
+	//		dropped on a given DropTarget
+	type: "",
+	
+	register: function(){
+		// summary: register this DragObject with the manager
+		var dm = dojo.dnd.dragManager;
+		if(dm["registerDragObject"]){ // side-effect prevention
+			dm.registerDragObject(this);
+		}
+	},
+
+	onDragStart: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		// 		over-ridden by subclasses. Gets called directly after being
+		// 		created by the DragSource default action is to clone self as
+		// 		icon
+	},
+
+	onDragMove: function(/*dojo.dnd.DragEvent*/evt){
+		// summary: 
+		//		Implemented by subclasses. Should change the UI for the drag
+		//		icon i.e., "it moves itself"
+	},
+
+	onDragOver: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		//		stub handler that is called when the DragObject instance is
+		//		"over" a DropTarget.
+	},
+
+	onDragOut: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		//		stub handler that is called when the DragObject instance leaves
+		//		a DropTarget.
+	},
+
+	onDragEnd: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		//		stub handler that is called when dragging ends, either through
+		//		dropping or cancelation.
+	},
+
+	// normal aliases
+	onDragLeave: dojo.lang.forward("onDragOut"),
+	onDragEnter: dojo.lang.forward("onDragOver"),
+
+	// non-camel aliases
+	ondragout: dojo.lang.forward("onDragOut"),
+	ondragover: dojo.lang.forward("onDragOver")
+});
+
+dojo.declare("dojo.dnd.DropTarget", null, {
+
+	acceptsType: function(/*String*/type){
+		// summary: 
+		//		determines whether or not this DropTarget will accept the given
+		//		type. The default behavior is to consult this.acceptedTypes and
+		//		if "*" is a member, to always accept the type.
+		if(!dojo.lang.inArray(this.acceptedTypes, "*")){ // wildcard
+			if(!dojo.lang.inArray(this.acceptedTypes, type)) { return false; } // Boolean
+		}
+		return true; // Boolean
+	},
+
+	accepts: function(/*Array*/dragObjects){
+		// summary: 
+		//		determines if we'll accept all members of the passed array of
+		//		dojo.dnd.DragObject instances
+		if(!dojo.lang.inArray(this.acceptedTypes, "*")){ // wildcard
+			for (var i = 0; i < dragObjects.length; i++) {
+				if (!dojo.lang.inArray(this.acceptedTypes,
+					dragObjects[i].type)) { return false; } // Boolean
+			}
+		}
+		return true; // Boolean
+	},
+
+	unregister: function(){
+		// summary: remove from the drag manager
+		dojo.dnd.dragManager.unregisterDropTarget(this);
+	},
+
+	onDragOver: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		//		stub handler that is called when DragObject instances are
+		//		"over" this DropTarget.
+	},
+
+	onDragOut: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		//		stub handler that is called when DragObject instances are
+		//		"leave" this DropTarget.
+	},
+
+	onDragMove: function(/*dojo.dnd.DragEvent*/evt){
+		// summary:
+		//		stub handler that is called when DragObject instances are
+		//		moved across this DropTarget. May fire many times in the course
+		//		of the drag operation but will end after onDragOut
+	},
+
+	onDropStart: function(/*dojo.dnd.DragEvent*/evt){ // Boolean
+		// summary:
+		//		stub handler that is called when DragObject instances are
+		//		dropped on this target. If true is returned from onDropStart,
+		//		dropping proceeds, otherwise it's cancled.
+	},
+
+	onDrop: function(/*dojo.dnd.DragEvent*/evt){
+		// summary: we're getting dropped on!
+	},
+
+	onDropEnd: function(){
+		// summary: dropping is over
+	}
+}, function(){
+	this.acceptedTypes = [];
+});
+
+// NOTE: this interface is defined here for the convenience of the DragManager
+// implementor. It is expected that in most cases it will be satisfied by
+// extending a native event (DOM event in HTML and SVG).
+dojo.dnd.DragEvent = function(){
+	this.dragSource = null;
+	this.dragObject = null;
+	this.target = null;
+	this.eventStatus = "success";
+	//
+	// can be one of:
+	//	[	"dropSuccess", "dropFailure", "dragMove",
+	//		"dragStart", "dragEnter", "dragLeave"]
+	//
+}
+/*
+ *	The DragManager handles listening for low-level events and dispatching
+ *	them to higher-level primitives like drag sources and drop targets. In
+ *	order to do this, it must keep a list of the items.
+ */
+dojo.declare("dojo.dnd.DragManager", null, {
+	// Array: an array of currently selected DragSource objects
+	selectedSources: [],
+	// Array: all DragObjects we know about
+	dragObjects: [],
+	// Array: all DragSources we know about
+	dragSources: [],
+	registerDragSource: function(/*dojo.dnd.DragSource*/ source){
+		// summary: called by DragSource class constructor
+	},
+	// Array: all DropTargets we know about
+	dropTargets: [],
+	registerDropTarget: function(/*dojo.dnd.DropTarget*/ target){
+		// summary: called by DropTarget class constructor
+	},
+	// dojo.dnd.DropTarget:
+	//		what was the last DropTarget instance we left in the drag phase?
+	lastDragTarget: null,
+	// dojo.dnd.DropTarget:
+	//		the DropTarget the mouse is currently over
+	currentDragTarget: null,
+	onKeyDown: function(){
+		// summary: generic handler called by low-level events
+	},
+	onMouseOut: function(){
+		// summary: generic handler called by low-level events
+	},
+	onMouseMove: function(){
+		// summary: generic handler called by low-level events
+	},
+	onMouseUp: function(){
+		// summary: generic handler called by low-level events
+	}
+});
+
+// NOTE: despite the existance of the DragManager class, there will be a
+// singleton drag manager provided by the renderer-specific D&D support code.
+// It is therefore sane for us to assign instance variables to the DragManager
+// prototype
+
+// The renderer-specific file will define the following object:
+// dojo.dnd.dragManager = null;

source/web/scripts/ajax/dojo/src/dnd/HtmlDragAndDrop.js

@@ -0,0 +1,519 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dnd.HtmlDragAndDrop");
+
+dojo.require("dojo.dnd.HtmlDragManager");
+dojo.require("dojo.dnd.DragAndDrop");
+
+dojo.require("dojo.html.*");
+dojo.require("dojo.html.display");
+dojo.require("dojo.html.util");
+dojo.require("dojo.html.selection");
+dojo.require("dojo.html.iframe");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.lfx.*");
+dojo.require("dojo.event.*");
+
+dojo.declare("dojo.dnd.HtmlDragSource", dojo.dnd.DragSource, {
+		dragClass: "", // CSS classname(s) applied to node when it is being dragged
+
+		onDragStart: function(){
+			var dragObj = new dojo.dnd.HtmlDragObject(this.dragObject, this.type);
+			if(this.dragClass){
+				dragObj.dragClass = this.dragClass;
+			}
+
+			if(this.constrainToContainer){
+				dragObj.constrainTo(this.constrainingContainer || this.domNode.parentNode);
+			}
+
+			return dragObj;
+		},
+
+		setDragHandle: function(node){
+			node = dojo.byId(node);
+			dojo.dnd.dragManager.unregisterDragSource(this);
+			this.domNode = node;
+			dojo.dnd.dragManager.registerDragSource(this);
+		},
+
+		setDragTarget: function(node){
+			this.dragObject = node;
+		},
+
+		constrainTo: function(container){
+			this.constrainToContainer = true;
+			if(container){
+				this.constrainingContainer = container;
+			}
+		},
+		
+		/*
+		*
+		* see dojo.dnd.DragSource.onSelected
+		*/
+		onSelected: function(){
+			for(var i=0; i<this.dragObjects.length; i++){
+				dojo.dnd.dragManager.selectedSources.push(new dojo.dnd.HtmlDragSource(this.dragObjects[i]));
+			}
+		},
+
+		/**
+		* Register elements that should be dragged along with
+		* the actual DragSource.
+		*
+		* Example usage:
+		* 	var dragSource = new dojo.dnd.HtmlDragSource(...);
+		*	// add a single element
+		*	dragSource.addDragObjects(dojo.byId('id1'));
+		*	// add multiple elements to drag along
+		*	dragSource.addDragObjects('id2', dojo.byId('id3'));
+		*
+		* el A dom node to add to the drag list.
+		*/
+		addDragObjects: function(/*DOMNode*/ el){
+			for(var i=0; i<arguments.length; i++){
+				this.dragObjects.push(dojo.byId(arguments[i]));
+			}
+		}
+	}, 
+
+	function(node, type){
+		node = dojo.byId(node);
+		this.dragObjects = [];
+		this.constrainToContainer = false;
+		if(node){
+			this.domNode = node;
+			this.dragObject = node;
+			// set properties that might have been clobbered by the mixin
+			this.type = (type)||(this.domNode.nodeName.toLowerCase());
+			dojo.dnd.DragSource.prototype.reregister.call(this);
+		}
+	}
+);
+
+dojo.declare("dojo.dnd.HtmlDragObject", 
+	dojo.dnd.DragObject, 
+	{
+		dragClass: "",
+		opacity: 0.5,
+		createIframe: true,		// workaround IE6 bug
+
+		// if true, node will not move in X and/or Y direction
+		disableX: false,
+		disableY: false,
+
+		createDragNode: function() {
+			var node = this.domNode.cloneNode(true);
+			if(this.dragClass) { dojo.html.addClass(node, this.dragClass); }
+			if(this.opacity < 1) { dojo.html.setOpacity(node, this.opacity); }
+			var ltn = node.tagName.toLowerCase();
+			var isTr = (ltn == "tr");
+			if((isTr)||(ltn == "tbody")){
+				// dojo.debug("Dragging table row")
+				// Create a table for the cloned row
+				var doc = this.domNode.ownerDocument;
+				var table = doc.createElement("table");
+				if(isTr){
+					var tbody = doc.createElement("tbody");
+					table.appendChild(tbody);
+					tbody.appendChild(node);
+				}else{
+					table.appendChild(node);
+				}
+
+				// Set a fixed width to the cloned TDs
+				var tmpSrcTr = ((isTr) ? this.domNode : this.domNode.firstChild);
+				var tmpDstTr = ((isTr) ? node : node.firstChild);
+				var domTds = tdp.childNodes;
+				var cloneTds = tmpDstTr.childNodes;
+				for(var i = 0; i < domTds.length; i++){
+					if((cloneTds[i])&&(cloneTds[i].style)){
+						cloneTds[i].style.width = dojo.html.getContentBox(domTds[i]).width + "px";
+					}
+				}
+				node = table;
+			}
+
+			if((dojo.render.html.ie55||dojo.render.html.ie60) && this.createIframe){
+				with(node.style) {
+					top="0px";
+					left="0px";
+				}
+				var outer = document.createElement("div");
+				outer.appendChild(node);
+				this.bgIframe = new dojo.html.BackgroundIframe(outer);
+				outer.appendChild(this.bgIframe.iframe);
+				node = outer;
+			}
+			node.style.zIndex = 999;
+
+			return node;
+		},
+
+		onDragStart: function(e){
+			dojo.html.clearSelection();
+
+			this.scrollOffset = dojo.html.getScroll().offset;
+			this.dragStartPosition = dojo.html.getAbsolutePosition(this.domNode, true);
+
+			this.dragOffset = {y: this.dragStartPosition.y - e.pageY,
+				x: this.dragStartPosition.x - e.pageX};
+
+			this.dragClone = this.createDragNode();
+
+			this.containingBlockPosition = this.domNode.offsetParent ? 
+				dojo.html.getAbsolutePosition(this.domNode.offsetParent, true) : {x:0, y:0};
+
+			if(this.constrainToContainer){
+				this.constraints = this.getConstraints();
+			}
+
+			// set up for dragging
+			with(this.dragClone.style){
+				position = "absolute";
+				top = this.dragOffset.y + e.pageY + "px";
+				left = this.dragOffset.x + e.pageX + "px";
+			}
+
+			dojo.body().appendChild(this.dragClone);
+
+			dojo.event.topic.publish('dragStart', { source: this } );
+		},
+
+		/** Return min/max x/y (relative to document.body) for this object) **/
+		getConstraints: function(){
+			if(this.constrainingContainer.nodeName.toLowerCase() == 'body'){
+				var viewport = dojo.html.getViewport();
+				var width = viewport.width;
+				var height = viewport.height;
+				var scroll = dojo.html.getScroll().offset;
+				var x = scroll.x;
+				var y = scroll.y;
+			}else{
+				var content = dojo.html.getContentBox(this.constrainingContainer);
+				width = content.width;
+				height = content.height;
+				x =
+					this.containingBlockPosition.x +
+					dojo.html.getPixelValue(this.constrainingContainer, "padding-left", true) +
+					dojo.html.getBorderExtent(this.constrainingContainer, "left");
+				y =
+					this.containingBlockPosition.y +
+					dojo.html.getPixelValue(this.constrainingContainer, "padding-top", true) +
+					dojo.html.getBorderExtent(this.constrainingContainer, "top");
+			}
+
+			// TODO: should handle left/top/right/bottom margin separately; left/top should affect minX/minY
+			var mb = dojo.html.getMarginBox(this.domNode);
+			return {
+				minX: x,
+				minY: y,
+				maxX: x + width - mb.width,
+				maxY: y + height - mb.height
+			}
+		},
+
+		updateDragOffset: function(){
+			var scroll = dojo.html.getScroll().offset;
+			if(scroll.y != this.scrollOffset.y){
+				var diff = scroll.y - this.scrollOffset.y;
+				this.dragOffset.y += diff;
+				this.scrollOffset.y = scroll.y;
+			}
+			if(scroll.x != this.scrollOffset.x){
+				var diff = scroll.x - this.scrollOffset.x;
+				this.dragOffset.x += diff;
+				this.scrollOffset.x = scroll.x;
+			}
+		},
+
+		/** Moves the node to follow the mouse */
+		onDragMove: function(e){
+			this.updateDragOffset();
+			var x = this.dragOffset.x + e.pageX;
+			var y = this.dragOffset.y + e.pageY;
+
+			if (this.constrainToContainer) {
+				if (x < this.constraints.minX) { x = this.constraints.minX; }
+				if (y < this.constraints.minY) { y = this.constraints.minY; }
+				if (x > this.constraints.maxX) { x = this.constraints.maxX; }
+				if (y > this.constraints.maxY) { y = this.constraints.maxY; }
+			}
+
+			this.setAbsolutePosition(x, y);
+
+			dojo.event.topic.publish('dragMove', { source: this } );
+		},
+
+		/**
+		 * Set the position of the drag clone.  (x,y) is relative to <body>.
+		 */
+		setAbsolutePosition: function(x, y){
+			// The drag clone is attached to document.body so this is trivial
+			if(!this.disableY) { this.dragClone.style.top = y + "px"; }
+			if(!this.disableX) { this.dragClone.style.left = x + "px"; }
+		},
+
+
+		/**
+		 * If the drag operation returned a success we remove the clone of
+		 * ourself from the original position. If the drag operation returned
+		 * failure we slide back over to where we came from and end the operation
+		 * with a little grace.
+		 */
+		onDragEnd: function(e){
+			switch(e.dragStatus){
+
+				case "dropSuccess":
+					dojo.html.removeNode(this.dragClone);
+					this.dragClone = null;
+					break;
+
+				case "dropFailure": // slide back to the start
+					var startCoords = dojo.html.getAbsolutePosition(this.dragClone, true);
+					// offset the end so the effect can be seen
+					var endCoords = { left: this.dragStartPosition.x + 1,
+						top: this.dragStartPosition.y + 1};
+
+					// animate
+					var anim = dojo.lfx.slideTo(this.dragClone, endCoords, 300);
+					var dragObject = this;
+					dojo.event.connect(anim, "onEnd", function(e){
+						// pause for a second (not literally) and disappear
+						// dojo.lang.setTimeout(function() {
+								dojo.html.removeNode(dragObject.dragClone);
+								// Allow drag clone to be gc'ed
+								dragObject.dragClone = null;
+						// 	},
+						// 	50);
+					});
+					anim.play();
+					break;
+			}
+
+			dojo.event.topic.publish('dragEnd', { source: this } );
+		},
+
+		constrainTo: function(container){
+			this.constrainToContainer=true;
+			if(container){
+				this.constrainingContainer = container;
+			}else{
+				this.constrainingContainer = this.domNode.parentNode;
+			}
+		}
+	}, 
+	function(node, type){
+		this.domNode = dojo.byId(node);
+		this.type = type;
+		this.constrainToContainer = false;
+		this.dragSource = null;
+		// this.register();
+		dojo.dnd.DragObject.prototype.register.call(this);
+	}
+);
+
+dojo.declare("dojo.dnd.HtmlDropTarget", 
+	dojo.dnd.DropTarget, 
+	{
+		vertical: false,
+		onDragOver: function(e){
+			if(!this.accepts(e.dragObjects)){ return false; }
+
+			// cache the positions of the child nodes
+			this.childBoxes = [];
+			for(var i = 0, child; i < this.domNode.childNodes.length; i++){
+				child = this.domNode.childNodes[i];
+				if(child.nodeType != dojo.html.ELEMENT_NODE){ continue; }
+				var pos = dojo.html.getAbsolutePosition(child, true);
+				var inner = dojo.html.getBorderBox(child);
+				this.childBoxes.push({top: pos.y, bottom: pos.y+inner.height,
+					left: pos.x, right: pos.x+inner.width, height: inner.height, 
+					width: inner.width, node: child});
+			}
+
+			// TODO: use dummy node
+
+			return true;
+		},
+
+		_getNodeUnderMouse: function(e){
+			// find the child
+			for(var i = 0, child; i < this.childBoxes.length; i++){
+				with(this.childBoxes[i]){
+					if (e.pageX >= left && e.pageX <= right &&
+						e.pageY >= top && e.pageY <= bottom){ return i; }
+				}
+			}
+
+			return -1;
+		},
+
+		createDropIndicator: function(){
+			this.dropIndicator = document.createElement("div");
+			with(this.dropIndicator.style){
+				position = "absolute";
+				zIndex = 999;
+				if(this.vertical){
+					borderLeftWidth = "1px";
+					borderLeftColor = "black";
+					borderLeftStyle = "solid";
+					height = dojo.html.getBorderBox(this.domNode).height + "px";
+					top = dojo.html.getAbsolutePosition(this.domNode, true).y + "px";
+				}else{
+					borderTopWidth = "1px";
+					borderTopColor = "black";
+					borderTopStyle = "solid";
+					width = dojo.html.getBorderBox(this.domNode).width + "px";
+					left = dojo.html.getAbsolutePosition(this.domNode, true).x + "px";
+				}
+			}
+		},
+
+		onDragMove: function(e, dragObjects){
+			var i = this._getNodeUnderMouse(e);
+
+			if(!this.dropIndicator){
+				this.createDropIndicator();
+			}
+
+			var gravity = this.vertical ? dojo.html.gravity.WEST : dojo.html.gravity.NORTH;
+			var hide = false;
+			if(i < 0){
+				if(this.childBoxes.length){
+					var before = (dojo.html.gravity(this.childBoxes[0].node, e) & gravity);
+					if(before){ hide = true; }
+				}else{
+					var before = true;
+				}
+			}else{
+				var child = this.childBoxes[i];
+				var before = (dojo.html.gravity(child.node, e) & gravity);
+				if(child.node === dragObjects[0].dragSource.domNode){
+					hide = true;
+				}else{
+					var currentPosChild = before ? 
+							(i>0?this.childBoxes[i-1]:child) : 
+							(i<this.childBoxes.length-1?this.childBoxes[i+1]:child);
+					if(currentPosChild.node === dragObjects[0].dragSource.domNode){
+						hide = true;
+					}
+				}
+			}
+
+			if(hide){
+				this.dropIndicator.style.display="none";
+				return;
+			}else{
+				this.dropIndicator.style.display="";
+			}
+
+			this.placeIndicator(e, dragObjects, i, before);
+
+			if(!dojo.html.hasParent(this.dropIndicator)) {
+				dojo.body().appendChild(this.dropIndicator);
+			}
+		},
+
+		/**
+		 * Position the horizontal line that indicates "insert between these two items"
+		 */
+		placeIndicator: function(e, dragObjects, boxIndex, before) {
+			var targetProperty = this.vertical ? "left" : "top";
+			var child;
+			if(boxIndex < 0){
+				if(this.childBoxes.length){
+					child = before ? this.childBoxes[0]
+						: this.childBoxes[this.childBoxes.length - 1];
+				}else{
+					this.dropIndicator.style[targetProperty] = dojo.html.getAbsolutePosition(this.domNode, true)[this.vertical?"x":"y"] + "px";
+				}
+			}else{
+				child = this.childBoxes[boxIndex];
+			}
+			if(child){
+				this.dropIndicator.style[targetProperty] = (before ? child[targetProperty] : child[this.vertical?"right":"bottom"]) + "px";
+				if(this.vertical){
+					this.dropIndicator.style.height = child.height + "px";
+					this.dropIndicator.style.top = child.top + "px";
+				}else{
+					this.dropIndicator.style.width = child.width + "px";
+					this.dropIndicator.style.left = child.left + "px";
+				}
+			}
+		},
+
+		onDragOut: function(e) {
+			if(this.dropIndicator) {
+				dojo.html.removeNode(this.dropIndicator);
+				delete this.dropIndicator;
+			}
+		},
+
+		/**
+		 * Inserts the DragObject as a child of this node relative to the
+		 * position of the mouse.
+		 *
+		 * @return true if the DragObject was inserted, false otherwise
+		 */
+		onDrop: function(e){
+			this.onDragOut(e);
+
+			var i = this._getNodeUnderMouse(e);
+
+			var gravity = this.vertical ? dojo.html.gravity.WEST : dojo.html.gravity.NORTH;
+			if(i < 0){
+				if(this.childBoxes.length){
+					if(dojo.html.gravity(this.childBoxes[0].node, e) & gravity){
+						return this.insert(e, this.childBoxes[0].node, "before");
+					}else{
+						return this.insert(e, this.childBoxes[this.childBoxes.length-1].node, "after");
+					}
+				}
+				return this.insert(e, this.domNode, "append");
+			}
+
+			var child = this.childBoxes[i];
+			if(dojo.html.gravity(child.node, e) & gravity){
+				return this.insert(e, child.node, "before");
+			}else{
+				return this.insert(e, child.node, "after");
+			}
+		},
+
+		insert: function(e, refNode, position){
+			var node = e.dragObject.domNode;
+
+			if(position == "before"){
+				return dojo.html.insertBefore(node, refNode);
+			}else if(position == "after"){
+				return dojo.html.insertAfter(node, refNode);
+			}else if(position == "append"){
+				refNode.appendChild(node);
+				return true;
+			}
+
+			return false;
+		}
+	}, 
+
+	function(node, types){
+		if(arguments.length == 0){ return; }
+		this.domNode = dojo.byId(node);
+		dojo.dnd.DropTarget.call(this);
+		if(types && dojo.lang.isString(types)) {
+			types = [types];
+		}
+		this.acceptedTypes = types || [];
+		dojo.dnd.dragManager.registerDropTarget(this);
+	}
+);

source/web/scripts/ajax/dojo/src/dnd/HtmlDragCopy.js

@@ -0,0 +1,85 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dnd.HtmlDragCopy");
+dojo.require("dojo.dnd.*");
+
+dojo.declare("dojo.dnd.HtmlDragCopySource", dojo.dnd.HtmlDragSource,
+function(node, type, copyOnce){
+		this.copyOnce = copyOnce;
+		this.makeCopy = true;
+},
+{
+	onDragStart: function(){
+		var dragObj = new dojo.dnd.HtmlDragCopyObject(this.dragObject, this.type, this);
+		if(this.dragClass) { dragObj.dragClass = this.dragClass; }
+
+		if (this.constrainToContainer) {
+			dragObj.constrainTo(this.constrainingContainer || this.domNode.parentNode);
+		}
+
+		return dragObj;
+	},
+	onSelected: function() {
+		for (var i=0; i<this.dragObjects.length; i++) {
+			dojo.dnd.dragManager.selectedSources.push(new dojo.dnd.HtmlDragCopySource(this.dragObjects[i]));
+		}
+	}
+});
+
+dojo.declare("dojo.dnd.HtmlDragCopyObject", dojo.dnd.HtmlDragObject,
+function(dragObject, type, source){
+		this.copySource = source;
+},
+{
+	onDragStart: function(e) {
+		dojo.dnd.HtmlDragCopyObject.superclass.onDragStart.apply(this, arguments);
+		if(this.copySource.makeCopy) {
+			this.sourceNode = this.domNode;
+			this.domNode    = this.domNode.cloneNode(true);
+		}
+	},
+	onDragEnd: function(e){
+		switch(e.dragStatus){
+			case "dropFailure": // slide back to the start
+				var startCoords = dojo.html.getAbsolutePosition(this.dragClone, true);
+				// offset the end so the effect can be seen
+				var endCoords = { left: this.dragStartPosition.x + 1,
+					top: this.dragStartPosition.y + 1};
+
+				// animate
+				var anim = dojo.lfx.slideTo(this.dragClone, endCoords, 500, dojo.lfx.easeOut);
+				var dragObject = this;
+				dojo.event.connect(anim, "onEnd", function (e) {
+					// pause for a second (not literally) and disappear
+					dojo.lang.setTimeout(function() {
+							dojo.html.removeNode(dragObject.dragClone);
+							dragObject.dragClone = null;
+							if(dragObject.copySource.makeCopy) {
+								dojo.html.removeNode(dragObject.domNode);
+								dragObject.domNode = dragObject.sourceNode;
+								dragObject.sourceNode = null;
+							}
+						},
+						200);
+				});
+				anim.play();
+				dojo.event.topic.publish('dragEnd', { source: this } );
+				return;
+		}
+		dojo.dnd.HtmlDragCopyObject.superclass.onDragEnd.apply(this, arguments);
+		this.copySource.dragObject = this.domNode;
+		if(this.copySource.copyOnce){
+			this.copySource.makeCopy = false;
+		}
+		new dojo.dnd.HtmlDragCopySource(this.sourceNode, this.type, this.copySource.copyOnce);
+		this.sourceNode = null;
+	}
+});

source/web/scripts/ajax/dojo/src/dnd/HtmlDragManager.js

@@ -0,0 +1,506 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dnd.HtmlDragManager");
+dojo.require("dojo.dnd.DragAndDrop");
+dojo.require("dojo.event.*");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.html.common");
+dojo.require("dojo.html.layout");
+
+// NOTE: there will only ever be a single instance of HTMLDragManager, so it's
+// safe to use prototype properties for book-keeping.
+dojo.declare("dojo.dnd.HtmlDragManager", dojo.dnd.DragManager, {
+	/**
+	 * There are several sets of actions that the DnD code cares about in the
+	 * HTML context:
+	 *	1.) mouse-down ->
+	 *			(draggable selection)
+	 *			(dragObject generation)
+	 *		mouse-move ->
+	 *			(draggable movement)
+	 *			(droppable detection)
+	 *			(inform droppable)
+	 *			(inform dragObject)
+	 *		mouse-up
+	 *			(inform/destroy dragObject)
+	 *			(inform draggable)
+	 *			(inform droppable)
+	 *	2.) mouse-down -> mouse-down
+	 *			(click-hold context menu)
+	 *	3.) mouse-click ->
+	 *			(draggable selection)
+	 *		shift-mouse-click ->
+	 *			(augment draggable selection)
+	 *		mouse-down ->
+	 *			(dragObject generation)
+	 *		mouse-move ->
+	 *			(draggable movement)
+	 *			(droppable detection)
+	 *			(inform droppable)
+	 *			(inform dragObject)
+	 *		mouse-up
+	 *			(inform draggable)
+	 *			(inform droppable)
+	 *	4.) mouse-up
+	 *			(clobber draggable selection)
+	 */
+	disabled: false, // to kill all dragging!
+	nestedTargets: false,
+	mouseDownTimer: null, // used for click-hold operations
+	dsCounter: 0,
+	dsPrefix: "dojoDragSource",
+
+	// dimension calculation cache for use durring drag
+	dropTargetDimensions: [],
+
+	currentDropTarget: null,
+	// currentDropTargetPoints: null,
+	previousDropTarget: null,
+	_dragTriggered: false,
+
+	selectedSources: [],
+	dragObjects: [],
+	dragSources: [],
+
+	// mouse position properties
+	currentX: null,
+	currentY: null,
+	lastX: null,
+	lastY: null,
+	mouseDownX: null,
+	mouseDownY: null,
+	threshold: 7,
+
+	dropAcceptable: false,
+
+	cancelEvent: function(e){ e.stopPropagation(); e.preventDefault();},
+
+	// method over-rides
+	registerDragSource: function(ds){
+		//dojo.profile.start("register DragSource");
+
+		if(ds["domNode"]){
+			// FIXME: dragSource objects SHOULD have some sort of property that
+			// references their DOM node, we shouldn't just be passing nodes and
+			// expecting it to work.
+			//dojo.profile.start("register DragSource 1");
+			var dp = this.dsPrefix;
+			var dpIdx = dp+"Idx_"+(this.dsCounter++);
+			ds.dragSourceId = dpIdx;
+			this.dragSources[dpIdx] = ds;
+			ds.domNode.setAttribute(dp, dpIdx);
+			//dojo.profile.end("register DragSource 1");
+
+			//dojo.profile.start("register DragSource 2");
+
+			// so we can drag links
+			if(dojo.render.html.ie){
+				//dojo.profile.start("register DragSource IE");
+				
+				dojo.event.browser.addListener(ds.domNode, "ondragstart", this.cancelEvent);
+				// terribly slow
+				//dojo.event.connect(ds.domNode, "ondragstart", this.cancelEvent);
+				//dojo.profile.end("register DragSource IE");
+
+			}
+			//dojo.profile.end("register DragSource 2");
+
+		}
+		//dojo.profile.end("register DragSource");
+	},
+
+	unregisterDragSource: function(ds){
+		if (ds["domNode"]){
+			var dp = this.dsPrefix;
+			var dpIdx = ds.dragSourceId;
+			delete ds.dragSourceId;
+			delete this.dragSources[dpIdx];
+			ds.domNode.setAttribute(dp, null);
+			if(dojo.render.html.ie){
+				dojo.event.browser.removeListener(ds.domNode, "ondragstart", this.cancelEvent);			
+			}
+		}
+	},
+
+	registerDropTarget: function(dt){
+		this.dropTargets.push(dt);
+	},
+
+	unregisterDropTarget: function(dt){
+		var index = dojo.lang.find(this.dropTargets, dt, true);
+		if (index>=0) {
+			this.dropTargets.splice(index, 1);
+		}
+	},
+
+	/**
+	* Get the DOM element that is meant to drag.
+	* Loop through the parent nodes of the event target until
+	* the element is found that was created as a DragSource and 
+	* return it.
+	*
+	* @param event object The event for which to get the drag source.
+	*/
+	getDragSource: function(e){
+		var tn = e.target;
+		if(tn === dojo.body()){ return; }
+		var ta = dojo.html.getAttribute(tn, this.dsPrefix);
+		while((!ta)&&(tn)){
+			tn = tn.parentNode;
+			if((!tn)||(tn === dojo.body())){ return; }
+			ta = dojo.html.getAttribute(tn, this.dsPrefix);
+		}
+		return this.dragSources[ta];
+	},
+
+	onKeyDown: function(e){
+	},
+
+	onMouseDown: function(e){
+		if(this.disabled) { return; }
+
+		// only begin on left click
+		if(dojo.render.html.ie) {
+			if(e.button != 1) { return; }
+		} else if(e.which != 1) {
+			return;
+		}
+
+		var target = e.target.nodeType == dojo.html.TEXT_NODE ?
+			e.target.parentNode : e.target;
+
+		// do not start drag involvement if the user is interacting with
+		// a form element.
+		if(dojo.html.isTag(target, "button", "textarea", "input", "select", "option")) {
+			return;
+		}
+
+		// find a selection object, if one is a parent of the source node
+		var ds = this.getDragSource(e);
+		
+		// this line is important.  if we aren't selecting anything then
+		// we need to return now, so preventDefault() isn't called, and thus
+		// the event is propogated to other handling code
+		if(!ds){ return; }
+
+		if(!dojo.lang.inArray(this.selectedSources, ds)){
+			this.selectedSources.push(ds);
+			ds.onSelected();
+		}
+
+ 		this.mouseDownX = e.pageX;
+ 		this.mouseDownY = e.pageY;
+
+		// Must stop the mouse down from being propogated, or otherwise can't
+		// drag links in firefox.
+		// WARNING: preventing the default action on all mousedown events
+		// prevents user interaction with the contents.
+		e.preventDefault();
+
+		dojo.event.connect(document, "onmousemove", this, "onMouseMove");
+	},
+
+	onMouseUp: function(e, cancel){
+		// if we aren't dragging then ignore the mouse-up
+		// (in particular, don't call preventDefault(), because other
+		// code may need to process this event)
+		if(this.selectedSources.length==0){
+			return;
+		}
+
+		this.mouseDownX = null;
+		this.mouseDownY = null;
+		this._dragTriggered = false;
+ 		// e.preventDefault();
+		e.dragSource = this.dragSource;
+		// let ctrl be used for multiselect or another action
+		// if I use same key to trigger treeV3 node selection and here,
+		// I have bugs with drag'n'drop. why ?? no idea..
+		if((!e.shiftKey)&&(!e.ctrlKey)){ 
+		//if(!e.shiftKey){
+			if(this.currentDropTarget) {
+				this.currentDropTarget.onDropStart();
+			}
+			dojo.lang.forEach(this.dragObjects, function(tempDragObj){
+				var ret = null;
+				if(!tempDragObj){ return; }
+				if(this.currentDropTarget) {
+					e.dragObject = tempDragObj;
+
+					// NOTE: we can't get anything but the current drop target
+					// here since the drag shadow blocks mouse-over events.
+					// This is probelematic for dropping "in" something
+					var ce = this.currentDropTarget.domNode.childNodes;
+					if(ce.length > 0){
+						e.dropTarget = ce[0];
+						while(e.dropTarget == tempDragObj.domNode){
+							e.dropTarget = e.dropTarget.nextSibling;
+						}
+					}else{
+						e.dropTarget = this.currentDropTarget.domNode;
+					}
+					if(this.dropAcceptable){
+						ret = this.currentDropTarget.onDrop(e);
+					}else{
+						 this.currentDropTarget.onDragOut(e);
+					}
+				}
+
+				e.dragStatus = this.dropAcceptable && ret ? "dropSuccess" : "dropFailure";
+				// decouple the calls for onDragEnd, so they don't block the execution here
+				// ie. if the onDragEnd would call an alert, the execution here is blocked until the
+				// user has confirmed the alert box and then the rest of the dnd code is executed
+				// while the mouse doesnt "hold" the dragged object anymore ... and so on
+				dojo.lang.delayThese([
+					function() {
+						// in FF1.5 this throws an exception, see 
+						// http://dojotoolkit.org/pipermail/dojo-interest/2006-April/006751.html
+						try{
+							tempDragObj.dragSource.onDragEnd(e)
+						} catch(err) {
+							// since the problem seems passing e, we just copy all 
+							// properties and try the copy ...
+							var ecopy = {};
+							for (var i in e) {
+								if (i=="type") { // the type property contains the exception, no idea why...
+									ecopy.type = "mouseup";
+									continue;
+								}
+								ecopy[i] = e[i];
+							}
+							tempDragObj.dragSource.onDragEnd(ecopy);
+						}
+					}
+					, function() {tempDragObj.onDragEnd(e)}]);
+			}, this);
+
+			this.selectedSources = [];
+			this.dragObjects = [];
+			this.dragSource = null;
+			if(this.currentDropTarget) {
+				this.currentDropTarget.onDropEnd();
+			}
+		} else {
+			//dojo.debug("special click");
+		}
+
+		dojo.event.disconnect(document, "onmousemove", this, "onMouseMove");
+		this.currentDropTarget = null;
+	},
+
+	onScroll: function(){
+		//dojo.profile.start("DNDManager updateoffset");
+		for(var i = 0; i < this.dragObjects.length; i++) {
+			if(this.dragObjects[i].updateDragOffset) {
+				this.dragObjects[i].updateDragOffset();
+			}
+		}
+		//dojo.profile.end("DNDManager updateoffset");
+
+		// TODO: do not recalculate, only adjust coordinates
+		if (this.dragObjects.length) {
+			this.cacheTargetLocations();
+		}
+	},
+
+	_dragStartDistance: function(x, y){
+		if((!this.mouseDownX)||(!this.mouseDownX)){
+			return;
+		}
+		var dx = Math.abs(x-this.mouseDownX);
+		var dx2 = dx*dx;
+		var dy = Math.abs(y-this.mouseDownY);
+		var dy2 = dy*dy;
+		return parseInt(Math.sqrt(dx2+dy2), 10);
+	},
+
+	cacheTargetLocations: function(){
+		dojo.profile.start("cacheTargetLocations");
+
+		this.dropTargetDimensions = [];
+		dojo.lang.forEach(this.dropTargets, function(tempTarget){
+			var tn = tempTarget.domNode;
+			//only cache dropTarget which can accept current dragSource
+			if(!tn || !tempTarget.accepts([this.dragSource])){ return; }
+			var abs = dojo.html.getAbsolutePosition(tn, true);
+			var bb = dojo.html.getBorderBox(tn);
+			this.dropTargetDimensions.push([
+				[abs.x, abs.y],	// upper-left
+				// lower-right
+				[ abs.x+bb.width, abs.y+bb.height ],
+				tempTarget
+			]);
+			//dojo.debug("Cached for "+tempTarget)
+		}, this);
+
+		dojo.profile.end("cacheTargetLocations");
+
+		//dojo.debug("Cache locations")
+	},
+
+	onMouseMove: function(e){
+		if((dojo.render.html.ie)&&(e.button != 1)){
+			// Oooops - mouse up occurred - e.g. when mouse was not over the
+			// window. I don't think we can detect this for FF - but at least
+			// we can be nice in IE.
+			this.currentDropTarget = null;
+			this.onMouseUp(e, true);
+			return;
+		}
+
+		// if we've got some sources, but no drag objects, we need to send
+		// onDragStart to all the right parties and get things lined up for
+		// drop target detection
+
+		if(	(this.selectedSources.length)&&
+			(!this.dragObjects.length) ){
+			var dx;
+			var dy;
+			if(!this._dragTriggered){
+				this._dragTriggered = (this._dragStartDistance(e.pageX, e.pageY) > this.threshold);
+				if(!this._dragTriggered){ return; }
+				dx = e.pageX - this.mouseDownX;
+				dy = e.pageY - this.mouseDownY;
+			}
+
+			// the first element is always our dragSource, if there are multiple
+			// selectedSources (elements that move along) then the first one is the master
+			// and for it the events will be fired etc.
+			this.dragSource = this.selectedSources[0];
+			
+			dojo.lang.forEach(this.selectedSources, function(tempSource){
+				if(!tempSource){ return; }
+				var tdo = tempSource.onDragStart(e);
+				if(tdo){
+					tdo.onDragStart(e);
+
+					// "bump" the drag object to account for the drag threshold
+					tdo.dragOffset.y += dy;
+					tdo.dragOffset.x += dx;
+					tdo.dragSource = tempSource;
+
+					this.dragObjects.push(tdo);
+				}
+			}, this);
+
+			/* clean previous drop target in dragStart */
+			this.previousDropTarget = null;
+
+			this.cacheTargetLocations();
+		}
+
+		// FIXME: we need to add dragSources and dragObjects to e
+		dojo.lang.forEach(this.dragObjects, function(dragObj){
+			if(dragObj){ dragObj.onDragMove(e); }
+		});
+
+		// if we have a current drop target, check to see if we're outside of
+		// it. If so, do all the actions that need doing.
+		if(this.currentDropTarget){
+			//dojo.debug(dojo.html.hasParent(this.currentDropTarget.domNode))
+			var c = dojo.html.toCoordinateObject(this.currentDropTarget.domNode, true);
+			//		var dtp = this.currentDropTargetPoints;
+			var dtp = [
+				[c.x,c.y], [c.x+c.width, c.y+c.height]
+			];
+		}
+
+		if((!this.nestedTargets)&&(dtp)&&(this.isInsideBox(e, dtp))){
+			if(this.dropAcceptable){
+				this.currentDropTarget.onDragMove(e, this.dragObjects);
+			}
+		}else{
+			// FIXME: need to fix the event object!
+			// see if we can find a better drop target
+			var bestBox = this.findBestTarget(e);
+
+			if(bestBox.target === null){
+				if(this.currentDropTarget){
+					this.currentDropTarget.onDragOut(e);
+					this.previousDropTarget = this.currentDropTarget;
+					this.currentDropTarget = null;
+					// this.currentDropTargetPoints = null;
+				}
+				this.dropAcceptable = false;
+				return;
+			}
+
+			if(this.currentDropTarget !== bestBox.target){
+				if(this.currentDropTarget){
+					this.previousDropTarget = this.currentDropTarget;
+					this.currentDropTarget.onDragOut(e);
+				}
+				this.currentDropTarget = bestBox.target;
+				// this.currentDropTargetPoints = bestBox.points;
+				e.dragObjects = this.dragObjects;
+				this.dropAcceptable = this.currentDropTarget.onDragOver(e);
+
+			}else{
+				if(this.dropAcceptable){
+					this.currentDropTarget.onDragMove(e, this.dragObjects);
+				}
+			}
+		}
+	},
+
+	findBestTarget: function(e) {
+		var _this = this;
+		var bestBox = new Object();
+		bestBox.target = null;
+		bestBox.points = null;
+		dojo.lang.every(this.dropTargetDimensions, function(tmpDA) {
+			if(!_this.isInsideBox(e, tmpDA)){
+				return true;
+			}
+
+			bestBox.target = tmpDA[2];
+			bestBox.points = tmpDA;
+			// continue iterating only if _this.nestedTargets == true
+			return Boolean(_this.nestedTargets);
+		});
+
+		return bestBox;
+	},
+
+	isInsideBox: function(e, coords){
+		if(	(e.pageX > coords[0][0])&&
+			(e.pageX < coords[1][0])&&
+			(e.pageY > coords[0][1])&&
+			(e.pageY < coords[1][1]) ){
+			return true;
+		}
+		return false;
+	},
+
+	onMouseOver: function(e){
+	},
+
+	onMouseOut: function(e){
+	}
+});
+
+dojo.dnd.dragManager = new dojo.dnd.HtmlDragManager();
+
+// global namespace protection closure
+(function(){
+	var d = document;
+	var dm = dojo.dnd.dragManager;
+	//TODO: when focus manager is ready, dragManager should be rewritten to use it
+	// set up event handlers on the document (or no?)
+	dojo.event.connect(d, "onkeydown", dm, "onKeyDown");
+	dojo.event.connect(d, "onmouseover", dm, "onMouseOver");
+	dojo.event.connect(d, "onmouseout", dm, "onMouseOut");
+	dojo.event.connect(d, "onmousedown", dm, "onMouseDown");
+	dojo.event.connect(d, "onmouseup", dm, "onMouseUp");
+	// TODO: process scrolling of elements, not only window (focus manager would 
+	// probably come to rescue here as well)
+	dojo.event.connect(window, "onscroll", dm, "onScroll");
+})();

source/web/scripts/ajax/dojo/src/dnd/HtmlDragMove.js

@@ -0,0 +1,89 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dnd.HtmlDragMove");
+dojo.require("dojo.dnd.*");
+
+dojo.declare("dojo.dnd.HtmlDragMoveSource", dojo.dnd.HtmlDragSource, {
+	onDragStart: function(){
+		var dragObj =  new dojo.dnd.HtmlDragMoveObject(this.dragObject, this.type);
+		if (this.constrainToContainer) {
+			dragObj.constrainTo(this.constrainingContainer);
+		}
+		return dragObj;
+	},
+	/*
+	 * see dojo.dnd.HtmlDragSource.onSelected
+	 */
+	onSelected: function() {
+		for (var i=0; i<this.dragObjects.length; i++) {
+			dojo.dnd.dragManager.selectedSources.push(new dojo.dnd.HtmlDragMoveSource(this.dragObjects[i]));
+		}
+	}
+});
+
+dojo.declare("dojo.dnd.HtmlDragMoveObject", dojo.dnd.HtmlDragObject, {
+	onDragStart: function(e){
+		dojo.html.clearSelection();
+
+		this.dragClone = this.domNode;
+
+		// Record drag start position, where "position" is simply the top/left style values for
+		// the node (the meaning of top/left is dependent on whether node is position:absolute or
+		// position:relative, and also on the container).
+		// Not sure if we should support moving nodes that aren't position:absolute,
+		// but supporting it for now
+		if(dojo.html.getComputedStyle(this.domNode, 'position') != 'absolute'){
+			this.domNode.style.position = "relative";
+		}
+		var left = parseInt(dojo.html.getComputedStyle(this.domNode, 'left'));
+		var top = parseInt(dojo.html.getComputedStyle(this.domNode, 'top'));
+		this.dragStartPosition = {
+			x: isNaN(left) ? 0 : left,
+			y: isNaN(top) ? 0 : top
+		};
+
+		this.scrollOffset = dojo.html.getScroll().offset;
+
+		// used to convert mouse position into top/left value for node
+		this.dragOffset = {y: this.dragStartPosition.y - e.pageY,
+			x: this.dragStartPosition.x - e.pageX};
+
+		// since the DragObject's position is relative to the containing block, for our purposes
+		// the containing block's position is just (0,0)
+		this.containingBlockPosition = {x:0, y:0};
+
+		if (this.constrainToContainer) {
+			this.constraints = this.getConstraints();
+		}
+
+		// shortly the browser will fire an onClick() event,
+		// but since this was really a drag, just squelch it
+		dojo.event.connect(this.domNode, "onclick", this, "_squelchOnClick");
+	},
+
+	onDragEnd: function(e){
+	},
+
+	setAbsolutePosition: function(x, y){
+		// summary: Set the top & left style attributes of the drag node (TODO: function is poorly named)
+		if(!this.disableY) { this.domNode.style.top = y + "px"; }
+		if(!this.disableX) { this.domNode.style.left = x + "px"; }
+	},
+
+	_squelchOnClick: function(e){
+		// summary
+		//	this function is called to squelch this onClick() event because
+		//	it's the result of a drag (ie, it's not a real click)
+
+		dojo.event.browser.stopEvent(e);
+		dojo.event.disconnect(this.domNode, "onclick", this, "_squelchOnClick");
+	}
+});

source/web/scripts/ajax/dojo/src/dnd/Sortable.js

@@ -0,0 +1,28 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+dojo.provide("dojo.dnd.Sortable");
+dojo.require("dojo.dnd.*");
+
+dojo.dnd.Sortable = function () {}
+
+dojo.lang.extend(dojo.dnd.Sortable, {
+
+	ondragstart: function (e) {
+		var dragObject = e.target;
+		while (dragObject.parentNode && dragObject.parentNode != this) {
+			dragObject = dragObject.parentNode;
+		}
+		// TODO: should apply HtmlDropTarget interface to self
+		// TODO: should apply HtmlDragObject interface?
+		return dragObject;
+	}
+
+});

source/web/scripts/ajax/dojo/src/dnd/TreeDragAndDrop.js

@@ -0,0 +1,475 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+/**
+ * TreeDrag* specialized on managing subtree drags
+ * It selects nodes and visualises what's going on,
+ * but delegates real actions upon tree to the controller
+ *
+ * This code is considered a part of controller
+*/
+
+dojo.provide("dojo.dnd.TreeDragAndDrop");
+
+dojo.require("dojo.dnd.HtmlDragAndDrop");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.html.layout");
+
+dojo.dnd.TreeDragSource = function(node, syncController, type, treeNode){
+	this.controller = syncController;
+	this.treeNode = treeNode;
+
+	dojo.dnd.HtmlDragSource.call(this, node, type);
+}
+
+dojo.inherits(dojo.dnd.TreeDragSource, dojo.dnd.HtmlDragSource);
+
+dojo.lang.extend(dojo.dnd.TreeDragSource, {
+	onDragStart: function(){
+		/* extend adds functions to prototype */
+		var dragObject = dojo.dnd.HtmlDragSource.prototype.onDragStart.call(this);
+		//dojo.debugShallow(dragObject)
+
+		dragObject.treeNode = this.treeNode;
+
+		dragObject.onDragStart = dojo.lang.hitch(dragObject, function(e) {
+
+			/* save selection */
+			this.savedSelectedNode = this.treeNode.tree.selector.selectedNode;
+			if (this.savedSelectedNode) {
+				this.savedSelectedNode.unMarkSelected();
+			}
+
+			var result = dojo.dnd.HtmlDragObject.prototype.onDragStart.apply(this, arguments);
+
+
+			/* remove background grid from cloned object */
+			var cloneGrid = this.dragClone.getElementsByTagName('img');
+			for(var i=0; i<cloneGrid.length; i++) {
+				cloneGrid.item(i).style.backgroundImage='url()';
+			}
+
+			return result;
+
+
+		});
+
+		dragObject.onDragEnd = function(e) {
+
+			/* restore selection */
+			if (this.savedSelectedNode) {
+				this.savedSelectedNode.markSelected();
+			}
+			//dojo.debug(e.dragStatus);
+
+			return dojo.dnd.HtmlDragObject.prototype.onDragEnd.apply(this, arguments);
+		}
+		//dojo.debug(dragObject.domNode.outerHTML)
+
+
+		return dragObject;
+	},
+
+	onDragEnd: function(e){
+
+
+		 var res = dojo.dnd.HtmlDragSource.prototype.onDragEnd.call(this, e);
+
+
+		 return res;
+	}
+});
+
+// .......................................
+
+dojo.dnd.TreeDropTarget = function(domNode, controller, type, treeNode){
+
+	this.treeNode = treeNode;
+	this.controller = controller; // I will sync-ly process drops
+	
+	dojo.dnd.HtmlDropTarget.apply(this, [domNode, type]);
+}
+
+dojo.inherits(dojo.dnd.TreeDropTarget, dojo.dnd.HtmlDropTarget);
+
+dojo.lang.extend(dojo.dnd.TreeDropTarget, {
+
+	autoExpandDelay: 1500,
+	autoExpandTimer: null,
+
+
+	position: null,
+
+	indicatorStyle: "2px black solid",
+
+	showIndicator: function(position) {
+
+		// do not change style too often, cause of blinking possible
+		if (this.position == position) {
+			return;
+		}
+
+		//dojo.debug(position)
+
+		this.hideIndicator();
+
+		this.position = position;
+
+		if (position == "before") {
+			this.treeNode.labelNode.style.borderTop = this.indicatorStyle;
+		} else if (position == "after") {
+			this.treeNode.labelNode.style.borderBottom = this.indicatorStyle;
+		} else if (position == "onto") {
+			this.treeNode.markSelected();
+		}
+
+
+	},
+
+	hideIndicator: function() {
+		this.treeNode.labelNode.style.borderBottom="";
+		this.treeNode.labelNode.style.borderTop="";
+		this.treeNode.unMarkSelected();
+		this.position = null;
+	},
+
+
+
+	// is the target possibly ok ?
+	// This function is run on dragOver, but drop possibility is also determined by position over node
+	// that's why acceptsWithPosition is called
+	// doesnt take index into account ( can change while moving mouse w/o changing target )
+
+
+	/**
+	 * Coarse (tree-level) access check.
+	 * We can't determine real accepts status w/o position
+	*/
+	onDragOver: function(e){
+//dojo.debug("onDragOver for "+e);
+
+
+		var accepts = dojo.dnd.HtmlDropTarget.prototype.onDragOver.apply(this, arguments);
+
+		//dojo.debug("TreeDropTarget.onDragOver accepts:"+accepts)
+
+		if (accepts && this.treeNode.isFolder && !this.treeNode.isExpanded) {
+			this.setAutoExpandTimer();
+		}
+
+		return accepts;
+	},
+
+	/* Parent.onDragOver calls this function to get accepts status */
+	accepts: function(dragObjects) {
+
+		var accepts = dojo.dnd.HtmlDropTarget.prototype.accepts.apply(this, arguments);
+
+		if (!accepts) return false;
+
+		var sourceTreeNode = dragObjects[0].treeNode;
+
+		if (dojo.lang.isUndefined(sourceTreeNode) || !sourceTreeNode || !sourceTreeNode.isTreeNode) {
+			dojo.raise("Source is not TreeNode or not found");
+		}
+
+		if (sourceTreeNode === this.treeNode) return false;
+
+		return true;
+	},
+
+
+
+	setAutoExpandTimer: function() {
+		// set up autoexpand timer
+		var _this = this;
+
+		var autoExpand = function () {
+			if (dojo.dnd.dragManager.currentDropTarget === _this) {
+				_this.controller.expand(_this.treeNode);
+			}
+		}
+
+		this.autoExpandTimer = dojo.lang.setTimeout(autoExpand, _this.autoExpandDelay);
+	},
+
+
+	getDNDMode: function() {
+		return this.treeNode.tree.DNDMode;
+	},
+		
+
+	getAcceptPosition: function(e, sourceTreeNode) {
+
+		var DNDMode = this.getDNDMode();
+
+		if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO &&
+			// check if ONTO is allowed localy
+			!(
+			  !this.treeNode.actionIsDisabled(dojo.widget.TreeNode.prototype.actions.ADDCHILD) // check dynamically cause may change w/o regeneration of dropTarget
+			  && sourceTreeNode.parent !== this.treeNode
+			  && this.controller.canMove(sourceTreeNode, this.treeNode)
+			 )
+		) {
+			// disable ONTO if can't move
+			DNDMode &= ~dojo.widget.Tree.prototype.DNDModes.ONTO;
+		}
+
+
+		var position = this.getPosition(e, DNDMode);
+
+		//dojo.debug(DNDMode & +" : "+position);
+
+
+		// if onto is here => it was allowed before, no accept check is needed
+		if (position=="onto" ||
+			(!this.isAdjacentNode(sourceTreeNode, position)
+			 && this.controller.canMove(sourceTreeNode, this.treeNode.parent)
+			)
+		) {
+			return position;
+		} else {
+			return false;
+		}
+
+	},
+
+	onDragOut: function(e) {
+		this.clearAutoExpandTimer();
+
+		this.hideIndicator();
+	},
+
+
+	clearAutoExpandTimer: function() {
+		if (this.autoExpandTimer) {
+			clearTimeout(this.autoExpandTimer);
+			this.autoExpandTimer = null;
+		}
+	},
+
+
+
+	onDragMove: function(e, dragObjects){
+
+		var sourceTreeNode = dragObjects[0].treeNode;
+
+		var position = this.getAcceptPosition(e, sourceTreeNode);
+
+		if (position) {
+			this.showIndicator(position);
+		}
+
+	},
+
+	isAdjacentNode: function(sourceNode, position) {
+
+		if (sourceNode === this.treeNode) return true;
+		if (sourceNode.getNextSibling() === this.treeNode && position=="before") return true;
+		if (sourceNode.getPreviousSibling() === this.treeNode && position=="after") return true;
+
+		return false;
+	},
+
+
+	/* get DNDMode and see which position e fits */
+	getPosition: function(e, DNDMode) {
+		var node = dojo.byId(this.treeNode.labelNode);
+		var mousey = e.pageY || e.clientY + dojo.body().scrollTop;
+		var nodey = dojo.html.getAbsolutePosition(node).y;
+		var height = dojo.html.getBorderBox(node).height;
+
+		var relY = mousey - nodey;
+		var p = relY / height;
+
+		var position = ""; // "" <=> forbidden
+		if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO
+		  && DNDMode & dojo.widget.Tree.prototype.DNDModes.BETWEEN) {
+			if (p<=0.3) {
+				position = "before";
+			} else if (p<=0.7) {
+				position = "onto";
+			} else {
+				position = "after";
+			}
+		} else if (DNDMode & dojo.widget.Tree.prototype.DNDModes.BETWEEN) {
+			if (p<=0.5) {
+				position = "before";
+			} else {
+				position = "after";
+			}
+		}
+		else if (DNDMode & dojo.widget.Tree.prototype.DNDModes.ONTO) {
+			position = "onto";
+		}
+
+
+		return position;
+	},
+
+
+
+	getTargetParentIndex: function(sourceTreeNode, position) {
+
+		var index = position == "before" ? this.treeNode.getParentIndex() : this.treeNode.getParentIndex()+1;
+		if (this.treeNode.parent === sourceTreeNode.parent
+		  && this.treeNode.getParentIndex() > sourceTreeNode.getParentIndex()) {
+		  	index--;  // dragging a node is different for simple move bacause of before-after issues
+		}
+
+		return index;
+	},
+
+
+	onDrop: function(e){
+		// onDragOut will clean position
+
+
+		var position = this.position;
+
+//dojo.debug(position);
+
+		this.onDragOut(e);
+
+		var sourceTreeNode = e.dragObject.treeNode;
+
+		if (!dojo.lang.isObject(sourceTreeNode)) {
+			dojo.raise("TreeNode not found in dragObject")
+		}
+
+		if (position == "onto") {
+			return this.controller.move(sourceTreeNode, this.treeNode, 0);
+		} else {
+			var index = this.getTargetParentIndex(sourceTreeNode, position);
+			return this.controller.move(sourceTreeNode, this.treeNode.parent, index);
+		}
+
+		//dojo.debug('drop2');
+
+
+
+	}
+
+
+});
+
+
+
+dojo.dnd.TreeDNDController = function(treeController) {
+
+	// I use this controller to perform actions
+	this.treeController = treeController;
+
+	this.dragSources = {};
+
+	this.dropTargets = {};
+
+}
+
+dojo.lang.extend(dojo.dnd.TreeDNDController, {
+
+
+	listenTree: function(tree) {
+		//dojo.debug("Listen tree "+tree);
+		dojo.event.topic.subscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode");
+		dojo.event.topic.subscribe(tree.eventNames.moveFrom, this, "onMoveFrom");
+		dojo.event.topic.subscribe(tree.eventNames.moveTo, this, "onMoveTo");
+		dojo.event.topic.subscribe(tree.eventNames.addChild, this, "onAddChild");
+		dojo.event.topic.subscribe(tree.eventNames.removeNode, this, "onRemoveNode");
+		dojo.event.topic.subscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy");
+	},
+
+
+	unlistenTree: function(tree) {
+		//dojo.debug("Listen tree "+tree);
+		dojo.event.topic.unsubscribe(tree.eventNames.createDOMNode, this, "onCreateDOMNode");
+		dojo.event.topic.unsubscribe(tree.eventNames.moveFrom, this, "onMoveFrom");
+		dojo.event.topic.unsubscribe(tree.eventNames.moveTo, this, "onMoveTo");
+		dojo.event.topic.unsubscribe(tree.eventNames.addChild, this, "onAddChild");
+		dojo.event.topic.unsubscribe(tree.eventNames.removeNode, this, "onRemoveNode");
+		dojo.event.topic.unsubscribe(tree.eventNames.treeDestroy, this, "onTreeDestroy");
+	},
+
+	onTreeDestroy: function(message) {
+		this.unlistenTree(message.source);
+		// I'm not widget so don't use destroy() call and dieWithTree
+	},
+
+	onCreateDOMNode: function(message) {
+		this.registerDNDNode(message.source);
+	},
+
+	onAddChild: function(message) {
+		this.registerDNDNode(message.child);
+	},
+
+	onMoveFrom: function(message) {
+		var _this = this;
+		dojo.lang.forEach(
+			message.child.getDescendants(),
+			function(node) { _this.unregisterDNDNode(node); }
+		);
+	},
+
+	onMoveTo: function(message) {
+		var _this = this;
+		dojo.lang.forEach(
+			message.child.getDescendants(),
+			function(node) { _this.registerDNDNode(node); }
+		);
+	},
+
+	/**
+	 * Controller(node model) creates DNDNodes because it passes itself to node for synchroneous drops processing
+	 * I can't process DnD with events cause an event can't return result success/false
+	*/
+	registerDNDNode: function(node) {
+		if (!node.tree.DNDMode) return;
+
+//dojo.debug("registerDNDNode "+node);
+
+		/* I drag label, not domNode, because large domNodes are very slow to copy and large to drag */
+
+		var source = null;
+		var target = null;
+
+		if (!node.actionIsDisabled(node.actions.MOVE)) {
+			//dojo.debug("reg source")
+			var source = new dojo.dnd.TreeDragSource(node.labelNode, this, node.tree.widgetId, node);
+			this.dragSources[node.widgetId] = source;
+		}
+
+		var target = new dojo.dnd.TreeDropTarget(node.labelNode, this.treeController, node.tree.DNDAcceptTypes, node);
+
+		this.dropTargets[node.widgetId] = target;
+
+	},
+
+
+	unregisterDNDNode: function(node) {
+
+		if (this.dragSources[node.widgetId]) {
+			dojo.dnd.dragManager.unregisterDragSource(this.dragSources[node.widgetId]);
+			delete this.dragSources[node.widgetId];
+		}
+
+		if (this.dropTargets[node.widgetId]) {
+			dojo.dnd.dragManager.unregisterDropTarget(this.dropTargets[node.widgetId]);
+			delete this.dropTargets[node.widgetId];
+		}
+	}
+
+
+
+
+
+});

source/web/scripts/ajax/dojo/src/dnd/TreeDragAndDropV3.js

@@ -0,0 +1,403 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+/**
+ * TreeDrag* specialized on managing subtree drags
+ * It selects nodes and visualises what's going on,
+ * but delegates real actions upon tree to the controller
+ *
+ * This code is considered a part of controller
+*/
+
+dojo.provide("dojo.dnd.TreeDragAndDropV3");
+
+dojo.require("dojo.dnd.HtmlDragAndDrop");
+dojo.require("dojo.lang.func");
+dojo.require("dojo.lang.array");
+dojo.require("dojo.lang.extras");
+dojo.require("dojo.Deferred");
+dojo.require("dojo.html.layout");
+
+// FIXME: if controller can't move then skip node on move start
+dojo.dnd.TreeDragSourceV3 = function(node, syncController, type, treeNode){
+	//dojo.profile.start("TreeDragSourceV3 "+treeNode);
+	this.controller = syncController;
+	this.treeNode = treeNode;
+
+	dojo.dnd.HtmlDragSource.call(this, node, type);
+	//dojo.profile.end("TreeDragSourceV3 "+treeNode);
+}
+
+dojo.inherits(dojo.dnd.TreeDragSourceV3, dojo.dnd.HtmlDragSource);
+
+
+// .......................................
+
+dojo.dnd.TreeDropTargetV3 = function(domNode, controller, type, treeNode){
+
+	this.treeNode = treeNode;
+	this.controller = controller; // I will sync-ly process drops
+	
+	dojo.dnd.HtmlDropTarget.call(this, domNode, type);
+}
+
+dojo.inherits(dojo.dnd.TreeDropTargetV3, dojo.dnd.HtmlDropTarget);
+
+dojo.lang.extend(dojo.dnd.TreeDropTargetV3, {
+
+	autoExpandDelay: 1500,
+	autoExpandTimer: null,
+
+
+	position: null,
+
+	indicatorStyle: "2px black groove",
+
+	showIndicator: function(position) {
+
+		// do not change style too often, cause of blinking possible
+		if (this.position == position) {
+			return;
+		}
+
+		//dojo.debug("set position for "+this.treeNode)
+
+		this.hideIndicator();
+
+		this.position = position;
+		
+		var node = this.treeNode;
+			
+		
+		node.contentNode.style.width = dojo.html.getBorderBox(node.labelNode).width + "px";
+
+		if (position == "onto") {					
+			node.contentNode.style.border = this.indicatorStyle;
+		} else {
+			// FIXME: bottom-top or highlight should cover ONLY top/bottom or div itself,
+			// not span whole line (try Dnd)
+			// FAILURE: Can't put span inside div: multiline bottom-top will span multiple lines
+			if (position == "before") {
+				node.contentNode.style.borderTop = this.indicatorStyle;
+			} else if (position == "after") {
+				node.contentNode.style.borderBottom = this.indicatorStyle;
+			}									
+		}  
+	},
+
+	hideIndicator: function() {
+		this.treeNode.contentNode.style.borderBottom = "";
+		this.treeNode.contentNode.style.borderTop = "";
+		this.treeNode.contentNode.style.border = "";
+		this.treeNode.contentNode.style.width=""
+		this.position = null;
+	},
+
+
+
+	// is the target possibly ok ?
+	// This function is run on dragOver, but drop possibility is also determined by position over node
+	// that's why acceptsWithPosition is called
+	// doesnt take index into account ( can change while moving mouse w/o changing target )
+	/**
+	 * Coarse (tree-level) access check.
+	 * We can't determine real accepts status w/o position
+	*/
+	onDragOver: function(e){
+		//dojo.debug("onDragOver for "+e);
+
+		var accepts = dojo.dnd.HtmlDropTarget.prototype.onDragOver.apply(this, arguments);
+
+		//dojo.debug("TreeDropTarget.onDragOver accepts:"+accepts)
+
+		if (accepts && this.treeNode.isFolder && !this.treeNode.isExpanded) {
+			this.setAutoExpandTimer();
+		}
+		
+		if (accepts) {
+			this.cacheNodeCoords();
+		}
+
+
+		return accepts;
+	},
+
+	/* Parent.onDragOver calls this function to get accepts status */
+	accepts: function(dragObjects) {
+
+		var accepts = dojo.dnd.HtmlDropTarget.prototype.accepts.apply(this, arguments);
+
+		//dojo.debug("accepts "+accepts);
+
+		if (!accepts) return false;
+
+		for(var i=0; i<dragObjects.length; i++) {
+			// there may be NO treeNode
+			var sourceTreeNode = dragObjects[i].treeNode;
+			
+			if (sourceTreeNode === this.treeNode) return false;
+		}
+
+		return true;
+	},
+
+
+
+	setAutoExpandTimer: function() {
+		// set up autoexpand timer
+		var _this = this;
+
+		var autoExpand = function () {
+			if (dojo.dnd.dragManager.currentDropTarget === _this) {
+				_this.controller.expand(_this.treeNode);
+				// SLOW. Coordinates will not be recalculated if collapse occurs, or
+				// other (generic) resize. So that's a kind of hack.
+				dojo.dnd.dragManager.cacheTargetLocations();
+			}
+		}
+
+		this.autoExpandTimer = dojo.lang.setTimeout(autoExpand, _this.autoExpandDelay);
+	},
+
+		
+
+	getAcceptPosition: function(e, dragObjects) {
+
+
+		var DndMode = this.treeNode.tree.DndMode;
+
+		// disable ONTO mode possibility if impossible 
+		if (DndMode & dojo.widget.TreeV3.prototype.DndModes.ONTO &&
+			// check if ONTO is allowed localy
+			// check dynamically cause may change w/o regeneration of dropTarget
+			this.treeNode.actionIsDisabledNow(this.treeNode.actions.ADDCHILD) 
+		) {
+			// disable ONTO if can't move
+			DndMode &= ~dojo.widget.TreeV3.prototype.DndModes.ONTO;
+		}
+		
+
+		var position = this.getPosition(e, DndMode);
+
+		//dojo.debug(DndMode & +" : "+position);
+
+
+		// if onto is here => it was allowed before, no accept check is needed
+		if (position=="onto") {
+			return position;
+		}
+		
+		for(var i=0; i<dragObjects.length; i++) {
+			var source = dragObjects[i].dragSource;
+			if (source.treeNode && this.isAdjacentNode(source.treeNode, position)) { // skip check if same parent
+				continue;
+			}		
+						
+			if (!this.controller.canMove(source.treeNode ? source.treeNode : source, this.treeNode.parent)) {
+				return false;
+			}
+		}
+		
+		return position;
+	
+	},
+
+	
+
+	onDropEnd: function(e) {
+		this.clearAutoExpandTimer();
+
+		this.hideIndicator();
+	},
+
+
+	onDragOut: function(e) {
+		this.clearAutoExpandTimer();
+
+		this.hideIndicator();
+	},
+
+	clearAutoExpandTimer: function() {
+		if (this.autoExpandTimer) {
+			clearTimeout(this.autoExpandTimer);
+			this.autoExpandTimer = null;
+		}
+	},
+
+
+
+	onDragMove: function(e, dragObjects){
+		
+		var position = this.getAcceptPosition(e, dragObjects);
+
+		if (position) {
+			this.showIndicator(position);
+		}
+
+	},
+
+	isAdjacentNode: function(sourceNode, position) {
+
+		if (sourceNode === this.treeNode) return true;
+		if (sourceNode.getNextSibling() === this.treeNode && position=="before") return true;
+		if (sourceNode.getPreviousSibling() === this.treeNode && position=="after") return true;
+
+		return false;
+	},
+
+
+	/**
+	 * cache node coordinates to speed up onDragMove
+	 */
+	cacheNodeCoords: function() {
+		var node = this.treeNode.contentNode;
+		
+		this.cachedNodeY = dojo.html.getAbsolutePosition(node).y;
+		this.cachedNodeHeight = dojo.html.getBorderBox(node).height;
+	},
+	
+	
+
+	/* get DndMode and see which position e fits */
+	getPosition: function(e, DndMode) {
+		var mousey = e.pageY || e.clientY + dojo.body().scrollTop;
+		
+		var relY = mousey - this.cachedNodeY;
+		var p = relY / this.cachedNodeHeight;
+
+		var position = ""; // "" <=> forbidden
+		if (DndMode & dojo.widget.TreeV3.prototype.DndModes.ONTO
+		  && DndMode & dojo.widget.TreeV3.prototype.DndModes.BETWEEN) {
+			//dojo.debug("BOTH");
+			if (p<=0.33) {
+				position = "before";
+				// if children are expanded then I ignore understrike, cause it is confusing with firstChild
+				// but for last nodes I put understrike there
+			} else if (p<=0.66 || this.treeNode.isExpanded && this.treeNode.children.length && !this.treeNode.isLastChild()) {
+				position = "onto";
+			} else {
+				position = "after";
+			}
+		} else if (DndMode & dojo.widget.TreeV3.prototype.DndModes.BETWEEN) {
+			//dojo.debug("BETWEEN");
+			if (p<=0.5 || this.treeNode.isExpanded && this.treeNode.children.length && !this.treeNode.isLastChild()) {
+				position = "before";
+			} else {
+				position = "after";
+			}
+		}
+		else if (DndMode & dojo.widget.TreeV3.prototype.DndModes.ONTO) {
+			//dojo.debug("ONTO");
+			position = "onto";
+		}
+
+		//dojo.debug(position);
+
+		return position;
+	},
+
+
+
+	getTargetParentIndex: function(source, position) {
+
+		var index = position == "before" ? this.treeNode.getParentIndex() : this.treeNode.getParentIndex()+1;
+		if (source.treeNode
+		  && this.treeNode.parent === source.treeNode.parent
+		  && this.treeNode.getParentIndex() > source.treeNode.getParentIndex()) {
+		  	index--;  // dragging a node is different for simple move bacause of before-after issues
+		}
+
+		return index;
+	},
+
+
+	onDrop: function(e) {
+		// onDropEnd will clean position
+
+		
+		var position = this.position;
+
+//dojo.debug(position);
+		var source = e.dragObject.dragSource;
+		
+		//dojo.debug("onDrop "+source.treeNode+" " + position + " "+this.treeNode);
+
+
+		var targetParent, targetIndex;
+		if (position == "onto") {
+			targetParent = this.treeNode;
+			targetIndex = 0;
+		} else {
+			targetIndex = this.getTargetParentIndex(source, position);
+			targetParent = this.treeNode.parent;
+		}
+		
+		//dojo.profile.start("onDrop "+sourceTreeNode);
+		var r = this.getDropHandler(e, source, targetParent, targetIndex)();
+		
+		//dojo.profile.end("onDrop "+sourceTreeNode);
+			
+		return r;
+
+	},
+	
+	/**
+	 * determine, which action I should perform with nodes
+	 * e.g move, clone..
+	 */
+	getDropHandler: function(e, source, targetParent, targetIndex) {
+		var handler;
+		var _this = this;
+		handler = function () {
+			var result;
+			
+			//dojo.debug("Move "+source.treeNode+" to parent "+targetParent+":"+targetIndex);
+			if (source.treeNode) {
+				result = _this.controller.move(source.treeNode, targetParent, targetIndex, true);
+				//dojo.debug("moved "+result);
+			} else {
+				if (dojo.lang.isFunction(source.onDrop)) {
+					source.onDrop(targetParent, targetIndex);
+				}
+				
+				var treeNode = source.getTreeNode();
+				if (treeNode) {
+					result = _this.controller.createChild(targetParent, targetIndex, treeNode, true);
+				} else {
+					result = true;
+				}
+			}
+			
+			if (result instanceof dojo.Deferred) {
+				// this Deferred is always sync
+				var isSuccess = result.fired == 0;
+				if (!isSuccess) {
+					_this.handleDropError(source, targetParent, targetIndex, result);
+				}
+				
+				return isSuccess;				
+				
+			} else {
+				return result;
+			}
+		}
+		
+		return handler;
+	},
+	
+	
+	handleDropError: function(source, parent, index, result) {
+		dojo.debug("TreeDropTargetV3.handleDropError: DND error occured");
+		dojo.debugShallow(result);
+	}
+
+
+});
+

source/web/scripts/ajax/dojo/src/dnd/__package__.js

@@ -0,0 +1,16 @@
+/*
+	Copyright (c) 2004-2006, 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/community/licensing.shtml
+*/
+
+dojo.kwCompoundRequire({
+	common: ["dojo.dnd.DragAndDrop"],
+	browser: ["dojo.dnd.HtmlDragAndDrop"],
+	dashboard: ["dojo.dnd.HtmlDragAndDrop"]
+});
+dojo.provide("dojo.dnd.*");