dijit-rails 0.9.0 → 0.10.0

data/vendor/assets/javascripts/dijit/popup.js.uncompressed.js

@@ -0,0 +1,318 @@
+define("dijit/popup", [
+	"dojo/_base/array", // array.forEach array.some
+	"dojo/aspect",
+	"dojo/_base/connect",	// connect._keypress
+	"dojo/_base/declare", // declare
+	"dojo/dom", // dom.isDescendant
+	"dojo/dom-attr", // domAttr.set
+	"dojo/dom-construct", // domConstruct.create domConstruct.destroy
+	"dojo/dom-geometry", // domGeometry.isBodyLtr
+	"dojo/dom-style", // domStyle.set
+	"dojo/_base/event", // event.stop
+	"dojo/keys",
+	"dojo/_base/lang", // lang.hitch
+	"dojo/on",
+	"dojo/sniff", // has("ie") has("mozilla")
+	"./place",
+	"./BackgroundIframe",
+	"./main"	// dijit (defining dijit.popup to match API doc)
+], function(array, aspect, connect, declare, dom, domAttr, domConstruct, domGeometry, domStyle, event, keys, lang, on, has,
+			place, BackgroundIframe, dijit){
+
+	// module:
+	//		dijit/popup
+
+	/*=====
+	var __OpenArgs = {
+		// popup: Widget
+		//		widget to display
+		// parent: Widget
+		//		the button etc. that is displaying this popup
+		// around: DomNode
+		//		DOM node (typically a button); place popup relative to this node.  (Specify this *or* "x" and "y" parameters.)
+		// x: Integer
+		//		Absolute horizontal position (in pixels) to place node at.  (Specify this *or* "around" parameter.)
+		// y: Integer
+		//		Absolute vertical position (in pixels) to place node at.  (Specify this *or* "around" parameter.)
+		// orient: Object|String
+		//		When the around parameter is specified, orient should be a list of positions to try, ex:
+		//	|	[ "below", "above" ]
+		//		For backwards compatibility it can also be an (ordered) hash of tuples of the form
+		//		(around-node-corner, popup-node-corner), ex:
+		//	|	{ "BL": "TL", "TL": "BL" }
+		//		where BL means "bottom left" and "TL" means "top left", etc.
+		//
+		//		dijit/popup.open() tries to position the popup according to each specified position, in order,
+		//		until the popup appears fully within the viewport.
+		//
+		//		The default value is ["below", "above"]
+		//
+		//		When an (x,y) position is specified rather than an around node, orient is either
+		//		"R" or "L".  R (for right) means that it tries to put the popup to the right of the mouse,
+		//		specifically positioning the popup's top-right corner at the mouse position, and if that doesn't
+		//		fit in the viewport, then it tries, in order, the bottom-right corner, the top left corner,
+		//		and the top-right corner.
+		// onCancel: Function
+		//		callback when user has canceled the popup by:
+		//
+		//		1. hitting ESC or
+		//		2. by using the popup widget's proprietary cancel mechanism (like a cancel button in a dialog);
+		//		   i.e. whenever popupWidget.onCancel() is called, args.onCancel is called
+		// onClose: Function
+		//		callback whenever this popup is closed
+		// onExecute: Function
+		//		callback when user "executed" on the popup/sub-popup by selecting a menu choice, etc. (top menu only)
+		// padding: place.__Position
+		//		adding a buffer around the opening position. This is only useful when around is not set.
+	};
+	=====*/
+
+	function destroyWrapper(){
+		// summary:
+		//		Function to destroy wrapper when popup widget is destroyed.
+		//		Left in this scope to avoid memory leak on IE8 on refresh page, see #15206.
+		if(this._popupWrapper){
+			domConstruct.destroy(this._popupWrapper);
+			delete this._popupWrapper;
+		}
+	}
+
+	var PopupManager = declare(null, {
+		// summary:
+		//		Used to show drop downs (ex: the select list of a ComboBox)
+		//		or popups (ex: right-click context menus).
+
+		// _stack: dijit/_WidgetBase[]
+		//		Stack of currently popped up widgets.
+		//		(someone opened _stack[0], and then it opened _stack[1], etc.)
+		_stack: [],
+
+		// _beginZIndex: Number
+		//		Z-index of the first popup.   (If first popup opens other
+		//		popups they get a higher z-index.)
+		_beginZIndex: 1000,
+
+		_idGen: 1,
+
+		_createWrapper: function(/*Widget*/ widget){
+			// summary:
+			//		Initialization for widgets that will be used as popups.
+			//		Puts widget inside a wrapper DIV (if not already in one),
+			//		and returns pointer to that wrapper DIV.
+
+			var wrapper = widget._popupWrapper,
+				node = widget.domNode;
+
+			if(!wrapper){
+				// Create wrapper <div> for when this widget [in the future] will be used as a popup.
+				// This is done early because of IE bugs where creating/moving DOM nodes causes focus
+				// to go wonky, see tests/robot/Toolbar.html to reproduce
+				wrapper = domConstruct.create("div", {
+					"class":"dijitPopup",
+					style:{ display: "none"},
+					role: "presentation"
+				}, widget.ownerDocumentBody);
+				wrapper.appendChild(node);
+
+				var s = node.style;
+				s.display = "";
+				s.visibility = "";
+				s.position = "";
+				s.top = "0px";
+
+				widget._popupWrapper = wrapper;
+				aspect.after(widget, "destroy", destroyWrapper, true);
+			}
+
+			return wrapper;
+		},
+
+		moveOffScreen: function(/*Widget*/ widget){
+			// summary:
+			//		Moves the popup widget off-screen.
+			//		Do not use this method to hide popups when not in use, because
+			//		that will create an accessibility issue: the offscreen popup is
+			//		still in the tabbing order.
+
+			// Create wrapper if not already there
+			var wrapper = this._createWrapper(widget);
+
+			domStyle.set(wrapper, {
+				visibility: "hidden",
+				top: "-9999px",		// prevent transient scrollbar causing misalign (#5776), and initial flash in upper left (#10111)
+				display: ""
+			});
+		},
+
+		hide: function(/*Widget*/ widget){
+			// summary:
+			//		Hide this popup widget (until it is ready to be shown).
+			//		Initialization for widgets that will be used as popups
+			//
+			//		Also puts widget inside a wrapper DIV (if not already in one)
+			//
+			//		If popup widget needs to layout it should
+			//		do so when it is made visible, and popup._onShow() is called.
+
+			// Create wrapper if not already there
+			var wrapper = this._createWrapper(widget);
+
+			domStyle.set(wrapper, "display", "none");
+		},
+
+		getTopPopup: function(){
+			// summary:
+			//		Compute the closest ancestor popup that's *not* a child of another popup.
+			//		Ex: For a TooltipDialog with a button that spawns a tree of menus, find the popup of the button.
+			var stack = this._stack;
+			for(var pi=stack.length-1; pi > 0 && stack[pi].parent === stack[pi-1].widget; pi--){
+				/* do nothing, just trying to get right value for pi */
+			}
+			return stack[pi];
+		},
+
+		open: function(/*__OpenArgs*/ args){
+			// summary:
+			//		Popup the widget at the specified position
+			//
+			// example:
+			//		opening at the mouse position
+			//		|		popup.open({popup: menuWidget, x: evt.pageX, y: evt.pageY});
+			//
+			// example:
+			//		opening the widget as a dropdown
+			//		|		popup.open({parent: this, popup: menuWidget, around: this.domNode, onClose: function(){...}});
+			//
+			//		Note that whatever widget called dijit/popup.open() should also listen to its own _onBlur callback
+			//		(fired from _base/focus.js) to know that focus has moved somewhere else and thus the popup should be closed.
+
+			var stack = this._stack,
+				widget = args.popup,
+				orient = args.orient || ["below", "below-alt", "above", "above-alt"],
+				ltr = args.parent ? args.parent.isLeftToRight() : domGeometry.isBodyLtr(widget.ownerDocument),
+				around = args.around,
+				id = (args.around && args.around.id) ? (args.around.id+"_dropdown") : ("popup_"+this._idGen++);
+
+			// If we are opening a new popup that isn't a child of a currently opened popup, then
+			// close currently opened popup(s).   This should happen automatically when the old popups
+			// gets the _onBlur() event, except that the _onBlur() event isn't reliable on IE, see [22198].
+			while(stack.length && (!args.parent || !dom.isDescendant(args.parent.domNode, stack[stack.length-1].widget.domNode))){
+				this.close(stack[stack.length-1].widget);
+			}
+
+			// Get pointer to popup wrapper, and create wrapper if it doesn't exist
+			var wrapper = this._createWrapper(widget);
+
+
+			domAttr.set(wrapper, {
+				id: id,
+				style: {
+					zIndex: this._beginZIndex + stack.length
+				},
+				"class": "dijitPopup " + (widget.baseClass || widget["class"] || "").split(" ")[0] +"Popup",
+				dijitPopupParent: args.parent ? args.parent.id : ""
+			});
+
+			if(has("ie") || has("mozilla")){
+				if(!widget.bgIframe){
+					// setting widget.bgIframe triggers cleanup in _Widget.destroy()
+					widget.bgIframe = new BackgroundIframe(wrapper);
+				}
+			}
+
+			// position the wrapper node and make it visible
+			var best = around ?
+				place.around(wrapper, around, orient, ltr, widget.orient ? lang.hitch(widget, "orient") : null) :
+				place.at(wrapper, args, orient == 'R' ? ['TR','BR','TL','BL'] : ['TL','BL','TR','BR'], args.padding);
+
+			wrapper.style.display = "";
+			wrapper.style.visibility = "visible";
+			widget.domNode.style.visibility = "visible";	// counteract effects from _HasDropDown
+
+			var handlers = [];
+
+			// provide default escape and tab key handling
+			// (this will work for any widget, not just menu)
+			handlers.push(on(wrapper, connect._keypress, lang.hitch(this, function(evt){
+				if(evt.charOrCode == keys.ESCAPE && args.onCancel){
+					event.stop(evt);
+					args.onCancel();
+				}else if(evt.charOrCode === keys.TAB){
+					event.stop(evt);
+					var topPopup = this.getTopPopup();
+					if(topPopup && topPopup.onCancel){
+						topPopup.onCancel();
+					}
+				}
+			})));
+
+			// watch for cancel/execute events on the popup and notify the caller
+			// (for a menu, "execute" means clicking an item)
+			if(widget.onCancel && args.onCancel){
+				handlers.push(widget.on("cancel", args.onCancel));
+			}
+
+			handlers.push(widget.on(widget.onExecute ? "execute" : "change", lang.hitch(this, function(){
+				var topPopup = this.getTopPopup();
+				if(topPopup && topPopup.onExecute){
+					topPopup.onExecute();
+				}
+			})));
+
+			stack.push({
+				widget: widget,
+				parent: args.parent,
+				onExecute: args.onExecute,
+				onCancel: args.onCancel,
+				onClose: args.onClose,
+				handlers: handlers
+			});
+
+			if(widget.onOpen){
+				// TODO: in 2.0 standardize onShow() (used by StackContainer) and onOpen() (used here)
+				widget.onOpen(best);
+			}
+
+			return best;
+		},
+
+		close: function(/*Widget?*/ popup){
+			// summary:
+			//		Close specified popup and any popups that it parented.
+			//		If no popup is specified, closes all popups.
+
+			var stack = this._stack;
+
+			// Basically work backwards from the top of the stack closing popups
+			// until we hit the specified popup, but IIRC there was some issue where closing
+			// a popup would cause others to close too.  Thus if we are trying to close B in [A,B,C]
+			// closing C might close B indirectly and then the while() condition will run where stack==[A]...
+			// so the while condition is constructed defensively.
+			while((popup && array.some(stack, function(elem){return elem.widget == popup;})) ||
+				(!popup && stack.length)){
+				var top = stack.pop(),
+					widget = top.widget,
+					onClose = top.onClose;
+
+				if(widget.onClose){
+					// TODO: in 2.0 standardize onHide() (used by StackContainer) and onClose() (used here)
+					widget.onClose();
+				}
+
+				var h;
+				while(h = top.handlers.pop()){ h.remove(); }
+
+				// Hide the widget and it's wrapper unless it has already been destroyed in above onClose() etc.
+				if(widget && widget.domNode){
+					this.hide(widget);
+				}
+
+				if(onClose){
+					onClose();
+				}
+			}
+		}
+	});
+
+	return (dijit.popup = new PopupManager());
+});

