diff options
author | Andrew Dolgov <[email protected]> | 2011-11-08 20:40:44 +0400 |
---|---|---|
committer | Andrew Dolgov <[email protected]> | 2011-11-08 20:40:44 +0400 |
commit | 81bea17aefb26859f825b9293c7c99192874806e (patch) | |
tree | fb244408ca271affa2899adb634788802c9a89d8 /lib/dijit/tree/dndSource.js | |
parent | 870a70e109ac9e80a88047044530de53d0404ec7 (diff) |
upgrade Dojo to 1.6.1
Diffstat (limited to 'lib/dijit/tree/dndSource.js')
-rw-r--r-- | lib/dijit/tree/dndSource.js | 762 |
1 files changed, 533 insertions, 229 deletions
diff --git a/lib/dijit/tree/dndSource.js b/lib/dijit/tree/dndSource.js index ef129d9cb..4fc4660cc 100644 --- a/lib/dijit/tree/dndSource.js +++ b/lib/dijit/tree/dndSource.js @@ -1,240 +1,544 @@ /* - Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved. + Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved. Available via Academic Free License >= 2.1 OR the modified BSD license. see: http://dojotoolkit.org/license for details */ -if(!dojo._hasResource["dijit.tree.dndSource"]){ -dojo._hasResource["dijit.tree.dndSource"]=true; +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,{isSource:true,accept:["text","treeNode"],copyOnly:false,dragThreshold:5,betweenThreshold:0,constructor:function(_1,_2){ -if(!_2){ -_2={}; -} -dojo.mixin(this,_2); -this.isSource=typeof _2.isSource=="undefined"?true:_2.isSource; -var _3=_2.accept instanceof Array?_2.accept:["text","treeNode"]; -this.accept=null; -if(_3.length){ -this.accept={}; -for(var i=0;i<_3.length;++i){ -this.accept[_3[i]]=1; -} -} -this.isDragging=false; -this.mouseDown=false; -this.targetAnchor=null; -this.targetBox=null; -this.dropPosition=""; -this._lastX=0; -this._lastY=0; -this.sourceState=""; -if(this.isSource){ -dojo.addClass(this.node,"dojoDndSource"); -} -this.targetState=""; -if(this.accept){ -dojo.addClass(this.node,"dojoDndTarget"); -} -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")]; -},checkAcceptance:function(_4,_5){ -return true; -},copyState:function(_6){ -return this.copyOnly||_6; -},destroy:function(){ -this.inherited("destroy",arguments); -dojo.forEach(this.topics,dojo.unsubscribe); -this.targetAnchor=null; -},_onDragMouse:function(e){ -var m=dojo.dnd.manager(),_7=this.targetAnchor,_8=this.current,_9=this.currentWidget,_a=this.dropPosition; -var _b="Over"; -if(_8&&this.betweenThreshold>0){ -if(!this.targetBox||_7!=_8){ -this.targetBox=dojo.position(_8,true); -} -if((e.pageY-this.targetBox.y)<=this.betweenThreshold){ -_b="Before"; -}else{ -if((e.pageY-this.targetBox.y)>=(this.targetBox.h-this.betweenThreshold)){ -_b="After"; -} -} -} -if(_8!=_7||_b!=_a){ -if(_7){ -this._removeItemClass(_7,_a); -} -if(_8){ -this._addItemClass(_8,_b); -} -if(!_8){ -m.canDrop(false); -}else{ -if(_9==this.tree.rootNode&&_b!="Over"){ -m.canDrop(false); -}else{ -if(m.source==this&&(_8.id in this.selection)){ -m.canDrop(false); -}else{ -if(this.checkItemAcceptance(_8,m.source,_b.toLowerCase())&&!this._isParentChildDrop(m.source,_8)){ -m.canDrop(true); -}else{ -m.canDrop(false); -} -} -} -} -this.targetAnchor=_8; -this.dropPosition=_b; -} -},onMouseMove:function(e){ -if(this.isDragging&&this.targetState=="Disabled"){ -return; -} -this.inherited(arguments); -var m=dojo.dnd.manager(); -if(this.isDragging){ -this._onDragMouse(e); -}else{ -if(this.mouseDown&&this.isSource&&(Math.abs(e.pageX-this._lastX)>=this.dragThreshold||Math.abs(e.pageY-this._lastY)>=this.dragThreshold)){ -var n=this.getSelectedNodes(); -var _c=[]; -for(var i in n){ -_c.push(n[i]); -} -if(_c.length){ -m.startDrag(this,_c,this.copyState(dojo.isCopyKey(e))); -} -} -} -},onMouseDown:function(e){ -this.mouseDown=true; -this.mouseButton=e.button; -this._lastX=e.pageX; -this._lastY=e.pageY; -this.inherited("onMouseDown",arguments); -},onMouseUp:function(e){ -if(this.mouseDown){ -this.mouseDown=false; -this.inherited("onMouseUp",arguments); -} -},onMouseOut:function(){ -this.inherited(arguments); -this._unmarkTargetAnchor(); -},checkItemAcceptance:function(_d,_e,_f){ -return true; -},onDndSourceOver:function(_10){ -if(this!=_10){ -this.mouseDown=false; -this._unmarkTargetAnchor(); -}else{ -if(this.isDragging){ -var m=dojo.dnd.manager(); -m.canDrop(false); -} -} -},onDndStart:function(_11,_12,_13){ -if(this.isSource){ -this._changeState("Source",this==_11?(_13?"Copied":"Moved"):""); -} -var _14=this.checkAcceptance(_11,_12); -this._changeState("Target",_14?"":"Disabled"); -if(this==_11){ -dojo.dnd.manager().overSource(this); -} -this.isDragging=true; -},itemCreator:function(_15,_16,_17){ -return dojo.map(_15,function(_18){ -return {"id":_18.id,"name":_18.textContent||_18.innerText||""}; + + +/*===== +dijit.tree.__SourceArgs = function(){ + // summary: + // A dict of parameters for Tree source configuration. + // isSource: Boolean? + // Can be used as a DnD source. Defaults to true. + // accept: String[] + // List of accepted types (text strings) for a target; defaults to + // ["text", "treeNode"] + // copyOnly: Boolean? + // Copy items, if true, use a state of Ctrl key otherwise, + // dragThreshold: Number + // The move delay in pixels before detecting a drag; 0 by default + // betweenThreshold: Integer + // Distance from upper/lower edge of node to allow drop to reorder nodes + this.isSource = isSource; + this.accept = accept; + this.autoSync = autoSync; + this.copyOnly = copyOnly; + this.dragThreshold = dragThreshold; + this.betweenThreshold = betweenThreshold; +} +=====*/ + +dojo.declare("dijit.tree.dndSource", dijit.tree._dndSelector, { + // summary: + // Handles drag and drop operations (as a source or a target) for `dijit.Tree` + + // isSource: [private] Boolean + // Can be used as a DnD source. + isSource: true, + + // accept: String[] + // List of accepted types (text strings) for the Tree; defaults to + // ["text"] + accept: ["text", "treeNode"], + + // copyOnly: [private] Boolean + // Copy items, if true, use a state of Ctrl key otherwise + copyOnly: false, + + // dragThreshold: Number + // The move delay in pixels before detecting a drag; 5 by default + dragThreshold: 5, + + // betweenThreshold: Integer + // Distance from upper/lower edge of node to allow drop to reorder nodes + betweenThreshold: 0, + + constructor: function(/*dijit.Tree*/ tree, /*dijit.tree.__SourceArgs*/ params){ + // summary: + // a constructor of the Tree DnD Source + // tags: + // private + 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", "treeNode"]; + 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; // DOMNode corresponding to the currently moused over TreeNode + this.targetBox = null; // coordinates of this.targetAnchor + this.dropPosition = ""; // whether mouse is over/after/before this.targetAnchor + this._lastX = 0; + this._lastY = 0; + + // states + this.sourceState = ""; + if(this.isSource){ + dojo.addClass(this.node, "dojoDndSource"); + } + this.targetState = ""; + if(this.accept){ + dojo.addClass(this.node, "dojoDndTarget"); + } + + // 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: dijit.tree.dndSource + // The source which provides items + // nodes: DOMNode[] + // Array of DOM nodes corresponding to nodes being dropped, dijitTreeRow nodes if + // source is a dijit.Tree. + // tags: + // extension + 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" control key was pressed + // tags: + // protected + 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; + }, + + _onDragMouse: function(e){ + // summary: + // Helper method for processing onmousemove/onmouseover events while drag is in progress. + // Keeps track of current drop target. + + var m = dojo.dnd.manager(), + oldTarget = this.targetAnchor, // the TreeNode corresponding to TreeNode mouse was previously over + newTarget = this.current, // TreeNode corresponding to TreeNode mouse is currently over + oldDropPosition = this.dropPosition; // the previous drop position (over/before/after) + + // calculate if user is indicating to drop the dragged node before, after, or over + // (i.e., to become a child of) the target node + var newDropPosition = "Over"; + if(newTarget && this.betweenThreshold > 0){ + // If mouse is over a new TreeNode, then get new TreeNode's position and size + if(!this.targetBox || oldTarget != newTarget){ + this.targetBox = dojo.position(newTarget.rowNode, true); + } + if((e.pageY - this.targetBox.y) <= this.betweenThreshold){ + newDropPosition = "Before"; + }else if((e.pageY - this.targetBox.y) >= (this.targetBox.h - this.betweenThreshold)){ + newDropPosition = "After"; + } + } + + if(newTarget != oldTarget || newDropPosition != oldDropPosition){ + if(oldTarget){ + this._removeItemClass(oldTarget.rowNode, oldDropPosition); + } + if(newTarget){ + this._addItemClass(newTarget.rowNode, newDropPosition); + } + + // Check if it's ok to drop the dragged node on/before/after the target node. + if(!newTarget){ + m.canDrop(false); + }else if(newTarget == this.tree.rootNode && newDropPosition != "Over"){ + // Can't drop before or after tree's root node; the dropped node would just disappear (at least visually) + m.canDrop(false); + }else if(m.source == this && (newTarget.id in this.selection)){ + // Guard against dropping onto yourself (TODO: guard against dropping onto your descendant, #7140) + m.canDrop(false); + }else if(this.checkItemAcceptance(newTarget.rowNode, m.source, newDropPosition.toLowerCase()) + && !this._isParentChildDrop(m.source, newTarget.rowNode)){ + m.canDrop(true); + }else{ + m.canDrop(false); + } + + this.targetAnchor = newTarget; + this.dropPosition = newDropPosition; + } + }, + + onMouseMove: function(e){ + // summary: + // Called for any onmousemove events over the Tree + // e: Event + // onmousemouse event + // tags: + // private + if(this.isDragging && this.targetState == "Disabled"){ return; } + this.inherited(arguments); + var m = dojo.dnd.manager(); + if(this.isDragging){ + this._onDragMouse(e); + }else{ + if(this.mouseDown && this.isSource && + (Math.abs(e.pageX-this._lastX)>=this.dragThreshold || Math.abs(e.pageY-this._lastY)>=this.dragThreshold)){ + var nodes = this.getSelectedTreeNodes(); + if(nodes.length){ + if(nodes.length > 1){ + //filter out all selected items which has one of their ancestor selected as well + var seen = this.selection, i = 0, r = [], n, p; + nextitem: while((n = nodes[i++])){ + for(p = n.getParent(); p && p !== this.tree; p = p.getParent()){ + if(seen[p.id]){ //parent is already selected, skip this node + continue nextitem; + } + } + //this node does not have any ancestors selected, add it + r.push(n); + } + nodes = r; + } + nodes = dojo.map(nodes, function(n){return n.domNode}); + m.startDrag(this, nodes, this.copyState(dojo.isCopyKey(e))); + } + } + } + }, + + onMouseDown: function(e){ + // summary: + // Event processor for onmousedown + // e: Event + // onmousedown event + // tags: + // private + this.mouseDown = true; + this.mouseButton = e.button; + this._lastX = e.pageX; + this._lastY = e.pageY; + this.inherited(arguments); + }, + + onMouseUp: function(e){ + // summary: + // Event processor for onmouseup + // e: Event + // onmouseup event + // tags: + // private + if(this.mouseDown){ + this.mouseDown = false; + this.inherited(arguments); + } + }, + + onMouseOut: function(){ + // summary: + // Event processor for when mouse is moved away from a TreeNode + // tags: + // private + this.inherited(arguments); + this._unmarkTargetAnchor(); + }, + + checkItemAcceptance: function(target, source, position){ + // summary: + // Stub function to be overridden if one wants to check for the ability to drop at the node/item level + // description: + // In the base case, this is called to check if target can become a child of source. + // When betweenThreshold is set, position="before" or "after" means that we + // are asking if the source node can be dropped before/after the target node. + // target: DOMNode + // The dijitTreeRoot DOM node inside of the TreeNode that we are dropping on to + // Use dijit.getEnclosingWidget(target) to get the TreeNode. + // source: dijit.tree.dndSource + // The (set of) nodes we are dropping + // position: String + // "over", "before", or "after" + // tags: + // extension + 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 dijit.tree.dndSource / dojo.dnd.Source which has the mouse over it + // tags: + // private + if(this != source){ + this.mouseDown = false; + this._unmarkTargetAnchor(); + }else if(this.isDragging){ + var m = dojo.dnd.manager(); + m.canDrop(false); + } + }, + onDndStart: function(source, nodes, copy){ + // summary: + // Topic event processor for /dnd/start, called to initiate the DnD operation + // source: Object + // The dijit.tree.dndSource / dojo.dnd.Source which is providing the items + // nodes: DomNode[] + // The list of transferred items, dndTreeNode nodes if dragging from a Tree + // copy: Boolean + // Copy items, if true, move items otherwise + // tags: + // private + + if(this.isSource){ + this._changeState("Source", this == source ? (copy ? "Copied" : "Moved") : ""); + } + var accepted = this.checkAcceptance(source, nodes); + + this._changeState("Target", accepted ? "" : "Disabled"); + + if(this == source){ + dojo.dnd.manager().overSource(this); + } + + this.isDragging = true; + }, + + itemCreator: function(/*DomNode[]*/ nodes, target, /*dojo.dnd.Source*/ source){ + // summary: + // Returns objects passed to `Tree.model.newItem()` based on DnD nodes + // dropped onto the tree. Developer must override this method to enable + // dropping from external sources onto this Tree, unless the Tree.model's items + // happen to look like {id: 123, name: "Apple" } with no other attributes. + // description: + // For each node in nodes[], which came from source, create a hash of name/value + // pairs to be passed to Tree.model.newItem(). Returns array of those hashes. + // returns: Object[] + // Array of name/value hashes for each new item to be added to the Tree, like: + // | [ + // | { id: 123, label: "apple", foo: "bar" }, + // | { id: 456, label: "pear", zaz: "bam" } + // | ] + // tags: + // extension + + // TODO: for 2.0 refactor so itemCreator() is called once per drag node, and + // make signature itemCreator(sourceItem, node, target) (or similar). + + return dojo.map(nodes, function(node){ + return { + "id": node.id, + "name": node.textContent || node.innerText || "" + }; + }); // Object[] + }, + + onDndDrop: function(source, nodes, copy){ + // summary: + // Topic event processor for /dnd/drop, called to finish the DnD operation. + // description: + // 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 dijit.tree.dndSource / dojo.dnd.Source which is providing the items + // nodes: DomNode[] + // The list of transferred items, dndTreeNode nodes if dragging from a Tree + // copy: Boolean + // Copy items, if true, move items otherwise + // tags: + // protected + if(this.containerState == "Over"){ + var tree = this.tree, + model = tree.model, + target = this.targetAnchor, + requeryRoot = false; // set to true iff top level items change + + this.isDragging = false; + + // Compute the new parent item + var targetWidget = target; + var newParentItem; + var insertIndex; + newParentItem = (targetWidget && targetWidget.item) || tree.item; + if(this.dropPosition == "Before" || this.dropPosition == "After"){ + // TODO: if there is no parent item then disallow the drop. + // Actually this should be checked during onMouseMove too, to make the drag icon red. + newParentItem = (targetWidget.getParent() && targetWidget.getParent().item) || tree.item; + // Compute the insert index for reordering + insertIndex = targetWidget.getIndexInParent(); + if(this.dropPosition == "After"){ + insertIndex = targetWidget.getIndexInParent() + 1; + } + }else{ + newParentItem = (targetWidget && targetWidget.item) || tree.item; + } + + // If necessary, use this variable to hold array of hashes to pass to model.newItem() + // (one entry in the array for each dragged node). + var newItemsParams; + + dojo.forEach(nodes, function(node, idx){ + // dojo.dnd.Item representing the thing being dropped. + // Don't confuse the use of item here (meaning a DnD item) with the + // uses below where item means dojo.data item. + var sourceItem = source.getItem(node.id); + + // Information that's available if the source is another Tree + // (possibly but not necessarily this tree, possibly but not + // necessarily the same model as this Tree) + if(dojo.indexOf(sourceItem.type, "treeNode") != -1){ + var childTreeNode = sourceItem.data, + childItem = childTreeNode.item, + oldParentItem = childTreeNode.getParent().item; + } + + 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. + + if(typeof insertIndex == "number"){ + if(newParentItem == oldParentItem && childTreeNode.getIndexInParent() < insertIndex){ + insertIndex -= 1; + } + } + model.pasteItem(childItem, oldParentItem, newParentItem, copy, insertIndex); + }else if(model.isItem(childItem)){ + // Item from same model + // (maybe we should only do this branch if the source is a tree?) + model.pasteItem(childItem, oldParentItem, newParentItem, copy, insertIndex); + }else{ + // Get the hash to pass to model.newItem(). A single call to + // itemCreator() returns an array of hashes, one for each drag source node. + if(!newItemsParams){ + newItemsParams = this.itemCreator(nodes, target.rowNode, source); + } + + // Create new item in the tree, based on the drag source. + model.newItem(newItemsParams[idx], newParentItem, insertIndex); + } + }, 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 + // tags: + // private + this._unmarkTargetAnchor(); + this.isDragging = false; + this.mouseDown = false; + delete this.mouseButton; + this._changeState("Source", ""); + this._changeState("Target", ""); + }, + + // When focus moves in/out of the entire Tree + onOverEvent: function(){ + // summary: + // This method is called when mouse is moved over our container (like onmouseenter) + // tags: + // private + this.inherited(arguments); + dojo.dnd.manager().overSource(this); + }, + onOutEvent: function(){ + // summary: + // This method is called when mouse is moved out of our container (like onmouseleave) + // tags: + // private + this._unmarkTargetAnchor(); + var m = dojo.dnd.manager(); + if(this.isDragging){ + m.canDrop(false); + } + m.outSource(this); + + this.inherited(arguments); + }, + + _isParentChildDrop: function(source, targetRow){ + // summary: + // Checks whether the dragged items are parent rows in the tree which are being + // dragged into their own children. + // + // source: + // The DragSource object. + // + // targetRow: + // The tree row onto which the dragged nodes are being dropped. + // + // tags: + // private + + // If the dragged object is not coming from the tree this widget belongs to, + // it cannot be invalid. + if(!source.tree || source.tree != this.tree){ + return false; + } + + + var root = source.tree.domNode; + var ids = source.selection; + + var node = targetRow.parentNode; + + // Iterate up the DOM hierarchy from the target drop row, + // checking of any of the dragged nodes have the same ID. + while(node != root && !ids[node.id]){ + node = node.parentNode; + } + + return node.id && ids[node.id]; + }, + + _unmarkTargetAnchor: function(){ + // summary: + // Removes hover class of the current target anchor + // tags: + // private + if(!this.targetAnchor){ return; } + this._removeItemClass(this.targetAnchor.rowNode, this.dropPosition); + this.targetAnchor = null; + this.targetBox = null; + this.dropPosition = null; + }, + + _markDndStatus: function(copy){ + // summary: + // Changes source's state based on "copy" status + this._changeState("Source", copy ? "Copied" : "Moved"); + } }); -},onDndDrop:function(_19,_1a,_1b){ -if(this.containerState=="Over"){ -var _1c=this.tree,_1d=_1c.model,_1e=this.targetAnchor,_1f=false; -this.isDragging=false; -var _20=dijit.getEnclosingWidget(_1e); -var _21; -var _22; -_21=(_20&&_20.item)||_1c.item; -if(this.dropPosition=="Before"||this.dropPosition=="After"){ -_21=(_20.getParent()&&_20.getParent().item)||_1c.item; -_22=_20.getIndexInParent(); -if(this.dropPosition=="After"){ -_22=_20.getIndexInParent()+1; -} -}else{ -_21=(_20&&_20.item)||_1c.item; -} -var _23; -dojo.forEach(_1a,function(_24,idx){ -var _25=_19.getItem(_24.id); -if(dojo.indexOf(_25.type,"treeNode")!=-1){ -var _26=_25.data,_27=_26.item,_28=_26.getParent().item; -} -if(_19==this){ -if(typeof _22=="number"){ -if(_21==_28&&_26.getIndexInParent()<_22){ -_22-=1; -} -} -_1d.pasteItem(_27,_28,_21,_1b,_22); -}else{ -if(_1d.isItem(_27)){ -_1d.pasteItem(_27,_28,_21,_1b,_22); -}else{ -if(!_23){ -_23=this.itemCreator(_1a,_1e,_19); -} -_1d.newItem(_23[idx],_21,_22); -} -} -},this); -this.tree._expandNode(_20); -} -this.onDndCancel(); -},onDndCancel:function(){ -this._unmarkTargetAnchor(); -this.isDragging=false; -this.mouseDown=false; -delete this.mouseButton; -this._changeState("Source",""); -this._changeState("Target",""); -},onOverEvent:function(){ -this.inherited(arguments); -dojo.dnd.manager().overSource(this); -},onOutEvent:function(){ -this._unmarkTargetAnchor(); -var m=dojo.dnd.manager(); -if(this.isDragging){ -m.canDrop(false); -} -m.outSource(this); -this.inherited(arguments); -},_isParentChildDrop:function(_29,_2a){ -if(!_29.tree||_29.tree!=this.tree){ -return false; -} -var _2b=_29.tree.domNode; -var ids={}; -for(var x in _29.selection){ -ids[_29.selection[x].parentNode.id]=true; -} -var _2c=_2a.parentNode; -while(_2c!=_2b&&(!_2c.id||!ids[_2c.id])){ -_2c=_2c.parentNode; -} -return _2c.id&&ids[_2c.id]; -},_unmarkTargetAnchor:function(){ -if(!this.targetAnchor){ -return; -} -this._removeItemClass(this.targetAnchor,this.dropPosition); -this.targetAnchor=null; -this.targetBox=null; -this.dropPosition=null; -},_markDndStatus:function(_2d){ -this._changeState("Source",_2d?"Copied":"Moved"); -}}); + } |