dijit-rails 0.9.0 → 0.10.0

data/vendor/assets/javascripts/dijit/tree/_dndContainer.js.uncompressed.js

@@ -0,0 +1,165 @@
+define("dijit/tree/_dndContainer", [
+	"dojo/aspect",	// aspect.after
+	"dojo/_base/declare", // declare
+	"dojo/dom-class", // domClass.add domClass.remove domClass.replace
+	"dojo/_base/event",	// event.stop
+	"dojo/_base/lang", // lang.mixin lang.hitch
+	"dojo/on",
+	"dojo/touch"
+], function(aspect, declare,domClass, event, lang, on, touch){
+
+	// module:
+	//		dijit/tree/_dndContainer
+
+	/*=====
+	 var __Args = {
+		 // summary:
+		 //		A dict of parameters for Tree source configuration.
+		 // isSource: Boolean?
+		 //		Can be used as a DnD source. Defaults to true.
+		 // accept: String[]
+		 //		List of accepted types (text strings) for a target; defaults to
+		 //		["text", "treeNode"]
+		 // copyOnly: Boolean?
+		 //		Copy items, if true, use a state of Ctrl key otherwise,
+		 // dragThreshold: Number
+		 //		The move delay in pixels before detecting a drag; 0 by default
+		 // betweenThreshold: Integer
+		 //		Distance from upper/lower edge of node to allow drop to reorder nodes
+	 };
+	 =====*/
+
+	return declare("dijit.tree._dndContainer", null, {
+
+		// summary:
+		//		This is a base class for `dijit/tree/_dndSelector`, and isn't meant to be used directly.
+		//		It's modeled after `dojo/dnd/Container`.
+		// tags:
+		//		protected
+
+		/*=====
+		// current: DomNode
+		//		The currently hovered TreeNode.rowNode (which is the DOM node
+		//		associated w/a given node in the tree, excluding it's descendants)
+		current: null,
+		=====*/
+
+		constructor: function(tree, params){
+			// summary:
+			//		A constructor of the Container
+			// tree: Node
+			//		Node or node's id to build the container on
+			// params: __Args
+			//		A dict of parameters, which gets mixed into the object
+			// tags:
+			//		private
+			this.tree = tree;
+			this.node = tree.domNode;	// TODO: rename; it's not a TreeNode but the whole Tree
+			lang.mixin(this, params);
+
+			// class-specific variables
+			this.current = null;	// current TreeNode's DOM node
+
+			// states
+			this.containerState = "";
+			domClass.add(this.node, "dojoDndContainer");
+
+			// set up events
+			this.events = [
+				// Mouse (or touch) enter/leave on Tree itself
+				on(this.node, touch.enter, lang.hitch(this, "onOverEvent")),
+				on(this.node, touch.leave,	lang.hitch(this, "onOutEvent")),
+
+				// switching between TreeNodes
+				aspect.after(this.tree, "_onNodeMouseEnter", lang.hitch(this, "onMouseOver"), true),
+				aspect.after(this.tree, "_onNodeMouseLeave", lang.hitch(this, "onMouseOut"), true),
+
+				// cancel text selection and text dragging
+				on(this.node, "dragstart", lang.hitch(event, "stop")),
+				on(this.node, "selectstart", lang.hitch(event, "stop"))
+			];
+		},
+
+		destroy: function(){
+			// summary:
+			//		Prepares this object to be garbage-collected
+
+			var h;
+			while(h = this.events.pop()){ h.remove(); }
+
+			// this.clearItems();
+			this.node = this.parent = null;
+		},
+
+		// mouse events
+		onMouseOver: function(widget /*===== , evt =====*/){
+			// summary:
+			//		Called when mouse is moved over a TreeNode
+			// widget: TreeNode
+			// evt: Event
+			// tags:
+			//		protected
+			this.current = widget;
+		},
+
+		onMouseOut: function(/*===== widget, evt =====*/){
+			// summary:
+			//		Called when mouse is moved away from a TreeNode
+			// widget: TreeNode
+			// evt: Event
+			// tags:
+			//		protected
+			this.current = null;
+		},
+
+		_changeState: function(type, newState){
+			// summary:
+			//		Changes a named state to new state value
+			// type: String
+			//		A name of the state to change
+			// newState: String
+			//		new state
+			var prefix = "dojoDnd" + type;
+			var state = type.toLowerCase() + "State";
+			//domClass.replace(this.node, prefix + newState, prefix + this[state]);
+			domClass.replace(this.node, prefix + newState, prefix + this[state]);
+			this[state] = newState;
+		},
+
+		_addItemClass: function(node, type){
+			// summary:
+			//		Adds a class with prefix "dojoDndItem"
+			// node: Node
+			//		A node
+			// type: String
+			//		A variable suffix for a class name
+			domClass.add(node, "dojoDndItem" + type);
+		},
+
+		_removeItemClass: function(node, type){
+			// summary:
+			//		Removes a class with prefix "dojoDndItem"
+			// node: Node
+			//		A node
+			// type: String
+			//		A variable suffix for a class name
+			domClass.remove(node, "dojoDndItem" + type);
+		},
+
+		onOverEvent: function(){
+			// summary:
+			//		This function is called once, when mouse is over our container
+			// tags:
+			//		protected
+			this._changeState("Container", "Over");
+		},
+
+		onOutEvent: function(){
+			// summary:
+			//		This function is called once, when mouse is out of our container
+			// tags:
+			//		protected
+			this._changeState("Container", "");
+		}
+	});
+});

