/*! * Ext JS Library 3.4.0 * Copyright(c) 2006-2011 Sencha Inc. * licensing@sencha.com * http://www.sencha.com/license */ /** * @class Ext.form.Field * @extends Ext.BoxComponent * Base class for form fields that provides default event handling, sizing, value handling and other functionality. * @constructor * Creates a new Field * @param {Object} config Configuration options * @xtype field */ Ext.form.Field = Ext.extend(Ext.BoxComponent, { /** *
The label Element associated with this Field. Only available after this Field has been rendered by a * {@link form Ext.layout.FormLayout} layout manager.
* @type Ext.Element * @property label */ /** * @cfg {String} inputType The type attribute for input fields -- e.g. radio, text, password, file (defaults * to 'text'). The types 'file' and 'password' must be used to render those field types currently -- there are * no separate Ext components for those. Note that if you use inputType:'file', {@link #emptyText} * is not supported and should be avoided. */ /** * @cfg {Number} tabIndex The tabIndex for this field. Note this only applies to fields that are rendered, * not those which are built via applyTo (defaults to undefined). */ /** * @cfg {Mixed} value A value to initialize this field with (defaults to undefined). */ /** * @cfg {String} name The field's HTML name attribute (defaults to ''). * Note: this property must be set if this field is to be automatically included with * {@link Ext.form.BasicForm#submit form submit()}. */ /** * @cfg {String} cls A custom CSS class to apply to the field's underlying element (defaults to ''). */ /** * @cfg {String} invalidClass The CSS class to use when marking a field invalid (defaults to 'x-form-invalid') */ invalidClass : 'x-form-invalid', /** * @cfg {String} invalidText The error text to use when marking a field invalid and no message is provided * (defaults to 'The value in this field is invalid') */ invalidText : 'The value in this field is invalid', /** * @cfg {String} focusClass The CSS class to use when the field receives focus (defaults to 'x-form-focus') */ focusClass : 'x-form-focus', /** * @cfg {Boolean} preventMark * true to disable {@link #markInvalid marking the field invalid}. * Defaults to false. */ /** * @cfg {String/Boolean} validationEvent The event that should initiate field validation. Set to false to disable automatic validation (defaults to 'keyup'). */ validationEvent : 'keyup', /** * @cfg {Boolean} validateOnBlur Whether the field should validate when it loses focus (defaults to true). */ validateOnBlur : true, /** * @cfg {Number} validationDelay The length of time in milliseconds after user input begins until validation * is initiated (defaults to 250) */ validationDelay : 250, /** * @cfg {String/Object} autoCreateA {@link Ext.DomHelper DomHelper} element spec, or true for a default * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. * See {@link Ext.Component#autoEl autoEl} for details. Defaults to:
*{tag: 'input', type: 'text', size: '20', autocomplete: 'off'}
*/
defaultAutoCreate : {tag: 'input', type: 'text', size: '20', autocomplete: 'off'},
/**
* @cfg {String} fieldClass The default CSS class for the field (defaults to 'x-form-field')
*/
fieldClass : 'x-form-field',
/**
* @cfg {String} msgTarget The location where the message text set through {@link #markInvalid} should display. * Must be one of the following values:
*qtip
Display a quick tip containing the message when the user hovers over the field. This is the default.
* title
Display the message in a default browser title attribute popup.under
Add a block div beneath the field containing the error message.side
Add an error icon to the right of the field, displaying the message in a popup on hover.[element id]
Add the error message directly to the innerHTML of the specified element.Note: this only sets the element's readOnly DOM attribute.
* Setting readOnly=true
, for example, will not disable triggering a
* ComboBox or DateField; it gives you the option of forcing the user to choose
* via the trigger without typing in the text box. To hide the trigger use
* {@link Ext.form.TriggerField#hideTrigger hideTrigger}
.
Be aware that conformant with the HTML specification, * disabled Fields will not be {@link Ext.form.BasicForm#submit submitted}.
*/ disabled : false, /** * @cfg {Boolean} submitValue False to clear the name attribute on the field so that it is not submitted during a form post. * Defaults to true. */ submitValue: true, // private isFormField : true, // private msgDisplay: '', // private hasFocus : false, // private initComponent : function(){ Ext.form.Field.superclass.initComponent.call(this); this.addEvents( /** * @event focus * Fires when this field receives input focus. * @param {Ext.form.Field} this */ 'focus', /** * @event blur * Fires when this field loses input focus. * @param {Ext.form.Field} this */ 'blur', /** * @event specialkey * Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed. * To handle other keys see {@link Ext.Panel#keys} or {@link Ext.KeyMap}. * You can check {@link Ext.EventObject#getKey} to determine which key was pressed. * For example:
var form = new Ext.form.FormPanel({
...
items: [{
fieldLabel: 'Field 1',
name: 'field1',
allowBlank: false
},{
fieldLabel: 'Field 2',
name: 'field2',
listeners: {
specialkey: function(field, e){
// e.HOME, e.END, e.PAGE_UP, e.PAGE_DOWN,
// e.TAB, e.ESC, arrow keys: e.LEFT, e.RIGHT, e.UP, e.DOWN
if (e.{@link Ext.EventObject#getKey getKey()} == e.ENTER) {
var form = field.ownerCt.getForm();
form.submit();
}
}
}
}
],
...
});
*
* @param {Ext.form.Field} this
* @param {Ext.EventObject} e The event object
*/
'specialkey',
/**
* @event change
* Fires just before the field blurs if the field value has changed.
* @param {Ext.form.Field} this
* @param {Mixed} newValue The new value
* @param {Mixed} oldValue The original value
*/
'change',
/**
* @event invalid
* Fires after the field has been marked as invalid.
* @param {Ext.form.Field} this
* @param {String} msg The validation message
*/
'invalid',
/**
* @event valid
* Fires after the field has been validated with no errors.
* @param {Ext.form.Field} this
*/
'valid'
);
},
/**
* Returns the {@link Ext.form.Field#name name} or {@link Ext.form.ComboBox#hiddenName hiddenName}
* attribute of the field if available.
* @return {String} name The field {@link Ext.form.Field#name name} or {@link Ext.form.ComboBox#hiddenName hiddenName}
*/
getName : function(){
return this.rendered && this.el.dom.name ? this.el.dom.name : this.name || this.id || '';
},
// private
onRender : function(ct, position){
if(!this.el){
var cfg = this.getAutoCreate();
if(!cfg.name){
cfg.name = this.name || this.id;
}
if(this.inputType){
cfg.type = this.inputType;
}
this.autoEl = cfg;
}
Ext.form.Field.superclass.onRender.call(this, ct, position);
if(this.submitValue === false){
this.el.dom.removeAttribute('name');
}
var type = this.el.dom.type;
if(type){
if(type == 'password'){
type = 'text';
}
this.el.addClass('x-form-'+type);
}
if(this.readOnly){
this.setReadOnly(true);
}
if(this.tabIndex !== undefined){
this.el.dom.setAttribute('tabIndex', this.tabIndex);
}
this.el.addClass([this.fieldClass, this.cls]);
},
// private
getItemCt : function(){
return this.itemCt;
},
// private
initValue : function(){
if(this.value !== undefined){
this.setValue(this.value);
}else if(!Ext.isEmpty(this.el.dom.value) && this.el.dom.value != this.emptyText){
this.setValue(this.el.dom.value);
}
/**
* The original value of the field as configured in the {@link #value} configuration, or
* as loaded by the last form load operation if the form's {@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad}
* setting is true
.
* @type mixed
* @property originalValue
*/
this.originalValue = this.getValue();
},
/**
* Returns true if the value of this Field has been changed from its original value. * Will return false if the field is disabled or has not been rendered yet.
*Note that if the owning {@link Ext.form.BasicForm form} was configured with * {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad} * then the original value is updated when the values are loaded by * {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#setValues setValues}.
* @return {Boolean} True if this field has been changed from its original value (and * is not disabled), false otherwise. */ isDirty : function() { if(this.disabled || !this.rendered) { return false; } return String(this.getValue()) !== String(this.originalValue); }, /** * Sets the read only state of this field. * @param {Boolean} readOnly Whether the field should be read only. */ setReadOnly : function(readOnly){ if(this.rendered){ this.el.dom.readOnly = readOnly; } this.readOnly = readOnly; }, // private afterRender : function(){ Ext.form.Field.superclass.afterRender.call(this); this.initEvents(); this.initValue(); }, // private fireKey : function(e){ if(e.isSpecialKey()){ this.fireEvent('specialkey', this, e); } }, /** * Resets the current field value to the originally loaded value and clears any validation messages. * See {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad} */ reset : function(){ this.setValue(this.originalValue); this.clearInvalid(); }, // private initEvents : function(){ this.mon(this.el, Ext.EventManager.getKeyEvent(), this.fireKey, this); this.mon(this.el, 'focus', this.onFocus, this); // standardise buffer across all browsers + OS-es for consistent event order. // (the 10ms buffer for Editors fixes a weird FF/Win editor issue when changing OS window focus) this.mon(this.el, 'blur', this.onBlur, this, this.inEditor ? {buffer:10} : null); }, // private preFocus: Ext.emptyFn, // private onFocus : function(){ this.preFocus(); if(this.focusClass){ this.el.addClass(this.focusClass); } if(!this.hasFocus){ this.hasFocus = true; /** *The value that the Field had at the time it was last focused. This is the value that is passed * to the {@link #change} event which is fired if the value has been changed when the Field is blurred.
*This will be undefined until the Field has been visited. Compare {@link #originalValue}.
* @type mixed * @property startValue */ this.startValue = this.getValue(); this.fireEvent('focus', this); } }, // private beforeBlur : Ext.emptyFn, // private onBlur : function(){ this.beforeBlur(); if(this.focusClass){ this.el.removeClass(this.focusClass); } this.hasFocus = false; if(this.validationEvent !== false && (this.validateOnBlur || this.validationEvent == 'blur')){ this.validate(); } var v = this.getValue(); if(String(v) !== String(this.startValue)){ this.fireEvent('change', this, v, this.startValue); } this.fireEvent('blur', this); this.postBlur(); }, // private postBlur : Ext.emptyFn, /** * Returns whether or not the field value is currently valid by * {@link #validateValue validating} the {@link #processValue processed value} * of the field. Note: {@link #disabled} fields are ignored. * @param {Boolean} preventMark True to disable marking the field invalid * @return {Boolean} True if the value is valid, else false */ isValid : function(preventMark){ if(this.disabled){ return true; } var restore = this.preventMark; this.preventMark = preventMark === true; var v = this.validateValue(this.processValue(this.getRawValue()), preventMark); this.preventMark = restore; return v; }, /** * Validates the field value * @return {Boolean} True if the value is valid, else false */ validate : function(){ if(this.disabled || this.validateValue(this.processValue(this.getRawValue()))){ this.clearInvalid(); return true; } return false; }, /** * This method should only be overridden if necessary to prepare raw values * for validation (see {@link #validate} and {@link #isValid}). This method * is expected to return the processed value for the field which will * be used for validation (see validateValue method). * @param {Mixed} value */ processValue : function(value){ return value; }, /** * Uses getErrors to build an array of validation errors. If any errors are found, markInvalid is called * with the first and false is returned, otherwise true is returned. Previously, subclasses were invited * to provide an implementation of this to process validations - from 3.2 onwards getErrors should be * overridden instead. * @param {Mixed} The current value of the field * @return {Boolean} True if all validations passed, false if one or more failed */ validateValue : function(value) { //currently, we only show 1 error at a time for a field, so just use the first one var error = this.getErrors(value)[0]; if (error == undefined) { return true; } else { this.markInvalid(error); return false; } }, /** * Runs this field's validators and returns an array of error messages for any validation failures. * This is called internally during validation and would not usually need to be used manually. * Each subclass should override or augment the return value to provide their own errors * @return {Array} All error messages for this field */ getErrors: function() { return []; }, /** * Gets the active error message for this field. * @return {String} Returns the active error message on the field, if there is no error, an empty string is returned. */ getActiveError : function(){ return this.activeError || ''; }, /** *Display an error message associated with this field, using {@link #msgTarget} to determine how to * display the message and applying {@link #invalidClass} to the field's UI element.
*Note: this method does not cause the Field's {@link #validate} method to return false
* if the value does pass validation. So simply marking a Field as invalid will not prevent
* submission of forms submitted with the {@link Ext.form.Action.Submit#clientValidation} option set.