dojo_src 1.4.102 → 1.5.0

data/dojo/dojox/layout/tests/test_TableContainer.html

@@ -220,8 +220,8 @@
 					} else if (width < 800) {
 					  numCols = 2;
 					}
-					if (_this.attr("cols") != numCols) {
-					  _this.attr("cols", numCols);
+					if (_this.get("cols") != numCols) {
+					  _this.set("cols", numCols);
 					}
 				}
 				var timer;

data/dojo/dojox/math/BigInteger-ext.js

@@ -3,9 +3,7 @@ dojo.experimental("dojox.math.BigInteger-ext");
 
 dojo.require("dojox.math.BigInteger");
 
-// Copyright (c) 2005  Tom Wu
-// All Rights Reserved.
-// See "LICENSE-BigInteger" for details.
+// Contributed under CLA by Tom Wu
 
 // Extended JavaScript BN functions, required for RSA private ops.
 

data/dojo/dojox/math/BigInteger.js

@@ -1,11 +1,11 @@
 dojo.provide("dojox.math.BigInteger");
 dojo.experimental("dojox.math.BigInteger");
 
-// Copyright (c) 2005  Tom Wu
-// All Rights Reserved.
-// See "LICENSE-BigInteger" for details.
+// Contributed under CLA by Tom Wu <tjw@cs.Stanford.EDU>
+// See http://www-cs-students.stanford.edu/~tjw/jsbn/ for details.
 
 // Basic JavaScript BN library - subset useful for RSA encryption.