data/vendor/assets/javascripts/dijit/tree/_dndSelector.js

@@ -0,0 +1,186 @@
+//>>built
+define("dijit/tree/_dndSelector",["dojo/_base/array","dojo/_base/connect","dojo/_base/declare","dojo/_base/Deferred","dojo/_base/kernel","dojo/_base/lang","dojo/cookie","dojo/mouse","dojo/on","dojo/touch","./_dndContainer"],function(_1,_2,_3,_4,_5,_6,_7,_8,on,_9,_a){
+return _3("dijit.tree._dndSelector",_a,{constructor:function(){
+this.selection={};
+this.anchor=null;
+if(!this.cookieName&&this.tree.id){
+this.cookieName=this.tree.id+"SaveSelectedCookie";
+}
+this.events.push(on(this.tree.domNode,_9.press,_6.hitch(this,"onMouseDown")),on(this.tree.domNode,_9.release,_6.hitch(this,"onMouseUp")),on(this.tree.domNode,_9.move,_6.hitch(this,"onMouseMove")));
+},singular:false,getSelectedTreeNodes:function(){
+var _b=[],_c=this.selection;
+for(var i in _c){
+_b.push(_c[i]);
+}
+return _b;
+},selectNone:function(){
+this.setSelection([]);
+return this;
+},destroy:function(){
+this.inherited(arguments);
+this.selection=this.anchor=null;
+},addTreeNode:function(_d,_e){
+this.setSelection(this.getSelectedTreeNodes().concat([_d]));
+if(_e){
+this.anchor=_d;
+}
+return _d;
+},removeTreeNode:function(_f){
+this.setSelection(this._setDifference(this.getSelectedTreeNodes(),[_f]));
+return _f;
+},isTreeNodeSelected:function(_10){
+return _10.id&&!!this.selection[_10.id];
+},setSelection:function(_11){
+var _12=this.getSelectedTreeNodes();
+_1.forEach(this._setDifference(_12,_11),_6.hitch(this,function(_13){
+_13.setSelected(false);
+if(this.anchor==_13){
+delete this.anchor;
+}
+delete this.selection[_13.id];
+}));
+_1.forEach(this._setDifference(_11,_12),_6.hitch(this,function(_14){
+_14.setSelected(true);
+this.selection[_14.id]=_14;
+}));
+this._updateSelectionProperties();
+},_setDifference:function(xs,ys){
+_1.forEach(ys,function(y){
+y.__exclude__=true;
+});
+var ret=_1.filter(xs,function(x){
+return !x.__exclude__;
+});
+_1.forEach(ys,function(y){
+delete y["__exclude__"];
+});
+return ret;
+},_updateSelectionProperties:function(){
+var _15=this.getSelectedTreeNodes();
+var _16=[],_17=[],_18=[];
+_1.forEach(_15,function(_19){
+var ary=_19.getTreePath(),_1a=this.tree.model;
+_17.push(_19);
+_16.push(ary);
+ary=_1.map(ary,function(_1b){
+return _1a.getIdentity(_1b);
+},this);
+_18.push(ary.join("/"));
+},this);
+var _1c=_1.map(_17,function(_1d){
+return _1d.item;
+});
+this.tree._set("paths",_16);
+this.tree._set("path",_16[0]||[]);
+this.tree._set("selectedNodes",_17);
+this.tree._set("selectedNode",_17[0]||null);
+this.tree._set("selectedItems",_1c);
+this.tree._set("selectedItem",_1c[0]||null);
+if(this.tree.persist&&_18.length>0){
+_7(this.cookieName,_18.join(","),{expires:365});
+}
+},_getSavedPaths:function(){
+var _1e=this.tree;
+if(_1e.persist&&_1e.dndController.cookieName){
+var _1f,_20=[];
+_1f=_7(_1e.dndController.cookieName);
+if(_1f){
+_20=_1.map(_1f.split(","),function(_21){
+return _21.split("/");
+});
+}
+return _20;
+}
+},onMouseDown:function(e){
+if(!this.current||this.tree.isExpandoNode(e.target,this.current)){
+return;
+}
+if(e.type!="touchstart"&&!_8.isLeft(e)){
+return;
+}
+e.preventDefault();
+var _22=this.current,_23=_2.isCopyKey(e),id=_22.id;
+if(!this.singular&&!e.shiftKey&&this.selection[id]){
+this._doDeselect=true;
+return;
+}else{
+this._doDeselect=false;
+}
+this.userSelect(_22,_23,e.shiftKey);
+},onMouseUp:function(e){
+if(!this._doDeselect){
+return;
+}
+this._doDeselect=false;
+this.userSelect(this.current,_2.isCopyKey(e),e.shiftKey);
+},onMouseMove:function(){
+this._doDeselect=false;
+},_compareNodes:function(n1,n2){
+if(n1===n2){
+return 0;
+}
+if("sourceIndex" in document.documentElement){
+return n1.sourceIndex-n2.sourceIndex;
+}else{
+if("compareDocumentPosition" in document.documentElement){
+return n1.compareDocumentPosition(n2)&2?1:-1;
+}else{
+if(document.createRange){
+var r1=doc.createRange();
+r1.setStartBefore(n1);
+var r2=doc.createRange();
+r2.setStartBefore(n2);
+return r1.compareBoundaryPoints(r1.END_TO_END,r2);
+}else{
+throw Error("dijit.tree._compareNodes don't know how to compare two different nodes in this browser");
+}
+}
+}
+},userSelect:function(_24,_25,_26){
+if(this.singular){
+if(this.anchor==_24&&_25){
+this.selectNone();
+}else{
+this.setSelection([_24]);
+this.anchor=_24;
+}
+}else{
+if(_26&&this.anchor){
+var cr=this._compareNodes(this.anchor.rowNode,_24.rowNode),_27,end,_28=this.anchor;
+if(cr<0){
+_27=_28;
+end=_24;
+}else{
+_27=_24;
+end=_28;
+}
+var _29=[];
+while(_27!=end){
+_29.push(_27);
+_27=this.tree._getNextNode(_27);
+}
+_29.push(end);
+this.setSelection(_29);
+}else{
+if(this.selection[_24.id]&&_25){
+this.removeTreeNode(_24);
+}else{
+if(_25){
+this.addTreeNode(_24,true);
+}else{
+this.setSelection([_24]);
+this.anchor=_24;
+}
+}
+}
+}
+},getItem:function(key){
+var _2a=this.selection[key];
+return {data:_2a,type:["treeNode"]};
+},forInSelectedItems:function(f,o){
+o=o||_5.global;
+for(var id in this.selection){
+f.call(o,this.getItem(id),id,this);
+}
+}});
+});

