dijit-rails 0.9.0 → 0.10.0

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

@@ -0,0 +1,146 @@
+//>>built
+define("dijit/tree/TreeStoreModel",["dojo/_base/array","dojo/aspect","dojo/_base/declare","dojo/_base/lang"],function(_1,_2,_3,_4){
+return _3("dijit.tree.TreeStoreModel",null,{store:null,childrenAttrs:["children"],newItemIdAttr:"id",labelAttr:"",root:null,query:null,deferItemLoadingUntilExpand:false,constructor:function(_5){
+_4.mixin(this,_5);
+this.connects=[];
+var _6=this.store;
+if(!_6.getFeatures()["dojo.data.api.Identity"]){
+throw new Error("dijit.tree.TreeStoreModel: store must support dojo.data.Identity");
+}
+if(_6.getFeatures()["dojo.data.api.Notification"]){
+this.connects=this.connects.concat([_2.after(_6,"onNew",_4.hitch(this,"onNewItem"),true),_2.after(_6,"onDelete",_4.hitch(this,"onDeleteItem"),true),_2.after(_6,"onSet",_4.hitch(this,"onSetItem"),true)]);
+}
+},destroy:function(){
+var h;
+while(h=this.connects.pop()){
+h.remove();
+}
+},getRoot:function(_7,_8){
+if(this.root){
+_7(this.root);
+}else{
+this.store.fetch({query:this.query,onComplete:_4.hitch(this,function(_9){
+if(_9.length!=1){
+throw new Error("dijit.tree.TreeStoreModel: root query returned "+_9.length+" items, but must return exactly one");
+}
+this.root=_9[0];
+_7(this.root);
+}),onError:_8});
+}
+},mayHaveChildren:function(_a){
+return _1.some(this.childrenAttrs,function(_b){
+return this.store.hasAttribute(_a,_b);
+},this);
+},getChildren:function(_c,_d,_e){
+var _f=this.store;
+if(!_f.isItemLoaded(_c)){
+var _10=_4.hitch(this,arguments.callee);
+_f.loadItem({item:_c,onItem:function(_11){
+_10(_11,_d,_e);
+},onError:_e});
+return;
+}
+var _12=[];
+for(var i=0;i<this.childrenAttrs.length;i++){
+var _13=_f.getValues(_c,this.childrenAttrs[i]);
+_12=_12.concat(_13);
+}
+var _14=0;
+if(!this.deferItemLoadingUntilExpand){
+_1.forEach(_12,function(_15){
+if(!_f.isItemLoaded(_15)){
+_14++;
+}
+});
+}
+if(_14==0){
+_d(_12);
+}else{
+_1.forEach(_12,function(_16,idx){
+if(!_f.isItemLoaded(_16)){
+_f.loadItem({item:_16,onItem:function(_17){
+_12[idx]=_17;
+if(--_14==0){
+_d(_12);
+}
+},onError:_e});
+}
+});
+}
+},isItem:function(_18){
+return this.store.isItem(_18);
+},fetchItemByIdentity:function(_19){
+this.store.fetchItemByIdentity(_19);
+},getIdentity:function(_1a){
+return this.store.getIdentity(_1a);
+},getLabel:function(_1b){
+if(this.labelAttr){
+return this.store.getValue(_1b,this.labelAttr);
+}else{
+return this.store.getLabel(_1b);
+}
+},newItem:function(_1c,_1d,_1e){
+var _1f={parent:_1d,attribute:this.childrenAttrs[0]},_20;
+if(this.newItemIdAttr&&_1c[this.newItemIdAttr]){
+this.fetchItemByIdentity({identity:_1c[this.newItemIdAttr],scope:this,onItem:function(_21){
+if(_21){
+this.pasteItem(_21,null,_1d,true,_1e);
+}else{
+_20=this.store.newItem(_1c,_1f);
+if(_20&&(_1e!=undefined)){
+this.pasteItem(_20,_1d,_1d,false,_1e);
+}
+}
+}});
+}else{
+_20=this.store.newItem(_1c,_1f);
+if(_20&&(_1e!=undefined)){
+this.pasteItem(_20,_1d,_1d,false,_1e);
+}
+}
+},pasteItem:function(_22,_23,_24,_25,_26){
+var _27=this.store,_28=this.childrenAttrs[0];
+if(_23){
+_1.forEach(this.childrenAttrs,function(_29){
+if(_27.containsValue(_23,_29,_22)){
+if(!_25){
+var _2a=_1.filter(_27.getValues(_23,_29),function(x){
+return x!=_22;
+});
+_27.setValues(_23,_29,_2a);
+}
+_28=_29;
+}
+});
+}
+if(_24){
+if(typeof _26=="number"){
+var _2b=_27.getValues(_24,_28).slice();
+_2b.splice(_26,0,_22);
+_27.setValues(_24,_28,_2b);
+}else{
+_27.setValues(_24,_28,_27.getValues(_24,_28).concat(_22));
+}
+}
+},onChange:function(){
+},onChildrenChange:function(){
+},onDelete:function(){
+},onNewItem:function(_2c,_2d){
+if(!_2d){
+return;
+}
+this.getChildren(_2d.item,_4.hitch(this,function(_2e){
+this.onChildrenChange(_2d.item,_2e);
+}));
+},onDeleteItem:function(_2f){
+this.onDelete(_2f);
+},onSetItem:function(_30,_31){
+if(_1.indexOf(this.childrenAttrs,_31)!=-1){
+this.getChildren(_30,_4.hitch(this,function(_32){
+this.onChildrenChange(_30,_32);
+}));
+}else{
+this.onChange(_30);
+}
+}});
+});

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

