mirror of
https://git.tt-rss.org/git/tt-rss.git
synced 2025-12-22 19:51:28 +00:00
upgrade Dojo to 1.6.1
This commit is contained in:
Andrew Dolgov
@@ -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={};
|
||||
|
||||
|
||||
/*=====
|
||||
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.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||""};
|
||||
=====*/
|
||||
|
||||
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");
|
||||
}});
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user