dijit-rails 0.9.0 → 0.10.0

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

@@ -0,0 +1,94 @@
+define("dijit/_Container", [
+	"dojo/_base/array", // array.forEach array.indexOf
+	"dojo/_base/declare", // declare
+	"dojo/dom-construct" // domConstruct.place
+], function(array, declare, domConstruct){
+
+	// module:
+	//		dijit/_Container
+
+	return declare("dijit._Container", null, {
+		// summary:
+		//		Mixin for widgets that contain HTML and/or a set of widget children.
+
+		buildRendering: function(){
+			this.inherited(arguments);
+			if(!this.containerNode){
+				// all widgets with descendants must set containerNode
+				this.containerNode = this.domNode;
+			}
+		},
+
+		addChild: function(/*dijit/_WidgetBase*/ widget, /*int?*/ insertIndex){
+			// summary:
+			//		Makes the given widget a child of this widget.
+			// description:
+			//		Inserts specified child widget's dom node as a child of this widget's
+			//		container node, and possibly does other processing (such as layout).
+			//
+			//		Functionality is undefined if this widget contains anything besides
+			//		a list of child widgets (ie, if it contains arbitrary non-widget HTML).
+
+			var refNode = this.containerNode;
+			if(insertIndex && typeof insertIndex == "number"){
+				var children = this.getChildren();
+				if(children && children.length >= insertIndex){
+					refNode = children[insertIndex-1].domNode;
+					insertIndex = "after";
+				}
+			}
+			domConstruct.place(widget.domNode, refNode, insertIndex);
+
+			// If I've been started but the child widget hasn't been started,
+			// start it now.  Make sure to do this after widget has been
+			// inserted into the DOM tree, so it can see that it's being controlled by me,
+			// so it doesn't try to size itself.
+			if(this._started && !widget._started){
+				widget.startup();
+			}
+		},
+
+		removeChild: function(/*Widget|int*/ widget){
+			// summary:
+			//		Removes the passed widget instance from this widget but does
+			//		not destroy it.  You can also pass in an integer indicating
+			//		the index within the container to remove (ie, removeChild(5) removes the sixth widget).
+
+			if(typeof widget == "number"){
+				widget = this.getChildren()[widget];
+			}
+
+			if(widget){
+				var node = widget.domNode;
+				if(node && node.parentNode){
+					node.parentNode.removeChild(node); // detach but don't destroy
+				}
+			}
+		},
+
+		hasChildren: function(){
+			// summary:
+			//		Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
+			return this.getChildren().length > 0;	// Boolean
+		},
+
+		_getSiblingOfChild: function(/*dijit/_WidgetBase*/ child, /*int*/ dir){
+			// summary:
+			//		Get the next or previous widget sibling of child
+			// dir:
+			//		if 1, get the next sibling
+			//		if -1, get the previous sibling
+			// tags:
+			//		private
+			var children = this.getChildren(),
+				idx = array.indexOf(this.getChildren(), child);	// int
+			return children[idx + dir];
+		},
+
+		getIndexOfChild: function(/*dijit/_WidgetBase*/ child){
+			// summary:
+			//		Gets the index of the child in this container or -1 if not found
+			return array.indexOf(this.getChildren(), child);	// int
+		}
+	});
+});

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