+// The API for dojox.math.BigInteger closely resembles that of the java.math.BigInteger class in Java.
 
 (function(){
 

data/dojo/dojox/math/README

@@ -18,9 +18,6 @@ Project description
 A port of the main functionality of dojo.math 0.4.  Includes advanced math
 functions, abstract curve definitions, and some point calculations.
 
-Port of Tom Wu's port of java.math.BigInteger released in 2005 under the BSD
-license (CLA on file). See http://www-cs-students.stanford.edu/~tjw/jsbn/
-for details.
 -------------------------------------------------------------------------------
 Dependencies:
 

data/dojo/dojox/math/_base.js

@@ -24,20 +24,57 @@ dojo.provide("dojox.math._base");
 			return m.toDegrees(n);	//	Number
 		},
 
-		factorial: function(/* Number */n){
+		_gamma: function(z){
 			//	summary:
-			//		Return the factorial of n
-			if(n === 0){ 
-				return 1;	// Number
-			}else if(n < 0 || Math.floor(n) != n){
-				return NaN; // NaN
+			//		Compute the gamma function for the passed number.
+			//		Approximately 14 dijits of precision with non-integers.
+			var answer = 1; // 0!
+			// gamma(n+1) = n * gamma(n)
+			while (--z >= 1){
+				answer *= z;
 			}
-
-			var ret = 1;
-			for(var i = 1; i <= n; i++){
-				ret *= i;
+			if(z == 0){ return answer; } // normal integer quick return
+			if(Math.floor(z) == z){ return NaN; } // undefined at nonpositive integers since sin() below will return 0
+			// assert: z < 1, remember this z is really z-1
+			if(z == -0.5){ return Math.sqrt(Math.PI); } // popular gamma(1/2)
+			if(z < -0.5){ // remember this z is really z-1
+				return Math.PI / (Math.sin(Math.PI * (z + 1)) * this._gamma(-z)); // reflection
 			}
-			return ret;	// Number
+			// assert: -0.5 < z < 1
+			// Spouge approximation algorithm
+			var a = 13;
+			// c[0] = sqrt(2*PI) / exp(a)
+			// var kfact = 1
+			// for (var k=1; k < a; k++){
+			//      c[k] = pow(-k + a, k - 0.5) * exp(-k) / kfact
+			//      kfact *= -k  // (-1)^(k-1) * (k-1)!
+			// }
+			var c = [ // precomputed from the above algorithm
+					 5.6658056015186327e-6,
+					 1.2743717663379679,
+					-4.9374199093155115,
+					 7.8720267032485961,
+					-6.6760503749436087,
+					 3.2525298444485167,
+					-9.1852521441026269e-1,
+					 1.4474022977730785e-1,
+					-1.1627561382389853e-2,
+					 4.0117980757066622e-4,
+					-4.2652458386405744e-6,
+					 6.6651913290336086e-9,
+					-1.5392547381874824e-13
+				];
+			var sum = c[0];
+			for (var k=1; k < a; k++){
+				sum += c[k] / (z + k);
+			}
+			return answer * Math.pow(z + a, z + 0.5) / Math.exp(z) * sum;
+		},
+
+		factorial: function(/* Number */n){
+			//	summary:
+			//		Return the factorial of n
+			return this._gamma(n+1);	// Number
 		},
 
 		permutations: function(/* Number */n, /* Number */k){

data/dojo/dojox/math/tests/math.js

@@ -3,9 +3,27 @@ dojo.provide("dojox.math.tests.math");
 dojo.require("dojox.math");
 
 (function(){
+	function approx(r){
+		return Math.floor(r * (1 << 30)) / (1 << 30);
+	}
 	tests.register("dojox.math.tests.factorial", [
+		// standard integer values
 		function fact0(t){ t.assertEqual(1, dojox.math.factorial(0)); },
+		function fact1(t){ t.assertEqual(1, dojox.math.factorial(1)); },
+		function fact2(t){ t.assertEqual(2, dojox.math.factorial(2)); },
 		function fact5(t){ t.assertEqual(120, dojox.math.factorial(5)); },
-		function factneg(t){ t.assertTrue(isNaN(dojox.math.factorial(-1))); }
+		// almost integer
+		function fact5minus(t){ t.assertEqual(approx(119.999804750496600), approx(dojox.math.factorial(5-1/1048576))); },
+		function fact5plus(t){ t.assertEqual(approx(120.000195249840876), approx(dojox.math.factorial(5+1/1048576))); },
+		// geometric values
+		function factNeg1half(t){ t.assertEqual(Math.sqrt(Math.PI), dojox.math.factorial(-0.5)); },
+		function factPos1half(t){ t.assertEqual(approx(Math.sqrt(Math.PI)/2), approx(dojox.math.factorial(0.5))); },
+		function factNeg3halves(t){ t.assertEqual(approx(-Math.sqrt(Math.PI)*2), approx(dojox.math.factorial(-1.5))); },
+		function factNeg5halves(t){ t.assertEqual(approx(Math.sqrt(Math.PI)*4/3), approx(dojox.math.factorial(-2.5))); },
+		function factPos5halves(t){ t.assertEqual(approx(Math.sqrt(Math.PI)*15/8), approx(dojox.math.factorial(2.5))); },
+		// invalid values
+		function factNeg1(t){ t.assertEqual(NaN, dojox.math.factorial(-1)); },
+		function factNeg2(t){ t.assertEqual(NaN, dojox.math.factorial(-2)); }
 	]);
+	
 })();

data/dojo/dojox/mdnd/AreaManager.js

@@ -0,0 +1,707 @@
+dojo.provide("dojox.mdnd.AreaManager");
+dojo.require("dojox.mdnd.Moveable");
+
+dojo.declare(
+	"dojox.mdnd.AreaManager",
+	null,
+{
+	// summary:
+	//		Drag And Drop manager
+
+	// autoRefresh: Boolean
+	//		Enable the refresh of registered areas on drag start.
+	autoRefresh: true,
+
+
+	// areaClass: String
+	//		CSS class enabled an area if areaClass is defined
+	areaClass: "dojoxDndArea",
+
+	// dragHandleClass: String
+	//		CSS class enabled a drag handle.
+	dragHandleClass: "dojoxDragHandle",
+
+	constructor: function(){
+		// summary:
+		//		Constructor of AreaManager class.
+		//		Initialize arrays, connects and subscribes.
+
+		//console.log("dojox.mdnd.AreaManager ::: constructor");
+		this._areaList = [];
+		this.resizeHandler = dojo.connect(dojo.global,"onresize", this, function(){
+			this._dropMode.updateAreas(this._areaList);
+		});
+
+		this._oldIndexArea = this._currentIndexArea = this._oldDropIndex = this._currentDropIndex = this._sourceIndexArea = this._sourceDropIndex = -1;
+	},
+
+	init: function(){
+		// summary:
+		//		Initialize the manager by calling the registerByClass method
+
+		//console.log("dojox.mdnd.AreaManager ::: init");
+		this.registerByClass();
+	},
+
+	registerByNode: function(/*DOMNode*/area, /*Boolean*/notInitAreas){
+		// summary:
+		//		To register Dnd Area : insert the DndArea using the specific sort of dropMode.
+		// area:
+		//		a DOM node corresponding to the Dnd Area
+		// notInitAreas:
+		//		if false or undefined, init the areas.
+
+		//console.log("dojox.mdnd.AreaManager ::: registerByNode", area);
+		var index = this._getIndexArea(area);
+		if(area && index == -1){
+			var acceptType = area.getAttribute("accept");
+			var accept = (acceptType) ? acceptType.split(/\s*,\s*/) : ["text"];
+			var obj = {
+				'node': area,
+				'items': [],
+				'coords': {},
+				'margin': null,
+				'accept': accept,
+				'initItems': false
+			};
+			dojo.forEach(this._getChildren(area), function(item){
+				this._setMarginArea(obj, item);
+				obj.items.push(this._addMoveableItem(item));
+			}, this);
+			this._areaList = this._dropMode.addArea(this._areaList, obj);
+			if(!notInitAreas){
+				this._dropMode.updateAreas(this._areaList);
+			}
+			dojo.publish("/dojox/mdnd/manager/register",[area]);
+		}
+	},
+
+	registerByClass: function(){
+		// summary:
+		//		Register all Dnd Areas identified by the attribute areaClass :
+		//		insert Dnd Areas using the specific sort of dropMode.
+
+		//console.log("dojox.mdnd.AreaManager ::: registerByClass");
+		dojo.query('.'+this.areaClass).forEach(function(area){
+			this.registerByNode(area, true);
+		}, this);
+		this._dropMode.updateAreas(this._areaList);
+	},
+
+	unregister: function(/*DOMNode*/area){
+		// summary:
+		//		Unregister a D&D Area and its children into the AreaManager.
+		// area:
+		//		A node corresponding to the D&D Area.
+		// returns:
+		//		True if the area is found and unregistered.
+
+		//console.log("dojox.mdnd.AreaManager ::: unregister");
+		var index = this._getIndexArea(area);
+		if(index != -1){
+			dojo.forEach(this._areaList[index].items, function(item){
+				this._deleteMoveableItem(item);
+			}, this);
+			this._areaList.splice(index,1);
+			// refresh target area
+			this._dropMode.updateAreas(this._areaList);
+			return true; // Boolean
+		}
+		return false; // Boolean
+	},
+
+	_addMoveableItem: function(/*DOMNode*/node){
+		// summary:
+		//		Create a draggable item with a DOM node.
+		// node:
+		//		A child of the D&D Area.
+		// returns:
+		//		The draggable item.
+		// tags:
+		//		protected
+
+		//console.log("dojox.mdnd.AreaManager ::: _addMoveableItem");
+		node.setAttribute("tabIndex", "0");
+		var handle = this._searchDragHandle(node);
+		var moveable = new dojox.mdnd.Moveable({ 'handle': handle, 'skip': true }, node);
+		// add a css style :
+		dojo.addClass(handle || node, "dragHandle");
+		var type = node.getAttribute("dndType");
+		var item = {
+			'item': moveable,
+			'type': type ? type.split(/\s*,\s*/) : ["text"],
+			'handlers': [dojo.connect(moveable, "onDragStart", this, "onDragStart")]
+		}
+		// connect to the uninitialize method of dijit._Widget to delete a moveable before a destruct
+		if(dijit && dijit.byNode){
+			var widget = dijit.byNode(node);
+			if(widget){
+				item.type = widget.dndType ? widget.dndType.split(/\s*,\s*/) : ["text"];
+				item.handlers.push(
+					dojo.connect(widget, "uninitialize", this, function(){
+						this.removeDragItem(node.parentNode, moveable.node);
+					})
+				);
+			}
+		}
+		return item; // Object
+	},
+
+	_deleteMoveableItem: function(/*Object*/ objItem){
+		// summary:
+		//		Delete the Moveable object associated with a node.
+		// item:
+		//		A moveable Object.
+		// tags:
+		//		protected
+
+		//console.log("dojox.mdnd.AreaManager ::: _deleteMoveableItem", objItem);
+		// disconnect the handle
+		dojo.forEach(objItem.handlers, function(handler){
+			dojo.disconnect(handler);
+		});
+		// delete css style :
+		var node = objItem.item.node,
+			handle = this._searchDragHandle(node);
+		dojo.removeClass(handle || node, "dragHandle");
+		// call destroy of Moveable class
+		objItem.item.destroy();
+	},
+
+	_getIndexArea: function(/*DOMNode*/area){
+		// summary:
+		//		Get the index of an area.
+	 	// area:
+	 	//		A moveable Object.
+	 	// returns:
+	 	//		area index or -1
+	 	// tags:
+	 	//		protected
+
+		//console.log("dojox.mdnd.AreaManager ::: _getIndexArea");
+		if(area){
+			for(var i = 0; i < this._areaList.length; i++){
+				if(this._areaList[i].node === area){
+					return i;	// Integer
+				}
+			}
+		}
+		return -1;	// Integer
+	},
+
+	_searchDragHandle: function(/*DOMNode*/node){
+		// summary:
+		//		Return the node which contains the first specific CSS class handle.
+		// node:
+		//		A child of the D&D Area.
+		// returns:
+		//		The drag handle node.
+		// tags:
+		//		protected
+
+		//console.log("dojox.mdnd.AreaManager ::: _searchDragHandle");
+		if(node){
+			var cssArray = this.dragHandleClass.split(' '),
+				length = cssArray.length,
+				queryCss = "";
+			dojo.forEach(cssArray, function(css, i){
+				queryCss += "." + css;
+				if(i != length - 1){
+					queryCss += ", ";
+				}
+			});
+			return dojo.query(queryCss, node)[0]; // DomNode
+		}
+	},
+
+	addDragItem: function(/*DOMNode*/area, /*DOMNode*/node, /*Integer*/index, /*Boolean*/notCheckParent){
+		// summary:
+		//		To add an item programmatically.
+		// area:
+		//		a node corresponding to the D&D Area
+		// node:
+		//		the node which has to be treated.
+		// index:
+		//		the place in the area
+		// noCheckParent:
+		//		if true, doesn't check if node has a parent.
+		// returns:
+		//		True if the node has been inserted else false.
+
+		//console.log("dojox.mdnd.AreaManager ::: addDragItem");
+		var add = true;
+		if(!notCheckParent){
+			add = area && node && (node.parentNode === null || (node.parentNode && node.parentNode.nodeType !== 1));
+		}
+		if(add){
+			var indexArea = this._getIndexArea(area);
+			if(indexArea !== -1){
+				var item = this._addMoveableItem(node),
+					items = this._areaList[indexArea].items;
+				if(0 <= index && index < items.length){
+					var firstListChild = items.slice(0, index),
+						lastListChild = items.slice(index, items.length);
+					firstListChild[firstListChild.length] = item;
+					this._areaList[indexArea].items = firstListChild.concat(lastListChild);
+					area.insertBefore(node, items[index].item.node);
+				}
+				else{
+					this._areaList[indexArea].items.push(item);
+					area.appendChild(node);
+				}
+				this._setMarginArea(this._areaList[indexArea], node);
+				this._areaList[indexArea].initItems = false;
+				return true;	// Boolean
+			}
+		}
+		return false;	// Boolean
+	},
+
+	removeDragItem: function(/*DOMNode*/area, /*DOMNode*/node){
+		// summary:
+		//		Delete a moveable item programmatically. The node is removed from the area.
+		// area:
+		//		A node corresponding to the DndArea.
+		// node:
+		//		The node which has to be treated.
+		// returns:
+		//		the removed node
+
+		//console.log("dojox.mdnd.AreaManager ::: removeDragItem");
+		var index = this._getIndexArea(area);
+		if(area && index !== -1){
+			var items = this._areaList[index].items;
+			for(var j = 0; j < items.length; j++){
+				if(items[j].item.node === node){
+					this._deleteMoveableItem(items[j]);
+					// delete item of the array
+					items.splice(j, 1);
+					return area.removeChild(node); // Object
+				}
+			}
+		}
+		return null;
+	},
+
+	_getChildren: function(/*DOMNode*/area){
+		// summary:
+		//		Get the children of a D&D area.
+		// area:
+		//		A DnD area.
+		// returns:
+		//		The children of a DnD area
+		// tags:
+		//		protected
+
+		//console.log("dojox.mdnd.AreaManager ::: _getChildren");
+		var children = [];
+		dojo.forEach(area.childNodes, function(child){
+			// delete \n
+			if(child.nodeType == 1){
+				if(dijit && dijit.byNode){
+					var widget = dijit.byNode(child);
+					if(widget){
+						if(!widget.dragRestriction){
+							children.push(child);
+						}
+					}
+					else{
+						children.push(child);
+					}
+				}
+				else{
+					children.push(child);
+				}
+			}
+		});
+		return children;	//Array
+	},
+
+	_setMarginArea: function(/*Object*/area,/*DOMNode*/node){
+		// summary:
+		//		Set the value of margin in the data type of areaManager
+		//		only when the margin has never been computed.
+		// area:
+		//		The object of a D&D Area.
+		// node:
+		//		The node which contains margins
+		// tags:
+		//		protected
+
+		//console.log("dojox.mdnd.AreaManager ::: _setMarginArea");
+		if(area && area.margin === null && node){
+			area.margin = dojo._getMarginExtents(node);
+		}
+	},
+
+	findCurrentIndexArea: function(/*Object*/coords, /*Object*/size){
+		// summary:
+		//		find the nearest target area according to coordinates.
+		//		Coordinates are representing by an object : for example, {'x':10,'y':10}
+		// coords:
+		//		an object encapsulating X and Y position
+		// size:
+		//		an object encapsulating the area size
+		// returns:
+		//		an index of area
+
+		//console.log("dojox.mdnd.AreaManager ::: findCurrentIndexArea");
+		this._oldIndexArea = this._currentIndexArea;
+		this._currentIndexArea = this._dropMode.getTargetArea(this._areaList, coords, this._currentIndexArea);
+		if(this._currentIndexArea != this._oldIndexArea){
+			if(this._oldIndexArea != -1){
+				this.onDragExit(coords, size);
+			}
+			if(this._currentIndexArea != -1){
+				this.onDragEnter(coords, size);
+			}
+		}
+		return this._currentIndexArea;	//Integer
+	},
+
+	_isAccepted: function(/*Array*/ type, /*Array*/ accept){
+		// summary:
+		//		True if user can drop widget on this node.
+		// type:
+		//		Array containing item type
+		// accept:
+		//		Array containing types
+		this._accept = false;
+		for(var i = 0; i < accept.length; ++i){
+			for(var j = 0; j < type.length;++j){
+				if(type[j] == accept[i]){
+					this._accept = true;
+					break;
+				}
+			}
+		}
+	},
+
+	onDragStart: function(/*DOMNode*/node, /*Object*/coords, /*Object*/size){
+		// summary:
+		//		Initialize the drag (see dojox.mdnd.Moveable.initOffsetDrag())
+		// node:
+		//		The node which is about to be dragged
+		// coords:
+		//		an object encapsulating X and Y position
+		// size:
+		//		an object encapsulating width and height values
+		// tags:
+		//		callback
+
+		//console.log("dojox.mdnd.AreaManager ::: onDragStart");
+		if(this.autoRefresh){
+			this._dropMode.updateAreas(this._areaList);
+		}
+
+		// Create the cover :
+		var _html = (dojo.isWebKit) ? dojo.body() : dojo.body().parentNode;
+		if(!this._cover){
+			this._cover = dojo.create('div', {
+				'class': "dndCover"
+			});
+			this._cover2 = dojo.clone(this._cover);
+			dojo.addClass(this._cover2, "dndCover2");
+		}
+		var h = _html.scrollHeight+"px";
+		this._cover.style.height = this._cover2.style.height = h;
+		dojo.body().appendChild(this._cover);
+		dojo.body().appendChild(this._cover2);
+
+		this._dragStartHandler = dojo.connect(node.ownerDocument, "ondragstart", dojo, "stopEvent");
+		// to know the source
+		this._sourceIndexArea = this._lastValidIndexArea = this._currentIndexArea = this._getIndexArea(node.parentNode);
+		// delete the dragItem into the source area
+		var sourceArea = this._areaList[this._sourceIndexArea];
+		var children = sourceArea.items;
+		for(var i = 0; i < children.length; i++){
+			if(children[i].item.node == node){
+				this._dragItem = children[i];
+				this._dragItem.handlers.push(dojo.connect(this._dragItem.item, "onDrag", this, "onDrag"));
+				this._dragItem.handlers.push(dojo.connect(this._dragItem.item, "onDragEnd", this, "onDrop"));
+				children.splice(i,1);
+				this._currentDropIndex = this._sourceDropIndex = i;
+				break;
+			}
+		}
+		var nodeRef = null;
+		if(this._sourceDropIndex !== sourceArea.items.length){
+			nodeRef = sourceArea.items[this._sourceDropIndex].item.node;
+		}
+		// IE7 OPTIMIZATION
+		if(dojo.isIE > 7){
+			// connect these events on the cover
+			this._eventsIE7 = [
+				dojo.connect(this._cover, "onmouseover", dojo, "stopEvent"),
+				dojo.connect(this._cover, "onmouseout", dojo, "stopEvent"),
+				dojo.connect(this._cover, "onmouseenter", dojo, "stopEvent"),
+				dojo.connect(this._cover, "onmouseleave", dojo, "stopEvent")
+			];
+		}
+
+		var s = node.style;
+		s.left = coords.x+"px";
+		s.top = coords.y+"px";
+		// attach the node to the cover
+		if(s.position == "relative" || s.position == ""){
+			s.position = "absolute"; // enforcing the absolute mode
+		}
+		this._cover.appendChild(node);
+
+		this._dropIndicator.place(sourceArea.node, nodeRef, size);
+		// add a style to place the _dragNode in foreground
+		dojo.addClass(node, "dragNode");
+		// A dragged node is always draggable in this source area.
+		this._accept = true;
+		dojo.publish("/dojox/mdnd/drag/start",[node, sourceArea, this._sourceDropIndex]);
+	},
+
+	onDragEnter: function(/*Object*/coords, /*Object*/size){
+		// summary:
+		//		Optionally called by the getTargetArea method of TargetFinder class.
+		// coords:
+		//		coordinates of the dragged Node.
+		// size:
+		//		size of the dragged Node.
+		// tags:
+		//		callback
+
+		//console.log("dojox.mdnd.AreaManager ::: onDragEnter", coords, size);
+		if(this._currentIndexArea === this._sourceIndexArea){
+			this._accept = true;
+		}
+		else{
+			this._isAccepted(this._dragItem.type, this._areaList[this._currentIndexArea].accept);
+		}
+	},
+
+	onDragExit: function(/*Object*/coords, /*Object*/size){
+		// summary:
+		//		Optionally called by the getTargetArea method of TargetFinder class.
+		// coords:
+		//		coordinates of the dragged Node.
+		// size:
+		//		size of the dragged Node.
+		// tags:
+		//		callback
+
+		//console.log("dojox.mdnd.AreaManager ::: onDragExit");
+		this._accept = false;
+	},
+
+	onDrag: function(/*DOMNode*/node, /*Object*/coords, /*Object*/size, /*Object*/mousePosition){
+		// summary:
+		//		Occurs when the dojo.dnd.Moveable.onDrag is fired.
+		//		Search the nearest target area and called the placeDropIndicator
+		// node:
+		//		The node which is dragged
+		// coords:
+		//		an object encapsulating X and Y position
+		// size:
+		//		an object encapsulating width and height values
+		// mousePosition:
+		//		coordinates of mouse
+		// tags:
+		//		callback
+
+		//console.log("dojox.mdnd.AreaManager ::: onDrag", node, ",", coords,size);
+		var coordinates = this._dropMode.getDragPoint(coords, size, mousePosition);
+		this.findCurrentIndexArea(coordinates, size);
+		if(this._currentIndexArea !== -1 && this._accept){
+			this.placeDropIndicator(coordinates, size);
+		}
+	},
+
+	placeDropIndicator: function(/*Object*/coords, /*Object*/size){
+		// summary:
+		//		Search the right place to insert the dropIndicator and display the dropIndicator.
+		// coords:
+		//		an object encapsulating X and Y position
+		// size:
+		//		an object encapsulating width and height values
+		// returns:
+		//		the current drop index
+
+		//console.log("dojox.mdnd.AreaManager ::: placeDropIndicator");
+		//keep old drop Index
+		this._oldDropIndex = this._currentDropIndex;
+		// calculate all children marker (see VerticalDropMode.initItems())
+		var area = this._areaList[this._currentIndexArea];
+		if(!area.initItems){
+			this._dropMode.initItems(area);
+		}
+		//get the index where the drop has to be placed.
+		this._currentDropIndex = this._dropMode.getDropIndex(area, coords);
+		if(!(this._currentIndexArea === this._oldIndexArea && this._oldDropIndex === this._currentDropIndex)){
+			this._placeDropIndicator(size);
+		}
+		return this._currentDropIndex;	//Integer
+	},
+
+	_placeDropIndicator: function(/*Object*/size){
+		// summary:
+		//		place the dropIndicator
+		// size:
+		//		an object encapsulating width and height values
+		// tags:
+		//		protected
+
+		var oldArea = this._areaList[this._lastValidIndexArea];
+		var currentArea = this._areaList[this._currentIndexArea];
+		//refresh the previous area after moving out the drop indicator
+		this._dropMode.refreshItems(oldArea, this._oldDropIndex, size, false);
+		// place dropIndicator
+		var node = null;
+		if(this._currentDropIndex != -1){
+			node = currentArea.items[this._currentDropIndex].item.node;
+		}
+		this._dropIndicator.place(currentArea.node, node);
+		this._lastValidIndexArea = this._currentIndexArea;
+		//refresh the current area after placing the drop indicator
+		this._dropMode.refreshItems(currentArea, this._currentDropIndex, size, true);
+	},
+
+	onDropCancel: function(){
+		// summary:
+		//		Cancel the drop.
+		//		The dragNode returns into the source.
+		// tags:
+		//		callback
+
+		//console.log("dojox.mdnd.AreaManager ::: onDropCancel");
+		if(!this._accept){
+			var index = this._getIndexArea(this._dropIndicator.node.parentNode);
+			if(index != -1){
+				this._currentIndexArea = index;
+			}
+			else{
+				// case if the dropIndicator is in the area which has been unregistered during the drag.
+				// chose by default the first area.
+				this._currentIndexArea = 0;
+			}
+		}
+	},
+
+	onDrop: function(/*DOMNode*/node){
+		// summary:
+		//		Drop the dragged item where the dropIndicator is displayed.
+		// node:
+		//		The node which is about to be dropped
+		// tags:
+		//		callback
+
+		//console.log("dojox.mdnd.AreaManager ::: onDrop");
+		//dropCancel
+		this.onDropCancel();
+		var targetArea = this._areaList[this._currentIndexArea];
+		dojo.removeClass(node, "dragNode");
+		var style = node.style;
+		style.position = "relative";
+		style.left = "0";
+		style.top = "0";
+		style.width = "auto";
+		if(targetArea.node == this._dropIndicator.node.parentNode){
+			targetArea.node.insertBefore(node, this._dropIndicator.node);
+		}
+		else{
+			// case if the dropIndicator is in the area which has been unregistered during the drag.
+			targetArea.node.appendChild(node);
+			this._currentDropIndex = targetArea.items.length;
+		}
+		// add child into the new target area.
+		var indexChild = this._currentDropIndex;
+		if(indexChild == -1){
+			indexChild = targetArea.items.length;
+		}
+		var children = targetArea.items;
+		var firstListArea = children.slice(0, indexChild);
+		var lastListArea = children.slice(indexChild, children.length);
+		firstListArea[firstListArea.length] = this._dragItem;
+		targetArea.items = firstListArea.concat(lastListArea);
+
+		this._setMarginArea(targetArea, node);
+		dojo.forEach(this._areaList, function(obj){
+			obj.initItems = false;
+		});
+		// disconnect onDrop handler
+		dojo.disconnect(this._dragItem.handlers.pop());
+		dojo.disconnect(this._dragItem.handlers.pop());
+		this._resetAfterDrop();
+		// remove the cover
+		if(this._cover){
+			dojo.body().removeChild(this._cover);
+			dojo.body().removeChild(this._cover2);
+		}
+		dojo.publish("/dojox/mdnd/drop",[node, targetArea, indexChild]);
+	},
+
+	_resetAfterDrop: function(){
+		// summary:
+		//		reset manager properties after dropping an item
+		// tags:
+		//		protected
+
+		this._accept = false;
+		this._dragItem = null;
+		this._currentDropIndex = -1;
+		this._currentIndexArea = -1;
+		this._oldDropIndex = -1;
+		this._sourceIndexArea = -1;
+		this._sourceDropIndex = -1;
+		this._dropIndicator.remove();
+		if(this._dragStartHandler){
+			dojo.disconnect(this._dragStartHandler);
+		}
+		if(dojo.isIE > 7){
+			dojo.forEach(this._eventsIE7, dojo.disconnect);
+		}
+	},
+
+	destroy: function(){
+		// summary:
+		//		Destroy the component.
+
+		//console.log("dojox.mdnd.AreaManager ::: destroy");
+		//see implementation of unregister()
+		while(this._areaList.length > 0){
+			if(!this.unregister(this._areaList[0].node)){
+				throw new Error("Error while destroying AreaManager");
+			}
+		}
+		dojo.disconnect(this.resizeHandler);
+		this._dropIndicator.destroy();
+		this._dropMode.destroy();
+		if(dojox.mdnd.autoScroll){
+			dojox.mdnd.autoScroll.destroy();
+		}
+		if(this.refreshListener){
+			dojo.unsubscribe(this.refreshListener);
+		}
+		// destroy the cover
+		if(this._cover){
+			dojo._destroyElement(this._cover);
+			dojo._destroyElement(this._cover2);
+			delete this._cover;
+			delete this._cover2;
+		}
+	}
+});
+
+if(dijit && dijit._Widget){
+	//	Add a new property to widget
+	dojo.extend(dijit._Widget, {
+		// dndType: String
+		//		Defines a type of widget.
+		dndType : "text"
+	});
+}
+
+dojox.mdnd._areaManager = null;
+dojox.mdnd.areaManager = function(){
+	// summary:
+	//		Returns the current areaManager, creates one if it is not created yet.
+	if(!dojox.mdnd._areaManager){
+		dojox.mdnd._areaManager = new dojox.mdnd.AreaManager();
+	}
+	return dojox.mdnd._areaManager;	// Object
+};