RubyGems - dijit-rails - Versions diffs - 0.11.0 → 0.14.0 - Mend

dijit-rails 0.11.0 → 0.14.0

Files changed (1043) hide show

data/vendor/assets/javascripts/dijit/registry.js.uncompressed.js DELETED Viewed

@@ -1,161 +0,0 @@
-define("dijit/registry", [
-	"dojo/_base/array", // array.forEach array.map
-	"dojo/sniff", // has("ie")
-	"dojo/_base/unload", // unload.addOnWindowUnload
-	"dojo/_base/window", // win.body
-	"./main"	// dijit._scopeName
-], function(array, has, unload, win, dijit){
-	// module:
-	//		dijit/registry
-	var _widgetTypeCtr = {}, hash = {};
-	var registry =  {
-		// summary:
-		//		Registry of existing widget on page, plus some utility methods.
-		// length: Number
-		//		Number of registered widgets
-		length: 0,
-		add: function(widget){
-			// summary:
-			//		Add a widget to the registry. If a duplicate ID is detected, a error is thrown.
-			// widget: dijit/_WidgetBase
-			//		Any dijit/_WidgetBase subclass.
-			if(hash[widget.id]){
-				throw new Error("Tried to register widget with id==" + widget.id + " but that id is already registered");
-			}
-			hash[widget.id] = widget;
-			this.length++;
-		},
-		remove: function(/*String*/ id){
-			// summary:
-			//		Remove a widget from the registry. Does not destroy the widget; simply
-			//		removes the reference.
-			if(hash[id]){
-				delete hash[id];
-				this.length--;
-			}
-		},
-		byId: function(/*String|Widget*/ id){
-			// summary:
-			//		Find a widget by it's id.
-			//		If passed a widget then just returns the widget.
-			return typeof id == "string" ? hash[id] : id;	// dijit/_WidgetBase
-		},
-		byNode: function(/*DOMNode*/ node){
-			// summary:
-			//		Returns the widget corresponding to the given DOMNode
-			return hash[node.getAttribute("widgetId")]; // dijit/_WidgetBase
-		},
-		toArray: function(){
-			// summary:
-			//		Convert registry into a true Array
-			//
-			// example:
-			//		Work with the widget .domNodes in a real Array
-			//		|	array.map(registry.toArray(), function(w){ return w.domNode; });
-			var ar = [];
-			for(var id in hash){
-				ar.push(hash[id]);
-			}
-			return ar;	// dijit/_WidgetBase[]
-		},
-		getUniqueId: function(/*String*/widgetType){
-			// summary:
-			//		Generates a unique id for a given widgetType
-			var id;
-			do{
-				id = widgetType + "_" +
-					(widgetType in _widgetTypeCtr ?
-						++_widgetTypeCtr[widgetType] : _widgetTypeCtr[widgetType] = 0);
-			}while(hash[id]);
-			return dijit._scopeName == "dijit" ? id : dijit._scopeName + "_" + id; // String
-		},
-		findWidgets: function(root, skipNode){
-			// summary:
-			//		Search subtree under root returning widgets found.
-			//		Doesn't search for nested widgets (ie, widgets inside other widgets).
-			// root: DOMNode
-			//		Node to search under.
-			// skipNode: DOMNode
-			//		If specified, don't search beneath this node (usually containerNode).
-			var outAry = [];
-			function getChildrenHelper(root){
-				for(var node = root.firstChild; node; node = node.nextSibling){
-					if(node.nodeType == 1){
-						var widgetId = node.getAttribute("widgetId");
-						if(widgetId){
-							var widget = hash[widgetId];
-							if(widget){	// may be null on page w/multiple dojo's loaded
-								outAry.push(widget);
-							}
-						}else if(node !== skipNode){
-							getChildrenHelper(node);
-						}
-					}
-				}
-			}
-			getChildrenHelper(root);
-			return outAry;
-		},
-		_destroyAll: function(){
-			// summary:
-			//		Code to destroy all widgets and do other cleanup on page unload
-			// Clean up focus manager lingering references to widgets and nodes
-			dijit._curFocus = null;
-			dijit._prevFocus = null;
-			dijit._activeStack = [];
-			// Destroy all the widgets, top down
-			array.forEach(registry.findWidgets(win.body()), function(widget){
-				// Avoid double destroy of widgets like Menu that are attached to <body>
-				// even though they are logically children of other widgets.
-				if(!widget._destroyed){
-					if(widget.destroyRecursive){
-						widget.destroyRecursive();
-					}else if(widget.destroy){
-						widget.destroy();
-					}
-				}
-			});
-		},
-		getEnclosingWidget: function(/*DOMNode*/ node){
-			// summary:
-			//		Returns the widget whose DOM tree contains the specified DOMNode, or null if
-			//		the node is not contained within the DOM tree of any widget
-			while(node){
-				var id = node.getAttribute && node.getAttribute("widgetId");
-				if(id){
-					return hash[id];
-				}
-				node = node.parentNode;
-			}
-			return null;
-		},
-		// In case someone needs to access hash.
-		// Actually, this is accessed from WidgetSet back-compatibility code
-		_hash: hash
-	};
-	dijit.registry = registry;
-	return registry;
-});

