docs/source/TriggerField.html

   1 <html>\r
   2 <head>\r
   3   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />    \r
   4   <title>The source code</title>\r
   5     <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />\r
   6     <script type="text/javascript" src="../resources/prettify/prettify.js"></script>\r
   7 </head>\r
   8 <body  onload="prettyPrint();">\r
   9     <pre class="prettyprint lang-js"><div id="cls-Ext.form.TriggerField"></div>/**
  10  * @class Ext.form.TriggerField
  11  * @extends Ext.form.TextField
  12  * Provides a convenient wrapper for TextFields that adds a clickable trigger button (looks like a combobox by default).
  13  * The trigger has no default action, so you must assign a function to implement the trigger click handler by
  14  * overriding {@link #onTriggerClick}. You can create a TriggerField directly, as it renders exactly like a combobox
  15  * for which you can provide a custom implementation.  For example:
  16  * <pre><code>
  17 var trigger = new Ext.form.TriggerField();
  18 trigger.onTriggerClick = myTriggerFn;
  19 trigger.applyToMarkup('my-field');
  20 </code></pre>
  21  *
  22  * However, in general you will most likely want to use TriggerField as the base class for a reusable component.
  23  * {@link Ext.form.DateField} and {@link Ext.form.ComboBox} are perfect examples of this.
  24  *
  25  * @constructor
  26  * Create a new TriggerField.
  27  * @param {Object} config Configuration options (valid {@Ext.form.TextField} config options will also be applied
  28  * to the base TextField)
  29  * @xtype trigger
  30  */
  31 Ext.form.TriggerField = Ext.extend(Ext.form.TextField,  {
  32     <div id="cfg-Ext.form.TriggerField-triggerClass"></div>/**
  33      * @cfg {String} triggerClass
  34      * An additional CSS class used to style the trigger button.  The trigger will always get the
  35      * class <tt>'x-form-trigger'</tt> by default and <tt>triggerClass</tt> will be <b>appended</b> if specified.
  36      */
  37     <div id="cfg-Ext.form.TriggerField-triggerConfig"></div>/**
  38      * @cfg {Mixed} triggerConfig
  39      * <p>A {@link Ext.DomHelper DomHelper} config object specifying the structure of the
  40      * trigger element for this Field. (Optional).</p>
  41      * <p>Specify this when you need a customized element to act as the trigger button for a TriggerField.</p>
  42      * <p>Note that when using this option, it is the developer's responsibility to ensure correct sizing, positioning
  43      * and appearance of the trigger.  Defaults to:</p>
  44      * <pre><code>{tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.triggerClass}</code></pre>
  45      */
  46     <div id="cfg-Ext.form.TriggerField-autoCreate"></div>/**
  47      * @cfg {String/Object} autoCreate <p>A {@link Ext.DomHelper DomHelper} element spec, or true for a default
  48      * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component.
  49      * See <tt>{@link Ext.Component#autoEl autoEl}</tt> for details.  Defaults to:</p>
  50      * <pre><code>{tag: "input", type: "text", size: "16", autocomplete: "off"}</code></pre>
  51      */
  52     defaultAutoCreate : {tag: "input", type: "text", size: "16", autocomplete: "off"},
  53     <div id="cfg-Ext.form.TriggerField-hideTrigger"></div>/**
  54      * @cfg {Boolean} hideTrigger <tt>true</tt> to hide the trigger element and display only the base
  55      * text field (defaults to <tt>false</tt>)
  56      */
  57     hideTrigger:false,
  58     <div id="cfg-Ext.form.TriggerField-editable"></div>/**
  59      * @cfg {Boolean} editable <tt>false</tt> to prevent the user from typing text directly into the field,
  60      * the field will only respond to a click on the trigger to set the value. (defaults to <tt>true</tt>).
  61      */
  62     editable: true,
  63     <div id="cfg-Ext.form.TriggerField-readOnly"></div>/**
  64      * @cfg {Boolean} readOnly <tt>true</tt> to prevent the user from changing the field, and
  65      * hides the trigger.  Superceeds the editable and hideTrigger options if the value is true.
  66      * (defaults to <tt>false</tt>)
  67      */
  68     readOnly: false,
  69     <div id="cfg-Ext.form.TriggerField-wrapFocusClass"></div>/**
  70      * @cfg {String} wrapFocusClass The class added to the to the wrap of the trigger element. Defaults to
  71      * <tt>x-trigger-wrap-focus</tt>.
  72      */
  73     wrapFocusClass: 'x-trigger-wrap-focus',
  74     <div id="method-Ext.form.TriggerField-autoSize"></div>/**
  75      * @hide
  76      * @method autoSize
  77      */
  78     autoSize: Ext.emptyFn,
  79     // private
  80     monitorTab : true,
  81     // private
  82     deferHeight : true,
  83     // private
  84     mimicing : false,
  85
  86     actionMode: 'wrap',
  87
  88     defaultTriggerWidth: 17,
  89
  90     // private
  91     onResize : function(w, h){
  92         Ext.form.TriggerField.superclass.onResize.call(this, w, h);
  93         var tw = this.getTriggerWidth();
  94         if(Ext.isNumber(w)){
  95             this.el.setWidth(w - tw);
  96         }
  97         this.wrap.setWidth(this.el.getWidth() + tw);
  98     },
  99
 100     getTriggerWidth: function(){
 101         var tw = this.trigger.getWidth();
 102         if(!this.hideTrigger && tw === 0){
 103             tw = this.defaultTriggerWidth;
 104         }
 105         return tw;
 106     },
 107
 108     // private
 109     alignErrorIcon : function(){
 110         if(this.wrap){
 111             this.errorIcon.alignTo(this.wrap, 'tl-tr', [2, 0]);
 112         }
 113     },
 114
 115     // private
 116     onRender : function(ct, position){
 117         this.doc = Ext.isIE ? Ext.getBody() : Ext.getDoc();
 118         Ext.form.TriggerField.superclass.onRender.call(this, ct, position);
 119
 120         this.wrap = this.el.wrap({cls: 'x-form-field-wrap x-form-field-trigger-wrap'});
 121         this.trigger = this.wrap.createChild(this.triggerConfig ||
 122                 {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.triggerClass});
 123         this.initTrigger();
 124         if(!this.width){
 125             this.wrap.setWidth(this.el.getWidth()+this.trigger.getWidth());
 126         }
 127         this.resizeEl = this.positionEl = this.wrap;
 128     },
 129
 130     updateEditState: function(){
 131         if(this.rendered){
 132             if (this.readOnly) {
 133                 this.el.dom.readOnly = true;
 134                 this.el.addClass('x-trigger-noedit');
 135                 this.mun(this.el, 'click', this.onTriggerClick, this);
 136                 this.trigger.setDisplayed(false);
 137             } else {
 138                 if (!this.editable) {
 139                     this.el.dom.readOnly = true;
 140                     this.el.addClass('x-trigger-noedit');
 141                     this.mon(this.el, 'click', this.onTriggerClick, this);
 142                 } else {
 143                     this.el.dom.readOnly = false;
 144                     this.el.removeClass('x-trigger-noedit');
 145                     this.mun(this.el, 'click', this.onTriggerClick, this);
 146                 }
 147                 this.trigger.setDisplayed(!this.hideTrigger);
 148             }
 149             this.onResize(this.width || this.wrap.getWidth());
 150         }
 151     },
 152
 153     setHideTrigger: function(hideTrigger){
 154         if(hideTrigger != this.hideTrigger){
 155             this.hideTrigger = hideTrigger;
 156             this.updateEditState();
 157         }
 158     },
 159
 160     <div id="method-Ext.form.TriggerField-setEditable"></div>/**
 161      * @param {Boolean} value True to allow the user to directly edit the field text
 162      * Allow or prevent the user from directly editing the field text.  If false is passed,
 163      * the user will only be able to modify the field using the trigger.  Will also add
 164      * a click event to the text field which will call the trigger. This method
 165      * is the runtime equivalent of setting the 'editable' config option at config time.
 166      */
 167     setEditable: function(editable){
 168         if(editable != this.editable){
 169             this.editable = editable;
 170             this.updateEditState();
 171         }
 172     },
 173
 174     <div id="method-Ext.form.TriggerField-setReadOnly"></div>/**
 175      * @param {Boolean} value True to prevent the user changing the field and explicitly
 176      * hide the trigger.
 177      * Setting this to true will superceed settings editable and hideTrigger.
 178      * Setting this to false will defer back to editable and hideTrigger. This method
 179      * is the runtime equivalent of setting the 'readOnly' config option at config time.
 180      */
 181     setReadOnly: function(readOnly){
 182         if(readOnly != this.readOnly){
 183             this.readOnly = readOnly;
 184             this.updateEditState();
 185         }
 186     },
 187
 188     afterRender : function(){
 189         Ext.form.TriggerField.superclass.afterRender.call(this);
 190         this.updateEditState();
 191     },
 192
 193     // private
 194     initTrigger : function(){
 195         this.mon(this.trigger, 'click', this.onTriggerClick, this, {preventDefault:true});
 196         this.trigger.addClassOnOver('x-form-trigger-over');
 197         this.trigger.addClassOnClick('x-form-trigger-click');
 198     },
 199
 200     // private
 201     onDestroy : function(){
 202         Ext.destroy(this.trigger, this.wrap);
 203         if (this.mimicing){
 204             this.doc.un('mousedown', this.mimicBlur, this);
 205         }
 206         delete this.doc;
 207         Ext.form.TriggerField.superclass.onDestroy.call(this);
 208     },
 209
 210     // private
 211     onFocus : function(){
 212         Ext.form.TriggerField.superclass.onFocus.call(this);
 213         if(!this.mimicing){
 214             this.wrap.addClass(this.wrapFocusClass);
 215             this.mimicing = true;
 216             this.doc.on('mousedown', this.mimicBlur, this, {delay: 10});
 217             if(this.monitorTab){
 218                 this.on('specialkey', this.checkTab, this);
 219             }
 220         }
 221     },
 222
 223     // private
 224     checkTab : function(me, e){
 225         if(e.getKey() == e.TAB){
 226             this.triggerBlur();
 227         }
 228     },
 229
 230     // private
 231     onBlur : Ext.emptyFn,
 232
 233     // private
 234     mimicBlur : function(e){
 235         if(!this.isDestroyed && !this.wrap.contains(e.target) && this.validateBlur(e)){
 236             this.triggerBlur();
 237         }
 238     },
 239
 240     // private
 241     triggerBlur : function(){
 242         this.mimicing = false;
 243         this.doc.un('mousedown', this.mimicBlur, this);
 244         if(this.monitorTab && this.el){
 245             this.un('specialkey', this.checkTab, this);
 246         }
 247         Ext.form.TriggerField.superclass.onBlur.call(this);
 248         if(this.wrap){
 249             this.wrap.removeClass(this.wrapFocusClass);
 250         }
 251     },
 252
 253     beforeBlur : Ext.emptyFn,
 254
 255     // private
 256     // This should be overriden by any subclass that needs to check whether or not the field can be blurred.
 257     validateBlur : function(e){
 258         return true;
 259     },
 260
 261     <div id="method-Ext.form.TriggerField-onTriggerClick"></div>/**
 262      * The function that should handle the trigger's click event.  This method does nothing by default
 263      * until overridden by an implementing function.  See Ext.form.ComboBox and Ext.form.DateField for
 264      * sample implementations.
 265      * @method
 266      * @param {EventObject} e
 267      */
 268     onTriggerClick : Ext.emptyFn
 269
 270     <div id="cfg-Ext.form.TriggerField-grow"></div>/**
 271      * @cfg {Boolean} grow @hide
 272      */
 273     <div id="cfg-Ext.form.TriggerField-growMin"></div>/**
 274      * @cfg {Number} growMin @hide
 275      */
 276     <div id="cfg-Ext.form.TriggerField-growMax"></div>/**
 277      * @cfg {Number} growMax @hide
 278      */
 279 });
 280
 281 <div id="cls-Ext.form.TwinTriggerField"></div>/**
 282  * @class Ext.form.TwinTriggerField
 283  * @extends Ext.form.TriggerField
 284  * TwinTriggerField is not a public class to be used directly.  It is meant as an abstract base class
 285  * to be extended by an implementing class.  For an example of implementing this class, see the custom
 286  * SearchField implementation here:
 287  * <a href="http://extjs.com/deploy/ext/examples/form/custom.html">http://extjs.com/deploy/ext/examples/form/custom.html</a>
 288  */
 289 Ext.form.TwinTriggerField = Ext.extend(Ext.form.TriggerField, {
 290     <div id="cfg-Ext.form.TwinTriggerField-triggerConfig"></div>/**
 291      * @cfg {Mixed} triggerConfig
 292      * <p>A {@link Ext.DomHelper DomHelper} config object specifying the structure of the trigger elements
 293      * for this Field. (Optional).</p>
 294      * <p>Specify this when you need a customized element to contain the two trigger elements for this Field.
 295      * Each trigger element must be marked by the CSS class <tt>x-form-trigger</tt> (also see
 296      * <tt>{@link #trigger1Class}</tt> and <tt>{@link #trigger2Class}</tt>).</p>
 297      * <p>Note that when using this option, it is the developer's responsibility to ensure correct sizing,
 298      * positioning and appearance of the triggers.</p>
 299      */
 300     <div id="cfg-Ext.form.TwinTriggerField-trigger1Class"></div>/**
 301      * @cfg {String} trigger1Class
 302      * An additional CSS class used to style the trigger button.  The trigger will always get the
 303      * class <tt>'x-form-trigger'</tt> by default and <tt>triggerClass</tt> will be <b>appended</b> if specified.
 304      */
 305     <div id="cfg-Ext.form.TwinTriggerField-trigger2Class"></div>/**
 306      * @cfg {String} trigger2Class
 307      * An additional CSS class used to style the trigger button.  The trigger will always get the
 308      * class <tt>'x-form-trigger'</tt> by default and <tt>triggerClass</tt> will be <b>appended</b> if specified.
 309      */
 310
 311     initComponent : function(){
 312         Ext.form.TwinTriggerField.superclass.initComponent.call(this);
 313
 314         this.triggerConfig = {
 315             tag:'span', cls:'x-form-twin-triggers', cn:[
 316             {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger1Class},
 317             {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger2Class}
 318         ]};
 319     },
 320
 321     getTrigger : function(index){
 322         return this.triggers[index];
 323     },
 324
 325     initTrigger : function(){
 326         var ts = this.trigger.select('.x-form-trigger', true);
 327         var triggerField = this;
 328         ts.each(function(t, all, index){
 329             var triggerIndex = 'Trigger'+(index+1);
 330             t.hide = function(){
 331                 var w = triggerField.wrap.getWidth();
 332                 this.dom.style.display = 'none';
 333                 triggerField.el.setWidth(w-triggerField.trigger.getWidth());
 334                 this['hidden' + triggerIndex] = true;
 335             };
 336             t.show = function(){
 337                 var w = triggerField.wrap.getWidth();
 338                 this.dom.style.display = '';
 339                 triggerField.el.setWidth(w-triggerField.trigger.getWidth());
 340                 this['hidden' + triggerIndex] = false;
 341             };
 342
 343             if(this['hide'+triggerIndex]){
 344                 t.dom.style.display = 'none';
 345                 this['hidden' + triggerIndex] = true;
 346             }
 347             this.mon(t, 'click', this['on'+triggerIndex+'Click'], this, {preventDefault:true});
 348             t.addClassOnOver('x-form-trigger-over');
 349             t.addClassOnClick('x-form-trigger-click');
 350         }, this);
 351         this.triggers = ts.elements;
 352     },
 353
 354     getTriggerWidth: function(){
 355         var tw = 0;
 356         Ext.each(this.triggers, function(t, index){
 357             var triggerIndex = 'Trigger' + (index + 1),
 358                 w = t.getWidth();
 359             if(w === 0 && !this['hidden' + triggerIndex]){
 360                 tw += this.defaultTriggerWidth;
 361             }else{
 362                 tw += w;
 363             }
 364         }, this);
 365         return tw;
 366     },
 367
 368     // private
 369     onDestroy : function() {
 370         Ext.destroy(this.triggers);
 371         Ext.form.TwinTriggerField.superclass.onDestroy.call(this);
 372     },
 373
 374     <div id="method-Ext.form.TwinTriggerField-onTrigger1Click"></div>/**
 375      * The function that should handle the trigger's click event.  This method does nothing by default
 376      * until overridden by an implementing function. See {@link Ext.form.TriggerField#onTriggerClick}
 377      * for additional information.
 378      * @method
 379      * @param {EventObject} e
 380      */
 381     onTrigger1Click : Ext.emptyFn,
 382     <div id="method-Ext.form.TwinTriggerField-onTrigger2Click"></div>/**
 383      * The function that should handle the trigger's click event.  This method does nothing by default
 384      * until overridden by an implementing function. See {@link Ext.form.TriggerField#onTriggerClick}
 385      * for additional information.
 386      * @method
 387      * @param {EventObject} e
 388      */
 389     onTrigger2Click : Ext.emptyFn
 390 });
 391 Ext.reg('trigger', Ext.form.TriggerField);
 392 </pre>    \r
 393 </body>\r
 394 </html>