diff options
Diffstat (limited to 'includes/js/dijit/_tree/dndSource.js')
| -rw-r--r-- | includes/js/dijit/_tree/dndSource.js | 373 |
1 files changed, 373 insertions, 0 deletions
diff --git a/includes/js/dijit/_tree/dndSource.js b/includes/js/dijit/_tree/dndSource.js new file mode 100644 index 0000000..ccb91ad --- /dev/null +++ b/includes/js/dijit/_tree/dndSource.js @@ -0,0 +1,373 @@ +if(!dojo._hasResource["dijit._tree.dndSource"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. +dojo._hasResource["dijit._tree.dndSource"] = true; +dojo.provide("dijit._tree.dndSource"); + +dojo.require("dijit._tree.dndSelector"); +dojo.require("dojo.dnd.Manager"); + +dojo.declare("dijit._tree.dndSource", dijit._tree.dndSelector, { + // summary: a Source object, which can be used as a DnD source, or a DnD target + + // object attributes (for markup) + isSource: true, + copyOnly: false, + skipForm: false, + accept: ["text"], + + constructor: function(tree, params){ + // summary: a constructor of the Source + // tree: dijit.Tree: the tree widget to build the source on + // params: Object: a dict of parameters, recognized parameters are: + // isSource: Boolean: can be used as a DnD source, if true; assumed to be "true" if omitted + // accept: Array: list of accepted types (text strings) for a target; assumed to be ["text"] if omitted + // horizontal: Boolean: a horizontal container, if true, vertical otherwise or when omitted + // copyOnly: Boolean: always copy items, if true, use a state of Ctrl key otherwise + // skipForm: Boolean: don't start the drag operation, if clicked on form elements + // the rest of parameters are passed to the selector + if(!params){ params = {}; } + dojo.mixin(this, params); + this.isSource = typeof params.isSource == "undefined" ? true : params.isSource; + var type = params.accept instanceof Array ? params.accept : ["text"]; + this.accept = null; + if(type.length){ + this.accept = {}; + for(var i = 0; i < type.length; ++i){ + this.accept[type[i]] = 1; + } + } + + // class-specific variables + this.isDragging = false; + this.mouseDown = false; + this.targetAnchor = null; + this.targetBox = null; + this.before = true; + + // states + this.sourceState = ""; + if(this.isSource){ + dojo.addClass(this.node, "dojoDndSource"); + } + this.targetState = ""; + if(this.accept){ + dojo.addClass(this.node, "dojoDndTarget"); + } + if(this.horizontal){ + dojo.addClass(this.node, "dojoDndHorizontal"); + } + // set up events + this.topics = [ + dojo.subscribe("/dnd/source/over", this, "onDndSourceOver"), + dojo.subscribe("/dnd/start", this, "onDndStart"), + dojo.subscribe("/dnd/drop", this, "onDndDrop"), + dojo.subscribe("/dnd/cancel", this, "onDndCancel") + ]; + }, + + startup: function(){ + }, + + // methods + checkAcceptance: function(source, nodes){ + // summary: checks, if the target can accept nodes from this source + // source: Object: the source which provides items + // nodes: Array: the list of transferred items + return true; // Boolean + }, + copyState: function(keyPressed){ + // summary: Returns true, if we need to copy items, false to move. + // It is separated to be overwritten dynamically, if needed. + // keyPressed: Boolean: the "copy" was pressed + return this.copyOnly || keyPressed; // Boolean + }, + destroy: function(){ + // summary: prepares the object to be garbage-collected + this.inherited("destroy",arguments); + dojo.forEach(this.topics, dojo.unsubscribe); + this.targetAnchor = null; + }, + + // markup methods + markupFactory: function(params, node){ + params._skipStartup = true; + return new dijit._tree.dndSource(node, params); + }, + + // mouse event processors + onMouseMove: function(e){ + // summary: event processor for onmousemove + // e: Event: mouse event + if(this.isDragging && this.targetState == "Disabled"){ return; } + this.inherited("onMouseMove", arguments); + var m = dojo.dnd.manager(); + if(this.isDragging){ + // calculate before/after + + if (this.allowBetween){ // not implemented yet for tree since it has no concept of order + var before = false; + if(this.current){ + if(!this.targetBox || this.targetAnchor != this.current){ + this.targetBox = { + xy: dojo.coords(this.current, true), + w: this.current.offsetWidth, + h: this.current.offsetHeight + }; + } + if(this.horizontal){ + before = (e.pageX - this.targetBox.xy.x) < (this.targetBox.w / 2); + }else{ + before = (e.pageY - this.targetBox.xy.y) < (this.targetBox.h / 2); + } + } + if(this.current != this.targetAnchor || before != this.before){ + this._markTargetAnchor(before); + m.canDrop(!this.current || m.source != this || !(this.current.id in this.selection)); + } + } + }else{ + if(this.mouseDown && this.isSource){ + var n = this.getSelectedNodes(); + var nodes=[]; + for (var i in n){ + nodes.push(n[i]); + } + if(nodes.length){ + m.startDrag(this, nodes, this.copyState(dojo.dnd.getCopyKeyState(e))); + } + } + } + }, + + onMouseDown: function(e){ + // summary: event processor for onmousedown + // e: Event: mouse event + this.mouseDown = true; + this.mouseButton = e.button; + this.inherited("onMouseDown",arguments); + }, + + onMouseUp: function(e){ + // summary: event processor for onmouseup + // e: Event: mouse event + if(this.mouseDown){ + this.mouseDown = false; + this.inherited("onMouseUp",arguments); + } + }, + + onMouseOver: function(e){ + // summary: event processor for onmouseover + // e: Event: mouse event + + // handle when mouse has just moved over the Tree itself (not a TreeNode, but the Tree) + var rt = e.relatedTarget; // the previous location + while(rt){ + if(rt == this.node){ break; } + try{ + rt = rt.parentNode; + }catch(x){ + rt = null; + } + } + if(!rt){ + this._changeState("Container", "Over"); + this.onOverEvent(); + } + + // code below is for handling depending on which TreeNode we are over + var n = this._getChildByEvent(e); // the TreeNode + if(this.current == n){ return; } + if(this.current){ this._removeItemClass(this.current, "Over"); } + var m = dojo.dnd.manager(); + if(n){ + this._addItemClass(n, "Over"); + if(this.isDragging){ + if(this.checkItemAcceptance(n,m.source)){ + m.canDrop(this.targetState != "Disabled" && (!this.current || m.source != this || !(n in this.selection))); + }else{ + m.canDrop(false); + } + } + }else{ + if(this.isDragging){ + if (m.source && this.checkAcceptance(m.source,m.source.getSelectedNodes())){ + m.canDrop(this.targetState != "Disabled" && (!this.current || m.source != this || !(this.current.id in this.selection))); + }else{ + m.canDrop(false); + } + } + } + this.current = n; + }, + + checkItemAcceptance: function(node, source){ + // summary: stub funciton to be overridden if one wants to check for the ability to drop at the node/item level + return true; + }, + + // topic event processors + onDndSourceOver: function(source){ + // summary: topic event processor for /dnd/source/over, called when detected a current source + // source: Object: the source which has the mouse over it + if(this != source){ + this.mouseDown = false; + if(this.targetAnchor){ + this._unmarkTargetAnchor(); + } + }else if(this.isDragging){ + var m = dojo.dnd.manager(); + m.canDrop(this.targetState != "Disabled" && (!this.current || m.source != this || !(this.current.id in this.selection))); + } + }, + onDndStart: function(source, nodes, copy){ + // summary: topic event processor for /dnd/start, called to initiate the DnD operation + // source: Object: the source which provides items + // nodes: Array: the list of transferred items + // copy: Boolean: copy items, if true, move items otherwise + + if(this.isSource){ + this._changeState("Source", this == source ? (copy ? "Copied" : "Moved") : ""); + } + var accepted = this.checkAcceptance(source, nodes); + + this._changeState("Target", accepted ? "" : "Disabled"); + + if(accepted){ + dojo.dnd.manager().overSource(this); + } + + this.isDragging = true; + }, + + itemCreator: function(nodes){ + return dojo.map(nodes, function(node){ + return { + "id": node.id, + "name": node.textContent || node.innerText || "" + }; + }); + }, + + onDndDrop: function(source, nodes, copy){ + // summary: + // Topic event processor for /dnd/drop, called to finish the DnD operation.. + // Updates data store items according to where node was dragged from and dropped + // to. The tree will then respond to those data store updates and redraw itself. + // source: Object: the source which provides items + // nodes: Array: the list of transferred items + // copy: Boolean: copy items, if true, move items otherwise + + if(this.containerState == "Over"){ + var tree = this.tree, + model = tree.model, + target = this.current, + requeryRoot = false; // set to true iff top level items change + + this.isDragging = false; + + // Compute the new parent item + var targetWidget = dijit.getEnclosingWidget(target), + newParentItem = (targetWidget && targetWidget.item) || tree.item; + + // If we are dragging from another source (or at least, another source + // that points to a different data store), then we need to make new data + // store items for each element in nodes[]. This call get the parameters + // to pass to store.newItem() + var newItemsParams; + if(source != this){ + newItemsParams = this.itemCreator(nodes, target); + } + + dojo.forEach(nodes, function(node, idx){ + if(source == this){ + // This is a node from my own tree, and we are moving it, not copying. + // Remove item from old parent's children attribute. + // TODO: dijit._tree.dndSelector should implement deleteSelectedNodes() + // and this code should go there. + var childTreeNode = dijit.getEnclosingWidget(node), + childItem = childTreeNode.item, + oldParentItem = childTreeNode.getParent().item; + + model.pasteItem(childItem, oldParentItem, newParentItem, copy); + }else{ + model.newItem(newItemsParams[idx], newParentItem); + } + }, this); + + // Expand the target node (if it's currently collapsed) so the user can see + // where their node was dropped. In particular since that node is still selected. + this.tree._expandNode(targetWidget); + } + this.onDndCancel(); + }, + onDndCancel: function(){ + // summary: topic event processor for /dnd/cancel, called to cancel the DnD operation + if(this.targetAnchor){ + this._unmarkTargetAnchor(); + this.targetAnchor = null; + } + this.before = true; + this.isDragging = false; + this.mouseDown = false; + delete this.mouseButton; + this._changeState("Source", ""); + this._changeState("Target", ""); + }, + + // utilities + + onOverEvent: function(){ + // summary: this function is called once, when mouse is over our container + this.inherited("onOverEvent",arguments); + dojo.dnd.manager().overSource(this); + }, + onOutEvent: function(){ + // summary: this function is called once, when mouse is out of our container + this.inherited("onOutEvent",arguments); + dojo.dnd.manager().outSource(this); + }, + _markTargetAnchor: function(before){ + // summary: assigns a class to the current target anchor based on "before" status + // before: Boolean: insert before, if true, after otherwise + if(this.current == this.targetAnchor && this.before == before){ return; } + if(this.targetAnchor){ + this._removeItemClass(this.targetAnchor, this.before ? "Before" : "After"); + } + this.targetAnchor = this.current; + this.targetBox = null; + this.before = before; + if(this.targetAnchor){ + this._addItemClass(this.targetAnchor, this.before ? "Before" : "After"); + } + }, + _unmarkTargetAnchor: function(){ + // summary: removes a class of the current target anchor based on "before" status + if(!this.targetAnchor){ return; } + this._removeItemClass(this.targetAnchor, this.before ? "Before" : "After"); + this.targetAnchor = null; + this.targetBox = null; + this.before = true; + }, + _markDndStatus: function(copy){ + // summary: changes source's state based on "copy" status + this._changeState("Source", copy ? "Copied" : "Moved"); + } +}); + +dojo.declare("dijit._tree.dndTarget", dijit._tree.dndSource, { + // summary: a Target object, which can be used as a DnD target + + constructor: function(node, params){ + // summary: a constructor of the Target --- see the Source constructor for details + this.isSource = false; + dojo.removeClass(this.node, "dojoDndSource"); + }, + + // markup methods + markupFactory: function(params, node){ + params._skipStartup = true; + return new dijit._tree.dndTarget(node, params); + } +}); + +} |