New file |
0,0 → 1,346 |
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(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 |
// 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 |
var n = e.relatedTarget; |
while(n){ |
if(n == this.node){ break; } |
try{ |
n = n.parentNode; |
}catch(x){ |
n = null; |
} |
} |
if(!n){ |
this._changeState("Container", "Over"); |
this.onOverEvent(); |
} |
n = this._getChildByEvent(e); |
if(this.current == n){ return; } |
if(this.current){ this._removeItemClass(this.current, "Over"); } |
if(n){ |
this._addItemClass(n, "Over"); |
if(this.isDragging){ |
var m = dojo.dnd.manager(); |
if(this.checkItemAcceptance(n,m.source)){ |
m.canDrop(this.targetState != "Disabled" && (!this.current || m.source != this || !(this.current.id in this.selection))); |
}else{ |
m.canDrop(false); |
} |
} |
}else{ |
if(this.isDragging){ |
var m = dojo.dnd.manager(); |
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){ |
var items = [] |
|
for(var i=0;i<nodes.length;i++){ |
items.push({ |
"name":nodes[i].textContent, |
"id": nodes[i].id |
}); |
} |
|
return items; |
}, |
|
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 |
|
if(this.containerState == "Over"){ |
this.isDragging = false; |
var target = this.current; |
var items = this.itemCreator(nodes, target); |
if(!target || target == this.tree.domNode){ |
for(var i = 0; i < items.length; i++){ |
this.tree.store.newItem(items[i], null); |
} |
}else{ |
for(var i = 0; i < items.length; i++){ |
pInfo = {parent: dijit.getEnclosingWidget(target).item, attribute: "children"}; |
var newItem = this.tree.store.newItem(items[i], pInfo); |
console.log("newItem:", newItem); |
} |
} |
} |
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); |
} |
}); |
|
} |