dijit-rails 0.9.0 → 0.10.0

data/vendor/assets/javascripts/dijit/form/NumberSpinner.js.uncompressed.js

@@ -0,0 +1,67 @@
+define("dijit/form/NumberSpinner", [
+	"dojo/_base/declare", // declare
+	"dojo/_base/event", // event.stop
+	"dojo/keys", // keys.END keys.HOME
+	"./_Spinner",
+	"./NumberTextBox"
+], function(declare, event, keys, _Spinner, NumberTextBox){
+
+// module:
+//		dijit/form/NumberSpinner
+
+
+return declare("dijit.form.NumberSpinner", [_Spinner, NumberTextBox.Mixin], {
+	// summary:
+	//		Extends NumberTextBox to add up/down arrows and pageup/pagedown for incremental change to the value
+	//
+	// description:
+	//		A `dijit/form/NumberTextBox` extension to provide keyboard accessible value selection
+	//		as well as icons for spinning direction. When using the keyboard, the typematic rules
+	//		apply, meaning holding the key will gradually increase or decrease the value and
+	//		accelerate.
+	//
+	// example:
+	//	| new NumberSpinner({ constraints:{ max:300, min:100 }}, "someInput");
+
+	adjust: function(/*Object*/ val, /*Number*/ delta){
+		// summary:
+		//		Change Number val by the given amount
+		// tags:
+		//		protected
+
+		var tc = this.constraints,
+			v = isNaN(val),
+			gotMax = !isNaN(tc.max),
+			gotMin = !isNaN(tc.min)
+		;
+		if(v && delta != 0){ // blank or invalid value and they want to spin, so create defaults
+			val = (delta > 0) ?
+				gotMin ? tc.min : gotMax ? tc.max : 0 :
+				gotMax ? this.constraints.max : gotMin ? tc.min : 0
+			;
+		}
+		var newval = val + delta;
+		if(v || isNaN(newval)){ return val; }
+		if(gotMax && (newval > tc.max)){
+			newval = tc.max;
+		}
+		if(gotMin && (newval < tc.min)){
+			newval = tc.min;
+		}
+		return newval;
+	},
+
+	_onKeyPress: function(e){
+		if((e.charOrCode == keys.HOME || e.charOrCode == keys.END) && !(e.ctrlKey || e.altKey || e.metaKey)
+		&& typeof this.get('value') != 'undefined' /* gibberish, so HOME and END are default editing keys*/){
+			var value = this.constraints[(e.charOrCode == keys.HOME ? "min" : "max")];
+			if(typeof value == "number"){
+				this._setValueAttr(value, false);
+			}
+			// eat home or end key whether we change the value or not
+			event.stop(e);
+		}
+	}
+});
+
+});

data/vendor/assets/javascripts/dijit/form/NumberTextBox.js

