diff options
Diffstat (limited to 'js/dojo/dojox/mdnd/AreaManager.js')
| -rw-r--r-- | js/dojo/dojox/mdnd/AreaManager.js | 709 |
1 files changed, 709 insertions, 0 deletions
diff --git a/js/dojo/dojox/mdnd/AreaManager.js b/js/dojo/dojox/mdnd/AreaManager.js new file mode 100644 index 0000000..e7c09e6 --- /dev/null +++ b/js/dojo/dojox/mdnd/AreaManager.js @@ -0,0 +1,709 @@ +//>>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; +});
\ No newline at end of file |