data/vendor/assets/javascripts/dijit/registry.js

@@ -0,0 +1,79 @@
+//>>built
+define("dijit/registry",["dojo/_base/array","dojo/sniff","dojo/_base/unload","dojo/_base/window","./main"],function(_1,_2,_3,_4,_5){
+var _6={},_7={};
+var _8={length:0,add:function(_9){
+if(_7[_9.id]){
+throw new Error("Tried to register widget with id=="+_9.id+" but that id is already registered");
+}
+_7[_9.id]=_9;
+this.length++;
+},remove:function(id){
+if(_7[id]){
+delete _7[id];
+this.length--;
+}
+},byId:function(id){
+return typeof id=="string"?_7[id]:id;
+},byNode:function(_a){
+return _7[_a.getAttribute("widgetId")];
+},toArray:function(){
+var ar=[];
+for(var id in _7){
+ar.push(_7[id]);
+}
+return ar;
+},getUniqueId:function(_b){
+var id;
+do{
+id=_b+"_"+(_b in _6?++_6[_b]:_6[_b]=0);
+}while(_7[id]);
+return _5._scopeName=="dijit"?id:_5._scopeName+"_"+id;
+},findWidgets:function(_c,_d){
+var _e=[];
+function _f(_10){
+for(var _11=_10.firstChild;_11;_11=_11.nextSibling){
+if(_11.nodeType==1){
+var _12=_11.getAttribute("widgetId");
+if(_12){
+var _13=_7[_12];
+if(_13){
+_e.push(_13);
+}
+}else{
+if(_11!==_d){
+_f(_11);
+}
+}
+}
+}
+};
+_f(_c);
+return _e;
+},_destroyAll:function(){
+_5._curFocus=null;
+_5._prevFocus=null;
+_5._activeStack=[];
+_1.forEach(_8.findWidgets(_4.body()),function(_14){
+if(!_14._destroyed){
+if(_14.destroyRecursive){
+_14.destroyRecursive();
+}else{
+if(_14.destroy){
+_14.destroy();
+}
+}
+}
+});
+},getEnclosingWidget:function(_15){
+while(_15){
+var id=_15.getAttribute&&_15.getAttribute("widgetId");
+if(id){
+return _7[id];
+}
+_15=_15.parentNode;
+}
+return null;
+},_hash:_7};
+_5.registry=_8;
+return _8;
+});

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

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,77 @@
+//>>built
+define("dijit/tree/ForestStoreModel",["dojo/_base/array","dojo/_base/declare","dojo/_base/kernel","dojo/_base/lang","./TreeStoreModel"],function(_1,_2,_3,_4,_5){
+return _2("dijit.tree.ForestStoreModel",_5,{rootId:"$root$",rootLabel:"ROOT",query:null,constructor:function(_6){
+this.root={store:this,root:true,id:_6.rootId,label:_6.rootLabel,children:_6.rootChildren};
+},mayHaveChildren:function(_7){
+return _7===this.root||this.inherited(arguments);
+},getChildren:function(_8,_9,_a){
+if(_8===this.root){
+if(this.root.children){
+_9(this.root.children);
+}else{
+this.store.fetch({query:this.query,onComplete:_4.hitch(this,function(_b){
+this.root.children=_b;
+_9(_b);
+}),onError:_a});
+}
+}else{
+this.inherited(arguments);
+}
+},isItem:function(_c){
+return (_c===this.root)?true:this.inherited(arguments);
+},fetchItemByIdentity:function(_d){
+if(_d.identity==this.root.id){
+var _e=_d.scope||_3.global;
+if(_d.onItem){
+_d.onItem.call(_e,this.root);
+}
+}else{
+this.inherited(arguments);
+}
+},getIdentity:function(_f){
+return (_f===this.root)?this.root.id:this.inherited(arguments);
+},getLabel:function(_10){
+return (_10===this.root)?this.root.label:this.inherited(arguments);
+},newItem:function(_11,_12,_13){
+if(_12===this.root){
+this.onNewRootItem(_11);
+return this.store.newItem(_11);
+}else{
+return this.inherited(arguments);
+}
+},onNewRootItem:function(){
+},pasteItem:function(_14,_15,_16,_17,_18){
+if(_15===this.root){
+if(!_17){
+this.onLeaveRoot(_14);
+}
+}
+this.inherited(arguments,[_14,_15===this.root?null:_15,_16===this.root?null:_16,_17,_18]);
+if(_16===this.root){
+this.onAddToRoot(_14);
+}
+},onAddToRoot:function(_19){
+},onLeaveRoot:function(_1a){
+},_requeryTop:function(){
+var _1b=this.root.children||[];
+this.store.fetch({query:this.query,onComplete:_4.hitch(this,function(_1c){
+this.root.children=_1c;
+if(_1b.length!=_1c.length||_1.some(_1b,function(_1d,idx){
+return _1c[idx]!=_1d;
+})){
+this.onChildrenChange(this.root,_1c);
+}
+})});
+},onNewItem:function(_1e,_1f){
+this._requeryTop();
+this.inherited(arguments);
+},onDeleteItem:function(_20){
+if(_1.indexOf(this.root.children,_20)!=-1){
+this._requeryTop();
+}
+this.inherited(arguments);
+},onSetItem:function(_21,_22,_23,_24){
+this._requeryTop();
+this.inherited(arguments);
+}});
+});