@@ -0,0 +1,116 @@
+//>>built
+define("dijit/form/NumberTextBox",["dojo/_base/declare","dojo/_base/lang","dojo/number","./RangeBoundTextBox"],function(_1,_2,_3,_4){
+var _5=_1("dijit.form.NumberTextBoxMixin",null,{pattern:_3.regexp,value:NaN,editOptions:{pattern:"#.######"},_formatter:_3.format,postMixInProperties:function(){
+this.inherited(arguments);
+this._set("type","text");
+},_setConstraintsAttr:function(_6){
+var _7=typeof _6.places=="number"?_6.places:0;
+if(_7){
+_7++;
+}
+if(typeof _6.max!="number"){
+_6.max=9*Math.pow(10,15-_7);
+}
+if(typeof _6.min!="number"){
+_6.min=-9*Math.pow(10,15-_7);
+}
+this.inherited(arguments,[_6]);
+if(this.focusNode&&this.focusNode.value&&!isNaN(this.value)){
+this.set("value",this.value);
+}
+},_onFocus:function(){
+if(this.disabled){
+return;
+}
+var _8=this.get("value");
+if(typeof _8=="number"&&!isNaN(_8)){
+var _9=this.format(_8,this.constraints);
+if(_9!==undefined){
+this.textbox.value=_9;
+}
+}
+this.inherited(arguments);
+},format:function(_a,_b){
+var _c=String(_a);
+if(typeof _a!="number"){
+return _c;
+}
+if(isNaN(_a)){
+return "";
+}
+if(!("rangeCheck" in this&&this.rangeCheck(_a,_b))&&_b.exponent!==false&&/\de[-+]?\d/i.test(_c)){
+return _c;
+}
+if(this.editOptions&&this.focused){
+_b=_2.mixin({},_b,this.editOptions);
+}
+return this._formatter(_a,_b);
+},_parser:_3.parse,parse:function(_d,_e){
+var v=this._parser(_d,_2.mixin({},_e,(this.editOptions&&this.focused)?this.editOptions:{}));
+if(this.editOptions&&this.focused&&isNaN(v)){
+v=this._parser(_d,_e);
+}
+return v;
+},_getDisplayedValueAttr:function(){
+var v=this.inherited(arguments);
+return isNaN(v)?this.textbox.value:v;
+},filter:function(_f){
+return (_f==null||_f==="")?NaN:this.inherited(arguments);
+},serialize:function(_10,_11){
+return (typeof _10!="number"||isNaN(_10))?"":this.inherited(arguments);
+},_setBlurValue:function(){
+var val=_2.hitch(_2.mixin({},this,{focused:true}),"get")("value");
+this._setValueAttr(val,true);
+},_setValueAttr:function(_12,_13,_14){
+if(_12!==undefined&&_14===undefined){
+_14=String(_12);
+if(typeof _12=="number"){
+if(isNaN(_12)){
+_14="";
+}else{
+if(("rangeCheck" in this&&this.rangeCheck(_12,this.constraints))||this.constraints.exponent===false||!/\de[-+]?\d/i.test(_14)){
+_14=undefined;
+}
+}
+}else{
+if(!_12){
+_14="";
+_12=NaN;
+}else{
+_12=undefined;
+}
+}
+}
+this.inherited(arguments,[_12,_13,_14]);
+},_getValueAttr:function(){
+var v=this.inherited(arguments);
+if(isNaN(v)&&this.textbox.value!==""){
+if(this.constraints.exponent!==false&&/\de[-+]?\d/i.test(this.textbox.value)&&(new RegExp("^"+_3._realNumberRegexp(_2.mixin({},this.constraints))+"$").test(this.textbox.value))){
+var n=Number(this.textbox.value);
+return isNaN(n)?undefined:n;
+}else{
+return undefined;
+}
+}else{
+return v;
+}
+},isValid:function(_15){
+if(!this.focused||this._isEmpty(this.textbox.value)){
+return this.inherited(arguments);
+}else{
+var v=this.get("value");
+if(!isNaN(v)&&this.rangeCheck(v,this.constraints)){
+if(this.constraints.exponent!==false&&/\de[-+]?\d/i.test(this.textbox.value)){
+return true;
+}else{
+return this.inherited(arguments);
+}
+}else{
+return false;
+}
+}
+}});
+var _16=_1("dijit.form.NumberTextBox",[_4,_5],{baseClass:"dijitTextBox dijitNumberTextBox"});
+_16.Mixin=_5;
+return _16;
+});

data/vendor/assets/javascripts/dijit/form/NumberTextBox.js.uncompressed.js