data/vendor/assets/javascripts/dijit/tree/ForestStoreModel.js.uncompressed.js DELETED Viewed

@@ -1,279 +0,0 @@
-define("dijit/tree/ForestStoreModel", [
-	"dojo/_base/array", // array.indexOf array.some
-	"dojo/_base/declare", // declare
-	"dojo/_base/kernel", // global
-	"dojo/_base/lang", // lang.hitch
-	"./TreeStoreModel"
-], function(array, declare, kernel, lang, TreeStoreModel){
-// module:
-//		dijit/tree/ForestStoreModel
-return declare("dijit.tree.ForestStoreModel", TreeStoreModel, {
-	// summary:
-	//		Interface between a dijit.Tree and a dojo.data store that doesn't have a root item,
-	//		a.k.a. a store that has multiple "top level" items.
-	//
-	// description:
-	//		Use this class to wrap a dojo.data store, making all the items matching the specified query
-	//		appear as children of a fabricated "root item".  If no query is specified then all the
-	//		items returned by fetch() on the underlying store become children of the root item.
-	//		This class allows dijit.Tree to assume a single root item, even if the store doesn't have one.
-	//
-	//		When using this class the developer must override a number of methods according to their app and
-	//		data, including:
-	//
-	//		- onNewRootItem
-	//		- onAddToRoot
-	//		- onLeaveRoot
-	//		- onNewItem
-	//		- onSetItem
-	// Parameters to constructor
-	// rootId: String
-	//		ID of fabricated root item
-	rootId: "$root$",
-	// rootLabel: String
-	//		Label of fabricated root item
-	rootLabel: "ROOT",
-	// query: String
-	//		Specifies the set of children of the root item.
-	// example:
-	//	|	{type:'continent'}
-	query: null,
-	// End of parameters to constructor
-	constructor: function(params){
-		// summary:
-		//		Sets up variables, etc.
-		// tags:
-		//		private
-		// Make dummy root item
-		this.root = {
-			store: this,
-			root: true,
-			id: params.rootId,
-			label: params.rootLabel,
-			children: params.rootChildren	// optional param
-		};
-	},
-	// =======================================================================
-	// Methods for traversing hierarchy
-	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)
-		// tags:
-		//		extension
-		return item === this.root || this.inherited(arguments);
-	},
-	getChildren: function(/*dojo/data/Item*/ parentItem, /*function(items)*/ callback, /*function*/ onError){
-		// summary:
-		//		Calls onComplete() with array of child items of given parent item, all loaded.
-		if(parentItem === this.root){
-			if(this.root.children){
-				// already loaded, just return
-				callback(this.root.children);
-			}else{
-				this.store.fetch({
-					query: this.query,
-					onComplete: lang.hitch(this, function(items){
-						this.root.children = items;
-						callback(items);
-					}),
-					onError: onError
-				});
-			}
-		}else{
-			this.inherited(arguments);
-		}
-	},
-	// =======================================================================
-	// Inspecting items
-	isItem: function(/* anything */ something){
-		return (something === this.root) ? true : this.inherited(arguments);
-	},
-	fetchItemByIdentity: function(/* object */ keywordArgs){
-		if(keywordArgs.identity == this.root.id){
-			var scope = keywordArgs.scope || kernel.global;
-			if(keywordArgs.onItem){
-				keywordArgs.onItem.call(scope, this.root);
-			}
-		}else{
-			this.inherited(arguments);
-		}
-	},
-	getIdentity: function(/* item */ item){
-		return (item === this.root) ? this.root.id : this.inherited(arguments);
-	},
-	getLabel: function(/* item */ item){
-		return	(item === this.root) ? this.root.label : this.inherited(arguments);
-	},
-	// =======================================================================
-	// Write interface
-	newItem: function(/* dijit/tree/dndSource.__Item */ args, /*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.
-		if(parent === this.root){
-			this.onNewRootItem(args);
-			return this.store.newItem(args);
-		}else{
-			return this.inherited(arguments);
-		}
-	},
-	onNewRootItem: function(/* dijit/tree/dndSource.__Item */ /*===== args =====*/){
-		// summary:
-		//		User can override this method to modify a new element that's being
-		//		added to the root of the tree, for example to add a flag like root=true
-	},
-	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
-		if(oldParentItem === this.root){
-			if(!bCopy){
-				// It's onLeaveRoot()'s responsibility to modify the item so it no longer matches
-				// this.query... thus triggering an onChildrenChange() event to notify the Tree
-				// that this element is no longer a child of the root node
-				this.onLeaveRoot(childItem);
-			}
-		}
-		this.inherited(arguments, [childItem,
-			oldParentItem === this.root ? null : oldParentItem,
-			newParentItem === this.root ? null : newParentItem,
-			bCopy,
-			insertIndex
-		]);
-		if(newParentItem === this.root){
-			// It's onAddToRoot()'s responsibility to modify the item so it matches
-			// this.query... thus triggering an onChildrenChange() event to notify the Tree
-			// that this element is now a child of the root node
-			this.onAddToRoot(childItem);
-		}
-	},
-	// =======================================================================
-	// Handling for top level children
-	onAddToRoot: function(/* item */ item){
-		// summary:
-		//		Called when item added to root of tree; user must override this method
-		//		to modify the item so that it matches the query for top level items
-		// example:
-		//	|	store.setValue(item, "root", true);
-		// tags:
-		//		extension
-		console.log(this, ": item ", item, " added to root");
-	},
-	onLeaveRoot: function(/* item */ item){
-		// summary:
-		//		Called when item removed from root of tree; user must override this method
-		//		to modify the item so it doesn't match the query for top level items
-		// example:
-		//	|	store.unsetAttribute(item, "root");
-		// tags:
-		//		extension
-		console.log(this, ": item ", item, " removed from root");
-	},
-	// =======================================================================
-	// Events from data store
-	_requeryTop: function(){
-		// reruns the query for the children of the root node,
-		// sending out an onSet notification if those children have changed
-		var oldChildren = this.root.children || [];
-		this.store.fetch({
-			query: this.query,
-			onComplete: lang.hitch(this, function(newChildren){
-				this.root.children = newChildren;
-				// If the list of children or the order of children has changed...
-				if(oldChildren.length != newChildren.length ||
-					array.some(oldChildren, function(item, idx){ return newChildren[idx] != item;})){
-					this.onChildrenChange(this.root, newChildren);
-				}
-			})
-		});
-	},
-	onNewItem: function(/* dojo/data/api/Item */ item, /* Object */ parentInfo){
-		// summary:
-		//		Handler for when new items appear in the store.  Developers should override this
-		//		method to be more efficient based on their app/data.
-		// description:
-		//		Note that the default implementation requeries the top level items every time
-		//		a new item is created, since any new item could be a top level item (even in
-		//		addition to being a child of another item, since items can have multiple parents).
-		//
-		//		If developers can detect which items are possible top level items (based on the item and the
-		//		parentInfo parameters), they should override this method to only call _requeryTop() for top
-		//		level items.  Often all top level items have parentInfo==null, but
-		//		that will depend on which store you use and what your data is like.
-		// tags:
-		//		extension
-		this._requeryTop();
-		this.inherited(arguments);
-	},
-	onDeleteItem: function(/*Object*/ item){
-		// summary:
-		//		Handler for delete notifications from underlying store
-		// check if this was a child of root, and if so send notification that root's children
-		// have changed
-		if(array.indexOf(this.root.children, item) != -1){
-			this._requeryTop();
-		}
-		this.inherited(arguments);
-	},
-	onSetItem: function(/* item */ item,
-					/* attribute-name-string */ attribute,
-					/* Object|Array */ oldValue,
-					/* Object|Array */ newValue){
-		// summary:
-		//		Updates the tree view according to changes to an item in the data store.
-		//		Developers should override this method to be more efficient based on their app/data.
-		// description:
-		//		Handles updates to an item's children by calling onChildrenChange(), and
-		//		other updates to an item by calling onChange().
-		//
-		//		Also, any change to any item re-executes the query for the tree's top-level items,
-		//		since this modified item may have started/stopped matching the query for top level items.
-		//
-		//		If possible, developers should override this function to only call _requeryTop() when
-		//		the change to the item has caused it to stop/start being a top level item in the tree.
-		// tags:
-		//		extension
-		this._requeryTop();
-		this.inherited(arguments);
-	}
-});
-});