@@ -0,0 +1,172 @@
+//>>built
+define("dijit/_CssStateMixin",["dojo/_base/array","dojo/_base/declare","dojo/dom","dojo/dom-class","dojo/_base/lang","dojo/on","dojo/ready","dojo/_base/window","./registry"],function(_1,_2,_3,_4,_5,on,_6,_7,_8){
+var _9=_2("dijit._CssStateMixin",[],{cssStateNodes:{},hovering:false,active:false,_applyAttributes:function(){
+this.inherited(arguments);
+_1.forEach(["disabled","readOnly","checked","selected","focused","state","hovering","active","_opened"],function(_a){
+this.watch(_a,_5.hitch(this,"_setStateClass"));
+},this);
+for(var ap in this.cssStateNodes){
+this._trackMouseState(this[ap],this.cssStateNodes[ap]);
+}
+this._trackMouseState(this.domNode,this.baseClass);
+this._setStateClass();
+},_cssMouseEvent:function(_b){
+if(!this.disabled){
+switch(_b.type){
+case "mouseover":
+this._set("hovering",true);
+this._set("active",this._mouseDown);
+break;
+case "mouseout":
+this._set("hovering",false);
+this._set("active",false);
+break;
+case "mousedown":
+case "touchstart":
+this._set("active",true);
+break;
+case "mouseup":
+case "touchend":
+this._set("active",false);
+break;
+}
+}
+},_setStateClass:function(){
+var _c=this.baseClass.split(" ");
+function _d(_e){
+_c=_c.concat(_1.map(_c,function(c){
+return c+_e;
+}),"dijit"+_e);
+};
+if(!this.isLeftToRight()){
+_d("Rtl");
+}
+var _f=this.checked=="mixed"?"Mixed":(this.checked?"Checked":"");
+if(this.checked){
+_d(_f);
+}
+if(this.state){
+_d(this.state);
+}
+if(this.selected){
+_d("Selected");
+}
+if(this._opened){
+_d("Opened");
+}
+if(this.disabled){
+_d("Disabled");
+}else{
+if(this.readOnly){
+_d("ReadOnly");
+}else{
+if(this.active){
+_d("Active");
+}else{
+if(this.hovering){
+_d("Hover");
+}
+}
+}
+}
+if(this.focused){
+_d("Focused");
+}
+var tn=this.stateNode||this.domNode,_10={};
+_1.forEach(tn.className.split(" "),function(c){
+_10[c]=true;
+});
+if("_stateClasses" in this){
+_1.forEach(this._stateClasses,function(c){
+delete _10[c];
+});
+}
+_1.forEach(_c,function(c){
+_10[c]=true;
+});
+var _11=[];
+for(var c in _10){
+_11.push(c);
+}
+tn.className=_11.join(" ");
+this._stateClasses=_c;
+},_subnodeCssMouseEvent:function(_12,_13,evt){
+if(this.disabled||this.readOnly){
+return;
+}
+function _14(_15){
+_4.toggle(_12,_13+"Hover",_15);
+};
+function _16(_17){
+_4.toggle(_12,_13+"Active",_17);
+};
+function _18(_19){
+_4.toggle(_12,_13+"Focused",_19);
+};
+switch(evt.type){
+case "mouseover":
+_14(true);
+break;
+case "mouseout":
+_14(false);
+_16(false);
+break;
+case "mousedown":
+case "touchstart":
+_16(true);
+break;
+case "mouseup":
+case "touchend":
+_16(false);
+break;
+case "focus":
+case "focusin":
+_18(true);
+break;
+case "blur":
+case "focusout":
+_18(false);
+break;
+}
+},_trackMouseState:function(_1a,_1b){
+_1a._cssState=_1b;
+}});
+_6(function(){
+function _1c(evt){
+if(!_3.isDescendant(evt.relatedTarget,evt.target)){
+for(var _1d=evt.target;_1d&&_1d!=evt.relatedTarget;_1d=_1d.parentNode){
+if(_1d._cssState){
+var _1e=_8.getEnclosingWidget(_1d);
+if(_1e){
+if(_1d==_1e.domNode){
+_1e._cssMouseEvent(evt);
+}else{
+_1e._subnodeCssMouseEvent(_1d,_1d._cssState,evt);
+}
+}
+}
+}
+}
+};
+function _1f(evt){
+evt.target=evt.srcElement;
+_1c(evt);
+};
+var _20=_7.body();
+_1.forEach(["mouseover","mouseout","mousedown","touchstart","mouseup","touchend"],function(_21){
+if(_20.addEventListener){
+_20.addEventListener(_21,_1c,true);
+}else{
+_20.attachEvent("on"+_21,_1f);
+}
+});
+on(_20,"focusin, focusout",function(evt){
+var _22=evt.target;
+if(_22._cssState&&!_22.getAttribute("widgetId")){
+var _23=_8.getEnclosingWidget(_22);
+_23._subnodeCssMouseEvent(_22,_22._cssState,evt);
+}
+});
+});
+return _9;
+});

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