data/vendor/assets/javascripts/dijit/tree/_dndSelector.js.uncompressed.js

@@ -0,0 +1,352 @@
+define("dijit/tree/_dndSelector", [
+	"dojo/_base/array", // array.filter array.forEach array.map
+	"dojo/_base/connect", // connect.isCopyKey
+	"dojo/_base/declare", // declare
+	"dojo/_base/Deferred", // Deferred
+	"dojo/_base/kernel",	// global
+	"dojo/_base/lang", // lang.hitch
+	"dojo/cookie", // cookie
+	"dojo/mouse", // mouse.isLeft
+	"dojo/on",
+	"dojo/touch",
+	"./_dndContainer"
+], function(array, connect, declare, Deferred, kernel, lang, cookie, mouse, on, touch, _dndContainer){
+
+	// module:
+	//		dijit/tree/_dndSelector
+
+
+	return declare("dijit.tree._dndSelector", _dndContainer, {
+		// summary:
+		//		This is a base class for `dijit/tree/dndSource` , and isn't meant to be used directly.
+		//		It's based on `dojo/dnd/Selector`.
+		// tags:
+		//		protected
+
+		/*=====
+		// selection: Object
+		//		(id to DomNode) map for every TreeNode that's currently selected.
+		//		The DOMNode is the TreeNode.rowNode.
+		selection: {},
+		=====*/
+
+		constructor: function(){
+			// summary:
+			//		Initialization
+			// tags:
+			//		private
+
+			this.selection={};
+			this.anchor = null;
+
+			if(!this.cookieName && this.tree.id){
+				this.cookieName = this.tree.id + "SaveSelectedCookie";
+			}
+
+			this.events.push(
+				on(this.tree.domNode, touch.press, lang.hitch(this,"onMouseDown")),
+				on(this.tree.domNode, touch.release, lang.hitch(this,"onMouseUp")),
+				on(this.tree.domNode, touch.move, lang.hitch(this,"onMouseMove"))
+			);
+		},
+
+		// singular: Boolean
+		//		Allows selection of only one element, if true.
+		//		Tree hasn't been tested in singular=true mode, unclear if it works.
+		singular: false,
+
+		// methods
+		getSelectedTreeNodes: function(){
+			// summary:
+			//		Returns a list of selected node(s).
+			//		Used by dndSource on the start of a drag.
+			// tags:
+			//		protected
+			var nodes=[], sel = this.selection;
+			for(var i in sel){
+				nodes.push(sel[i]);
+			}
+			return nodes;
+		},
+
+		selectNone: function(){
+			// summary:
+			//		Unselects all items
+			// tags:
+			//		private
+
+			this.setSelection([]);
+			return this;	// self
+		},
+
+		destroy: function(){
+			// summary:
+			//		Prepares the object to be garbage-collected
+			this.inherited(arguments);
+			this.selection = this.anchor = null;
+		},
+		addTreeNode: function(/*dijit/Tree._TreeNode*/ node, /*Boolean?*/isAnchor){
+			// summary:
+			//		add node to current selection
+			// node: Node
+			//		node to add
+			// isAnchor: Boolean
+			//		Whether the node should become anchor.
+
+			this.setSelection(this.getSelectedTreeNodes().concat( [node] ));
+			if(isAnchor){ this.anchor = node; }
+			return node;
+		},
+		removeTreeNode: function(/*dijit/Tree._TreeNode*/ node){
+			// summary:
+			//		remove node from current selection
+			// node: Node
+			//		node to remove
+			this.setSelection(this._setDifference(this.getSelectedTreeNodes(), [node]));
+			return node;
+		},
+		isTreeNodeSelected: function(/*dijit/Tree._TreeNode*/ node){
+			// summary:
+			//		return true if node is currently selected
+			// node: Node
+			//		the node to check whether it's in the current selection
+
+			return node.id && !!this.selection[node.id];
+		},
+		setSelection: function(/*dijit/Tree._TreeNode[]*/ newSelection){
+			// summary:
+			//		set the list of selected nodes to be exactly newSelection. All changes to the
+			//		selection should be passed through this function, which ensures that derived
+			//		attributes are kept up to date. Anchor will be deleted if it has been removed
+			//		from the selection, but no new anchor will be added by this function.
+			// newSelection: Node[]
+			//		list of tree nodes to make selected
+			var oldSelection = this.getSelectedTreeNodes();
+			array.forEach(this._setDifference(oldSelection, newSelection), lang.hitch(this, function(node){
+				node.setSelected(false);
+				if(this.anchor == node){
+					delete this.anchor;
+				}
+				delete this.selection[node.id];
+			}));
+			array.forEach(this._setDifference(newSelection, oldSelection), lang.hitch(this, function(node){
+				node.setSelected(true);
+				this.selection[node.id] = node;
+			}));
+			this._updateSelectionProperties();
+		},
+		_setDifference: function(xs,ys){
+			// summary:
+			//		Returns a copy of xs which lacks any objects
+			//		occurring in ys. Checks for membership by
+			//		modifying and then reading the object, so it will
+			//		not properly handle sets of numbers or strings.
+
+			array.forEach(ys, function(y){ y.__exclude__ = true; });
+			var ret = array.filter(xs, function(x){ return !x.__exclude__; });
+
+			// clean up after ourselves.
+			array.forEach(ys, function(y){ delete y['__exclude__'] });
+			return ret;
+		},
+		_updateSelectionProperties: function(){
+			// summary:
+			//		Update the following tree properties from the current selection:
+			//		path[s], selectedItem[s], selectedNode[s]
+
+			var selected = this.getSelectedTreeNodes();
+			var paths = [], nodes = [], selects = [];
+			array.forEach(selected, function(node){
+				var ary = node.getTreePath(), model = this.tree.model;
+				nodes.push(node);
+				paths.push(ary);
+				ary = array.map(ary, function(item){
+					return model.getIdentity(item);
+				}, this);
+				selects.push(ary.join("/"))
+			}, this);
+			var items = array.map(nodes,function(node){ return node.item; });
+			this.tree._set("paths", paths);
+			this.tree._set("path", paths[0] || []);
+			this.tree._set("selectedNodes", nodes);
+			this.tree._set("selectedNode", nodes[0] || null);
+			this.tree._set("selectedItems", items);
+			this.tree._set("selectedItem", items[0] || null);
+            if (this.tree.persist && selects.length > 0) {
+                cookie(this.cookieName, selects.join(","), {expires:365});
+            }
+		},
+		_getSavedPaths: function(){
+			// summary:
+			//		Returns paths of nodes that were selected previously and saved in the cookie.
+
+			var tree = this.tree;
+			if(tree.persist && tree.dndController.cookieName){
+				var oreo, paths = [];
+				oreo = cookie(tree.dndController.cookieName);
+				if(oreo){
+					paths = array.map(oreo.split(","), function(path){
+					   return path.split("/");
+					})
+				}
+				return paths;
+			}
+		},
+		// mouse events
+		onMouseDown: function(e){
+			// summary:
+			//		Event processor for onmousedown/ontouchstart
+			// e: Event
+			//		onmousedown/ontouchstart event
+			// tags:
+			//		protected
+
+			// ignore click on expando node
+			if(!this.current || this.tree.isExpandoNode(e.target, this.current)){ return; }
+
+			// ignore right-click
+			if(e.type != "touchstart" && !mouse.isLeft(e)){ return; }
+
+			e.preventDefault();
+
+			var treeNode = this.current,
+			  copy = connect.isCopyKey(e), id = treeNode.id;
+
+			// if shift key is not pressed, and the node is already in the selection,
+			// delay deselection until onmouseup so in the case of DND, deselection
+			// will be canceled by onmousemove.
+			if(!this.singular && !e.shiftKey && this.selection[id]){
+				this._doDeselect = true;
+				return;
+			}else{
+				this._doDeselect = false;
+			}
+			this.userSelect(treeNode, copy, e.shiftKey);
+		},
+
+		onMouseUp: function(e){
+			// summary:
+			//		Event processor for onmouseup/ontouchend
+			// e: Event
+			//		onmouseup/ontouchend event
+			// tags:
+			//		protected
+
+			// _doDeselect is the flag to indicate that the user wants to either ctrl+click on
+			// a already selected item (to deselect the item), or click on a not-yet selected item
+			// (which should remove all current selection, and add the clicked item). This can not
+			// be done in onMouseDown, because the user may start a drag after mousedown. By moving
+			// the deselection logic here, the user can drags an already selected item.
+			if(!this._doDeselect){ return; }
+			this._doDeselect = false;
+			this.userSelect(this.current, connect.isCopyKey(e), e.shiftKey);
+		},
+		onMouseMove: function(/*===== e =====*/){
+			// summary:
+			//		event processor for onmousemove/ontouchmove
+			// e: Event
+			//		onmousemove/ontouchmove event
+			this._doDeselect = false;
+		},
+
+		_compareNodes: function(n1, n2){
+			if(n1 === n2){
+				return 0;
+			}
+
+			if('sourceIndex' in document.documentElement){ //IE
+				//TODO: does not yet work if n1 and/or n2 is a text node
+				return n1.sourceIndex - n2.sourceIndex;
+			}else if('compareDocumentPosition' in document.documentElement){ //FF, Opera
+				return n1.compareDocumentPosition(n2) & 2 ? 1: -1;
+			}else if(document.createRange){ //Webkit
+				var r1 = doc.createRange();
+				r1.setStartBefore(n1);
+
+				var r2 = doc.createRange();
+				r2.setStartBefore(n2);
+
+				return r1.compareBoundaryPoints(r1.END_TO_END, r2);
+			}else{
+				throw Error("dijit.tree._compareNodes don't know how to compare two different nodes in this browser");
+			}
+		},
+
+		userSelect: function(node, multi, range){
+			// summary:
+			//		Add or remove the given node from selection, responding
+			//		to a user action such as a click or keypress.
+			// multi: Boolean
+			//		Indicates whether this is meant to be a multi-select action (e.g. ctrl-click)
+			// range: Boolean
+			//		Indicates whether this is meant to be a ranged action (e.g. shift-click)
+			// tags:
+			//		protected
+
+			if(this.singular){
+				if(this.anchor == node && multi){
+					this.selectNone();
+				}else{
+					this.setSelection([node]);
+					this.anchor = node;
+				}
+			}else{
+				if(range && this.anchor){
+					var cr = this._compareNodes(this.anchor.rowNode, node.rowNode),
+					begin, end, anchor = this.anchor;
+
+					if(cr < 0){ //current is after anchor
+						begin = anchor;
+						end = node;
+					}else{ //current is before anchor
+						begin = node;
+						end = anchor;
+					}
+					var nodes = [];
+					//add everything betweeen begin and end inclusively
+					while(begin != end){
+						nodes.push(begin);
+						begin = this.tree._getNextNode(begin);
+					}
+					nodes.push(end);
+
+					this.setSelection(nodes);
+				}else{
+					if( this.selection[ node.id ] && multi ){
+						this.removeTreeNode( node );
+					}else if(multi){
+						this.addTreeNode(node, true);
+					}else{
+						this.setSelection([node]);
+						this.anchor = node;
+					}
+				}
+			}
+		},
+
+		getItem: function(/*String*/ key){
+			// summary:
+			//		Returns the dojo/dnd/Container._Item (representing a dragged node) by it's key (id).
+			//		Called by dojo/dnd/Source.checkAcceptance().
+			// tags:
+			//		protected
+
+			var widget = this.selection[key];
+			return {
+				data: widget,
+				type: ["treeNode"]
+			}; // dojo/dnd/Container._Item
+		},
+
+		forInSelectedItems: function(/*Function*/ f, /*Object?*/ o){
+			// summary:
+			//		Iterates over selected items;
+			//		see `dojo/dnd/Container.forInItems()` for details
+			o = o || kernel.global;
+			for(var id in this.selection){
+				// console.log("selected item id: " + id);
+				f.call(o, this.getItem(id), id, this);
+			}
+		}
+	});
+});