709 lines
21 KiB
JavaScript
709 lines
21 KiB
JavaScript
//>>built
|
|
define("dojox/mdnd/AreaManager", ["dojo/_base/kernel","dojo/_base/declare","dojo/_base/connect","dojo/_base/window",
|
|
"dojo/_base/array","dojo/query","dojo/_base/html","./Moveable"],function(dojo){
|
|
var am = 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
|
|
};
|
|
return am;
|
|
}); |