@@ -0,0 +1,275 @@
+define("dijit/form/NumberTextBox", [
+	"dojo/_base/declare", // declare
+	"dojo/_base/lang", // lang.hitch lang.mixin
+	"dojo/number", // number._realNumberRegexp number.format number.parse number.regexp
+	"./RangeBoundTextBox"
+], function(declare, lang, number, RangeBoundTextBox){
+
+	// module:
+	//		dijit/form/NumberTextBox
+
+
+	var NumberTextBoxMixin = declare("dijit.form.NumberTextBoxMixin", null, {
+		// summary:
+		//		A mixin for all number textboxes
+		// tags:
+		//		protected
+
+		// Override ValidationTextBox.pattern.... we use a reg-ex generating function rather
+		// than a straight regexp to deal with locale (plus formatting options too?)
+		pattern: number.regexp,
+
+		/*=====
+		// constraints: NumberTextBox.__Constraints
+		//		Despite the name, this parameter specifies both constraints on the input
+		//		(including minimum/maximum allowed values) as well as
+		//		formatting options like places (the number of digits to display after
+		//		the decimal point).
+		constraints: {},
+		======*/
+
+		// value: Number
+		//		The value of this NumberTextBox as a Javascript Number (i.e., not a String).
+		//		If the displayed value is blank, the value is NaN, and if the user types in
+		//		an gibberish value (like "hello world"), the value is undefined
+		//		(i.e. get('value') returns undefined).
+		//
+		//		Symmetrically, set('value', NaN) will clear the displayed value,
+		//		whereas set('value', undefined) will have no effect.
+		value: NaN,
+
+		// editOptions: [protected] Object
+		//		Properties to mix into constraints when the value is being edited.
+		//		This is here because we edit the number in the format "12345", which is
+		//		different than the display value (ex: "12,345")
+		editOptions: { pattern: '#.######' },
+
+		/*=====
+		_formatter: function(value, options){
+			// summary:
+			//		_formatter() is called by format().  It's the base routine for formatting a number,
+			//		as a string, for example converting 12345 into "12,345".
+			// value: Number
+			//		The number to be converted into a string.
+			// options: number.__FormatOptions?
+			//		Formatting options
+			// tags:
+			//		protected extension
+
+			return "12345";		// String
+		},
+		 =====*/
+		_formatter: number.format,
+
+		postMixInProperties: function(){
+			this.inherited(arguments);
+			this._set("type", "text"); // in case type="number" was specified which messes up parse/format
+		},
+
+		_setConstraintsAttr: function(/*Object*/ constraints){
+			var places = typeof constraints.places == "number"? constraints.places : 0;
+			if(places){ places++; } // decimal rounding errors take away another digit of precision
+			if(typeof constraints.max != "number"){
+				constraints.max = 9 * Math.pow(10, 15-places);
+			}
+			if(typeof constraints.min != "number"){
+				constraints.min = -9 * Math.pow(10, 15-places);
+			}
+			this.inherited(arguments, [ constraints ]);
+			if(this.focusNode && this.focusNode.value && !isNaN(this.value)){
+				this.set('value', this.value);
+			}
+		},
+
+		_onFocus: function(){
+			if(this.disabled){ return; }
+			var val = this.get('value');
+			if(typeof val == "number" && !isNaN(val)){
+				var formattedValue = this.format(val, this.constraints);
+				if(formattedValue !== undefined){
+					this.textbox.value = formattedValue;
+				}
+			}
+			this.inherited(arguments);
+		},
+
+		format: function(/*Number*/ value, /*number.__FormatOptions*/ constraints){
+			// summary:
+			//		Formats the value as a Number, according to constraints.
+			// tags:
+			//		protected
+
+			var formattedValue = String(value);
+			if(typeof value != "number"){ return formattedValue; }
+			if(isNaN(value)){ return ""; }
+			// check for exponential notation that dojo/number.format() chokes on
+			if(!("rangeCheck" in this && this.rangeCheck(value, constraints)) && constraints.exponent !== false && /\de[-+]?\d/i.test(formattedValue)){
+				return formattedValue;
+			}
+			if(this.editOptions && this.focused){
+				constraints = lang.mixin({}, constraints, this.editOptions);
+			}
+			return this._formatter(value, constraints);
+		},
+
+		/*=====
+		_parser: function(value, constraints){
+			// summary:
+			//		Parses the string value as a Number, according to constraints.
+			// value: String
+			//		String representing a number
+			// constraints: number.__ParseOptions
+			//		Formatting options
+			// tags:
+			//		protected
+
+			return 123.45;		// Number
+		},
+		=====*/
+		_parser: number.parse,
+
+		parse: function(/*String*/ value, /*number.__FormatOptions*/ constraints){
+			// summary:
+			//		Replaceable function to convert a formatted string to a number value
+			// tags:
+			//		protected extension
+
+			var v = this._parser(value, lang.mixin({}, constraints, (this.editOptions && this.focused) ? this.editOptions : {}));
+			if(this.editOptions && this.focused && isNaN(v)){
+				v = this._parser(value, constraints); // parse w/o editOptions: not technically needed but is nice for the user
+			}
+			return v;
+		},
+
+		_getDisplayedValueAttr: function(){
+			var v = this.inherited(arguments);
+			return isNaN(v) ? this.textbox.value : v;
+		},
+
+		filter: function(/*Number*/ value){
+			// summary:
+			//		This is called with both the display value (string), and the actual value (a number).
+			//		When called with the actual value it does corrections so that '' etc. are represented as NaN.
+			//		Otherwise it dispatches to the superclass's filter() method.
+			//
+			//		See `dijit/form/TextBox.filter()` for more details.
+			return (value == null /* or undefined */ || value === '') ? NaN : this.inherited(arguments); // set('value', null||''||undefined) should fire onChange(NaN)
+		},
+
+		serialize: function(/*Number*/ value, /*Object?*/ options){
+			// summary:
+			//		Convert value (a Number) into a canonical string (ie, how the number literal is written in javascript/java/C/etc.)
+			// tags:
+			//		protected
+			return (typeof value != "number" || isNaN(value)) ? '' : this.inherited(arguments);
+		},
+
+		_setBlurValue: function(){
+			var val = lang.hitch(lang.mixin({}, this, { focused: true }), "get")('value'); // parse with editOptions
+			this._setValueAttr(val, true);
+		},
+
+		_setValueAttr: function(/*Number*/ value, /*Boolean?*/ priorityChange, /*String?*/ formattedValue){
+			// summary:
+			//		Hook so set('value', ...) works.
+			if(value !== undefined && formattedValue === undefined){
+				formattedValue = String(value);
+				if(typeof value == "number"){
+					if(isNaN(value)){ formattedValue = '' }
+					// check for exponential notation that number.format chokes on
+					else if(("rangeCheck" in this && this.rangeCheck(value, this.constraints)) || this.constraints.exponent === false || !/\de[-+]?\d/i.test(formattedValue)){
+						formattedValue = undefined; // lets format compute a real string value
+					}
+				}else if(!value){ // 0 processed in if branch above, ''|null|undefined flows through here
+					formattedValue = '';
+					value = NaN;
+				}else{ // non-numeric values
+					value = undefined;
+				}
+			}
+			this.inherited(arguments, [value, priorityChange, formattedValue]);
+		},
+
+		_getValueAttr: function(){
+			// summary:
+			//		Hook so get('value') works.
+			//		Returns Number, NaN for '', or undefined for unparseable text
+			var v = this.inherited(arguments); // returns Number for all values accepted by parse() or NaN for all other displayed values
+
+			// If the displayed value of the textbox is gibberish (ex: "hello world"), this.inherited() above
+			// returns NaN; this if() branch converts the return value to undefined.
+			// Returning undefined prevents user text from being overwritten when doing _setValueAttr(_getValueAttr()).
+			// A blank displayed value is still returned as NaN.
+			if(isNaN(v) && this.textbox.value !== ''){
+				if(this.constraints.exponent !== false && /\de[-+]?\d/i.test(this.textbox.value) && (new RegExp("^"+number._realNumberRegexp(lang.mixin({}, this.constraints))+"$").test(this.textbox.value))){	// check for exponential notation that parse() rejected (erroneously?)
+					var n = Number(this.textbox.value);
+					return isNaN(n) ? undefined : n; // return exponential Number or undefined for random text (may not be possible to do with the above RegExp check)
+				}else{
+					return undefined; // gibberish
+				}
+			}else{
+				return v; // Number or NaN for ''
+			}
+		},
+
+		isValid: function(/*Boolean*/ isFocused){
+			// Overrides dijit/form/RangeBoundTextBox.isValid() to check that the editing-mode value is valid since
+			// it may not be formatted according to the regExp validation rules
+			if(!this.focused || this._isEmpty(this.textbox.value)){
+				return this.inherited(arguments);
+			}else{
+				var v = this.get('value');
+				if(!isNaN(v) && this.rangeCheck(v, this.constraints)){
+					if(this.constraints.exponent !== false && /\de[-+]?\d/i.test(this.textbox.value)){ // exponential, parse doesn't like it
+						return true; // valid exponential number in range
+					}else{
+						return this.inherited(arguments);
+					}
+				}else{
+					return false;
+				}
+			}
+		}
+	});
+
+	var NumberTextBox = declare("dijit.form.NumberTextBox", [RangeBoundTextBox, NumberTextBoxMixin], {
+		// summary:
+		//		A TextBox for entering numbers, with formatting and range checking
+		// description:
+		//		NumberTextBox is a textbox for entering and displaying numbers, supporting
+		//		the following main features:
+		//
+		//		1. Enforce minimum/maximum allowed values (as well as enforcing that the user types
+		//			a number rather than a random string)
+		//		2. NLS support (altering roles of comma and dot as "thousands-separator" and "decimal-point"
+		//			depending on locale).
+		//		3. Separate modes for editing the value and displaying it, specifically that
+		//			the thousands separator character (typically comma) disappears when editing
+		//			but reappears after the field is blurred.
+		//		4. Formatting and constraints regarding the number of places (digits after the decimal point)
+		//			allowed on input, and number of places displayed when blurred (see `constraints` parameter).
+
+		baseClass: "dijitTextBox dijitNumberTextBox"
+	});
+
+	NumberTextBox.Mixin = NumberTextBoxMixin;	// for monkey patching
+
+	/*=====
+	 NumberTextBox.__Constraints = declare([RangeBoundTextBox.__Constraints, number.__FormatOptions, number.__ParseOptions], {
+		 // summary:
+		 //		Specifies both the rules on valid/invalid values (minimum, maximum,
+		 //		number of required decimal places), and also formatting options for
+		 //		displaying the value when the field is not focused.
+		 // example:
+		 //		Minimum/maximum:
+		 //		To specify a field between 0 and 120:
+		 //	|		{min:0,max:120}
+		 //		To specify a field that must be an integer:
+		 //	|		{fractional:false}
+		 //		To specify a field where 0 to 3 decimal places are allowed on input:
+		 //	|		{places:'0,3'}
+	 });
+	 =====*/
+
+	return NumberTextBox;
+});

