| New file |
|---|
| 0,0 → 1,375 |
|---|
| if(!dojo._hasResource["dojo.dnd.Source"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojo.dnd.Source"] = true; |
| dojo.provide("dojo.dnd.Source"); |
| |
| dojo.require("dojo.dnd.Selector"); |
| dojo.require("dojo.dnd.Manager"); |
| |
| /* |
| 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 |
| */ |
| |
| dojo.declare("dojo.dnd.Source", dojo.dnd.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, |
| skipForm: false, |
| withHandles: false, |
| accept: ["text"], |
| |
| constructor: function(node, params){ |
| // summary: a constructor of the Source |
| // node: Node: node or node's id 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 |
| // withHandles: Boolean: allows dragging only by handles |
| // the rest of parameters are passed to the selector |
| if(!params){ 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; |
| } |
| } |
| this.horizontal = params.horizontal; |
| this.copyOnly = params.copyOnly; |
| this.withHandles = params.withHandles; |
| // 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") |
| ]; |
| }, |
| |
| // 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 true; } |
| 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){ |
| // 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 |
| dojo.dnd.Source.superclass.destroy.call(this); |
| dojo.forEach(this.topics, dojo.unsubscribe); |
| this.targetAnchor = null; |
| }, |
| |
| // markup methods |
| markupFactory: function(params, node){ |
| params._skipStartup = true; |
| return new dojo.dnd.Source(node, params); |
| }, |
| |
| // mouse event processors |
| onMouseMove: function(e){ |
| // summary: event processor for onmousemove |
| // e: Event: mouse event |
| if(this.isDragging && this.targetState == "Disabled"){ return; } |
| dojo.dnd.Source.superclass.onMouseMove.call(this, e); |
| var m = dojo.dnd.manager(); |
| if(this.isDragging){ |
| // calculate before/after |
| 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 nodes = this.getSelectedNodes(); |
| 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 |
| if(this._legalMouseDown(e) && (!this.skipForm || !dojo.dnd.isFormElement(e))){ |
| this.mouseDown = true; |
| this.mouseButton = e.button; |
| dojo.dnd.Source.superclass.onMouseDown.call(this, e); |
| } |
| }, |
| onMouseUp: function(e){ |
| // summary: event processor for onmouseup |
| // e: Event: mouse event |
| if(this.mouseDown){ |
| this.mouseDown = false; |
| dojo.dnd.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 = 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.accept && this.checkAcceptance(source, nodes); |
| this._changeState("Target", accepted ? "" : "Disabled"); |
| if(accepted && this == source){ |
| dojo.dnd.manager().overSource(this); |
| } |
| this.isDragging = true; |
| }, |
| onDndDrop: function(source, nodes, copy){ |
| // 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 |
| do{ //break box |
| if(this.containerState != "Over"){ break; } |
| var oldCreator = this._normalizedCreator; |
| if(this != source){ |
| // 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 = dojo.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}; |
| }; |
| } |
| } |
| }else{ |
| // transferring nodes within the single source |
| if(this.current && this.current.id in this.selection){ break; } |
| if(this.creator){ |
| // use defined creator |
| if(copy){ |
| // create new copies of data items |
| this._normalizedCreator = function(node, hint){ |
| return oldCreator.call(this, source.getItem(node.id).data, hint); |
| }; |
| }else{ |
| // move nodes |
| if(!this.current){ break; } |
| this._normalizedCreator = function(node, hint){ |
| var t = source.getItem(node.id); |
| return {node: node, data: t.data, type: t.type}; |
| }; |
| } |
| }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 = dojo.dnd.getUniqueId(); |
| return {node: n, data: t.data, type: t.type}; |
| }; |
| }else{ |
| // move nodes |
| if(!this.current){ break; } |
| this._normalizedCreator = function(node, hint){ |
| var t = source.getItem(node.id); |
| return {node: node, data: t.data, type: t.type}; |
| }; |
| } |
| } |
| } |
| this._removeSelection(); |
| if(this != source){ |
| this._removeAnchor(); |
| } |
| if(this != source && !copy && !this.creator){ |
| source.selectNone(); |
| } |
| this.insertNodes(true, nodes, this.before, this.current); |
| if(this != source && !copy && this.creator){ |
| source.deleteSelectedNodes(); |
| } |
| this._normalizedCreator = oldCreator; |
| }while(false); |
| 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 |
| dojo.dnd.Source.superclass.onOverEvent.call(this); |
| dojo.dnd.manager().overSource(this); |
| }, |
| onOutEvent: function(){ |
| // summary: this function is called once, when mouse is out of our container |
| dojo.dnd.Source.superclass.onOutEvent.call(this); |
| 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"); |
| }, |
| _legalMouseDown: function(e){ |
| // summary: checks if user clicked on "approved" items |
| // e: Event: mouse event |
| if(!this.withHandles){ return true; } |
| for(var node = e.target; node && !dojo.hasClass(node, "dojoDndItem"); node = node.parentNode){ |
| if(dojo.hasClass(node, "dojoDndHandle")){ return true; } |
| } |
| return false; // Boolean |
| } |
| }); |
| |
| dojo.declare("dojo.dnd.Target", dojo.dnd.Source, { |
| // 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 dojo.dnd.Target(node, params); |
| } |
| }); |
| |
| } |