data/vendor/assets/javascripts/dijit/tree/ObjectStoreModel.js.uncompressed.js DELETED Viewed

@@ -1,252 +0,0 @@
-define("dijit/tree/ObjectStoreModel", [
-	"dojo/_base/array", // array.filter array.forEach array.indexOf array.some
-	"dojo/aspect", // aspect.before, aspect.after
-	"dojo/_base/declare", // declare
-	"dojo/_base/lang", // lang.hitch
-	"dojo/when"
-], function(array, aspect, declare, lang, when){
-	// module:
-	//		dijit/tree/ObjectStoreModel
-	return declare("dijit.tree.ObjectStoreModel", null, {
-		// summary:
-		//		Implements dijit/Tree/model connecting dijit.Tree to a dojo.store that implements
-		//		getChildren().
-		//
-		//		If the store implements Observable, then it will be leveraged to reflect
-		//		store updates to the tree.
-		//
-		//		Drag and Drop: To support drag and drop, besides implementing getChildren()
-		//		and Observable, the store must support the parent option to put().
-		//		And in order to have child elements ordered according to how the user dropped them,
-		//		put() must support the before option.
-		// store: dojo/store/api/Store
-		//		Underlying store
-		store: null,
-		// labelAttr: String
-		//		Get label for tree node from this attribute
-		labelAttr: "name",
-		// root: [readonly] Object
-		//		Pointer to the root item from the dojo/store (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,
-		constructor: function(/* Object */ args){
-			// summary:
-			//		Passed the arguments listed above (store, etc)
-			// tags:
-			//		private
-			lang.mixin(this, args);
-			this.childrenCache = {};	// map from id to array of children
-		},
-		destroy: function(){
-			// TODO: should cancel any in-progress processing of getRoot(), getChildren()
-			for(var id in this.childrenCache){
-				this.childrenCache[id].close && this.childrenCache[id].close();
-			}
-		},
-		// =======================================================================
-		// 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{
-				var res;
-				when(res = this.store.query(this.query),
-					lang.hitch(this, function(items){
-						//console.log("queried root: ", res);
-						if(items.length != 1){
-							throw new Error("dijit.tree.ObjectStoreModel: root query returned " + items.length +
-								" items, but must return exactly one");
-						}
-						this.root = items[0];
-						onItem(this.root);
-						// Setup listener in case children list changes
-						if(res.observe){
-							res.observe(lang.hitch(this, function(obj){
-								// Presumably removedFrom == insertedInto == 1, and this call indicates item has changed.
-								//console.log("root changed: ", obj);
-								this.onChange(obj);
-							}), true);	// true to listen for updates to obj
-						}
-					}),
-					onError
-				);
-			}
-		},
-		mayHaveChildren: function(/*===== 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).
-			//
-			//		Application code should override this method based on the data, for example
-			//		it could be `return item.leaf == true;`.
-			// item: Object
-			//		Item from the dojo/store
-			return true;
-		},
-		getChildren: function(/*Object*/ parentItem, /*function(items)*/ onComplete, /*function*/ onError){
-			// summary:
-			//		Calls onComplete() with array of child items of given parent item.
-			// parentItem:
-			//		Item from the dojo/store
-			var id = this.store.getIdentity(parentItem);
-			if(this.childrenCache[id]){
-				when(this.childrenCache[id], onComplete, onError);
-				return;
-			}
-			when(
-				this.childrenCache[id] = this.store.getChildren(parentItem),
-				lang.hitch(this, function(children){
-					//console.log("queried children of " + id + ": ", children);
-					// Setup listener in case children list changes, or the item(s) in the children list are
-					// updated in some way.
-					if(children.observe){
-						children.observe(lang.hitch(this, function(obj, removedFrom, insertedInto){
-							//console.log("observe on children of ", id, ": ", obj, removedFrom, insertedInto);
-							// If removedFrom == insertedInto, this call indicates that the item has changed.
-							// Even if removedFrom != insertedInto, the item may have changed.
-							this.onChange(obj);
-							if(removedFrom != insertedInto){
-								// Indicates an item was added, removed, or re-parented.
-								// children[] has already been updated (like a live collection), so just use it.
-								this.onChildrenChange(parentItem, children);
-							}
-						}), true);	// true means to notify on item changes
-					}
-					// User callback
-					onComplete(children);
-				}),
-				onError
-			);
-		},
-		// =======================================================================
-		// Inspecting items
-		isItem: function(/*===== something =====*/){
-			return true;	// Boolean
-		},
-		fetchItemByIdentity: function(/* object */ keywordArgs){
-			this.store.get(keywordArgs.identity).then(
-				lang.hitch(keywordArgs.scope, keywordArgs.onItem),
-				lang.hitch(keywordArgs.scope, keywordArgs.onError)
-			);
-		},
-		getIdentity: function(/* item */ item){
-			return this.store.getIdentity(item);	// Object
-		},
-		getLabel: function(/*dojo/data/Item*/ item){
-			// summary:
-			//		Get the label for an item
-			return item[this.labelAttr];	// String
-		},
-		// =======================================================================
-		// Write interface, for DnD
-		newItem: function(/* dijit/tree/dndSource.__Item */ args, /*Item*/ parent, /*int?*/ insertIndex, /*Item*/ before){
-			// 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.
-			return this.store.put(args, {
-				parent: parent,
-				before: before
-			});
-		},
-		pasteItem: function(/*Item*/ childItem, /*Item*/ oldParentItem, /*Item*/ newParentItem,
-					/*Boolean*/ bCopy, /*int?*/ insertIndex, /*Item*/ before){
-			// summary:
-			//		Move or copy an item from one parent item to another.
-			//		Used in drag & drop
-			if(!bCopy){
-				// In order for DnD moves to work correctly, childItem needs to be orphaned from oldParentItem
-				// before being adopted by newParentItem.   That way, the TreeNode is moved rather than
-				// an additional TreeNode being created, and the old TreeNode subsequently being deleted.
-				// The latter loses information such as selection and opened/closed children TreeNodes.
-				// Unfortunately simply calling this.store.put() will send notifications in a random order, based
-				// on when the TreeNodes in question originally appeared, and not based on the drag-from
-				// TreeNode vs. the drop-onto TreeNode.
-				var oldParentChildren = [].concat(this.childrenCache[this.getIdentity(oldParentItem)]), // concat to make copy
-					index = array.indexOf(oldParentChildren, childItem);
-				oldParentChildren.splice(index, 1);
-				this.onChildrenChange(oldParentItem, oldParentChildren);
-			}
-			return this.store.put(childItem, {
-				overwrite: true,
-				parent: newParentItem,
-				before: before
-			});
-		},
-		// =======================================================================
-		// 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: Object[]
-			//		Items from the store
-			// tags:
-			//		callback
-		},
-		onDelete: function(/*dojo/data/Item*/ /*===== item =====*/){
-			// summary:
-			//		Callback when an item has been deleted.
-			//		Actually we have no way of knowing this with the new dojo.store API,
-			//		so this method is never called (but it's left here since Tree connects
-			//		to it).
-			// tags:
-			//		callback
-		}
-	});
-});