view release on metacpan or  search on metacpan

share/docs/source/NumberField.html  view on Meta::CPAN

    minText : "The minimum value for this field is {0}",
    
<span id='Ext-form-NumberField-cfg-maxText'>    /**
</span>     * @cfg {String} maxText Error text to display if the maximum value validation fails (defaults to &quot;The maximum value for this field is {maxValue}&quot;)
     */
    maxText : &quot;The maximum value for this field is {0}&quot;,
    
<span id='Ext-form-NumberField-cfg-nanText'>    /**
</span>     * @cfg {String} nanText Error text to display if the value is not a valid number.  For example, this can happen
     * if a valid character like '.' or '-' is left in the field with no number (defaults to &quot;{value} is not a valid number&quot;)
     */
    nanText : &quot;{0} is not a valid number&quot;,
    
<span id='Ext-form-NumberField-cfg-baseChars'>    /**
</span>     * @cfg {String} baseChars The base set of characters to evaluate as valid numbers (defaults to '0123456789').
     */
    baseChars : &quot;0123456789&quot;,
    
<span id='Ext-form-NumberField-cfg-autoStripChars'>    /**
</span>     * @cfg {Boolean} autoStripChars True to automatically strip not allowed characters from the field. Defaults to &lt;tt&gt;false&lt;/tt&gt;
     */
    autoStripChars: false,

<span id='Ext-form-NumberField-method-initEvents'>    // private
</span>    initEvents : function() {
        var allowed = this.baseChars + '';
        if (this.allowDecimals) {
            allowed += this.decimalSeparator;
        }
        if (this.allowNegative) {
            allowed += '-';
        }
        allowed = Ext.escapeRe(allowed);
        this.maskRe = new RegExp('[' + allowed + ']');
        if (this.autoStripChars) {
            this.stripCharsRe = new RegExp('[^' + allowed + ']', 'gi');
        }
        
        Ext.form.NumberField.superclass.initEvents.call(this);
    },
    
<span id='Ext-form-NumberField-method-getErrors'>    /**
</span>     * Runs all of NumberFields validations and returns an array of any errors. Note that this first
     * runs TextField's validations, so the returned array is an amalgamation of all field errors.
     * The additional validations run test that the value is a number, and that it is within the
     * configured min and max values.
     * @param {Mixed} value The value to get errors for (defaults to the current field value)
     * @return {Array} All validation errors for this field
     */
    getErrors: function(value) {
        var errors = Ext.form.NumberField.superclass.getErrors.apply(this, arguments);
        
        value = Ext.isDefined(value) ? value : this.processValue(this.getRawValue());
        
        if (value.length &lt; 1) { // if it's blank and textfield didn't flag it then it's valid
             return errors;
        }
        
        value = String(value).replace(this.decimalSeparator, &quot;.&quot;);
        
        if(isNaN(value)){
            errors.push(String.format(this.nanText, value));
        }
        
        var num = this.parseValue(value);
        
        if (num &lt; this.minValue) {
            errors.push(String.format(this.minText, this.minValue));
        }
        
        if (num &gt; this.maxValue) {
            errors.push(String.format(this.maxText, this.maxValue));
        }
        
        return errors;
    },

<span id='Ext-form-NumberField-method-getValue'>    getValue : function() {
</span>        return this.fixPrecision(this.parseValue(Ext.form.NumberField.superclass.getValue.call(this)));
    },

<span id='Ext-form-NumberField-method-setValue'>    setValue : function(v) {
</span>    	v = Ext.isNumber(v) ? v : parseFloat(String(v).replace(this.decimalSeparator, &quot;.&quot;));
        v = this.fixPrecision(v);
        v = isNaN(v) ? '' : String(v).replace(&quot;.&quot;, this.decimalSeparator);
        return Ext.form.NumberField.superclass.setValue.call(this, v);
    },
    
<span id='Ext-form-NumberField-method-setMinValue'>    /**
</span>     * Replaces any existing {@link #minValue} with the new value.
     * @param {Number} value The minimum value
     */
    setMinValue : function(value) {
        this.minValue = Ext.num(value, Number.NEGATIVE_INFINITY);
    },
    
<span id='Ext-form-NumberField-method-setMaxValue'>    /**
</span>     * Replaces any existing {@link #maxValue} with the new value.
     * @param {Number} value The maximum value
     */
    setMaxValue : function(value) {
        this.maxValue = Ext.num(value, Number.MAX_VALUE);    
    },

<span id='Ext-form-NumberField-method-parseValue'>    // private
</span>    parseValue : function(value) {
        value = parseFloat(String(value).replace(this.decimalSeparator, &quot;.&quot;));
        return isNaN(value) ? '' : value;
    },

<span id='Ext-form-NumberField-method-fixPrecision'>    /**
</span>     * @private
     * 
     */
    fixPrecision : function(value) {
        var nan = isNaN(value);
        
        if (!this.allowDecimals || this.decimalPrecision == -1 || nan || !value) {
            return nan ? '' : value;
        }
        
        return parseFloat(parseFloat(value).toFixed(this.decimalPrecision));
    },

<span id='Ext-form-NumberField-method-beforeBlur'>    beforeBlur : function() {
</span>        var v = this.parseValue(this.getRawValue());
        
        if (!Ext.isEmpty(v)) {
            this.setValue(v);
        }
    }
});

Ext.reg('numberfield', Ext.form.NumberField);
</pre>
</body>
</html>