dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/dnd/Manager.js.uncompressed.js

@@ -0,0 +1,213 @@
+define("dojo/dnd/Manager", ["../main", "../Evented", "./common", "./autoscroll", "./Avatar"], function(dojo, Evented) {
+	// module:
+	//		dojo/dnd/Manager
+	// summary:
+	//		TODOC
+
+
+var Manager = dojo.declare("dojo.dnd.Manager", [Evented], {
+	// summary:
+	//		the manager of DnD operations (usually a singleton)
+	constructor: function(){
+		this.avatar  = null;
+		this.source = null;
+		this.nodes = [];
+		this.copy  = true;
+		this.target = null;
+		this.canDropFlag = false;
+		this.events = [];
+	},
+
+	// avatar's offset from the mouse
+	OFFSET_X: 16,
+	OFFSET_Y: 16,
+
+	// methods
+	overSource: function(source){
+		// summary:
+		//		called when a source detected a mouse-over condition
+		// source: Object
+		//		the reporter
+		if(this.avatar){
+			this.target = (source && source.targetState != "Disabled") ? source : null;
+			this.canDropFlag = Boolean(this.target);
+			this.avatar.update();
+		}
+		dojo.publish("/dnd/source/over", [source]);
+	},
+	outSource: function(source){
+		// summary:
+		//		called when a source detected a mouse-out condition
+		// source: Object
+		//		the reporter
+		if(this.avatar){
+			if(this.target == source){
+				this.target = null;
+				this.canDropFlag = false;
+				this.avatar.update();
+				dojo.publish("/dnd/source/over", [null]);
+			}
+		}else{
+			dojo.publish("/dnd/source/over", [null]);
+		}
+	},
+	startDrag: function(source, nodes, copy){
+		// summary:
+		//		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
+		this.source = source;
+		this.nodes  = nodes;
+		this.copy   = Boolean(copy); // normalizing to true boolean
+		this.avatar = this.makeAvatar();
+		dojo.body().appendChild(this.avatar.node);
+		dojo.publish("/dnd/start", [source, nodes, this.copy]);
+		this.events = [
+			dojo.connect(dojo.doc, "onmousemove", this, "onMouseMove"),
+			dojo.connect(dojo.doc, "onmouseup",   this, "onMouseUp"),
+			dojo.connect(dojo.doc, "onkeydown",   this, "onKeyDown"),
+			dojo.connect(dojo.doc, "onkeyup",     this, "onKeyUp"),
+			// cancel text selection and text dragging
+			dojo.connect(dojo.doc, "ondragstart",   dojo.stopEvent),
+			dojo.connect(dojo.body(), "onselectstart", dojo.stopEvent)
+		];
+		var c = "dojoDnd" + (copy ? "Copy" : "Move");
+		dojo.addClass(dojo.body(), c);
+	},
+	canDrop: function(flag){
+		// summary:
+		//		called to notify if the current target can accept items
+		var canDropFlag = Boolean(this.target && flag);
+		if(this.canDropFlag != canDropFlag){
+			this.canDropFlag = canDropFlag;
+			this.avatar.update();
+		}
+	},
+	stopDrag: function(){
+		// summary:
+		//		stop the DnD in progress
+		dojo.removeClass(dojo.body(), ["dojoDndCopy", "dojoDndMove"]);
+		dojo.forEach(this.events, dojo.disconnect);
+		this.events = [];
+		this.avatar.destroy();
+		this.avatar = null;
+		this.source = this.target = null;
+		this.nodes = [];
+	},
+	makeAvatar: function(){
+		// summary:
+		//		makes the avatar; it is separate to be overwritten dynamically, if needed
+		return new dojo.dnd.Avatar(this);
+	},
+	updateAvatar: function(){
+		// summary:
+		//		updates the avatar; it is separate to be overwritten dynamically, if needed
+		this.avatar.update();
+	},
+
+	// mouse event processors
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove
+		// e: Event
+		//		mouse event
+		var a = this.avatar;
+		if(a){
+			dojo.dnd.autoScrollNodes(e);
+			//dojo.dnd.autoScroll(e);
+			var s = a.node.style;
+			s.left = (e.pageX + this.OFFSET_X) + "px";
+			s.top  = (e.pageY + this.OFFSET_Y) + "px";
+			var copy = Boolean(this.source.copyState(dojo.isCopyKey(e)));
+			if(this.copy != copy){
+				this._setCopyStatus(copy);
+			}
+		}
+	},
+	onMouseUp: function(e){
+		// summary:
+		//		event processor for onmouseup
+		// e: Event
+		//		mouse event
+		if(this.avatar){
+			if(this.target && this.canDropFlag){
+				var copy = Boolean(this.source.copyState(dojo.isCopyKey(e))),
+				params = [this.source, this.nodes, copy, this.target, e];
+				dojo.publish("/dnd/drop/before", params);
+				dojo.publish("/dnd/drop", params);
+			}else{
+				dojo.publish("/dnd/cancel");
+			}
+			this.stopDrag();
+		}
+	},
+
+	// keyboard event processors
+	onKeyDown: function(e){
+		// summary:
+		//		event processor for onkeydown:
+		//		watching for CTRL for copy/move status, watching for ESCAPE to cancel the drag
+		// e: Event
+		//		keyboard event
+		if(this.avatar){
+			switch(e.keyCode){
+				case dojo.keys.CTRL:
+					var copy = Boolean(this.source.copyState(true));
+					if(this.copy != copy){
+						this._setCopyStatus(copy);
+					}
+					break;
+				case dojo.keys.ESCAPE:
+					dojo.publish("/dnd/cancel");
+					this.stopDrag();
+					break;
+			}
+		}
+	},
+	onKeyUp: function(e){
+		// summary:
+		//		event processor for onkeyup, watching for CTRL for copy/move status
+		// e: Event
+		//		keyboard event
+		if(this.avatar && e.keyCode == dojo.keys.CTRL){
+			var copy = Boolean(this.source.copyState(false));
+			if(this.copy != copy){
+				this._setCopyStatus(copy);
+			}
+		}
+	},
+
+	// utilities
+	_setCopyStatus: function(copy){
+		// summary:
+		//		changes the copy status
+		// copy: Boolean
+		//		the copy status
+		this.copy = copy;
+		this.source._markDndStatus(this.copy);
+		this.updateAvatar();
+		dojo.replaceClass(dojo.body(),
+			"dojoDnd" + (this.copy ? "Copy" : "Move"),
+			"dojoDnd" + (this.copy ? "Move" : "Copy"));
+	}
+});
+
+// dojo.dnd._manager:
+//		The manager singleton variable. Can be overwritten if needed.
+dojo.dnd._manager = null;
+
+Manager.manager = dojo.dnd.manager = function(){
+	// summary:
+	//		Returns the current DnD manager.  Creates one if it is not created yet.
+	if(!dojo.dnd._manager){
+		dojo.dnd._manager = new dojo.dnd.Manager();
+	}
+	return dojo.dnd._manager;	// Object
+};
+
+return Manager;
+});

