TriggerField.js
上传用户:shuoshiled
上传日期:2018-01-28
资源大小:10124k
文件大小:12k
源码类别:

中间件编程

开发平台:

JavaScript

  1. /*!
  2.  * Ext JS Library 3.0.0
  3.  * Copyright(c) 2006-2009 Ext JS, LLC
  4.  * licensing@extjs.com
  5.  * http://www.extjs.com/license
  6.  */
  7. /**
  8.  * @class Ext.form.TriggerField
  9.  * @extends Ext.form.TextField
  10.  * Provides a convenient wrapper for TextFields that adds a clickable trigger button (looks like a combobox by default).
  11.  * The trigger has no default action, so you must assign a function to implement the trigger click handler by
  12.  * overriding {@link #onTriggerClick}. You can create a TriggerField directly, as it renders exactly like a combobox
  13.  * for which you can provide a custom implementation.  For example:
  14.  * <pre><code>
  15. var trigger = new Ext.form.TriggerField();
  16. trigger.onTriggerClick = myTriggerFn;
  17. trigger.applyToMarkup('my-field');
  18. </code></pre>
  19.  *
  20.  * However, in general you will most likely want to use TriggerField as the base class for a reusable component.
  21.  * {@link Ext.form.DateField} and {@link Ext.form.ComboBox} are perfect examples of this.
  22.  * 
  23.  * @constructor
  24.  * Create a new TriggerField.
  25.  * @param {Object} config Configuration options (valid {@Ext.form.TextField} config options will also be applied
  26.  * to the base TextField)
  27.  * @xtype trigger
  28.  */
  29. Ext.form.TriggerField = Ext.extend(Ext.form.TextField,  {
  30.     /**
  31.      * @cfg {String} triggerClass
  32.      * An additional CSS class used to style the trigger button.  The trigger will always get the
  33.      * class <tt>'x-form-trigger'</tt> by default and <tt>triggerClass</tt> will be <b>appended</b> if specified.
  34.      */
  35.     /**
  36.      * @cfg {Mixed} triggerConfig
  37.      * <p>A {@link Ext.DomHelper DomHelper} config object specifying the structure of the
  38.      * trigger element for this Field. (Optional).</p>
  39.      * <p>Specify this when you need a customized element to act as the trigger button for a TriggerField.</p>
  40.      * <p>Note that when using this option, it is the developer's responsibility to ensure correct sizing, positioning
  41.      * and appearance of the trigger.  Defaults to:</p>
  42.      * <pre><code>{tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.triggerClass}</code></pre>
  43.      */
  44.     /**
  45.      * @cfg {String/Object} autoCreate <p>A {@link Ext.DomHelper DomHelper} element spec, or true for a default
  46.      * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component.
  47.      * See <tt>{@link Ext.Component#autoEl autoEl}</tt> for details.  Defaults to:</p>
  48.      * <pre><code>{tag: "input", type: "text", size: "16", autocomplete: "off"}</code></pre>
  49.      */
  50.     defaultAutoCreate : {tag: "input", type: "text", size: "16", autocomplete: "off"},
  51.     /**
  52.      * @cfg {Boolean} hideTrigger <tt>true</tt> to hide the trigger element and display only the base
  53.      * text field (defaults to <tt>false</tt>)
  54.      */
  55.     hideTrigger:false,
  56.     /**
  57.      * @cfg {Boolean} editable <tt>false</tt> to prevent the user from typing text directly into the field,
  58.      * the field will only respond to a click on the trigger to set the value. (defaults to <tt>true</tt>)
  59.      */
  60.     editable: true,
  61.     /**
  62.      * @cfg {String} wrapFocusClass The class added to the to the wrap of the trigger element. Defaults to
  63.      * <tt>x-trigger-wrap-focus</tt>.
  64.      */
  65.     wrapFocusClass: 'x-trigger-wrap-focus',
  66.     /**
  67.      * @hide 
  68.      * @method autoSize
  69.      */
  70.     autoSize: Ext.emptyFn,
  71.     // private
  72.     monitorTab : true,
  73.     // private
  74.     deferHeight : true,
  75.     // private
  76.     mimicing : false,
  77.     
  78.     actionMode: 'wrap',
  79.     // private
  80.     onResize : function(w, h){
  81.         Ext.form.TriggerField.superclass.onResize.call(this, w, h);
  82.         if(typeof w == 'number'){
  83.             this.el.setWidth(this.adjustWidth('input', w - this.trigger.getWidth()));
  84.         }
  85.         this.wrap.setWidth(this.el.getWidth()+this.trigger.getWidth());
  86.     },
  87.     // private
  88.     adjustSize : Ext.BoxComponent.prototype.adjustSize,
  89.     // private
  90.     getResizeEl : function(){
  91.         return this.wrap;
  92.     },
  93.     // private
  94.     getPositionEl : function(){
  95.         return this.wrap;
  96.     },
  97.     // private
  98.     alignErrorIcon : function(){
  99.         if(this.wrap){
  100.             this.errorIcon.alignTo(this.wrap, 'tl-tr', [2, 0]);
  101.         }
  102.     },
  103.     // private
  104.     onRender : function(ct, position){
  105.         Ext.form.TriggerField.superclass.onRender.call(this, ct, position);
  106.         this.wrap = this.el.wrap({cls: 'x-form-field-wrap x-form-field-trigger-wrap'});
  107.         this.trigger = this.wrap.createChild(this.triggerConfig ||
  108.                 {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.triggerClass});
  109.         if(this.hideTrigger){
  110.             this.trigger.setDisplayed(false);
  111.         }
  112.         this.initTrigger();
  113.         if(!this.width){
  114.             this.wrap.setWidth(this.el.getWidth()+this.trigger.getWidth());
  115.         }
  116.         if(!this.editable){
  117.             this.editable = true;
  118.             this.setEditable(false);
  119.         }
  120.     },
  121.     afterRender : function(){
  122.         Ext.form.TriggerField.superclass.afterRender.call(this);
  123.     },
  124.     // private
  125.     initTrigger : function(){
  126.      this.mon(this.trigger, 'click', this.onTriggerClick, this, {preventDefault:true});
  127.         this.trigger.addClassOnOver('x-form-trigger-over');
  128.         this.trigger.addClassOnClick('x-form-trigger-click');
  129.     },
  130.     // private
  131.     onDestroy : function(){
  132. Ext.destroy(this.trigger, this.wrap);
  133.         if (this.mimicing){
  134.             Ext.get(Ext.isIE ? document.body : document).un("mousedown", this.mimicBlur, this);
  135.         }
  136.         Ext.form.TriggerField.superclass.onDestroy.call(this);
  137.     },
  138.     // private
  139.     onFocus : function(){
  140.         Ext.form.TriggerField.superclass.onFocus.call(this);
  141.         if(!this.mimicing){
  142.             this.wrap.addClass(this.wrapFocusClass);
  143.             this.mimicing = true;
  144.             Ext.get(Ext.isIE ? document.body : document).on("mousedown", this.mimicBlur, this, {delay: 10});
  145.             if(this.monitorTab){
  146.              this.el.on('keydown', this.checkTab, this);
  147.             }
  148.         }
  149.     },
  150.     // private
  151.     checkTab : function(e){
  152.         if(e.getKey() == e.TAB){
  153.             this.triggerBlur();
  154.         }
  155.     },
  156.     // private
  157.     onBlur : function(){
  158.         // do nothing
  159.     },
  160.     // private
  161.     mimicBlur : function(e){
  162.         if(!this.wrap.contains(e.target) && this.validateBlur(e)){
  163.             this.triggerBlur();
  164.         }
  165.     },
  166.     // private
  167.     triggerBlur : function(){
  168.         this.mimicing = false;
  169.         Ext.get(Ext.isIE ? document.body : document).un("mousedown", this.mimicBlur, this);
  170.         if(this.monitorTab && this.el){
  171.             this.el.un("keydown", this.checkTab, this);
  172.         }
  173.         Ext.form.TriggerField.superclass.onBlur.call(this);
  174.         if(this.wrap){
  175.             this.wrap.removeClass(this.wrapFocusClass);
  176.         }
  177.     },
  178.     beforeBlur : Ext.emptyFn, 
  179.     
  180.     /**
  181.      * Allow or prevent the user from directly editing the field text.  If false is passed,
  182.      * the user will only be able to modify the field using the trigger.  This method
  183.      * is the runtime equivalent of setting the 'editable' config option at config time.
  184.      * @param {Boolean} value True to allow the user to directly edit the field text
  185.      */
  186.     setEditable : function(value){
  187.         if(value == this.editable){
  188.             return;
  189.         }
  190.         this.editable = value;
  191.         if(!value){
  192.             this.el.addClass('x-trigger-noedit').on('click', this.onTriggerClick, this).dom.setAttribute('readOnly', true);
  193.         }else{
  194.             this.el.removeClass('x-trigger-noedit').un('click', this.onTriggerClick,  this).dom.removeAttribute('readOnly');
  195.         }
  196.     },
  197.     // private
  198.     // This should be overriden by any subclass that needs to check whether or not the field can be blurred.
  199.     validateBlur : function(e){
  200.         return true;
  201.     },
  202.     /**
  203.      * The function that should handle the trigger's click event.  This method does nothing by default
  204.      * until overridden by an implementing function.  See Ext.form.ComboBox and Ext.form.DateField for
  205.      * sample implementations.
  206.      * @method
  207.      * @param {EventObject} e
  208.      */
  209.     onTriggerClick : Ext.emptyFn
  210.     /**
  211.      * @cfg {Boolean} grow @hide
  212.      */
  213.     /**
  214.      * @cfg {Number} growMin @hide
  215.      */
  216.     /**
  217.      * @cfg {Number} growMax @hide
  218.      */
  219. });
  220. /**
  221.  * @class Ext.form.TwinTriggerField
  222.  * @extends Ext.form.TriggerField
  223.  * TwinTriggerField is not a public class to be used directly.  It is meant as an abstract base class
  224.  * to be extended by an implementing class.  For an example of implementing this class, see the custom
  225.  * SearchField implementation here:
  226.  * <a href="http://extjs.com/deploy/ext/examples/form/custom.html">http://extjs.com/deploy/ext/examples/form/custom.html</a>
  227.  */
  228. Ext.form.TwinTriggerField = Ext.extend(Ext.form.TriggerField, {
  229.     /**
  230.      * @cfg {Mixed} triggerConfig
  231.      * <p>A {@link Ext.DomHelper DomHelper} config object specifying the structure of the trigger elements
  232.      * for this Field. (Optional).</p>
  233.      * <p>Specify this when you need a customized element to contain the two trigger elements for this Field.
  234.      * Each trigger element must be marked by the CSS class <tt>x-form-trigger</tt> (also see
  235.      * <tt>{@link #trigger1Class}</tt> and <tt>{@link #trigger2Class}</tt>).</p>
  236.      * <p>Note that when using this option, it is the developer's responsibility to ensure correct sizing,
  237.      * positioning and appearance of the triggers.</p>
  238.      */
  239.     /**
  240.      * @cfg {String} trigger1Class
  241.      * An additional CSS class used to style the trigger button.  The trigger will always get the
  242.      * class <tt>'x-form-trigger'</tt> by default and <tt>triggerClass</tt> will be <b>appended</b> if specified.
  243.      */
  244.     /**
  245.      * @cfg {String} trigger2Class
  246.      * An additional CSS class used to style the trigger button.  The trigger will always get the
  247.      * class <tt>'x-form-trigger'</tt> by default and <tt>triggerClass</tt> will be <b>appended</b> if specified.
  248.      */
  249.     initComponent : function(){
  250.         Ext.form.TwinTriggerField.superclass.initComponent.call(this);
  251.         this.triggerConfig = {
  252.             tag:'span', cls:'x-form-twin-triggers', cn:[
  253.             {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger1Class},
  254.             {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger2Class}
  255.         ]};
  256.     },
  257.     getTrigger : function(index){
  258.         return this.triggers[index];
  259.     },
  260.     initTrigger : function(){
  261.         var ts = this.trigger.select('.x-form-trigger', true);
  262.         this.wrap.setStyle('overflow', 'hidden');
  263.         var triggerField = this;
  264.         ts.each(function(t, all, index){
  265.             t.hide = function(){
  266.                 var w = triggerField.wrap.getWidth();
  267.                 this.dom.style.display = 'none';
  268.                 triggerField.el.setWidth(w-triggerField.trigger.getWidth());
  269.             };
  270.             t.show = function(){
  271.                 var w = triggerField.wrap.getWidth();
  272.                 this.dom.style.display = '';
  273.                 triggerField.el.setWidth(w-triggerField.trigger.getWidth());
  274.             };
  275.             var triggerIndex = 'Trigger'+(index+1);
  276.             if(this['hide'+triggerIndex]){
  277.                 t.dom.style.display = 'none';
  278.             }
  279.             this.mon(t, 'click', this['on'+triggerIndex+'Click'], this, {preventDefault:true});
  280.             t.addClassOnOver('x-form-trigger-over');
  281.             t.addClassOnClick('x-form-trigger-click');
  282.         }, this);
  283.         this.triggers = ts.elements;
  284.     },
  285.     /**
  286.      * The function that should handle the trigger's click event.  This method does nothing by default
  287.      * until overridden by an implementing function. See {@link Ext.form.TriggerField#onTriggerClick}
  288.      * for additional information.  
  289.      * @method
  290.      * @param {EventObject} e
  291.      */
  292.     onTrigger1Click : Ext.emptyFn,
  293.     /**
  294.      * The function that should handle the trigger's click event.  This method does nothing by default
  295.      * until overridden by an implementing function. See {@link Ext.form.TriggerField#onTriggerClick}
  296.      * for additional information.  
  297.      * @method
  298.      * @param {EventObject} e
  299.      */
  300.     onTrigger2Click : Ext.emptyFn
  301. });
  302. Ext.reg('trigger', Ext.form.TriggerField);