data/vendor/assets/javascripts/dijit/form/RadioButton.js

@@ -0,0 +1,4 @@
+//>>built
+define("dijit/form/RadioButton",["dojo/_base/declare","./CheckBox","./_RadioButtonMixin"],function(_1,_2,_3){
+return _1("dijit.form.RadioButton",[_2,_3],{baseClass:"dijitRadio"});
+});

data/vendor/assets/javascripts/dijit/form/RadioButton.js.uncompressed.js

@@ -0,0 +1,16 @@
+define("dijit/form/RadioButton", [
+	"dojo/_base/declare", // declare
+	"./CheckBox",
+	"./_RadioButtonMixin"
+], function(declare, CheckBox, _RadioButtonMixin){
+
+	// module:
+	//		dijit/form/RadioButton
+
+	return declare("dijit.form.RadioButton", [CheckBox, _RadioButtonMixin], {
+		// summary:
+		//		Same as an HTML radio, but with fancy styling.
+
+		baseClass: "dijitRadio"
+	});
+});

data/vendor/assets/javascripts/dijit/form/RangeBoundTextBox.js

@@ -0,0 +1,58 @@
+//>>built
+define("dijit/form/RangeBoundTextBox",["dojo/_base/declare","dojo/i18n","./MappedTextBox"],function(_1,_2,_3){
+var _4=_1("dijit.form.RangeBoundTextBox",_3,{rangeMessage:"",rangeCheck:function(_5,_6){
+return ("min" in _6?(this.compare(_5,_6.min)>=0):true)&&("max" in _6?(this.compare(_5,_6.max)<=0):true);
+},isInRange:function(){
+return this.rangeCheck(this.get("value"),this.constraints);
+},_isDefinitelyOutOfRange:function(){
+var _7=this.get("value");
+if(_7==null){
+return false;
+}
+var _8=false;
+if("min" in this.constraints){
+var _9=this.constraints.min;
+_8=this.compare(_7,((typeof _9=="number")&&_9>=0&&_7!=0)?0:_9)<0;
+}
+if(!_8&&("max" in this.constraints)){
+var _a=this.constraints.max;
+_8=this.compare(_7,((typeof _a!="number")||_a>0)?_a:0)>0;
+}
+return _8;
+},_isValidSubset:function(){
+return this.inherited(arguments)&&!this._isDefinitelyOutOfRange();
+},isValid:function(_b){
+return this.inherited(arguments)&&((this._isEmpty(this.textbox.value)&&!this.required)||this.isInRange(_b));
+},getErrorMessage:function(_c){
+var v=this.get("value");
+if(v!=null&&v!==""&&(typeof v!="number"||!isNaN(v))&&!this.isInRange(_c)){
+return this.rangeMessage;
+}
+return this.inherited(arguments);
+},postMixInProperties:function(){
+this.inherited(arguments);
+if(!this.rangeMessage){
+this.messages=_2.getLocalization("dijit.form","validate",this.lang);
+this.rangeMessage=this.messages.rangeMessage;
+}
+},_setConstraintsAttr:function(_d){
+this.inherited(arguments);
+if(this.focusNode){
+if(this.constraints.min!==undefined){
+this.focusNode.setAttribute("aria-valuemin",this.constraints.min);
+}else{
+this.focusNode.removeAttribute("aria-valuemin");
+}
+if(this.constraints.max!==undefined){
+this.focusNode.setAttribute("aria-valuemax",this.constraints.max);
+}else{
+this.focusNode.removeAttribute("aria-valuemax");
+}
+}
+},_setValueAttr:function(_e,_f){
+this.focusNode.setAttribute("aria-valuenow",_e);
+this.inherited(arguments);
+},applyTextDir:function(){
+}});
+return _4;
+});

