Page MenuHomeCode
Files F884719

Source.js
No OneTemporary
Actions

Source.js
View Options

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);
}
});
}

File Metadata

Mime Type
text/plain
Expires
Sun, Apr 6, 10:53 (2 w, 11 h ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
25487
Default Alt Text
Source.js (12 KB)

Event Timeline