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

中间件编程

开发平台:

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.CheckboxGroup
  9.  * @extends Ext.form.Field
  10.  * <p>A grouping container for {@link Ext.form.Checkbox} controls.</p>
  11.  * <p>Sample usage:</p>
  12.  * <pre><code>
  13. var myCheckboxGroup = new Ext.form.CheckboxGroup({
  14.     id:'myGroup',
  15.     xtype: 'checkboxgroup',
  16.     fieldLabel: 'Single Column',
  17.     itemCls: 'x-check-group-alt',
  18.     // Put all controls in a single column with width 100%
  19.     columns: 1,
  20.     items: [
  21.         {boxLabel: 'Item 1', name: 'cb-col-1'},
  22.         {boxLabel: 'Item 2', name: 'cb-col-2', checked: true},
  23.         {boxLabel: 'Item 3', name: 'cb-col-3'}
  24.     ]
  25. });
  26.  * </code></pre>
  27.  * @constructor
  28.  * Creates a new CheckboxGroup
  29.  * @param {Object} config Configuration options
  30.  * @xtype checkboxgroup
  31.  */
  32. Ext.form.CheckboxGroup = Ext.extend(Ext.form.Field, {
  33.     /**
  34.      * @cfg {Array} items An Array of {@link Ext.form.Checkbox Checkbox}es or Checkbox config objects
  35.      * to arrange in the group.
  36.      */
  37.     /**
  38.      * @cfg {String/Number/Array} columns Specifies the number of columns to use when displaying grouped
  39.      * checkbox/radio controls using automatic layout.  This config can take several types of values:
  40.      * <ul><li><b>'auto'</b> : <p class="sub-desc">The controls will be rendered one per column on one row and the width
  41.      * of each column will be evenly distributed based on the width of the overall field container. This is the default.</p></li>
  42.      * <li><b>Number</b> : <p class="sub-desc">If you specific a number (e.g., 3) that number of columns will be 
  43.      * created and the contained controls will be automatically distributed based on the value of {@link #vertical}.</p></li>
  44.      * <li><b>Array</b> : Object<p class="sub-desc">You can also specify an array of column widths, mixing integer
  45.      * (fixed width) and float (percentage width) values as needed (e.g., [100, .25, .75]). Any integer values will
  46.      * be rendered first, then any float values will be calculated as a percentage of the remaining space. Float
  47.      * values do not have to add up to 1 (100%) although if you want the controls to take up the entire field
  48.      * container you should do so.</p></li></ul>
  49.      */
  50.     columns : 'auto',
  51.     /**
  52.      * @cfg {Boolean} vertical True to distribute contained controls across columns, completely filling each column 
  53.      * top to bottom before starting on the next column.  The number of controls in each column will be automatically
  54.      * calculated to keep columns as even as possible.  The default value is false, so that controls will be added
  55.      * to columns one at a time, completely filling each row left to right before starting on the next row.
  56.      */
  57.     vertical : false,
  58.     /**
  59.      * @cfg {Boolean} allowBlank False to validate that at least one item in the group is checked (defaults to true).
  60.      * If no items are selected at validation time, {@link @blankText} will be used as the error text.
  61.      */
  62.     allowBlank : true,
  63.     /**
  64.      * @cfg {String} blankText Error text to display if the {@link #allowBlank} validation fails (defaults to "You must 
  65.      * select at least one item in this group")
  66.      */
  67.     blankText : "You must select at least one item in this group",
  68.     
  69.     // private
  70.     defaultType : 'checkbox',
  71.     
  72.     // private
  73.     groupCls : 'x-form-check-group',
  74.     
  75.     // private
  76.     initComponent: function(){
  77.         this.addEvents(
  78.             /**
  79.              * @event change
  80.              * Fires when the state of a child checkbox changes.
  81.              * @param {Ext.form.CheckboxGroup} this
  82.              * @param {Array} checked An array containing the checked boxes.
  83.              */
  84.             'change'
  85.         );   
  86.         Ext.form.CheckboxGroup.superclass.initComponent.call(this);
  87.     },
  88.     
  89.     // private
  90.     onRender : function(ct, position){
  91.         if(!this.el){
  92.             var panelCfg = {
  93.                 cls: this.groupCls,
  94.                 layout: 'column',
  95.                 border: false,
  96.                 renderTo: ct
  97.             };
  98.             var colCfg = {
  99.                 defaultType: this.defaultType,
  100.                 layout: 'form',
  101.                 border: false,
  102.                 defaults: {
  103.                     hideLabel: true,
  104.                     anchor: '100%'
  105.                 }
  106.             };
  107.             
  108.             if(this.items[0].items){
  109.                 
  110.                 // The container has standard ColumnLayout configs, so pass them in directly
  111.                 
  112.                 Ext.apply(panelCfg, {
  113.                     layoutConfig: {columns: this.items.length},
  114.                     defaults: this.defaults,
  115.                     items: this.items
  116.                 });
  117.                 for(var i=0, len=this.items.length; i<len; i++){
  118.                     Ext.applyIf(this.items[i], colCfg);
  119.                 }
  120.                 
  121.             }else{
  122.                 
  123.                 // The container has field item configs, so we have to generate the column
  124.                 // panels first then move the items into the columns as needed.
  125.                 
  126.                 var numCols, cols = [];
  127.                 
  128.                 if(typeof this.columns == 'string'){ // 'auto' so create a col per item
  129.                     this.columns = this.items.length;
  130.                 }
  131.                 if(!Ext.isArray(this.columns)){
  132.                     var cs = [];
  133.                     for(var i=0; i<this.columns; i++){
  134.                         cs.push((100/this.columns)*.01); // distribute by even %
  135.                     }
  136.                     this.columns = cs;
  137.                 }
  138.                 
  139.                 numCols = this.columns.length;
  140.                 
  141.                 // Generate the column configs with the correct width setting
  142.                 for(var i=0; i<numCols; i++){
  143.                     var cc = Ext.apply({items:[]}, colCfg);
  144.                     cc[this.columns[i] <= 1 ? 'columnWidth' : 'width'] = this.columns[i];
  145.                     if(this.defaults){
  146.                         cc.defaults = Ext.apply(cc.defaults || {}, this.defaults)
  147.                     }
  148.                     cols.push(cc);
  149.                 };
  150.                 
  151.                 // Distribute the original items into the columns
  152.                 if(this.vertical){
  153.                     var rows = Math.ceil(this.items.length / numCols), ri = 0;
  154.                     for(var i=0, len=this.items.length; i<len; i++){
  155.                         if(i>0 && i%rows==0){
  156.                             ri++;
  157.                         }
  158.                         if(this.items[i].fieldLabel){
  159.                             this.items[i].hideLabel = false;
  160.                         }
  161.                         cols[ri].items.push(this.items[i]);
  162.                     };
  163.                 }else{
  164.                     for(var i=0, len=this.items.length; i<len; i++){
  165.                         var ci = i % numCols;
  166.                         if(this.items[i].fieldLabel){
  167.                             this.items[i].hideLabel = false;
  168.                         }
  169.                         cols[ci].items.push(this.items[i]);
  170.                     };
  171.                 }
  172.                 
  173.                 Ext.apply(panelCfg, {
  174.                     layoutConfig: {columns: numCols},
  175.                     items: cols
  176.                 });
  177.             }
  178.             
  179.             this.panel = new Ext.Panel(panelCfg);
  180.             this.panel.ownerCt = this;
  181.             this.el = this.panel.getEl();
  182.             
  183.             if(this.forId && this.itemCls){
  184.                 var l = this.el.up(this.itemCls).child('label', true);
  185.                 if(l){
  186.                     l.setAttribute('htmlFor', this.forId);
  187.                 }
  188.             }
  189.             
  190.             var fields = this.panel.findBy(function(c){
  191.                 return c.isFormField;
  192.             }, this);
  193.             
  194.             this.items = new Ext.util.MixedCollection();
  195.             this.items.addAll(fields);
  196.         }
  197.         Ext.form.CheckboxGroup.superclass.onRender.call(this, ct, position);
  198.     },
  199.     
  200.     afterRender : function(){
  201.         Ext.form.CheckboxGroup.superclass.afterRender.call(this);
  202.         if(this.values){
  203.             this.setValue.apply(this, this.values);
  204.             delete this.values;
  205.         }
  206.         this.eachItem(function(item){
  207.             item.on('check', this.fireChecked, this);
  208.             item.inGroup = true;
  209.         });
  210.     },
  211.     
  212.     // private
  213.     doLayout: function(){
  214.         //ugly method required to layout hidden items
  215.         if(this.rendered){
  216.             this.panel.forceLayout = this.ownerCt.forceLayout;
  217.             this.panel.doLayout();
  218.         }
  219.     },
  220.     
  221.     // private
  222.     fireChecked: function(){
  223.         var arr = [];
  224.         this.eachItem(function(item){
  225.             if(item.checked){
  226.                 arr.push(item);
  227.             }
  228.         });
  229.         this.fireEvent('change', this, arr);
  230.     },
  231.     
  232.     // private
  233.     validateValue : function(value){
  234.         if(!this.allowBlank){
  235.             var blank = true;
  236.             this.eachItem(function(f){
  237.                 if(f.checked){
  238.                     return (blank = false);
  239.                 }
  240.             });
  241.             if(blank){
  242.                 this.markInvalid(this.blankText);
  243.                 return false;
  244.             }
  245.         }
  246.         return true;
  247.     },
  248.     
  249.     // private
  250.     onDisable : function(){
  251.         this.eachItem(function(item){
  252.             item.disable();
  253.         });
  254.     },
  255.     // private
  256.     onEnable : function(){
  257.         this.eachItem(function(item){
  258.             item.enable();
  259.         });
  260.     },
  261.     
  262.     // private
  263.     doLayout: function(){
  264.         if(this.rendered){
  265.             this.panel.forceLayout = this.ownerCt.forceLayout;
  266.             this.panel.doLayout();
  267.         }
  268.     },
  269.     
  270.     // private
  271.     onResize : function(w, h){
  272.         this.panel.setSize(w, h);
  273.         this.panel.doLayout();
  274.     },
  275.     
  276.     // inherit docs from Field
  277.     reset : function(){
  278.         Ext.form.CheckboxGroup.superclass.reset.call(this);
  279.         this.eachItem(function(c){
  280.             if(c.reset){
  281.                 c.reset();
  282.             }
  283.         });
  284.     },
  285.     
  286.     /**
  287.      * {@link Ext.form.Checkbox#setValue Set the value(s)} of an item or items
  288.      * in the group. Examples illustrating how this method may be called:
  289.      * <pre><code>
  290. // call with name and value
  291. myCheckboxGroup.setValue('cb-col-1', true);
  292. // call with an array of boolean values 
  293. myCheckboxGroup.setValue([true, false, false]);
  294. // call with an object literal specifying item:value pairs
  295. myCheckboxGroup.setValue({
  296.     'cb-col-2': false,
  297.     'cb-col-3': true
  298. });
  299. // use comma separated string to set items with name to true (checked)
  300. myCheckboxGroup.setValue('cb-col-1,cb-col-3');
  301.      * </code></pre>
  302.      * See {@link Ext.form.Checkbox#setValue} for additional information.
  303.      * @param {Mixed} id The checkbox to check, or as described by example shown.
  304.      * @param {Boolean} value (optional) The value to set the item.
  305.      * @return {Ext.form.CheckboxGroup} this
  306.      */
  307.     setValue : function(id, value){
  308.         if(this.rendered){
  309.             if(arguments.length == 1){
  310.                 if(Ext.isArray(id)){
  311.                     //an array of boolean values
  312.                     Ext.each(id, function(val, idx){
  313.                         var item = this.items.itemAt(idx);
  314.                         if(item){
  315.                             item.setValue(val);
  316.                         }
  317.                     }, this);
  318.                 }else if(Ext.isObject(id)){
  319.                     //set of name/value pairs
  320.                     for(var i in id){
  321.                         var f = this.getBox(i);
  322.                         if(f){
  323.                             f.setValue(id[i]);
  324.                         }
  325.                     }
  326.                 }else{
  327.                     this.setValueForItem(id);
  328.                 }
  329.             }else{
  330.                 var f = this.getBox(id);
  331.                 if(f){
  332.                     f.setValue(value);
  333.                 }
  334.             }
  335.         }else{
  336.             this.values = arguments;
  337.         }
  338.         return this;
  339.     },
  340.     
  341.     // private
  342.     onDestroy: function(){
  343.         Ext.destroy(this.panel);
  344.         Ext.form.CheckboxGroup.superclass.onDestroy.call(this);
  345.     },
  346.     
  347.     setValueForItem : function(val){
  348.         val = String(val).split(',');
  349.         this.eachItem(function(item){
  350.             if(val.indexOf(item.inputValue)> -1){
  351.                 item.setValue(true);
  352.             }
  353.         });
  354.     },
  355.     
  356.     // private
  357.     getBox : function(id){
  358.         var box = null;
  359.         this.eachItem(function(f){
  360.             if(id == f || f.dataIndex == id || f.id == id || f.getName() == id){
  361.                 box = f;
  362.                 return false;
  363.             }
  364.         });
  365.         return box;
  366.     },
  367.     
  368.     /**
  369.      * Gets an array of the selected {@link Ext.form.Checkbox} in the group.
  370.      * @return {Array} An array of the selected checkboxes.
  371.      */
  372.     getValue : function(){
  373.         var out = [];
  374.         this.eachItem(function(item){
  375.             if(item.checked){
  376.                 out.push(item);
  377.             }
  378.         });
  379.         return out;
  380.     },
  381.     
  382.     // private
  383.     eachItem: function(fn){
  384.         if(this.items && this.items.each){
  385.             this.items.each(fn, this);
  386.         }
  387.     },
  388.     
  389.     /**
  390.      * @cfg {String} name
  391.      * @hide
  392.      */
  393.     /**
  394.      * @method initValue
  395.      * @hide
  396.      */
  397.     initValue : Ext.emptyFn,
  398.     /**
  399.      * @method getValue
  400.      * @hide
  401.      */
  402.     getValue : Ext.emptyFn,
  403.     /**
  404.      * @method getRawValue
  405.      * @hide
  406.      */
  407.     getRawValue : Ext.emptyFn,
  408.     
  409.     /**
  410.      * @method setRawValue
  411.      * @hide
  412.      */
  413.     setRawValue : Ext.emptyFn
  414.     
  415. });
  416. Ext.reg('checkboxgroup', Ext.form.CheckboxGroup);