data/vendor/assets/javascripts/dijit/form/RangeBoundTextBox.js.uncompressed.js

@@ -0,0 +1,134 @@
+define("dijit/form/RangeBoundTextBox", [
+	"dojo/_base/declare", // declare
+	"dojo/i18n", // i18n.getLocalization
+	"./MappedTextBox"
+], function(declare, i18n, MappedTextBox){
+
+	// module:
+	//		dijit/form/RangeBoundTextBox
+
+
+	var RangeBoundTextBox = declare("dijit.form.RangeBoundTextBox", MappedTextBox, {
+		// summary:
+		//		Base class for textbox form widgets which defines a range of valid values.
+
+		// rangeMessage: String
+		//		The message to display if value is out-of-range
+		rangeMessage: "",
+
+		/*=====
+		// constraints: RangeBoundTextBox.__Constraints
+		constraints: {},
+		======*/
+
+		rangeCheck: function(/*Number*/ primitive, /*dijit/form/RangeBoundTextBox.__Constraints*/ constraints){
+			// summary:
+			//		Overridable function used to validate the range of the numeric input value.
+			// tags:
+			//		protected
+			return	("min" in constraints? (this.compare(primitive,constraints.min) >= 0) : true) &&
+				("max" in constraints? (this.compare(primitive,constraints.max) <= 0) : true); // Boolean
+		},
+
+		isInRange: function(/*Boolean*/ /*===== isFocused =====*/){
+			// summary:
+			//		Tests if the value is in the min/max range specified in constraints
+			// tags:
+			//		protected
+			return this.rangeCheck(this.get('value'), this.constraints);
+		},
+
+		_isDefinitelyOutOfRange: function(){
+			// summary:
+			//		Returns true if the value is out of range and will remain
+			//		out of range even if the user types more characters
+			var val = this.get('value');
+			if(val == null){ return false; } // not yet valid enough to compare to
+			var outOfRange = false;
+			if("min" in this.constraints){
+				var min = this.constraints.min;
+				outOfRange = this.compare(val, ((typeof min == "number") && min >= 0 && val != 0) ? 0 : min) < 0;
+			}
+			if(!outOfRange && ("max" in this.constraints)){
+				var max = this.constraints.max;
+				outOfRange = this.compare(val, ((typeof max != "number") || max > 0) ? max : 0) > 0;
+			}
+			return outOfRange;
+		},
+
+		_isValidSubset: function(){
+			// summary:
+			//		Overrides `dijit/form/ValidationTextBox._isValidSubset()`.
+			//		Returns true if the input is syntactically valid, and either within
+			//		range or could be made in range by more typing.
+			return this.inherited(arguments) && !this._isDefinitelyOutOfRange();
+		},
+
+		isValid: function(/*Boolean*/ isFocused){
+			// Overrides dijit/form/ValidationTextBox.isValid() to check that the value is also in range.
+			return this.inherited(arguments) &&
+				((this._isEmpty(this.textbox.value) && !this.required) || this.isInRange(isFocused)); // Boolean
+		},
+
+		getErrorMessage: function(/*Boolean*/ isFocused){
+			// Overrides dijit/form/ValidationTextBox.getErrorMessage() to print "out of range" message if appropriate
+			var v = this.get('value');
+			if(v != null /* and !undefined */ && v !== '' && (typeof v != "number" || !isNaN(v)) && !this.isInRange(isFocused)){ // don't check isInRange w/o a real value
+				return this.rangeMessage; // String
+			}
+			return this.inherited(arguments);
+		},
+
+		postMixInProperties: function(){
+			this.inherited(arguments);
+			if(!this.rangeMessage){
+				this.messages = i18n.getLocalization("dijit.form", "validate", this.lang);
+				this.rangeMessage = this.messages.rangeMessage;
+			}
+		},
+
+		_setConstraintsAttr: function(/*Object*/ constraints){
+			this.inherited(arguments);
+			if(this.focusNode){ // not set when called from postMixInProperties
+				if(this.constraints.min !== undefined){
+					this.focusNode.setAttribute("aria-valuemin", this.constraints.min);
+				}else{
+					this.focusNode.removeAttribute("aria-valuemin");
+				}
+				if(this.constraints.max !== undefined){
+					this.focusNode.setAttribute("aria-valuemax", this.constraints.max);
+				}else{
+					this.focusNode.removeAttribute("aria-valuemax");
+				}
+			}
+		},
+
+		_setValueAttr: function(/*Number*/ value, /*Boolean?*/ priorityChange){
+			// summary:
+			//		Hook so set('value', ...) works.
+
+			this.focusNode.setAttribute("aria-valuenow", value);
+			this.inherited(arguments);
+		},
+
+		applyTextDir: function(/*===== element, text =====*/){
+			// summary:
+			//		The function overridden in the _BidiSupport module,
+			//		originally used for setting element.dir according to this.textDir.
+			//		In this case does nothing.
+			// element: Object
+			// text: String
+			// tags:
+			//		protected.
+		}
+	});
+	/*=====
+	RangeBoundTextBox.__Constraints = declare(null, {
+		// min: Number
+		//		Minimum signed value.  Default is -Infinity
+		// max: Number
+		//		Maximum signed value.  Default is +Infinity
+	});
+	=====*/
+	return RangeBoundTextBox;
+});