Subversion Repositories Applications.papyrus

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

	}

});

}