@@ -0,0 +1,379 @@
+define("dijit/tree/TreeStoreModel", [
+	"dojo/_base/array", // array.filter array.forEach array.indexOf array.some
+	"dojo/aspect", // aspect.after
+	"dojo/_base/declare", // declare
+	"dojo/_base/lang" // lang.hitch
+], function(array, aspect, declare, lang){
+
+	// module:
+	//		dijit/tree/TreeStoreModel
+
+	return declare("dijit.tree.TreeStoreModel", null, {
+		// summary:
+		//		Implements dijit/Tree/model connecting to a dojo.data store with a single
+		//		root item.  Any methods passed into the constructor will override
+		//		the ones defined here.
+
+		// store: dojo/data/api/Read
+		//		Underlying store
+		store: null,
+
+		// childrenAttrs: String[]
+		//		One or more attribute names (attributes in the dojo.data item) that specify that item's children
+		childrenAttrs: ["children"],
+
+		// newItemIdAttr: String
+		//		Name of attribute in the Object passed to newItem() that specifies the id.
+		//
+		//		If newItemIdAttr is set then it's used when newItem() is called to see if an
+		//		item with the same id already exists, and if so just links to the old item
+		//		(so that the old item ends up with two parents).
+		//
+		//		Setting this to null or "" will make every drop create a new item.
+		newItemIdAttr: "id",
+
+		// labelAttr: String
+		//		If specified, get label for tree node from this attribute, rather
+		//		than by calling store.getLabel()
+		labelAttr: "",
+
+		// root: [readonly] dojo/data/Item
+		//		Pointer to the root item (read only, not a parameter)
+		root: null,
+
+		// query: anything
+		//		Specifies datastore query to return the root item for the tree.
+		//		Must only return a single item.   Alternately can just pass in pointer
+		//		to root item.
+		// example:
+		//	|	{id:'ROOT'}
+		query: null,
+
+		// deferItemLoadingUntilExpand: Boolean
+		//		Setting this to true will cause the TreeStoreModel to defer calling loadItem on nodes
+		//		until they are expanded. This allows for lazying loading where only one
+		//		loadItem (and generally one network call, consequently) per expansion
+		//		(rather than one for each child).
+		//		This relies on partial loading of the children items; each children item of a
+		//		fully loaded item should contain the label and info about having children.
+		deferItemLoadingUntilExpand: false,
+
+		constructor: function(/* Object */ args){
+			// summary:
+			//		Passed the arguments listed above (store, etc)
+			// tags:
+			//		private
+
+			lang.mixin(this, args);
+
+			this.connects = [];
+
+			var store = this.store;
+			if(!store.getFeatures()['dojo.data.api.Identity']){
+				throw new Error("dijit.tree.TreeStoreModel: store must support dojo.data.Identity");
+			}
+
+			// if the store supports Notification, subscribe to the notification events
+			if(store.getFeatures()['dojo.data.api.Notification']){
+				this.connects = this.connects.concat([
+					aspect.after(store, "onNew", lang.hitch(this, "onNewItem"), true),
+					aspect.after(store, "onDelete", lang.hitch(this, "onDeleteItem"), true),
+					aspect.after(store, "onSet", lang.hitch(this, "onSetItem"), true)
+				]);
+			}
+		},
+
+		destroy: function(){
+			var h;
+			while(h = this.connects.pop()){ h.remove(); }
+			// TODO: should cancel any in-progress processing of getRoot(), getChildren()
+		},
+
+		// =======================================================================
+		// Methods for traversing hierarchy
+
+		getRoot: function(onItem, onError){
+			// summary:
+			//		Calls onItem with the root item for the tree, possibly a fabricated item.
+			//		Calls onError on error.
+			if(this.root){
+				onItem(this.root);
+			}else{
+				this.store.fetch({
+					query: this.query,
+					onComplete: lang.hitch(this, function(items){
+						if(items.length != 1){
+							throw new Error("dijit.tree.TreeStoreModel: root query returned " + items.length +
+								" items, but must return exactly one");
+						}
+						this.root = items[0];
+						onItem(this.root);
+					}),
+					onError: onError
+				});
+			}
+		},
+
+		mayHaveChildren: function(/*dojo/data/Item*/ item){
+			// summary:
+			//		Tells if an item has or may have children.  Implementing logic here
+			//		avoids showing +/- expando icon for nodes that we know don't have children.
+			//		(For efficiency reasons we may not want to check if an element actually
+			//		has children until user clicks the expando node)
+			return array.some(this.childrenAttrs, function(attr){
+				return this.store.hasAttribute(item, attr);
+			}, this);
+		},
+
+		getChildren: function(/*dojo/data/Item*/ parentItem, /*function(items)*/ onComplete, /*function*/ onError){
+			// summary:
+			//		Calls onComplete() with array of child items of given parent item, all loaded.
+
+			var store = this.store;
+			if(!store.isItemLoaded(parentItem)){
+				// The parent is not loaded yet, we must be in deferItemLoadingUntilExpand
+				// mode, so we will load it and just return the children (without loading each
+				// child item)
+				var getChildren = lang.hitch(this, arguments.callee);
+				store.loadItem({
+					item: parentItem,
+					onItem: function(parentItem){
+						getChildren(parentItem, onComplete, onError);
+					},
+					onError: onError
+				});
+				return;
+			}
+			// get children of specified item
+			var childItems = [];
+			for(var i=0; i<this.childrenAttrs.length; i++){
+				var vals = store.getValues(parentItem, this.childrenAttrs[i]);
+				childItems = childItems.concat(vals);
+			}
+
+			// count how many items need to be loaded
+			var _waitCount = 0;
+			if(!this.deferItemLoadingUntilExpand){
+				array.forEach(childItems, function(item){ if(!store.isItemLoaded(item)){ _waitCount++; } });
+			}
+
+			if(_waitCount == 0){
+				// all items are already loaded (or we aren't loading them).  proceed...
+				onComplete(childItems);
+			}else{
+				// still waiting for some or all of the items to load
+				array.forEach(childItems, function(item, idx){
+					if(!store.isItemLoaded(item)){
+						store.loadItem({
+							item: item,
+							onItem: function(item){
+								childItems[idx] = item;
+								if(--_waitCount == 0){
+									// all nodes have been loaded, send them to the tree
+									onComplete(childItems);
+								}
+							},
+							onError: onError
+						});
+					}
+				});
+			}
+		},
+
+		// =======================================================================
+		// Inspecting items
+
+		isItem: function(/* anything */ something){
+			return this.store.isItem(something);	// Boolean
+		},
+
+		fetchItemByIdentity: function(/* object */ keywordArgs){
+			this.store.fetchItemByIdentity(keywordArgs);
+		},
+
+		getIdentity: function(/* item */ item){
+			return this.store.getIdentity(item);	// Object
+		},
+
+		getLabel: function(/*dojo/data/Item*/ item){
+			// summary:
+			//		Get the label for an item
+			if(this.labelAttr){
+				return this.store.getValue(item,this.labelAttr);	// String
+			}else{
+				return this.store.getLabel(item);	// String
+			}
+		},
+
+		// =======================================================================
+		// Write interface
+
+		newItem: function(/* dijit/tree/dndSource.__Item */ args, /*dojo/data/api/Item*/ parent, /*int?*/ insertIndex){
+			// summary:
+			//		Creates a new item.   See `dojo/data/api/Write` for details on args.
+			//		Used in drag & drop when item from external source dropped onto tree.
+			// description:
+			//		Developers will need to override this method if new items get added
+			//		to parents with multiple children attributes, in order to define which
+			//		children attribute points to the new item.
+
+			var pInfo = {parent: parent, attribute: this.childrenAttrs[0]}, LnewItem;
+
+			if(this.newItemIdAttr && args[this.newItemIdAttr]){
+				// Maybe there's already a corresponding item in the store; if so, reuse it.
+				this.fetchItemByIdentity({identity: args[this.newItemIdAttr], scope: this, onItem: function(item){
+					if(item){
+						// There's already a matching item in store, use it
+						this.pasteItem(item, null, parent, true, insertIndex);
+					}else{
+						// Create new item in the tree, based on the drag source.
+						LnewItem=this.store.newItem(args, pInfo);
+						if(LnewItem && (insertIndex!=undefined)){
+							// Move new item to desired position
+							this.pasteItem(LnewItem, parent, parent, false, insertIndex);
+						}
+					}
+				}});
+			}else{
+				// [as far as we know] there is no id so we must assume this is a new item
+				LnewItem=this.store.newItem(args, pInfo);
+				if(LnewItem && (insertIndex!=undefined)){
+					// Move new item to desired position
+					this.pasteItem(LnewItem, parent, parent, false, insertIndex);
+				}
+			}
+		},
+
+		pasteItem: function(/*Item*/ childItem, /*Item*/ oldParentItem, /*Item*/ newParentItem, /*Boolean*/ bCopy, /*int?*/ insertIndex){
+			// summary:
+			//		Move or copy an item from one parent item to another.
+			//		Used in drag & drop
+			var store = this.store,
+				parentAttr = this.childrenAttrs[0];	// name of "children" attr in parent item
+
+			// remove child from source item, and record the attribute that child occurred in
+			if(oldParentItem){
+				array.forEach(this.childrenAttrs, function(attr){
+					if(store.containsValue(oldParentItem, attr, childItem)){
+						if(!bCopy){
+							var values = array.filter(store.getValues(oldParentItem, attr), function(x){
+								return x != childItem;
+							});
+							store.setValues(oldParentItem, attr, values);
+						}
+						parentAttr = attr;
+					}
+				});
+			}
+
+			// modify target item's children attribute to include this item
+			if(newParentItem){
+				if(typeof insertIndex == "number"){
+					// call slice() to avoid modifying the original array, confusing the data store
+					var childItems = store.getValues(newParentItem, parentAttr).slice();
+					childItems.splice(insertIndex, 0, childItem);
+					store.setValues(newParentItem, parentAttr, childItems);
+				}else{
+					store.setValues(newParentItem, parentAttr,
+						store.getValues(newParentItem, parentAttr).concat(childItem));
+				}
+			}
+		},
+
+		// =======================================================================
+		// Callbacks
+
+		onChange: function(/*dojo/data/Item*/ /*===== item =====*/){
+			// summary:
+			//		Callback whenever an item has changed, so that Tree
+			//		can update the label, icon, etc.   Note that changes
+			//		to an item's children or parent(s) will trigger an
+			//		onChildrenChange() so you can ignore those changes here.
+			// tags:
+			//		callback
+		},
+
+		onChildrenChange: function(/*===== parent, newChildrenList =====*/){
+			// summary:
+			//		Callback to do notifications about new, updated, or deleted items.
+			// parent: dojo/data/Item
+			// newChildrenList: dojo/data/Item[]
+			// tags:
+			//		callback
+		},
+
+		onDelete: function(/*dojo/data/Item*/ /*===== item =====*/){
+			// summary:
+			//		Callback when an item has been deleted.
+			// description:
+			//		Note that there will also be an onChildrenChange() callback for the parent
+			//		of this item.
+			// tags:
+			//		callback
+		},
+
+		// =======================================================================
+		// Events from data store
+
+		onNewItem: function(/* dojo/data/Item */ item, /* Object */ parentInfo){
+			// summary:
+			//		Handler for when new items appear in the store, either from a drop operation
+			//		or some other way.   Updates the tree view (if necessary).
+			// description:
+			//		If the new item is a child of an existing item,
+			//		calls onChildrenChange() with the new list of children
+			//		for that existing item.
+			//
+			// tags:
+			//		extension
+
+			// We only care about the new item if it has a parent that corresponds to a TreeNode
+			// we are currently displaying
+			if(!parentInfo){
+				return;
+			}
+
+			// Call onChildrenChange() on parent (ie, existing) item with new list of children
+			// In the common case, the new list of children is simply parentInfo.newValue or
+			// [ parentInfo.newValue ], although if items in the store has multiple
+			// child attributes (see `childrenAttr`), then it's a superset of parentInfo.newValue,
+			// so call getChildren() to be sure to get right answer.
+			this.getChildren(parentInfo.item, lang.hitch(this, function(children){
+				this.onChildrenChange(parentInfo.item, children);
+			}));
+		},
+
+		onDeleteItem: function(/*Object*/ item){
+			// summary:
+			//		Handler for delete notifications from underlying store
+			this.onDelete(item);
+		},
+
+		onSetItem: function(item, attribute /*===== , oldValue, newValue =====*/){
+			// summary:
+			//		Updates the tree view according to changes in the data store.
+			// description:
+			//		Handles updates to an item's children by calling onChildrenChange(), and
+			//		other updates to an item by calling onChange().
+			//
+			//		See `onNewItem` for more details on handling updates to an item's children.
+			// item: Item
+			// attribute: attribute-name-string
+			// oldValue: Object|Array
+			// newValue: Object|Array
+			// tags:
+			//		extension
+
+			if(array.indexOf(this.childrenAttrs, attribute) != -1){
+				// item's children list changed
+				this.getChildren(item, lang.hitch(this, function(children){
+					// See comments in onNewItem() about calling getChildren()
+					this.onChildrenChange(item, children);
+				}));
+			}else{
+				// item's label/icon/etc. changed.
+				this.onChange(item);
+			}
+		}
+	});
+});

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

