docs/source/Field.html

   1 <html>
   2 <head>
   3   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   4   <title>The source code</title>
   5     <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   6     <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   7 </head>
   8 <body  onload="prettyPrint();">
   9     <pre class="prettyprint lang-js">/*!
  10  * Ext JS Library 3.3.1
  11  * Copyright(c) 2006-2010 Sencha Inc.
  12  * licensing@sencha.com
  13  * http://www.sencha.com/license
  14  */
  15 <div id="cls-Ext.form.Field"></div>/**
  16  * @class Ext.form.Field
  17  * @extends Ext.BoxComponent
  18  * Base class for form fields that provides default event handling, sizing, value handling and other functionality.
  19  * @constructor
  20  * Creates a new Field
  21  * @param {Object} config Configuration options
  22  * @xtype field
  23  */
  24 Ext.form.Field = Ext.extend(Ext.BoxComponent,  {
  25     <div id="prop-Ext.form.Field-label"></div>/**
  26      * <p>The label Element associated with this Field. <b>Only available after this Field has been rendered by a
  27      * {@link form Ext.layout.FormLayout} layout manager.</b></p>
  28      * @type Ext.Element
  29      * @property label
  30      */
  31     <div id="cfg-Ext.form.Field-inputType"></div>/**
  32      * @cfg {String} inputType The type attribute for input fields -- e.g. radio, text, password, file (defaults
  33      * to 'text'). The types 'file' and 'password' must be used to render those field types currently -- there are
  34      * no separate Ext components for those. Note that if you use <tt>inputType:'file'</tt>, {@link #emptyText}
  35      * is not supported and should be avoided.
  36      */
  37     <div id="cfg-Ext.form.Field-tabIndex"></div>/**
  38      * @cfg {Number} tabIndex The tabIndex for this field. Note this only applies to fields that are rendered,
  39      * not those which are built via applyTo (defaults to undefined).
  40      */
  41     <div id="cfg-Ext.form.Field-value"></div>/**
  42      * @cfg {Mixed} value A value to initialize this field with (defaults to undefined).
  43      */
  44     <div id="cfg-Ext.form.Field-name"></div>/**
  45      * @cfg {String} name The field's HTML name attribute (defaults to '').
  46      * <b>Note</b>: this property must be set if this field is to be automatically included with
  47      * {@link Ext.form.BasicForm#submit form submit()}.
  48      */
  49     <div id="cfg-Ext.form.Field-cls"></div>/**
  50      * @cfg {String} cls A custom CSS class to apply to the field's underlying element (defaults to '').
  51      */
  52
  53     <div id="cfg-Ext.form.Field-invalidClass"></div>/**
  54      * @cfg {String} invalidClass The CSS class to use when marking a field invalid (defaults to 'x-form-invalid')
  55      */
  56     invalidClass : 'x-form-invalid',
  57     <div id="cfg-Ext.form.Field-invalidText"></div>/**
  58      * @cfg {String} invalidText The error text to use when marking a field invalid and no message is provided
  59      * (defaults to 'The value in this field is invalid')
  60      */
  61     invalidText : 'The value in this field is invalid',
  62     <div id="cfg-Ext.form.Field-focusClass"></div>/**
  63      * @cfg {String} focusClass The CSS class to use when the field receives focus (defaults to 'x-form-focus')
  64      */
  65     focusClass : 'x-form-focus',
  66     <div id="cfg-Ext.form.Field-preventMark"></div>/**
  67      * @cfg {Boolean} preventMark
  68      * <tt>true</tt> to disable {@link #markInvalid marking the field invalid}.
  69      * Defaults to <tt>false</tt>.
  70      */
  71     <div id="cfg-Ext.form.Field-validationEvent"></div>/**
  72      * @cfg {String/Boolean} validationEvent The event that should initiate field validation. Set to false to disable
  73       automatic validation (defaults to 'keyup').
  74      */
  75     validationEvent : 'keyup',
  76     <div id="cfg-Ext.form.Field-validateOnBlur"></div>/**
  77      * @cfg {Boolean} validateOnBlur Whether the field should validate when it loses focus (defaults to true).
  78      */
  79     validateOnBlur : true,
  80     <div id="cfg-Ext.form.Field-validationDelay"></div>/**
  81      * @cfg {Number} validationDelay The length of time in milliseconds after user input begins until validation
  82      * is initiated (defaults to 250)
  83      */
  84     validationDelay : 250,
  85     <div id="cfg-Ext.form.Field-autoCreate"></div>/**
  86      * @cfg {String/Object} autoCreate <p>A {@link Ext.DomHelper DomHelper} element spec, or true for a default
  87      * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component.
  88      * See <tt>{@link Ext.Component#autoEl autoEl}</tt> for details.  Defaults to:</p>
  89      * <pre><code>{tag: 'input', type: 'text', size: '20', autocomplete: 'off'}</code></pre>
  90      */
  91     defaultAutoCreate : {tag: 'input', type: 'text', size: '20', autocomplete: 'off'},
  92     <div id="cfg-Ext.form.Field-fieldClass"></div>/**
  93      * @cfg {String} fieldClass The default CSS class for the field (defaults to 'x-form-field')
  94      */
  95     fieldClass : 'x-form-field',
  96     <div id="cfg-Ext.form.Field-msgTarget"></div>/**
  97      * @cfg {String} msgTarget <p>The location where the message text set through {@link #markInvalid} should display.
  98      * Must be one of the following values:</p>
  99      * <div class="mdetail-params"><ul>
 100      * <li><code>qtip</code> Display a quick tip containing the message when the user hovers over the field. This is the default.
 101      * <div class="subdesc"><b>{@link Ext.QuickTips#init Ext.QuickTips.init} must have been called for this setting to work.</b></div</li>
 102      * <li><code>title</code> Display the message in a default browser title attribute popup.</li>
 103      * <li><code>under</code> Add a block div beneath the field containing the error message.</li>
 104      * <li><code>side</code> Add an error icon to the right of the field, displaying the message in a popup on hover.</li>
 105      * <li><code>[element id]</code> Add the error message directly to the innerHTML of the specified element.</li>
 106      * </ul></div>
 107      */
 108     msgTarget : 'qtip',
 109     <div id="cfg-Ext.form.Field-msgFx"></div>/**
 110      * @cfg {String} msgFx <b>Experimental</b> The effect used when displaying a validation message under the field
 111      * (defaults to 'normal').
 112      */
 113     msgFx : 'normal',
 114     <div id="cfg-Ext.form.Field-readOnly"></div>/**
 115      * @cfg {Boolean} readOnly <tt>true</tt> to mark the field as readOnly in HTML
 116      * (defaults to <tt>false</tt>).
 117      * <br><p><b>Note</b>: this only sets the element's readOnly DOM attribute.
 118      * Setting <code>readOnly=true</code>, for example, will not disable triggering a
 119      * ComboBox or DateField; it gives you the option of forcing the user to choose
 120      * via the trigger without typing in the text box. To hide the trigger use
 121      * <code>{@link Ext.form.TriggerField#hideTrigger hideTrigger}</code>.</p>
 122      */
 123     readOnly : false,
 124     <div id="cfg-Ext.form.Field-disabled"></div>/**
 125      * @cfg {Boolean} disabled True to disable the field (defaults to false).
 126      * <p>Be aware that conformant with the <a href="http://www.w3.org/TR/html401/interact/forms.html#h-17.12.1">HTML specification</a>,
 127      * disabled Fields will not be {@link Ext.form.BasicForm#submit submitted}.</p>
 128      */
 129     disabled : false,
 130     <div id="cfg-Ext.form.Field-submitValue"></div>/**
 131      * @cfg {Boolean} submitValue False to clear the name attribute on the field so that it is not submitted during a form post.
 132      * Defaults to <tt>true</tt>.
 133      */
 134     submitValue: true,
 135
 136     // private
 137     isFormField : true,
 138
 139     // private
 140     msgDisplay: '',
 141
 142     // private
 143     hasFocus : false,
 144
 145     // private
 146     initComponent : function(){
 147         Ext.form.Field.superclass.initComponent.call(this);
 148         this.addEvents(
 149             <div id="event-Ext.form.Field-focus"></div>/**
 150              * @event focus
 151              * Fires when this field receives input focus.
 152              * @param {Ext.form.Field} this
 153              */
 154             'focus',
 155             <div id="event-Ext.form.Field-blur"></div>/**
 156              * @event blur
 157              * Fires when this field loses input focus.
 158              * @param {Ext.form.Field} this
 159              */
 160             'blur',
 161             <div id="event-Ext.form.Field-specialkey"></div>/**
 162              * @event specialkey
 163              * Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed.
 164              * To handle other keys see {@link Ext.Panel#keys} or {@link Ext.KeyMap}.
 165              * You can check {@link Ext.EventObject#getKey} to determine which key was pressed.
 166              * For example: <pre><code>
 167 var form = new Ext.form.FormPanel({
 168     ...
 169     items: [{
 170             fieldLabel: 'Field 1',
 171             name: 'field1',
 172             allowBlank: false
 173         },{
 174             fieldLabel: 'Field 2',
 175             name: 'field2',
 176             listeners: {
 177                 specialkey: function(field, e){
 178                     // e.HOME, e.END, e.PAGE_UP, e.PAGE_DOWN,
 179                     // e.TAB, e.ESC, arrow keys: e.LEFT, e.RIGHT, e.UP, e.DOWN
 180                     if (e.{@link Ext.EventObject#getKey getKey()} == e.ENTER) {
 181                         var form = field.ownerCt.getForm();
 182                         form.submit();
 183                     }
 184                 }
 185             }
 186         }
 187     ],
 188     ...
 189 });
 190              * </code></pre>
 191              * @param {Ext.form.Field} this
 192              * @param {Ext.EventObject} e The event object
 193              */
 194             'specialkey',
 195             <div id="event-Ext.form.Field-change"></div>/**
 196              * @event change
 197              * Fires just before the field blurs if the field value has changed.
 198              * @param {Ext.form.Field} this
 199              * @param {Mixed} newValue The new value
 200              * @param {Mixed} oldValue The original value
 201              */
 202             'change',
 203             <div id="event-Ext.form.Field-invalid"></div>/**
 204              * @event invalid
 205              * Fires after the field has been marked as invalid.
 206              * @param {Ext.form.Field} this
 207              * @param {String} msg The validation message
 208              */
 209             'invalid',
 210             <div id="event-Ext.form.Field-valid"></div>/**
 211              * @event valid
 212              * Fires after the field has been validated with no errors.
 213              * @param {Ext.form.Field} this
 214              */
 215             'valid'
 216         );
 217     },
 218
 219     <div id="method-Ext.form.Field-getName"></div>/**
 220      * Returns the {@link Ext.form.Field#name name} or {@link Ext.form.ComboBox#hiddenName hiddenName}
 221      * attribute of the field if available.
 222      * @return {String} name The field {@link Ext.form.Field#name name} or {@link Ext.form.ComboBox#hiddenName hiddenName}
 223      */
 224     getName : function(){
 225         return this.rendered && this.el.dom.name ? this.el.dom.name : this.name || this.id || '';
 226     },
 227
 228     // private
 229     onRender : function(ct, position){
 230         if(!this.el){
 231             var cfg = this.getAutoCreate();
 232
 233             if(!cfg.name){
 234                 cfg.name = this.name || this.id;
 235             }
 236             if(this.inputType){
 237                 cfg.type = this.inputType;
 238             }
 239             this.autoEl = cfg;
 240         }
 241         Ext.form.Field.superclass.onRender.call(this, ct, position);
 242         if(this.submitValue === false){
 243             this.el.dom.removeAttribute('name');
 244         }
 245         var type = this.el.dom.type;
 246         if(type){
 247             if(type == 'password'){
 248                 type = 'text';
 249             }
 250             this.el.addClass('x-form-'+type);
 251         }
 252         if(this.readOnly){
 253             this.setReadOnly(true);
 254         }
 255         if(this.tabIndex !== undefined){
 256             this.el.dom.setAttribute('tabIndex', this.tabIndex);
 257         }
 258
 259         this.el.addClass([this.fieldClass, this.cls]);
 260     },
 261
 262     // private
 263     getItemCt : function(){
 264         return this.itemCt;
 265     },
 266
 267     // private
 268     initValue : function(){
 269         if(this.value !== undefined){
 270             this.setValue(this.value);
 271         }else if(!Ext.isEmpty(this.el.dom.value) && this.el.dom.value != this.emptyText){
 272             this.setValue(this.el.dom.value);
 273         }
 274         <div id="prop-Ext.form.Field-originalValue"></div>/**
 275          * The original value of the field as configured in the {@link #value} configuration, or
 276          * as loaded by the last form load operation if the form's {@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad}
 277          * setting is <code>true</code>.
 278          * @type mixed
 279          * @property originalValue
 280          */
 281         this.originalValue = this.getValue();
 282     },
 283
 284     <div id="method-Ext.form.Field-isDirty"></div>/**
 285      * <p>Returns true if the value of this Field has been changed from its original value.
 286      * Will return false if the field is disabled or has not been rendered yet.</p>
 287      * <p>Note that if the owning {@link Ext.form.BasicForm form} was configured with
 288      * {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad}
 289      * then the <i>original value</i> is updated when the values are loaded by
 290      * {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#setValues setValues}.</p>
 291      * @return {Boolean} True if this field has been changed from its original value (and
 292      * is not disabled), false otherwise.
 293      */
 294     isDirty : function() {
 295         if(this.disabled || !this.rendered) {
 296             return false;
 297         }
 298         return String(this.getValue()) !== String(this.originalValue);
 299     },
 300
 301     <div id="method-Ext.form.Field-setReadOnly"></div>/**
 302      * Sets the read only state of this field.
 303      * @param {Boolean} readOnly Whether the field should be read only.
 304      */
 305     setReadOnly : function(readOnly){
 306         if(this.rendered){
 307             this.el.dom.readOnly = readOnly;
 308         }
 309         this.readOnly = readOnly;
 310     },
 311
 312     // private
 313     afterRender : function(){
 314         Ext.form.Field.superclass.afterRender.call(this);
 315         this.initEvents();
 316         this.initValue();
 317     },
 318
 319     // private
 320     fireKey : function(e){
 321         if(e.isSpecialKey()){
 322             this.fireEvent('specialkey', this, e);
 323         }
 324     },
 325
 326     <div id="method-Ext.form.Field-reset"></div>/**
 327      * Resets the current field value to the originally loaded value and clears any validation messages.
 328      * See {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad}
 329      */
 330     reset : function(){
 331         this.setValue(this.originalValue);
 332         this.clearInvalid();
 333     },
 334
 335     // private
 336     initEvents : function(){
 337         this.mon(this.el, Ext.EventManager.getKeyEvent(), this.fireKey,  this);
 338         this.mon(this.el, 'focus', this.onFocus, this);
 339
 340         // standardise buffer across all browsers + OS-es for consistent event order.
 341         // (the 10ms buffer for Editors fixes a weird FF/Win editor issue when changing OS window focus)
 342         this.mon(this.el, 'blur', this.onBlur, this, this.inEditor ? {buffer:10} : null);
 343     },
 344
 345     // private
 346     preFocus: Ext.emptyFn,
 347
 348     // private
 349     onFocus : function(){
 350         this.preFocus();
 351         if(this.focusClass){
 352             this.el.addClass(this.focusClass);
 353         }
 354         if(!this.hasFocus){
 355             this.hasFocus = true;
 356             <div id="prop-Ext.form.Field-startValue"></div>/**
 357              * <p>The value that the Field had at the time it was last focused. This is the value that is passed
 358              * to the {@link #change} event which is fired if the value has been changed when the Field is blurred.</p>
 359              * <p><b>This will be undefined until the Field has been visited.</b> Compare {@link #originalValue}.</p>
 360              * @type mixed
 361              * @property startValue
 362              */
 363             this.startValue = this.getValue();
 364             this.fireEvent('focus', this);
 365         }
 366     },
 367
 368     // private
 369     beforeBlur : Ext.emptyFn,
 370
 371     // private
 372     onBlur : function(){
 373         this.beforeBlur();
 374         if(this.focusClass){
 375             this.el.removeClass(this.focusClass);
 376         }
 377         this.hasFocus = false;
 378         if(this.validationEvent !== false && (this.validateOnBlur || this.validationEvent == 'blur')){
 379             this.validate();
 380         }
 381         var v = this.getValue();
 382         if(String(v) !== String(this.startValue)){
 383             this.fireEvent('change', this, v, this.startValue);
 384         }
 385         this.fireEvent('blur', this);
 386         this.postBlur();
 387     },
 388
 389     // private
 390     postBlur : Ext.emptyFn,
 391
 392     <div id="method-Ext.form.Field-isValid"></div>/**
 393      * Returns whether or not the field value is currently valid by
 394      * {@link #validateValue validating} the {@link #processValue processed value}
 395      * of the field. <b>Note</b>: {@link #disabled} fields are ignored.
 396      * @param {Boolean} preventMark True to disable marking the field invalid
 397      * @return {Boolean} True if the value is valid, else false
 398      */
 399     isValid : function(preventMark){
 400         if(this.disabled){
 401             return true;
 402         }
 403         var restore = this.preventMark;
 404         this.preventMark = preventMark === true;
 405         var v = this.validateValue(this.processValue(this.getRawValue()));
 406         this.preventMark = restore;
 407         return v;
 408     },
 409
 410     <div id="method-Ext.form.Field-validate"></div>/**
 411      * Validates the field value
 412      * @return {Boolean} True if the value is valid, else false
 413      */
 414     validate : function(){
 415         if(this.disabled || this.validateValue(this.processValue(this.getRawValue()))){
 416             this.clearInvalid();
 417             return true;
 418         }
 419         return false;
 420     },
 421
 422     <div id="method-Ext.form.Field-processValue"></div>/**
 423      * This method should only be overridden if necessary to prepare raw values
 424      * for validation (see {@link #validate} and {@link #isValid}).  This method
 425      * is expected to return the processed value for the field which will
 426      * be used for validation (see validateValue method).
 427      * @param {Mixed} value
 428      */
 429     processValue : function(value){
 430         return value;
 431     },
 432
 433     <div id="method-Ext.form.Field-validateValue"></div>/**
 434      * Uses getErrors to build an array of validation errors. If any errors are found, markInvalid is called
 435      * with the first and false is returned, otherwise true is returned. Previously, subclasses were invited
 436      * to provide an implementation of this to process validations - from 3.2 onwards getErrors should be
 437      * overridden instead.
 438      * @param {Mixed} The current value of the field
 439      * @return {Boolean} True if all validations passed, false if one or more failed
 440      */
 441      validateValue : function(value) {
 442          //currently, we only show 1 error at a time for a field, so just use the first one
 443          var error = this.getErrors(value)[0];
 444
 445          if (error == undefined) {
 446              return true;
 447          } else {
 448              this.markInvalid(error);
 449              return false;
 450          }
 451      },
 452
 453     <div id="method-Ext.form.Field-getErrors"></div>/**
 454      * Runs this field's validators and returns an array of error messages for any validation failures.
 455      * This is called internally during validation and would not usually need to be used manually.
 456      * Each subclass should override or augment the return value to provide their own errors
 457      * @return {Array} All error messages for this field
 458      */
 459     getErrors: function() {
 460         return [];
 461     },
 462
 463     <div id="method-Ext.form.Field-getActiveError"></div>/**
 464      * Gets the active error message for this field.
 465      * @return {String} Returns the active error message on the field, if there is no error, an empty string is returned.
 466      */
 467     getActiveError : function(){
 468         return this.activeError || '';
 469     },
 470
 471     <div id="method-Ext.form.Field-markInvalid"></div>/**
 472      * <p>Display an error message associated with this field, using {@link #msgTarget} to determine how to
 473      * display the message and applying {@link #invalidClass} to the field's UI element.</p>
 474      * <p><b>Note</b>: this method does not cause the Field's {@link #validate} method to return <code>false</code>
 475      * if the value does <i>pass</i> validation. So simply marking a Field as invalid will not prevent
 476      * submission of forms submitted with the {@link Ext.form.Action.Submit#clientValidation} option set.</p>
 477      * {@link #isValid invalid}.
 478      * @param {String} msg (optional) The validation message (defaults to {@link #invalidText})
 479      */
 480     markInvalid : function(msg){
 481         //don't set the error icon if we're not rendered or marking is prevented
 482         if (this.rendered && !this.preventMark) {
 483             msg = msg || this.invalidText;
 484
 485             var mt = this.getMessageHandler();
 486             if(mt){
 487                 mt.mark(this, msg);
 488             }else if(this.msgTarget){
 489                 this.el.addClass(this.invalidClass);
 490                 var t = Ext.getDom(this.msgTarget);
 491                 if(t){
 492                     t.innerHTML = msg;
 493                     t.style.display = this.msgDisplay;
 494                 }
 495             }
 496         }
 497
 498         this.setActiveError(msg);
 499     },
 500
 501     <div id="method-Ext.form.Field-clearInvalid"></div>/**
 502      * Clear any invalid styles/messages for this field
 503      */
 504     clearInvalid : function(){
 505         //don't remove the error icon if we're not rendered or marking is prevented
 506         if (this.rendered && !this.preventMark) {
 507             this.el.removeClass(this.invalidClass);
 508             var mt = this.getMessageHandler();
 509             if(mt){
 510                 mt.clear(this);
 511             }else if(this.msgTarget){
 512                 this.el.removeClass(this.invalidClass);
 513                 var t = Ext.getDom(this.msgTarget);
 514                 if(t){
 515                     t.innerHTML = '';
 516                     t.style.display = 'none';
 517                 }
 518             }
 519         }
 520
 521         this.unsetActiveError();
 522     },
 523
 524     <div id="method-Ext.form.Field-setActiveError"></div>/**
 525      * Sets the current activeError to the given string. Fires the 'invalid' event.
 526      * This does not set up the error icon, only sets the message and fires the event. To show the error icon,
 527      * use markInvalid instead, which calls this method internally
 528      * @param {String} msg The error message
 529      * @param {Boolean} suppressEvent True to suppress the 'invalid' event from being fired
 530      */
 531     setActiveError: function(msg, suppressEvent) {
 532         this.activeError = msg;
 533         if (suppressEvent !== true) this.fireEvent('invalid', this, msg);
 534     },
 535
 536     <div id="method-Ext.form.Field-unsetActiveError"></div>/**
 537      * Clears the activeError and fires the 'valid' event. This is called internally by clearInvalid and would not
 538      * usually need to be called manually
 539      * @param {Boolean} suppressEvent True to suppress the 'invalid' event from being fired
 540      */
 541     unsetActiveError: function(suppressEvent) {
 542         delete this.activeError;
 543         if (suppressEvent !== true) this.fireEvent('valid', this);
 544     },
 545
 546     // private
 547     getMessageHandler : function(){
 548         return Ext.form.MessageTargets[this.msgTarget];
 549     },
 550
 551     // private
 552     getErrorCt : function(){
 553         return this.el.findParent('.x-form-element', 5, true) || // use form element wrap if available
 554             this.el.findParent('.x-form-field-wrap', 5, true);   // else direct field wrap
 555     },
 556
 557     // Alignment for 'under' target
 558     alignErrorEl : function(){
 559         this.errorEl.setWidth(this.getErrorCt().getWidth(true) - 20);
 560     },
 561
 562     // Alignment for 'side' target
 563     alignErrorIcon : function(){
 564         this.errorIcon.alignTo(this.el, 'tl-tr', [2, 0]);
 565     },
 566
 567     <div id="method-Ext.form.Field-getRawValue"></div>/**
 568      * Returns the raw data value which may or may not be a valid, defined value.  To return a normalized value see {@link #getValue}.
 569      * @return {Mixed} value The field value
 570      */
 571     getRawValue : function(){
 572         var v = this.rendered ? this.el.getValue() : Ext.value(this.value, '');
 573         if(v === this.emptyText){
 574             v = '';
 575         }
 576         return v;
 577     },
 578
 579     <div id="method-Ext.form.Field-getValue"></div>/**
 580      * Returns the normalized data value (undefined or emptyText will be returned as '').  To return the raw value see {@link #getRawValue}.
 581      * @return {Mixed} value The field value
 582      */
 583     getValue : function(){
 584         if(!this.rendered) {
 585             return this.value;
 586         }
 587         var v = this.el.getValue();
 588         if(v === this.emptyText || v === undefined){
 589             v = '';
 590         }
 591         return v;
 592     },
 593
 594     <div id="method-Ext.form.Field-setRawValue"></div>/**
 595      * Sets the underlying DOM field's value directly, bypassing validation.  To set the value with validation see {@link #setValue}.
 596      * @param {Mixed} value The value to set
 597      * @return {Mixed} value The field value that is set
 598      */
 599     setRawValue : function(v){
 600         return this.rendered ? (this.el.dom.value = (Ext.isEmpty(v) ? '' : v)) : '';
 601     },
 602
 603     <div id="method-Ext.form.Field-setValue"></div>/**
 604      * Sets a data value into the field and validates it.  To set the value directly without validation see {@link #setRawValue}.
 605      * @param {Mixed} value The value to set
 606      * @return {Ext.form.Field} this
 607      */
 608     setValue : function(v){
 609         this.value = v;
 610         if(this.rendered){
 611             this.el.dom.value = (Ext.isEmpty(v) ? '' : v);
 612             this.validate();
 613         }
 614         return this;
 615     },
 616
 617     // private, does not work for all fields
 618     append : function(v){
 619          this.setValue([this.getValue(), v].join(''));
 620     }
 621
 622     <div id="cfg-Ext.form.Field-autoWidth"></div>/**
 623      * @cfg {Boolean} autoWidth @hide
 624      */
 625     <div id="cfg-Ext.form.Field-autoHeight"></div>/**
 626      * @cfg {Boolean} autoHeight @hide
 627      */
 628
 629     <div id="cfg-Ext.form.Field-autoEl"></div>/**
 630      * @cfg {String} autoEl @hide
 631      */
 632 });
 633
 634
 635 Ext.form.MessageTargets = {
 636     'qtip' : {
 637         mark: function(field, msg){
 638             field.el.addClass(field.invalidClass);
 639             field.el.dom.qtip = msg;
 640             field.el.dom.qclass = 'x-form-invalid-tip';
 641             if(Ext.QuickTips){ // fix for floating editors interacting with DND
 642                 Ext.QuickTips.enable();
 643             }
 644         },
 645         clear: function(field){
 646             field.el.removeClass(field.invalidClass);
 647             field.el.dom.qtip = '';
 648         }
 649     },
 650     'title' : {
 651         mark: function(field, msg){
 652             field.el.addClass(field.invalidClass);
 653             field.el.dom.title = msg;
 654         },
 655         clear: function(field){
 656             field.el.dom.title = '';
 657         }
 658     },
 659     'under' : {
 660         mark: function(field, msg){
 661             field.el.addClass(field.invalidClass);
 662             if(!field.errorEl){
 663                 var elp = field.getErrorCt();
 664                 if(!elp){ // field has no container el
 665                     field.el.dom.title = msg;
 666                     return;
 667                 }
 668                 field.errorEl = elp.createChild({cls:'x-form-invalid-msg'});
 669                 field.on('resize', field.alignErrorEl, field);
 670                 field.on('destroy', function(){
 671                     Ext.destroy(this.errorEl);
 672                 }, field);
 673             }
 674             field.alignErrorEl();
 675             field.errorEl.update(msg);
 676             Ext.form.Field.msgFx[field.msgFx].show(field.errorEl, field);
 677         },
 678         clear: function(field){
 679             field.el.removeClass(field.invalidClass);
 680             if(field.errorEl){
 681                 Ext.form.Field.msgFx[field.msgFx].hide(field.errorEl, field);
 682             }else{
 683                 field.el.dom.title = '';
 684             }
 685         }
 686     },
 687     'side' : {
 688         mark: function(field, msg){
 689             field.el.addClass(field.invalidClass);
 690             if(!field.errorIcon){
 691                 var elp = field.getErrorCt();
 692                 // field has no container el
 693                 if(!elp){
 694                     field.el.dom.title = msg;
 695                     return;
 696                 }
 697                 field.errorIcon = elp.createChild({cls:'x-form-invalid-icon'});
 698                 if (field.ownerCt) {
 699                     field.ownerCt.on('afterlayout', field.alignErrorIcon, field);
 700                     field.ownerCt.on('expand', field.alignErrorIcon, field);
 701                 }
 702                 field.on('resize', field.alignErrorIcon, field);
 703                 field.on('destroy', function(){
 704                     Ext.destroy(this.errorIcon);
 705                 }, field);
 706             }
 707             field.alignErrorIcon();
 708             field.errorIcon.dom.qtip = msg;
 709             field.errorIcon.dom.qclass = 'x-form-invalid-tip';
 710             field.errorIcon.show();
 711         },
 712         clear: function(field){
 713             field.el.removeClass(field.invalidClass);
 714             if(field.errorIcon){
 715                 field.errorIcon.dom.qtip = '';
 716                 field.errorIcon.hide();
 717             }else{
 718                 field.el.dom.title = '';
 719             }
 720         }
 721     }
 722 };
 723
 724 // anything other than normal should be considered experimental
 725 Ext.form.Field.msgFx = {
 726     normal : {
 727         show: function(msgEl, f){
 728             msgEl.setDisplayed('block');
 729         },
 730
 731         hide : function(msgEl, f){
 732             msgEl.setDisplayed(false).update('');
 733         }
 734     },
 735
 736     slide : {
 737         show: function(msgEl, f){
 738             msgEl.slideIn('t', {stopFx:true});
 739         },
 740
 741         hide : function(msgEl, f){
 742             msgEl.slideOut('t', {stopFx:true,useDisplay:true});
 743         }
 744     },
 745
 746     slideRight : {
 747         show: function(msgEl, f){
 748             msgEl.fixDisplay();
 749             msgEl.alignTo(f.el, 'tl-tr');
 750             msgEl.slideIn('l', {stopFx:true});
 751         },
 752
 753         hide : function(msgEl, f){
 754             msgEl.slideOut('l', {stopFx:true,useDisplay:true});
 755         }
 756     }
 757 };
 758 Ext.reg('field', Ext.form.Field);
 759 </pre>
 760 </body>
 761 </html>