@@ -0,0 +1,320 @@
+define("dijit/_CssStateMixin", [
+	"dojo/_base/array", // array.forEach array.map
+	"dojo/_base/declare",	// declare
+	"dojo/dom",			// dom.isDescendant()
+	"dojo/dom-class", // domClass.toggle
+	"dojo/_base/lang", // lang.hitch
+	"dojo/on",
+	"dojo/ready",
+	"dojo/_base/window", // win.body
+	"./registry"
+], function(array, declare, dom, domClass, lang, on, ready, win, registry){
+
+// module:
+//		dijit/_CssStateMixin
+
+var CssStateMixin = declare("dijit._CssStateMixin", [], {
+	// summary:
+	//		Mixin for widgets to set CSS classes on the widget DOM nodes depending on hover/mouse press/focus
+	//		state changes, and also higher-level state changes such becoming disabled or selected.
+	//
+	// description:
+	//		By mixing this class into your widget, and setting the this.baseClass attribute, it will automatically
+	//		maintain CSS classes on the widget root node (this.domNode) depending on hover,
+	//		active, focus, etc. state.   Ex: with a baseClass of dijitButton, it will apply the classes
+	//		dijitButtonHovered and dijitButtonActive, as the user moves the mouse over the widget and clicks it.
+	//
+	//		It also sets CSS like dijitButtonDisabled based on widget semantic state.
+	//
+	//		By setting the cssStateNodes attribute, a widget can also track events on subnodes (like buttons
+	//		within the widget).
+
+	// cssStateNodes: [protected] Object
+	//		List of sub-nodes within the widget that need CSS classes applied on mouse hover/press and focus
+	//
+	//		Each entry in the hash is a an attachpoint names (like "upArrowButton") mapped to a CSS class names
+	//		(like "dijitUpArrowButton"). Example:
+	//	|		{
+	//	|			"upArrowButton": "dijitUpArrowButton",
+	//	|			"downArrowButton": "dijitDownArrowButton"
+	//	|		}
+	//		The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
+	//		is hovered, etc.
+	cssStateNodes: {},
+
+	// hovering: [readonly] Boolean
+	//		True if cursor is over this widget
+	hovering: false,
+
+	// active: [readonly] Boolean
+	//		True if mouse was pressed while over this widget, and hasn't been released yet
+	active: false,
+
+	_applyAttributes: function(){
+		// This code would typically be in postCreate(), but putting in _applyAttributes() for
+		// performance: so the class changes happen before DOM is inserted into the document.
+		// Change back to postCreate() in 2.0.  See #11635.
+
+		this.inherited(arguments);
+
+		// Monitoring changes to disabled, readonly, etc. state, and update CSS class of root node
+		array.forEach(["disabled", "readOnly", "checked", "selected", "focused", "state", "hovering", "active", "_opened"], function(attr){
+			this.watch(attr, lang.hitch(this, "_setStateClass"));
+		}, this);
+
+		// Track hover and active mouse events on widget root node, plus possibly on subnodes
+		for(var ap in this.cssStateNodes){
+			this._trackMouseState(this[ap], this.cssStateNodes[ap]);
+		}
+		this._trackMouseState(this.domNode, this.baseClass);
+
+		// Set state initially; there's probably no hover/active/focus state but widget might be
+		// disabled/readonly/checked/selected so we want to set CSS classes for those conditions.
+		this._setStateClass();
+	},
+
+	_cssMouseEvent: function(/*Event*/ event){
+		// summary:
+		//		Handler for CSS event on this.domNode. Sets hovering and active properties depending on mouse state,
+		//		which triggers _setStateClass() to set appropriate CSS classes for this.domNode.
+
+		if(!this.disabled){
+			switch(event.type){
+				case "mouseover":
+					this._set("hovering", true);
+					this._set("active", this._mouseDown);
+					break;
+				case "mouseout":
+					this._set("hovering", false);
+					this._set("active", false);
+					break;
+				case "mousedown":
+				case "touchstart":
+					this._set("active", true);
+					break;
+				case "mouseup":
+				case "touchend":
+					this._set("active", false);
+					break;
+			}
+		}
+	},
+
+	_setStateClass: function(){
+		// summary:
+		//		Update the visual state of the widget by setting the css classes on this.domNode
+		//		(or this.stateNode if defined) by combining this.baseClass with
+		//		various suffixes that represent the current widget state(s).
+		//
+		// description:
+		//		In the case where a widget has multiple
+		//		states, it sets the class based on all possible
+		//		combinations.  For example, an invalid form widget that is being hovered
+		//		will be "dijitInput dijitInputInvalid dijitInputHover dijitInputInvalidHover".
+		//
+		//		The widget may have one or more of the following states, determined
+		//		by this.state, this.checked, this.valid, and this.selected:
+		//
+		//		- Error - ValidationTextBox sets this.state to "Error" if the current input value is invalid
+		//		- Incomplete - ValidationTextBox sets this.state to "Incomplete" if the current input value is not finished yet
+		//		- Checked - ex: a checkmark or a ToggleButton in a checked state, will have this.checked==true
+		//		- Selected - ex: currently selected tab will have this.selected==true
+		//
+		//		In addition, it may have one or more of the following states,
+		//		based on this.disabled and flags set in _onMouse (this.active, this.hovering) and from focus manager (this.focused):
+		//
+		//		- Disabled	- if the widget is disabled
+		//		- Active		- if the mouse (or space/enter key?) is being pressed down
+		//		- Focused		- if the widget has focus
+		//		- Hover		- if the mouse is over the widget
+
+		// Compute new set of classes
+		var newStateClasses = this.baseClass.split(" ");
+
+		function multiply(modifier){
+			newStateClasses = newStateClasses.concat(array.map(newStateClasses, function(c){ return c+modifier; }), "dijit"+modifier);
+		}
+
+		if(!this.isLeftToRight()){
+			// For RTL mode we need to set an addition class like dijitTextBoxRtl.
+			multiply("Rtl");
+		}
+
+		var checkedState = this.checked == "mixed" ? "Mixed" : (this.checked ? "Checked" : "");
+		if(this.checked){
+			multiply(checkedState);
+		}
+		if(this.state){
+			multiply(this.state);
+		}
+		if(this.selected){
+			multiply("Selected");
+		}
+		if(this._opened){
+			multiply("Opened");
+		}
+
+		if(this.disabled){
+			multiply("Disabled");
+		}else if(this.readOnly){
+			multiply("ReadOnly");
+		}else{
+			if(this.active){
+				multiply("Active");
+			}else if(this.hovering){
+				multiply("Hover");
+			}
+		}
+
+		if(this.focused){
+			multiply("Focused");
+		}
+
+		// Remove old state classes and add new ones.
+		// For performance concerns we only write into domNode.className once.
+		var tn = this.stateNode || this.domNode,
+			classHash = {};	// set of all classes (state and otherwise) for node
+
+		array.forEach(tn.className.split(" "), function(c){ classHash[c] = true; });
+
+		if("_stateClasses" in this){
+			array.forEach(this._stateClasses, function(c){ delete classHash[c]; });
+		}
+
+		array.forEach(newStateClasses, function(c){ classHash[c] = true; });
+
+		var newClasses = [];
+		for(var c in classHash){
+			newClasses.push(c);
+		}
+		tn.className = newClasses.join(" ");
+
+		this._stateClasses = newStateClasses;
+	},
+
+	_subnodeCssMouseEvent: function(node, clazz, evt){
+		// summary:
+		//		Handler for hover/active mouse event on widget's subnode
+		if(this.disabled || this.readOnly){
+			return;
+		}
+		function hover(isHovering){
+			domClass.toggle(node, clazz+"Hover", isHovering);
+		}
+		function active(isActive){
+			domClass.toggle(node, clazz+"Active", isActive);
+		}
+		function focused(isFocused){
+			domClass.toggle(node, clazz+"Focused", isFocused);
+		}
+		switch(evt.type){
+			case "mouseover":
+				hover(true);
+				break;
+			case "mouseout":
+				hover(false);
+				active(false);
+				break;
+			case "mousedown":
+			case "touchstart":
+				active(true);
+				break;
+			case "mouseup":
+			case "touchend":
+				active(false);
+				break;
+			case "focus":
+			case "focusin":
+				focused(true);
+				break;
+			case "blur":
+			case "focusout":
+				focused(false);
+				break;
+		}
+	},
+
+	_trackMouseState: function(/*DomNode*/ node, /*String*/ clazz){
+		// summary:
+		//		Track mouse/focus events on specified node and set CSS class on that node to indicate
+		//		current state.   Usually not called directly, but via cssStateNodes attribute.
+		// description:
+		//		Given class=foo, will set the following CSS class on the node
+		//
+		//		- fooActive: if the user is currently pressing down the mouse button while over the node
+		//		- fooHover: if the user is hovering the mouse over the node, but not pressing down a button
+		//		- fooFocus: if the node is focused
+		//
+		//		Note that it won't set any classes if the widget is disabled.
+		// node: DomNode
+		//		Should be a sub-node of the widget, not the top node (this.domNode), since the top node
+		//		is handled specially and automatically just by mixing in this class.
+		// clazz: String
+		//		CSS class name (ex: dijitSliderUpArrow)
+
+		// Flag for listener code below to call this._cssMouseEvent() or this._subnodeCssMouseEvent()
+		// when node is hovered/active
+		node._cssState = clazz;
+	}
+});
+
+ready(function(){
+	// Document level listener to catch hover etc. events on widget root nodes and subnodes.
+	// Note that when the mouse is moved quickly, a single onmouseenter event could signal that multiple widgets
+	// have been hovered or unhovered (try test_Accordion.html)
+	function handler(evt){
+		// Poor man's event propagation.  Don't propagate event to ancestors of evt.relatedTarget,
+		// to avoid processing mouseout events moving from a widget's domNode to a descendant node;
+		// such events shouldn't be interpreted as a mouseleave on the widget.
+		if(!dom.isDescendant(evt.relatedTarget, evt.target)){
+			for(var node = evt.target; node && node != evt.relatedTarget; node = node.parentNode){
+				// Process any nodes with _cssState property.   They are generally widget root nodes,
+				// but could also be sub-nodes within a widget
+				if(node._cssState){
+					var widget = registry.getEnclosingWidget(node);
+					if(widget){
+						if(node == widget.domNode){
+							// event on the widget's root node
+							widget._cssMouseEvent(evt);
+						}else{
+							// event on widget's sub-node
+							widget._subnodeCssMouseEvent(node, node._cssState, evt);
+						}
+					}
+				}
+			}
+		}
+	}
+	function ieHandler(evt){
+		evt.target = evt.srcElement;
+		handler(evt);
+	}
+
+	// Use addEventListener() (and attachEvent() on IE) to catch the relevant events even if other handlers
+	// (on individual nodes) call evt.stopPropagation() or event.stopEvent().
+	// Currently typematic.js is doing that, not sure why.
+	var body = win.body();
+	array.forEach(["mouseover", "mouseout", "mousedown", "touchstart", "mouseup", "touchend"], function(type){
+		if(body.addEventListener){
+			body.addEventListener(type, handler, true);	// W3C
+		}else{
+			body.attachEvent("on"+type, ieHandler);	// IE
+		}
+	});
+
+	// Track focus events on widget sub-nodes that have been registered via _trackMouseState().
+	// However, don't track focus events on the widget root nodes, because focus is tracked via the
+	// focus manager (and it's not really tracking focus, but rather tracking that focus is on one of the widget's
+	// nodes or a subwidget's node or a popup node, etc.)
+	// Remove for 2.0 (if focus CSS needed, just use :focus pseudo-selector).
+	on(body, "focusin, focusout", function(evt){
+		var node = evt.target;
+		if(node._cssState && !node.getAttribute("widgetId")){
+			var widget = registry.getEnclosingWidget(node);
+			widget._subnodeCssMouseEvent(node, node._cssState, evt);
+		}
+	});
+});
+
+return CssStateMixin;
+});

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