@@ -0,0 +1,35 @@
+//>>built
+define("dijit/tree/_dndContainer",["dojo/aspect","dojo/_base/declare","dojo/dom-class","dojo/_base/event","dojo/_base/lang","dojo/on","dojo/touch"],function(_1,_2,_3,_4,_5,on,_6){
+return _2("dijit.tree._dndContainer",null,{constructor:function(_7,_8){
+this.tree=_7;
+this.node=_7.domNode;
+_5.mixin(this,_8);
+this.current=null;
+this.containerState="";
+_3.add(this.node,"dojoDndContainer");
+this.events=[on(this.node,_6.enter,_5.hitch(this,"onOverEvent")),on(this.node,_6.leave,_5.hitch(this,"onOutEvent")),_1.after(this.tree,"_onNodeMouseEnter",_5.hitch(this,"onMouseOver"),true),_1.after(this.tree,"_onNodeMouseLeave",_5.hitch(this,"onMouseOut"),true),on(this.node,"dragstart",_5.hitch(_4,"stop")),on(this.node,"selectstart",_5.hitch(_4,"stop"))];
+},destroy:function(){
+var h;
+while(h=this.events.pop()){
+h.remove();
+}
+this.node=this.parent=null;
+},onMouseOver:function(_9){
+this.current=_9;
+},onMouseOut:function(){
+this.current=null;
+},_changeState:function(_a,_b){
+var _c="dojoDnd"+_a;
+var _d=_a.toLowerCase()+"State";
+_3.replace(this.node,_c+_b,_c+this[_d]);
+this[_d]=_b;
+},_addItemClass:function(_e,_f){
+_3.add(_e,"dojoDndItem"+_f);
+},_removeItemClass:function(_10,_11){
+_3.remove(_10,"dojoDndItem"+_11);
+},onOverEvent:function(){
+this._changeState("Container","Over");
+},onOutEvent:function(){
+this._changeState("Container","");
+}});
+});