define("dojo/dnd/Source", [ "../_base/array", "../_base/connect", "../_base/declare", "../_base/kernel", "../_base/lang", "../dom-class", "../dom-geometry", "../mouse", "../ready", "../topic", "./common", "./Selector", "./Manager" ], function(array, connect, declare, kernel, lang, domClass, domGeom, mouse, ready, topic, dnd, Selector, Manager){ // module: // dojo/dnd/Source /* Container property: "Horizontal"- if this is the horizontal container Source states: "" - normal state "Moved" - this source is being moved "Copied" - this source is being copied Target states: "" - normal state "Disabled" - the target cannot accept an avatar Target anchor state: "" - item is not selected "Before" - insert point is before the anchor "After" - insert point is after the anchor */ /*===== var __SourceArgs = { // summary: // a dict of parameters for DnD Source configuration. Note that any // property on Source elements may be configured, but this is the // short-list // isSource: Boolean? // can be used as a DnD source. Defaults to true. // accept: Array? // list of accepted types (text strings) for a target; defaults to // ["text"] // autoSync: Boolean // if true refreshes the node list on every operation; false by default // copyOnly: Boolean? // copy items, if true, use a state of Ctrl key otherwise, // see selfCopy and selfAccept for more details // delay: Number // the move delay in pixels before detecting a drag; 0 by default // horizontal: Boolean? // a horizontal container, if true, vertical otherwise or when omitted // selfCopy: Boolean? // copy items by default when dropping on itself, // false by default, works only if copyOnly is true // selfAccept: Boolean? // accept its own items when copyOnly is true, // true by default, works only if copyOnly is true // withHandles: Boolean? // allows dragging only by handles, false by default // generateText: Boolean? // generate text node for drag and drop, true by default }; =====*/ // For back-compat, remove in 2.0. if(!kernel.isAsync){ ready(0, function(){ var requires = ["dojo/dnd/AutoSource", "dojo/dnd/Target"]; require(requires); // use indirection so modules not rolled into a build }); } var Source = declare("dojo.dnd.Source", Selector, { // summary: // a Source object, which can be used as a DnD source, or a DnD target // object attributes (for markup) isSource: true, horizontal: false, copyOnly: false, selfCopy: false, selfAccept: true, skipForm: false, withHandles: false, autoSync: false, delay: 0, // pixels accept: ["text"], generateText: true, constructor: function(/*DOMNode|String*/ node, /*__SourceArgs?*/ params){ // summary: // a constructor of the Source // node: // node or node's id to build the source on // params: // any property of this class may be configured via the params // object which is mixed-in to the `dojo/dnd/Source` instance lang.mixin(this, lang.mixin({}, params)); var type = this.accept; 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; this._lastX = 0; this._lastY = 0; // states this.sourceState = ""; if(this.isSource){ domClass.add(this.node, "dojoDndSource"); } this.targetState = ""; if(this.accept){ domClass.add(this.node, "dojoDndTarget"); } if(this.horizontal){ domClass.add(this.node, "dojoDndHorizontal"); } // set up events this.topics = [ topic.subscribe("/dnd/source/over", lang.hitch(this, "onDndSourceOver")), topic.subscribe("/dnd/start", lang.hitch(this, "onDndStart")), topic.subscribe("/dnd/drop", lang.hitch(this, "onDndDrop")), topic.subscribe("/dnd/cancel", lang.hitch(this, "onDndCancel")) ]; }, // 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 if(this == source){ return !this.copyOnly || this.selfAccept; } for(var i = 0; i < nodes.length; ++i){ var type = source.getItem(nodes[i].id).type; // type instanceof Array var flag = false; for(var j = 0; j < type.length; ++j){ if(type[j] in this.accept){ flag = true; break; } } if(!flag){ return false; // Boolean } } return true; // Boolean }, copyState: function(keyPressed, self){ // 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" key was pressed // self: Boolean? // optional flag that means that we are about to drop on itself if(keyPressed){ return true; } if(arguments.length < 2){ self = this == Manager.manager().target; } if(self){ if(this.copyOnly){ return this.selfCopy; } }else{ return this.copyOnly; } return false; // Boolean }, destroy: function(){ // summary: // prepares the object to be garbage-collected Source.superclass.destroy.call(this); array.forEach(this.topics, function(t){t.remove();}); this.targetAnchor = null; }, // mouse event processors onMouseMove: function(e){ // summary: // event processor for onmousemove // e: Event // mouse event if(this.isDragging && this.targetState == "Disabled"){ return; } Source.superclass.onMouseMove.call(this, e); var m = Manager.manager(); if(!this.isDragging){ if(this.mouseDown && this.isSource && (Math.abs(e.pageX - this._lastX) > this.delay || Math.abs(e.pageY - this._lastY) > this.delay)){ var nodes = this.getSelectedNodes(); if(nodes.length){ m.startDrag(this, nodes, this.copyState(dnd.getCopyKeyState(e), true)); } } } if(this.isDragging){ // calculate before/after var before = false; if(this.current){ if(!this.targetBox || this.targetAnchor != this.current){ this.targetBox = domGeom.position(this.current, true); } if(this.horizontal){ // In LTR mode, the left part of the object means "before", but in RTL mode it means "after". before = (e.pageX - this.targetBox.x < this.targetBox.w / 2) == domGeom.isBodyLtr(this.current.ownerDocument); }else{ before = (e.pageY - this.targetBox.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)); } } }, onMouseDown: function(e){ // summary: // event processor for onmousedown // e: Event // mouse event if(!this.mouseDown && this._legalMouseDown(e) && (!this.skipForm || !dnd.isFormElement(e))){ this.mouseDown = true; this._lastX = e.pageX; this._lastY = e.pageY; Source.superclass.onMouseDown.call(this, e); } }, onMouseUp: function(e){ // summary: // event processor for onmouseup // e: Event // mouse event if(this.mouseDown){ this.mouseDown = false; Source.superclass.onMouseUp.call(this, e); } }, // 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 = Manager.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.autoSync){ this.sync(); } if(this.isSource){ this._changeState("Source", this == source ? (copy ? "Copied" : "Moved") : ""); } var accepted = this.accept && this.checkAcceptance(source, nodes); this._changeState("Target", accepted ? "" : "Disabled"); if(this == source){ Manager.manager().overSource(this); } this.isDragging = true; }, onDndDrop: function(source, nodes, copy, target){ // summary: // topic event processor for /dnd/drop, called to finish 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 // target: Object // the target which accepts items if(this == target){ // this one is for us => move nodes! this.onDrop(source, nodes, copy); } 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; this._changeState("Source", ""); this._changeState("Target", ""); }, // local events onDrop: function(source, nodes, copy){ // summary: // called only on the current target, when drop is performed // 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 != source){ this.onDropExternal(source, nodes, copy); }else{ this.onDropInternal(nodes, copy); } }, onDropExternal: function(source, nodes, copy){ // summary: // called only on the current target, when drop is performed // from an external source // source: Object // the source which provides items // nodes: Array // the list of transferred items // copy: Boolean // copy items, if true, move items otherwise var oldCreator = this._normalizedCreator; // transferring nodes from the source to the target if(this.creator){ // use defined creator this._normalizedCreator = function(node, hint){ return oldCreator.call(this, source.getItem(node.id).data, hint); }; }else{ // we have no creator defined => move/clone nodes if(copy){ // clone nodes this._normalizedCreator = function(node /*=====, hint =====*/){ var t = source.getItem(node.id); var n = node.cloneNode(true); n.id = dnd.getUniqueId(); return {node: n, data: t.data, type: t.type}; }; }else{ // move nodes this._normalizedCreator = function(node /*=====, hint =====*/){ var t = source.getItem(node.id); source.delItem(node.id); return {node: node, data: t.data, type: t.type}; }; } } this.selectNone(); if(!copy && !this.creator){ source.selectNone(); } this.insertNodes(true, nodes, this.before, this.current); if(!copy && this.creator){ source.deleteSelectedNodes(); } this._normalizedCreator = oldCreator; }, onDropInternal: function(nodes, copy){ // summary: // called only on the current target, when drop is performed // from the same target/source // nodes: Array // the list of transferred items // copy: Boolean // copy items, if true, move items otherwise var oldCreator = this._normalizedCreator; // transferring nodes within the single source if(this.current && this.current.id in this.selection){ // do nothing return; } if(copy){ if(this.creator){ // create new copies of data items this._normalizedCreator = function(node, hint){ return oldCreator.call(this, this.getItem(node.id).data, hint); }; }else{ // clone nodes this._normalizedCreator = function(node/*=====, hint =====*/){ var t = this.getItem(node.id); var n = node.cloneNode(true); n.id = dnd.getUniqueId(); return {node: n, data: t.data, type: t.type}; }; } }else{ // move nodes if(!this.current){ // do nothing return; } this._normalizedCreator = function(node /*=====, hint =====*/){ var t = this.getItem(node.id); return {node: node, data: t.data, type: t.type}; }; } this._removeSelection(); this.insertNodes(true, nodes, this.before, this.current); this._normalizedCreator = oldCreator; }, onDraggingOver: function(){ // summary: // called during the active DnD operation, when items // are dragged over this target, and it is not disabled }, onDraggingOut: function(){ // summary: // called during the active DnD operation, when items // are dragged away from this target, and it is not disabled }, // utilities onOverEvent: function(){ // summary: // this function is called once, when mouse is over our container Source.superclass.onOverEvent.call(this); Manager.manager().overSource(this); if(this.isDragging && this.targetState != "Disabled"){ this.onDraggingOver(); } }, onOutEvent: function(){ // summary: // this function is called once, when mouse is out of our container Source.superclass.onOutEvent.call(this); Manager.manager().outSource(this); if(this.isDragging && this.targetState != "Disabled"){ this.onDraggingOut(); } }, _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"); }, _legalMouseDown: function(e){ // summary: // checks if user clicked on "approved" items // e: Event // mouse event // accept only the left mouse button, or the left finger if(e.type != "touchstart" && !mouse.isLeft(e)){ return false; } if(!this.withHandles){ return true; } // check for handles for(var node = e.target; node && node !== this.node; node = node.parentNode){ if(domClass.contains(node, "dojoDndHandle")){ return true; } if(domClass.contains(node, "dojoDndItem") || domClass.contains(node, "dojoDndIgnore")){ break; } } return false; // Boolean } }); return Source; });