dojo-rails 0.9.8 → 0.9.9

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

@@ -0,0 +1,62 @@
+/*
+	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/Mover",["../main","../Evented","../touch","./common","./autoscroll"],function(_1,_2,_3){
+_1.declare("dojo.dnd.Mover",[_2],{constructor:function(_4,e,_5){
+this.node=_1.byId(_4);
+this.marginBox={l:e.pageX,t:e.pageY};
+this.mouseButton=e.button;
+var h=(this.host=_5),d=_4.ownerDocument;
+this.events=[_1.connect(d,_3.move,this,"onFirstMove"),_1.connect(d,_3.move,this,"onMouseMove"),_1.connect(d,_3.release,this,"onMouseUp"),_1.connect(d,"ondragstart",_1.stopEvent),_1.connect(d.body,"onselectstart",_1.stopEvent)];
+if(h&&h.onMoveStart){
+h.onMoveStart(this);
+}
+},onMouseMove:function(e){
+_1.dnd.autoScroll(e);
+var m=this.marginBox;
+this.host.onMove(this,{l:m.l+e.pageX,t:m.t+e.pageY},e);
+_1.stopEvent(e);
+},onMouseUp:function(e){
+if(_1.isWebKit&&_1.isMac&&this.mouseButton==2?e.button==0:this.mouseButton==e.button){
+this.destroy();
+}
+_1.stopEvent(e);
+},onFirstMove:function(e){
+var s=this.node.style,l,t,h=this.host;
+switch(s.position){
+case "relative":
+case "absolute":
+l=Math.round(parseFloat(s.left))||0;
+t=Math.round(parseFloat(s.top))||0;
+break;
+default:
+s.position="absolute";
+var m=_1.marginBox(this.node);
+var b=_1.doc.body;
+var bs=_1.getComputedStyle(b);
+var bm=_1._getMarginBox(b,bs);
+var bc=_1._getContentBox(b,bs);
+l=m.l-(bc.l-bm.l);
+t=m.t-(bc.t-bm.t);
+break;
+}
+this.marginBox.l=l-this.marginBox.l;
+this.marginBox.t=t-this.marginBox.t;
+if(h&&h.onFirstMove){
+h.onFirstMove(this,e);
+}
+_1.disconnect(this.events.shift());
+},destroy:function(){
+_1.forEach(this.events,_1.disconnect);
+var h=this.host;
+if(h&&h.onMoveStop){
+h.onMoveStop(this);
+}
+this.events=this.node=this.host=null;
+}});
+return _1.dnd.Mover;
+});

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

@@ -0,0 +1,119 @@
+define("dojo/dnd/Mover", ["../main", "../Evented", "../touch", "./common", "./autoscroll"], function(dojo, Evented, touch) {
+	// module:
+	//		dojo/dnd/Mover
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.dnd.Mover", [Evented], {
+	constructor: function(node, e, host){
+		// summary:
+		//		an object which makes a node follow the mouse, or touch-drag on touch devices.
+		//		Used as a default mover, and as a base class for custom movers.
+		// node: Node
+		//		a node (or node's id) to be moved
+		// e: Event
+		//		a mouse event, which started the move;
+		//		only pageX and pageY properties are used
+		// host: Object?
+		//		object which implements the functionality of the move,
+		//	 	and defines proper events (onMoveStart and onMoveStop)
+		this.node = dojo.byId(node);
+		this.marginBox = {l: e.pageX, t: e.pageY};
+		this.mouseButton = e.button;
+		var h = (this.host = host), d = node.ownerDocument;
+		this.events = [
+			// At the start of a drag, onFirstMove is called, and then the following two
+			// connects are disconnected
+			dojo.connect(d, touch.move, this, "onFirstMove"),
+
+			// These are called continually during the drag
+			dojo.connect(d, touch.move, this, "onMouseMove"),
+
+			// And these are called at the end of the drag
+			dojo.connect(d, touch.release,   this, "onMouseUp"),
+
+			// cancel text selection and text dragging
+			dojo.connect(d, "ondragstart",   dojo.stopEvent),
+			dojo.connect(d.body, "onselectstart", dojo.stopEvent)
+		];
+		// notify that the move has started
+		if(h && h.onMoveStart){
+			h.onMoveStart(this);
+		}
+	},
+	// mouse event processors
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove/ontouchmove
+		// e: Event
+		//		mouse/touch event
+		dojo.dnd.autoScroll(e);
+		var m = this.marginBox;
+		this.host.onMove(this, {l: m.l + e.pageX, t: m.t + e.pageY}, e);
+		dojo.stopEvent(e);
+	},
+	onMouseUp: function(e){
+		if(dojo.isWebKit && dojo.isMac && this.mouseButton == 2 ?
+				e.button == 0 : this.mouseButton == e.button){ // TODO Should condition be met for touch devices, too?
+			this.destroy();
+		}
+		dojo.stopEvent(e);
+	},
+	// utilities
+	onFirstMove: function(e){
+		// summary:
+		//		makes the node absolute; it is meant to be called only once.
+		// 		relative and absolutely positioned nodes are assumed to use pixel units
+		var s = this.node.style, l, t, h = this.host;
+		switch(s.position){
+			case "relative":
+			case "absolute":
+				// assume that left and top values are in pixels already
+				l = Math.round(parseFloat(s.left)) || 0;
+				t = Math.round(parseFloat(s.top)) || 0;
+				break;
+			default:
+				s.position = "absolute";	// enforcing the absolute mode
+				var m = dojo.marginBox(this.node);
+				// event.pageX/pageY (which we used to generate the initial
+				// margin box) includes padding and margin set on the body.
+				// However, setting the node's position to absolute and then
+				// doing dojo.marginBox on it *doesn't* take that additional
+				// space into account - so we need to subtract the combined
+				// padding and margin.  We use getComputedStyle and
+				// _getMarginBox/_getContentBox to avoid the extra lookup of
+				// the computed style.
+				var b = dojo.doc.body;
+				var bs = dojo.getComputedStyle(b);
+				var bm = dojo._getMarginBox(b, bs);
+				var bc = dojo._getContentBox(b, bs);
+				l = m.l - (bc.l - bm.l);
+				t = m.t - (bc.t - bm.t);
+				break;
+		}
+		this.marginBox.l = l - this.marginBox.l;
+		this.marginBox.t = t - this.marginBox.t;
+		if(h && h.onFirstMove){
+			h.onFirstMove(this, e);
+		}
+
+		// Disconnect onmousemove and ontouchmove events that call this function
+		dojo.disconnect(this.events.shift());
+	},
+	destroy: function(){
+		// summary:
+		//		stops the move, deletes all references, so the object can be garbage-collected
+		dojo.forEach(this.events, dojo.disconnect);
+		// undo global settings
+		var h = this.host;
+		if(h && h.onMoveStop){
+			h.onMoveStop(this);
+		}
+		// destroy objects
+		this.events = this.node = this.host = null;
+	}
+});
+
+return dojo.dnd.Mover;
+});

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

@@ -0,0 +1,233 @@
+/*
+	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/Selector",["../main","./common","./Container"],function(_1){
+_1.declare("dojo.dnd.Selector",_1.dnd.Container,{constructor:function(_2,_3){
+if(!_3){
+_3={};
+}
+this.singular=_3.singular;
+this.autoSync=_3.autoSync;
+this.selection={};
+this.anchor=null;
+this.simpleSelection=false;
+this.events.push(_1.connect(this.node,"onmousedown",this,"onMouseDown"),_1.connect(this.node,"onmouseup",this,"onMouseUp"));
+},singular:false,getSelectedNodes:function(){
+var t=new _1.NodeList();
+var e=_1.dnd._empty;
+for(var i in this.selection){
+if(i in e){
+continue;
+}
+t.push(_1.byId(i));
+}
+return t;
+},selectNone:function(){
+return this._removeSelection()._removeAnchor();
+},selectAll:function(){
+this.forInItems(function(_4,id){
+this._addItemClass(_1.byId(id),"Selected");
+this.selection[id]=1;
+},this);
+return this._removeAnchor();
+},deleteSelectedNodes:function(){
+var e=_1.dnd._empty;
+for(var i in this.selection){
+if(i in e){
+continue;
+}
+var n=_1.byId(i);
+this.delItem(i);
+_1.destroy(n);
+}
+this.anchor=null;
+this.selection={};
+return this;
+},forInSelectedItems:function(f,o){
+o=o||_1.global;
+var s=this.selection,e=_1.dnd._empty;
+for(var i in s){
+if(i in e){
+continue;
+}
+f.call(o,this.getItem(i),i,this);
+}
+},sync:function(){
+_1.dnd.Selector.superclass.sync.call(this);
+if(this.anchor){
+if(!this.getItem(this.anchor.id)){
+this.anchor=null;
+}
+}
+var t=[],e=_1.dnd._empty;
+for(var i in this.selection){
+if(i in e){
+continue;
+}
+if(!this.getItem(i)){
+t.push(i);
+}
+}
+_1.forEach(t,function(i){
+delete this.selection[i];
+},this);
+return this;
+},insertNodes:function(_5,_6,_7,_8){
+var _9=this._normalizedCreator;
+this._normalizedCreator=function(_a,_b){
+var t=_9.call(this,_a,_b);
+if(_5){
+if(!this.anchor){
+this.anchor=t.node;
+this._removeItemClass(t.node,"Selected");
+this._addItemClass(this.anchor,"Anchor");
+}else{
+if(this.anchor!=t.node){
+this._removeItemClass(t.node,"Anchor");
+this._addItemClass(t.node,"Selected");
+}
+}
+this.selection[t.node.id]=1;
+}else{
+this._removeItemClass(t.node,"Selected");
+this._removeItemClass(t.node,"Anchor");
+}
+return t;
+};
+_1.dnd.Selector.superclass.insertNodes.call(this,_6,_7,_8);
+this._normalizedCreator=_9;
+return this;
+},destroy:function(){
+_1.dnd.Selector.superclass.destroy.call(this);
+this.selection=this.anchor=null;
+},onMouseDown:function(e){
+if(this.autoSync){
+this.sync();
+}
+if(!this.current){
+return;
+}
+if(!this.singular&&!_1.isCopyKey(e)&&!e.shiftKey&&(this.current.id in this.selection)){
+this.simpleSelection=true;
+if(e.button===_1.mouseButtons.LEFT){
+_1.stopEvent(e);
+}
+return;
+}
+if(!this.singular&&e.shiftKey){
+if(!_1.isCopyKey(e)){
+this._removeSelection();
+}
+var c=this.getAllNodes();
+if(c.length){
+if(!this.anchor){
+this.anchor=c[0];
+this._addItemClass(this.anchor,"Anchor");
+}
+this.selection[this.anchor.id]=1;
+if(this.anchor!=this.current){
+var i=0;
+for(;i<c.length;++i){
+var _c=c[i];
+if(_c==this.anchor||_c==this.current){
+break;
+}
+}
+for(++i;i<c.length;++i){
+var _c=c[i];
+if(_c==this.anchor||_c==this.current){
+break;
+}
+this._addItemClass(_c,"Selected");
+this.selection[_c.id]=1;
+}
+this._addItemClass(this.current,"Selected");
+this.selection[this.current.id]=1;
+}
+}
+}else{
+if(this.singular){
+if(this.anchor==this.current){
+if(_1.isCopyKey(e)){
+this.selectNone();
+}
+}else{
+this.selectNone();
+this.anchor=this.current;
+this._addItemClass(this.anchor,"Anchor");
+this.selection[this.current.id]=1;
+}
+}else{
+if(_1.isCopyKey(e)){
+if(this.anchor==this.current){
+delete this.selection[this.anchor.id];
+this._removeAnchor();
+}else{
+if(this.current.id in this.selection){
+this._removeItemClass(this.current,"Selected");
+delete this.selection[this.current.id];
+}else{
+if(this.anchor){
+this._removeItemClass(this.anchor,"Anchor");
+this._addItemClass(this.anchor,"Selected");
+}
+this.anchor=this.current;
+this._addItemClass(this.current,"Anchor");
+this.selection[this.current.id]=1;
+}
+}
+}else{
+if(!(this.current.id in this.selection)){
+this.selectNone();
+this.anchor=this.current;
+this._addItemClass(this.current,"Anchor");
+this.selection[this.current.id]=1;
+}
+}
+}
+}
+_1.stopEvent(e);
+},onMouseUp:function(e){
+if(!this.simpleSelection){
+return;
+}
+this.simpleSelection=false;
+this.selectNone();
+if(this.current){
+this.anchor=this.current;
+this._addItemClass(this.anchor,"Anchor");
+this.selection[this.current.id]=1;
+}
+},onMouseMove:function(e){
+this.simpleSelection=false;
+},onOverEvent:function(){
+this.onmousemoveEvent=_1.connect(this.node,"onmousemove",this,"onMouseMove");
+},onOutEvent:function(){
+_1.disconnect(this.onmousemoveEvent);
+delete this.onmousemoveEvent;
+},_removeSelection:function(){
+var e=_1.dnd._empty;
+for(var i in this.selection){
+if(i in e){
+continue;
+}
+var _d=_1.byId(i);
+if(_d){
+this._removeItemClass(_d,"Selected");
+}
+}
+this.selection={};
+return this;
+},_removeAnchor:function(){
+if(this.anchor){
+this._removeItemClass(this.anchor,"Anchor");
+this.anchor=null;
+}
+return this;
+}});
+return _1.dnd.Selector;
+});

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

@@ -0,0 +1,324 @@
+define("dojo/dnd/Selector", ["../main", "./common", "./Container"], function(dojo) {
+	// module:
+	//		dojo/dnd/Selector
+	// summary:
+	//		TODOC
+
+
+/*
+	Container item states:
+		""			- an item is not selected
+		"Selected"	- an item is selected
+		"Anchor"	- an item is selected, and is an anchor for a "shift" selection
+*/
+
+/*=====
+dojo.declare("dojo.dnd.__SelectorArgs", [dojo.dnd.__ContainerArgs], {
+	//	singular: Boolean
+	//		allows selection of only one element, if true
+	singular: false,
+
+	//	autoSync: Boolean
+	//		autosynchronizes the source with its list of DnD nodes,
+	autoSync: false
+});
+=====*/
+
+dojo.declare("dojo.dnd.Selector", dojo.dnd.Container, {
+	// summary:
+	//		a Selector object, which knows how to select its children
+
+	/*=====
+	// selection: Set<String>
+	//		The set of id's that are currently selected, such that this.selection[id] == 1
+	//		if the node w/that id is selected.  Can iterate over selected node's id's like:
+	//	|		for(var id in this.selection)
+	selection: {},
+	=====*/
+
+	constructor: function(node, params){
+		// summary:
+		//		constructor of the Selector
+		// node: Node||String
+		//		node or node's id to build the selector on
+		// params: dojo.dnd.__SelectorArgs?
+		//		a dictionary of parameters
+		if(!params){ params = {}; }
+		this.singular = params.singular;
+		this.autoSync = params.autoSync;
+		// class-specific variables
+		this.selection = {};
+		this.anchor = null;
+		this.simpleSelection = false;
+		// set up events
+		this.events.push(
+			dojo.connect(this.node, "onmousedown", this, "onMouseDown"),
+			dojo.connect(this.node, "onmouseup",   this, "onMouseUp"));
+	},
+
+	// object attributes (for markup)
+	singular: false,	// is singular property
+
+	// methods
+	getSelectedNodes: function(){
+		// summary:
+		//		returns a list (an array) of selected nodes
+		var t = new dojo.NodeList();
+		var e = dojo.dnd._empty;
+		for(var i in this.selection){
+			if(i in e){ continue; }
+			t.push(dojo.byId(i));
+		}
+		return t;	// NodeList
+	},
+	selectNone: function(){
+		// summary:
+		//		unselects all items
+		return this._removeSelection()._removeAnchor();	// self
+	},
+	selectAll: function(){
+		// summary:
+		//		selects all items
+		this.forInItems(function(data, id){
+			this._addItemClass(dojo.byId(id), "Selected");
+			this.selection[id] = 1;
+		}, this);
+		return this._removeAnchor();	// self
+	},
+	deleteSelectedNodes: function(){
+		// summary:
+		//		deletes all selected items
+		var e = dojo.dnd._empty;
+		for(var i in this.selection){
+			if(i in e){ continue; }
+			var n = dojo.byId(i);
+			this.delItem(i);
+			dojo.destroy(n);
+		}
+		this.anchor = null;
+		this.selection = {};
+		return this;	// self
+	},
+	forInSelectedItems: function(/*Function*/ f, /*Object?*/ o){
+		// summary:
+		//		iterates over selected items;
+		//		see `dojo.dnd.Container.forInItems()` for details
+		o = o || dojo.global;
+		var s = this.selection, e = dojo.dnd._empty;
+		for(var i in s){
+			if(i in e){ continue; }
+			f.call(o, this.getItem(i), i, this);
+		}
+	},
+	sync: function(){
+		// summary:
+		//		sync up the node list with the data map
+
+		dojo.dnd.Selector.superclass.sync.call(this);
+
+		// fix the anchor
+		if(this.anchor){
+			if(!this.getItem(this.anchor.id)){
+				this.anchor = null;
+			}
+		}
+
+		// fix the selection
+		var t = [], e = dojo.dnd._empty;
+		for(var i in this.selection){
+			if(i in e){ continue; }
+			if(!this.getItem(i)){
+				t.push(i);
+			}
+		}
+		dojo.forEach(t, function(i){
+			delete this.selection[i];
+		}, this);
+
+		return this;	// self
+	},
+	insertNodes: function(addSelected, data, before, anchor){
+		// summary:
+		//		inserts new data items (see `dojo.dnd.Container.insertNodes()` method for details)
+		// addSelected: Boolean
+		//		all new nodes will be added to selected items, if true, no selection change otherwise
+		// data: Array
+		//		a list of data items, which should be processed by the creator function
+		// before: Boolean
+		//		insert before the anchor, if true, and after the anchor otherwise
+		// anchor: Node
+		//		the anchor node to be used as a point of insertion
+		var oldCreator = this._normalizedCreator;
+		this._normalizedCreator = function(item, hint){
+			var t = oldCreator.call(this, item, hint);
+			if(addSelected){
+				if(!this.anchor){
+					this.anchor = t.node;
+					this._removeItemClass(t.node, "Selected");
+					this._addItemClass(this.anchor, "Anchor");
+				}else if(this.anchor != t.node){
+					this._removeItemClass(t.node, "Anchor");
+					this._addItemClass(t.node, "Selected");
+				}
+				this.selection[t.node.id] = 1;
+			}else{
+				this._removeItemClass(t.node, "Selected");
+				this._removeItemClass(t.node, "Anchor");
+			}
+			return t;
+		};
+		dojo.dnd.Selector.superclass.insertNodes.call(this, data, before, anchor);
+		this._normalizedCreator = oldCreator;
+		return this;	// self
+	},
+	destroy: function(){
+		// summary:
+		//		prepares the object to be garbage-collected
+		dojo.dnd.Selector.superclass.destroy.call(this);
+		this.selection = this.anchor = null;
+	},
+
+	// mouse events
+	onMouseDown: function(e){
+		// summary:
+		//		event processor for onmousedown
+		// e: Event
+		//		mouse event
+		if(this.autoSync){ this.sync(); }
+		if(!this.current){ return; }
+		if(!this.singular && !dojo.isCopyKey(e) && !e.shiftKey && (this.current.id in this.selection)){
+			this.simpleSelection = true;
+			if(e.button === dojo.mouseButtons.LEFT){
+				// accept the left button and stop the event
+				// for IE we don't stop event when multiple buttons are pressed
+				dojo.stopEvent(e);
+			}
+			return;
+		}
+		if(!this.singular && e.shiftKey){
+			if(!dojo.isCopyKey(e)){
+				this._removeSelection();
+			}
+			var c = this.getAllNodes();
+			if(c.length){
+				if(!this.anchor){
+					this.anchor = c[0];
+					this._addItemClass(this.anchor, "Anchor");
+				}
+				this.selection[this.anchor.id] = 1;
+				if(this.anchor != this.current){
+					var i = 0;
+					for(; i < c.length; ++i){
+						var node = c[i];
+						if(node == this.anchor || node == this.current){ break; }
+					}
+					for(++i; i < c.length; ++i){
+						var node = c[i];
+						if(node == this.anchor || node == this.current){ break; }
+						this._addItemClass(node, "Selected");
+						this.selection[node.id] = 1;
+					}
+					this._addItemClass(this.current, "Selected");
+					this.selection[this.current.id] = 1;
+				}
+			}
+		}else{
+			if(this.singular){
+				if(this.anchor == this.current){
+					if(dojo.isCopyKey(e)){
+						this.selectNone();
+					}
+				}else{
+					this.selectNone();
+					this.anchor = this.current;
+					this._addItemClass(this.anchor, "Anchor");
+					this.selection[this.current.id] = 1;
+				}
+			}else{
+				if(dojo.isCopyKey(e)){
+					if(this.anchor == this.current){
+						delete this.selection[this.anchor.id];
+						this._removeAnchor();
+					}else{
+						if(this.current.id in this.selection){
+							this._removeItemClass(this.current, "Selected");
+							delete this.selection[this.current.id];
+						}else{
+							if(this.anchor){
+								this._removeItemClass(this.anchor, "Anchor");
+								this._addItemClass(this.anchor, "Selected");
+							}
+							this.anchor = this.current;
+							this._addItemClass(this.current, "Anchor");
+							this.selection[this.current.id] = 1;
+						}
+					}
+				}else{
+					if(!(this.current.id in this.selection)){
+						this.selectNone();
+						this.anchor = this.current;
+						this._addItemClass(this.current, "Anchor");
+						this.selection[this.current.id] = 1;
+					}
+				}
+			}
+		}
+		dojo.stopEvent(e);
+	},
+	onMouseUp: function(e){
+		// summary:
+		//		event processor for onmouseup
+		// e: Event
+		//		mouse event
+		if(!this.simpleSelection){ return; }
+		this.simpleSelection = false;
+		this.selectNone();
+		if(this.current){
+			this.anchor = this.current;
+			this._addItemClass(this.anchor, "Anchor");
+			this.selection[this.current.id] = 1;
+		}
+	},
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove
+		// e: Event
+		//		mouse event
+		this.simpleSelection = false;
+	},
+
+	// utilities
+	onOverEvent: function(){
+		// summary:
+		//		this function is called once, when mouse is over our container
+		this.onmousemoveEvent = dojo.connect(this.node, "onmousemove", this, "onMouseMove");
+	},
+	onOutEvent: function(){
+		// summary:
+		//		this function is called once, when mouse is out of our container
+		dojo.disconnect(this.onmousemoveEvent);
+		delete this.onmousemoveEvent;
+	},
+	_removeSelection: function(){
+		// summary:
+		//		unselects all items
+		var e = dojo.dnd._empty;
+		for(var i in this.selection){
+			if(i in e){ continue; }
+			var node = dojo.byId(i);
+			if(node){ this._removeItemClass(node, "Selected"); }
+		}
+		this.selection = {};
+		return this;	// self
+	},
+	_removeAnchor: function(){
+		if(this.anchor){
+			this._removeItemClass(this.anchor, "Anchor");
+			this.anchor = null;
+		}
+		return this;	// self
+	}
+});
+
+return dojo.dnd.Selector;
+});