data/vendor/assets/javascripts/dojo/dnd/Moveable.js

@@ -0,0 +1,75 @@
+/*
+	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
+*/
+
+//>>built
+define("dojo/dnd/Moveable",["../main","../Evented","../touch","./Mover"],function(_1,_2,_3){
+_1.declare("dojo.dnd.Moveable",[_2],{handle:"",delay:0,skip:false,constructor:function(_4,_5){
+this.node=_1.byId(_4);
+if(!_5){
+_5={};
+}
+this.handle=_5.handle?_1.byId(_5.handle):null;
+if(!this.handle){
+this.handle=this.node;
+}
+this.delay=_5.delay>0?_5.delay:0;
+this.skip=_5.skip;
+this.mover=_5.mover?_5.mover:_1.dnd.Mover;
+this.events=[_1.connect(this.handle,_3.press,this,"onMouseDown"),_1.connect(this.handle,"ondragstart",this,"onSelectStart"),_1.connect(this.handle,"onselectstart",this,"onSelectStart")];
+},markupFactory:function(_6,_7,_8){
+return new _8(_7,_6);
+},destroy:function(){
+_1.forEach(this.events,_1.disconnect);
+this.events=this.node=this.handle=null;
+},onMouseDown:function(e){
+if(this.skip&&_1.dnd.isFormElement(e)){
+return;
+}
+if(this.delay){
+this.events.push(_1.connect(this.handle,_3.move,this,"onMouseMove"),_1.connect(this.handle,_3.release,this,"onMouseUp"));
+this._lastX=e.pageX;
+this._lastY=e.pageY;
+}else{
+this.onDragDetected(e);
+}
+_1.stopEvent(e);
+},onMouseMove:function(e){
+if(Math.abs(e.pageX-this._lastX)>this.delay||Math.abs(e.pageY-this._lastY)>this.delay){
+this.onMouseUp(e);
+this.onDragDetected(e);
+}
+_1.stopEvent(e);
+},onMouseUp:function(e){
+for(var i=0;i<2;++i){
+_1.disconnect(this.events.pop());
+}
+_1.stopEvent(e);
+},onSelectStart:function(e){
+if(!this.skip||!_1.dnd.isFormElement(e)){
+_1.stopEvent(e);
+}
+},onDragDetected:function(e){
+new this.mover(this.node,e,this);
+},onMoveStart:function(_9){
+_1.publish("/dnd/move/start",[_9]);
+_1.addClass(_1.body(),"dojoMove");
+_1.addClass(this.node,"dojoMoveItem");
+},onMoveStop:function(_a){
+_1.publish("/dnd/move/stop",[_a]);
+_1.removeClass(_1.body(),"dojoMove");
+_1.removeClass(this.node,"dojoMoveItem");
+},onFirstMove:function(_b,e){
+},onMove:function(_c,_d,e){
+this.onMoving(_c,_d);
+var s=_c.node.style;
+s.left=_d.l+"px";
+s.top=_d.t+"px";
+this.onMoved(_c,_d);
+},onMoving:function(_e,_f){
+},onMoved:function(_10,_11){
+}});
+return _1.dnd.Moveable;
+});