@@ -0,0 +1,14 @@
+//>>built
+define("dijit/_DialogMixin",["dojo/_base/declare","./a11y"],function(_1,_2){
+return _1("dijit._DialogMixin",null,{execute:function(){
+},onCancel:function(){
+},onExecute:function(){
+},_onSubmit:function(){
+this.onExecute();
+this.execute(this.get("value"));
+},_getFocusItems:function(){
+var _3=_2._getTabNavigable(this.containerNode);
+this._firstFocusItem=_3.lowest||_3.first||this.closeButtonNode||this.domNode;
+this._lastFocusItem=_3.last||_3.highest||this._firstFocusItem;
+}});
+});

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

@@ -0,0 +1,70 @@
+define("dijit/_DialogMixin", [
+	"dojo/_base/declare", // declare
+	"./a11y"	// _getTabNavigable
+], function(declare, a11y){
+
+	// module:
+	//		dijit/_DialogMixin
+
+	return declare("dijit._DialogMixin", null, {
+		// summary:
+		//		This provides functions useful to Dialog and TooltipDialog
+
+		execute: function(/*Object*/ /*===== formContents =====*/){
+			// summary:
+			//		Callback when the user hits the submit button.
+			//		Override this method to handle Dialog execution.
+			// description:
+			//		After the user has pressed the submit button, the Dialog
+			//		first calls onExecute() to notify the container to hide the
+			//		dialog and restore focus to wherever it used to be.
+			//
+			//		*Then* this method is called.
+			// type:
+			//		callback
+		},
+
+		onCancel: function(){
+			// summary:
+			//		Called when user has pressed the Dialog's cancel button, to notify container.
+			// description:
+			//		Developer shouldn't override or connect to this method;
+			//		it's a private communication device between the TooltipDialog
+			//		and the thing that opened it (ex: `dijit/form/DropDownButton`)
+			// type:
+			//		protected
+		},
+
+		onExecute: function(){
+			// summary:
+			//		Called when user has pressed the dialog's OK button, to notify container.
+			// description:
+			//		Developer shouldn't override or connect to this method;
+			//		it's a private communication device between the TooltipDialog
+			//		and the thing that opened it (ex: `dijit/form/DropDownButton`)
+			// type:
+			//		protected
+		},
+
+		_onSubmit: function(){
+			// summary:
+			//		Callback when user hits submit button
+			// type:
+			//		protected
+			this.onExecute();	// notify container that we are about to execute
+			this.execute(this.get('value'));
+		},
+
+		_getFocusItems: function(){
+			// summary:
+			//		Finds focusable items in dialog,
+			//		and sets this._firstFocusItem and this._lastFocusItem
+			// tags:
+			//		protected
+
+			var elems = a11y._getTabNavigable(this.containerNode);
+			this._firstFocusItem = elems.lowest || elems.first || this.closeButtonNode || this.domNode;
+			this._lastFocusItem = elems.last || elems.highest || this._firstFocusItem;
+		}
+	});
+});

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

@@ -0,0 +1,11 @@
+//>>built
+define("dijit/_FocusMixin",["./focus","./_WidgetBase","dojo/_base/declare","dojo/_base/lang"],function(_1,_2,_3,_4){
+_4.extend(_2,{focused:false,onFocus:function(){
+},onBlur:function(){
+},_onFocus:function(){
+this.onFocus();
+},_onBlur:function(){
+this.onBlur();
+}});
+return _3("dijit._FocusMixin",null,{_focusManager:_1});
+});