data/vendor/assets/javascripts/dojo/dnd/Moveable.js.uncompressed.js

@@ -0,0 +1,173 @@
+define("dojo/dnd/Moveable", ["../main", "../Evented", "../touch", "./Mover"], function(dojo, Evented, touch) {
+	// module:
+	//		dojo/dnd/Moveable
+	// summary:
+	//		TODOC
+
+
+/*=====
+dojo.declare("dojo.dnd.__MoveableArgs", [], {
+	// handle: Node||String
+	//		A node (or node's id), which is used as a mouse handle.
+	//		If omitted, the node itself is used as a handle.
+	handle: null,
+
+	// delay: Number
+	//		delay move by this number of pixels
+	delay: 0,
+
+	// skip: Boolean
+	//		skip move of form elements
+	skip: false,
+
+	// mover: Object
+	//		a constructor of custom Mover
+	mover: dojo.dnd.Mover
+});
+=====*/
+
+dojo.declare("dojo.dnd.Moveable", [Evented], {
+	// object attributes (for markup)
+	handle: "",
+	delay: 0,
+	skip: false,
+
+	constructor: function(node, params){
+		// summary:
+		//		an object, which makes a node moveable
+		// node: Node
+		//		a node (or node's id) to be moved
+		// params: dojo.dnd.__MoveableArgs?
+		//		optional parameters
+		this.node = dojo.byId(node);
+		if(!params){ params = {}; }
+		this.handle = params.handle ? dojo.byId(params.handle) : null;
+		if(!this.handle){ this.handle = this.node; }
+		this.delay = params.delay > 0 ? params.delay : 0;
+		this.skip  = params.skip;
+		this.mover = params.mover ? params.mover : dojo.dnd.Mover;
+		this.events = [
+			dojo.connect(this.handle, touch.press, this, "onMouseDown"),
+			// cancel text selection and text dragging
+			dojo.connect(this.handle, "ondragstart",   this, "onSelectStart"),
+			dojo.connect(this.handle, "onselectstart", this, "onSelectStart")
+		];
+	},
+
+	// markup methods
+	markupFactory: function(params, node, ctor){
+		return new ctor(node, params);
+	},
+
+	// methods
+	destroy: function(){
+		// summary:
+		//		stops watching for possible move, deletes all references, so the object can be garbage-collected
+		dojo.forEach(this.events, dojo.disconnect);
+		this.events = this.node = this.handle = null;
+	},
+
+	// mouse event processors
+	onMouseDown: function(e){
+		// summary:
+		//		event processor for onmousedown/ontouchstart, creates a Mover for the node
+		// e: Event
+		//		mouse/touch event
+		if(this.skip && dojo.dnd.isFormElement(e)){ return; }
+		if(this.delay){
+			this.events.push(
+				dojo.connect(this.handle, touch.move, this, "onMouseMove"),
+				dojo.connect(this.handle, touch.release, this, "onMouseUp")
+			);
+			this._lastX = e.pageX;
+			this._lastY = e.pageY;
+		}else{
+			this.onDragDetected(e);
+		}
+		dojo.stopEvent(e);
+	},
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove/ontouchmove, used only for delayed drags
+		// e: Event
+		//		mouse/touch event
+		if(Math.abs(e.pageX - this._lastX) > this.delay || Math.abs(e.pageY - this._lastY) > this.delay){
+			this.onMouseUp(e);
+			this.onDragDetected(e);
+		}
+		dojo.stopEvent(e);
+	},
+	onMouseUp: function(e){
+		// summary:
+		//		event processor for onmouseup, used only for delayed drags
+		// e: Event
+		//		mouse event
+		for(var i = 0; i < 2; ++i){
+			dojo.disconnect(this.events.pop());
+		}
+		dojo.stopEvent(e);
+	},
+	onSelectStart: function(e){
+		// summary:
+		//		event processor for onselectevent and ondragevent
+		// e: Event
+		//		mouse event
+		if(!this.skip || !dojo.dnd.isFormElement(e)){
+			dojo.stopEvent(e);
+		}
+	},
+
+	// local events
+	onDragDetected: function(/* Event */ e){
+		// summary:
+		//		called when the drag is detected;
+		//		responsible for creation of the mover
+		new this.mover(this.node, e, this);
+	},
+	onMoveStart: function(/* dojo.dnd.Mover */ mover){
+		// summary:
+		//		called before every move operation
+		dojo.publish("/dnd/move/start", [mover]);
+		dojo.addClass(dojo.body(), "dojoMove");
+		dojo.addClass(this.node, "dojoMoveItem");
+	},
+	onMoveStop: function(/* dojo.dnd.Mover */ mover){
+		// summary:
+		//		called after every move operation
+		dojo.publish("/dnd/move/stop", [mover]);
+		dojo.removeClass(dojo.body(), "dojoMove");
+		dojo.removeClass(this.node, "dojoMoveItem");
+	},
+	onFirstMove: function(/* dojo.dnd.Mover */ mover, /* Event */ e){
+		// summary:
+		//		called during the very first move notification;
+		//		can be used to initialize coordinates, can be overwritten.
+
+		// default implementation does nothing
+	},
+	onMove: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop, /* Event */ e){
+		// summary:
+		//		called during every move notification;
+		//		should actually move the node; can be overwritten.
+		this.onMoving(mover, leftTop);
+		var s = mover.node.style;
+		s.left = leftTop.l + "px";
+		s.top  = leftTop.t + "px";
+		this.onMoved(mover, leftTop);
+	},
+	onMoving: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
+		// summary:
+		//		called before every incremental move; can be overwritten.
+
+		// default implementation does nothing
+	},
+	onMoved: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
+		// summary:
+		//		called after every incremental move; can be overwritten.
+
+		// default implementation does nothing
+	}
+});
+
+return dojo.dnd.Moveable;
+});