The source code

X-Git-Url: http://git.ithinksw.org/extjs.git/blobdiff_plain/c930e9176a5a85509c5b0230e2bff5c22a591432..f562e4c6e5fac7bcb445985b99acbea4d706e6f0:/docs/source/CheckboxGroup.html diff --git a/docs/source/CheckboxGroup.html b/docs/source/CheckboxGroup.html index b0b8c289..6efa745c 100644 --- a/docs/source/CheckboxGroup.html +++ b/docs/source/CheckboxGroup.html @@ -1,423 +1,418 @@ - - - The source code - - - - -
/**
- * @class Ext.form.CheckboxGroup
- * @extends Ext.form.Field
- * A grouping container for {@link Ext.form.Checkbox} controls.
- * Sample usage:
- * 
-var myCheckboxGroup = new Ext.form.CheckboxGroup({
-    id:'myGroup',
-    xtype: 'checkboxgroup',
-    fieldLabel: 'Single Column',
-    itemCls: 'x-check-group-alt',
-    // Put all controls in a single column with width 100%
-    columns: 1,
-    items: [
-        {boxLabel: 'Item 1', name: 'cb-col-1'},
-        {boxLabel: 'Item 2', name: 'cb-col-2', checked: true},
-        {boxLabel: 'Item 3', name: 'cb-col-3'}
-    ]
-});
- * 
- * @constructor
- * Creates a new CheckboxGroup
- * @param {Object} config Configuration options
- * @xtype checkboxgroup
+
+
+
+  
+  The source code
+  
+  
+  
+  
+
+
+  /**
+ * A {@link Ext.form.FieldContainer field container} which has a specialized layout for arranging
+ * {@link Ext.form.field.Checkbox} controls into columns, and provides convenience
+ * {@link Ext.form.field.Field} methods for {@link #getValue getting}, {@link #setValue setting},
+ * and {@link #validate validating} the group of checkboxes as a whole.
+ *
+ * # Validation
+ *
+ * Individual checkbox fields themselves have no default validation behavior, but
+ * sometimes you want to require a user to select at least one of a group of checkboxes. CheckboxGroup
+ * allows this by setting the config `{@link #allowBlank}:false`; when the user does not check at
+ * least one of the checkboxes, the entire group will be highlighted as invalid and the
+ * {@link #blankText error message} will be displayed according to the {@link #msgTarget} config.
+ *
+ * # Layout
+ *
+ * The default layout for CheckboxGroup makes it easy to arrange the checkboxes into
+ * columns; see the {@link #columns} and {@link #vertical} config documentation for details. You may also
+ * use a completely different layout by setting the {@link #layout} to one of the other supported layout
+ * types; for instance you may wish to use a custom arrangement of hbox and vbox containers. In that case
+ * the checkbox components at any depth will still be managed by the CheckboxGroup's validation.
+ *
+ *     @example
+ *     Ext.create('Ext.form.Panel', {
+ *         title: 'Checkbox Group',
+ *         width: 300,
+ *         height: 125,
+ *         bodyPadding: 10,
+ *         renderTo: Ext.getBody(),
+ *         items:[{
+ *             xtype: 'checkboxgroup',
+ *             fieldLabel: 'Two Columns',
+ *             // Arrange radio buttons into two columns, distributed vertically
+ *             columns: 2,
+ *             vertical: true,
+ *             items: [
+ *                 { boxLabel: 'Item 1', name: 'rb', inputValue: '1' },
+ *                 { boxLabel: 'Item 2', name: 'rb', inputValue: '2', checked: true },
+ *                 { boxLabel: 'Item 3', name: 'rb', inputValue: '3' },
+ *                 { boxLabel: 'Item 4', name: 'rb', inputValue: '4' },
+ *                 { boxLabel: 'Item 5', name: 'rb', inputValue: '5' },
+ *                 { boxLabel: 'Item 6', name: 'rb', inputValue: '6' }
+ *             ]
+ *         }]
+ *     });
  */
-Ext.form.CheckboxGroup = Ext.extend(Ext.form.Field, {
-    /**
-     * @cfg {Array} items An Array of {@link Ext.form.Checkbox Checkbox}es or Checkbox config objects
-     * to arrange in the group.
+Ext.define('Ext.form.CheckboxGroup', {
+    extend:'Ext.form.FieldContainer',
+    mixins: {
+        field: 'Ext.form.field.Field'
+    },
+    alias: 'widget.checkboxgroup',
+    requires: ['Ext.layout.container.CheckboxGroup', 'Ext.form.field.Base'],
+
+    /**
+     * @cfg {String} name
+     * @hide
      */
-    /**
-     * @cfg {String/Number/Array} columns Specifies the number of columns to use when displaying grouped
-     * checkbox/radio controls using automatic layout.  This config can take several types of values:
-     * 'auto' : The controls will be rendered one per column on one row and the width
-     * of each column will be evenly distributed based on the width of the overall field container. This is the default.
-     * Number : If you specific a number (e.g., 3) that number of columns will be 
-     * created and the contained controls will be automatically distributed based on the value of {@link #vertical}.
-     * Array : ObjectYou can also specify an array of column widths, mixing integer
-     * (fixed width) and float (percentage width) values as needed (e.g., [100, .25, .75]). Any integer values will
-     * be rendered first, then any float values will be calculated as a percentage of the remaining space. Float
-     * values do not have to add up to 1 (100%) although if you want the controls to take up the entire field
-     * container you should do so.
+
+    /**
+     * @cfg {Ext.form.field.Checkbox[]/Object[]} items
+     * An Array of {@link Ext.form.field.Checkbox Checkbox}es or Checkbox config objects to arrange in the group.
+     */
+
+    /**
+     * @cfg {String/Number/Number[]} columns
+     * Specifies the number of columns to use when displaying grouped checkbox/radio controls using automatic layout.
+     * This config can take several types of values:
+     *
+     * - 'auto' - The controls will be rendered one per column on one row and the width of each column will be evenly
+     *   distributed based on the width of the overall field container. This is the default.
+     * - Number - If you specific a number (e.g., 3) that number of columns will be created and the contained controls
+     *   will be automatically distributed based on the value of {@link #vertical}.
+     * - Array - You can also specify an array of column widths, mixing integer (fixed width) and float (percentage
+     *   width) values as needed (e.g., [100, .25, .75]). Any integer values will be rendered first, then any float
+     *   values will be calculated as a percentage of the remaining space. Float values do not have to add up to 1
+     *   (100%) although if you want the controls to take up the entire field container you should do so.
      */
     columns : 'auto',
-    /**
-     * @cfg {Boolean} vertical True to distribute contained controls across columns, completely filling each column 
-     * top to bottom before starting on the next column.  The number of controls in each column will be automatically
-     * calculated to keep columns as even as possible.  The default value is false, so that controls will be added
-     * to columns one at a time, completely filling each row left to right before starting on the next row.
+
+    /**
+     * @cfg {Boolean} vertical
+     * True to distribute contained controls across columns, completely filling each column top to bottom before
+     * starting on the next column. The number of controls in each column will be automatically calculated to keep
+     * columns as even as possible. The default value is false, so that controls will be added to columns one at a time,
+     * completely filling each row left to right before starting on the next row.
      */
     vertical : false,
-    /**
-     * @cfg {Boolean} allowBlank False to validate that at least one item in the group is checked (defaults to true).
-     * If no items are selected at validation time, {@link @blankText} will be used as the error text.
+
+    /**
+     * @cfg {Boolean} allowBlank
+     * False to validate that at least one item in the group is checked. If no items are selected at
+     * validation time, {@link #blankText} will be used as the error text.
      */
     allowBlank : true,
-    /**
-     * @cfg {String} blankText Error text to display if the {@link #allowBlank} validation fails (defaults to "You must 
-     * select at least one item in this group")
+
+    /**
+     * @cfg {String} blankText
+     * Error text to display if the {@link #allowBlank} validation fails
      */
-    blankText : "You must select at least one item in this group",
-    
+    blankText : "You must select at least one item in this group",
+
     // private
-    defaultType : 'checkbox',
-    
+    defaultType : 'checkboxfield',
+
     // private
-    groupCls : 'x-form-check-group',
-    
+    groupCls : Ext.baseCSSPrefix + 'form-check-group',
+
+    /**
+     * @cfg {String} fieldBodyCls
+     * An extra CSS class to be applied to the body content element in addition to {@link #baseBodyCls}.
+     * Defaults to 'x-form-checkboxgroup-body'.
+     */
+    fieldBodyCls: Ext.baseCSSPrefix + 'form-checkboxgroup-body',
+
     // private
-    initComponent: function(){
-        this.addEvents(
-            /**
-             * @event change
-             * Fires when the state of a child checkbox changes.
-             * @param {Ext.form.CheckboxGroup} this
-             * @param {Array} checked An array containing the checked boxes.
-             */
-            'change'
-        );   
-        Ext.form.CheckboxGroup.superclass.initComponent.call(this);
+    layout: 'checkboxgroup',
+
+    initComponent: function() {
+        var me = this;
+        me.callParent();
+        me.initField();
     },
-    
-    // private
-    onRender : function(ct, position){
-        if(!this.el){
-            var panelCfg = {
-                cls: this.groupCls,
-                layout: 'column',
-                border: false,
-                renderTo: ct
-            };
-            var colCfg = {
-                defaultType: this.defaultType,
-                layout: 'form',
-                border: false,
-                defaults: {
-                    hideLabel: true,
-                    anchor: '100%'
-                }
-            };
-            
-            if(this.items[0].items){
-                
-                // The container has standard ColumnLayout configs, so pass them in directly
-                
-                Ext.apply(panelCfg, {
-                    layoutConfig: {columns: this.items.length},
-                    defaults: this.defaults,
-                    items: this.items
-                });
-                for(var i=0, len=this.items.length; i0 && i%rows==0){
-                            ri++;
-                        }
-                        if(this.items[i].fieldLabel){
-                            this.items[i].hideLabel = false;
-                        }
-                        cols[ri].items.push(this.items[i]);
-                    };
-                }else{
-                    for(var i=0, len=this.items.length; i    /**
+     * Initializes the field's value based on the initial config. If the {@link #value} config is specified then we use
+     * that to set the value; otherwise we initialize the originalValue by querying the values of all sub-checkboxes
+     * after they have been initialized.
+     * @protected
+     */
+    initValue: function() {
+        var me = this,
+            valueCfg = me.value;
+        me.originalValue = me.lastValue = valueCfg || me.getValue();
+        if (valueCfg) {
+            me.setValue(valueCfg);
         }
-        Ext.form.CheckboxGroup.superclass.onRender.call(this, ct, position);
     },
-    
-    afterRender : function(){
-        Ext.form.CheckboxGroup.superclass.afterRender.call(this);
-        if(this.values){
-            this.setValue.apply(this, this.values);
-            delete this.values;
+
+    /**
+     * When a checkbox is added to the group, monitor it for changes
+     * @param {Object} field
+     * @protected
+     */
+    onFieldAdded: function(field) {
+        var me = this;
+        if (field.isCheckbox) {
+            me.mon(field, 'change', me.checkChange, me);
         }
-        this.eachItem(function(item){
-            item.on('check', this.fireChecked, this);
-            item.inGroup = true;
-        });
+        me.callParent(arguments);
     },
-    
-    // private
-    doLayout: function(){
-        //ugly method required to layout hidden items
-        if(this.rendered){
-            this.panel.forceLayout = this.ownerCt.forceLayout;
-            this.panel.doLayout();
+
+    onFieldRemoved: function(field) {
+        var me = this;
+        if (field.isCheckbox) {
+            me.mun(field, 'change', me.checkChange, me);
         }
+        me.callParent(arguments);
     },
-    
-    // private
-    fireChecked: function(){
-        var arr = [];
-        this.eachItem(function(item){
-            if(item.checked){
-                arr.push(item);
-            }
-        });
-        this.fireEvent('change', this, arr);
+
+    // private override - the group value is a complex object, compare using object serialization
+    isEqual: function(value1, value2) {
+        var toQueryString = Ext.Object.toQueryString;
+        return toQueryString(value1) === toQueryString(value2);
     },
-    
-    // private
-    validateValue : function(value){
-        if(!this.allowBlank){
-            var blank = true;
-            this.eachItem(function(f){
-                if(f.checked){
-                    return (blank = false);
-                }
-            });
-            if(blank){
-                this.markInvalid(this.blankText);
-                return false;
-            }
+
+    /**
+     * Runs CheckboxGroup's validations and returns an array of any errors. The only error by default is if allowBlank
+     * is set to true and no items are checked.
+     * @return {String[]} Array of all validation errors
+     */
+    getErrors: function() {
+        var errors = [];
+        if (!this.allowBlank && Ext.isEmpty(this.getChecked())) {
+            errors.push(this.blankText);
         }
-        return true;
+        return errors;
     },
-    
-    // private
-    onDisable : function(){
-        this.eachItem(function(item){
-            item.disable();
-        });
+
+    /**
+     * @private Returns all checkbox components within the container
+     */
+    getBoxes: function() {
+        return this.query('[isCheckbox]');
     },
 
-    // private
-    onEnable : function(){
-        this.eachItem(function(item){
-            item.enable();
+    /**
+     * @private Convenience function which calls the given function for every checkbox in the group
+     * @param {Function} fn The function to call
+     * @param {Object} scope (Optional) scope object
+     */
+    eachBox: function(fn, scope) {
+        Ext.Array.forEach(this.getBoxes(), fn, scope || this);
+    },
+
+    /**
+     * Returns an Array of all checkboxes in the container which are currently checked
+     * @return {Ext.form.field.Checkbox[]} Array of Ext.form.field.Checkbox components
+     */
+    getChecked: function() {
+        return Ext.Array.filter(this.getBoxes(), function(cb) {
+            return cb.getValue();
         });
     },
-    
-    // private
-    doLayout: function(){
-        if(this.rendered){
-            this.panel.forceLayout = this.ownerCt.forceLayout;
-            this.panel.doLayout();
-        }
+
+    // private override
+    isDirty: function(){
+        return Ext.Array.some(this.getBoxes(), function(cb) {
+            return cb.isDirty();
+        });
     },
-    
-    // private
-    onResize : function(w, h){
-        this.panel.setSize(w, h);
-        this.panel.doLayout();
+
+    // private override
+    setReadOnly: function(readOnly) {
+        this.eachBox(function(cb) {
+            cb.setReadOnly(readOnly);
+        });
+        this.readOnly = readOnly;
     },
-    
-    // inherit docs from Field
-    reset : function(){
-        Ext.form.CheckboxGroup.superclass.reset.call(this);
-        this.eachItem(function(c){
-            if(c.reset){
-                c.reset();
-            }
+
+    /**
+     * Resets the checked state of all {@link Ext.form.field.Checkbox checkboxes} in the group to their originally
+     * loaded values and clears any validation messages.
+     * See {@link Ext.form.Basic}.{@link Ext.form.Basic#trackResetOnLoad trackResetOnLoad}
+     */
+    reset: function() {
+        var me = this,
+            hadError = me.hasActiveError(),
+            preventMark = me.preventMark;
+        me.preventMark = true;
+        me.batchChanges(function() {
+            me.eachBox(function(cb) {
+                cb.reset();
+            });
         });
+        me.preventMark = preventMark;
+        me.unsetActiveError();
+        if (hadError) {
+            me.doComponentLayout();
+        }
     },
-    
-    /**
-     * {@link Ext.form.Checkbox#setValue Set the value(s)} of an item or items
-     * in the group. Examples illustrating how this method may be called:
-     * 
-// call with name and value
-myCheckboxGroup.setValue('cb-col-1', true);
-// call with an array of boolean values 
-myCheckboxGroup.setValue([true, false, false]);
-// call with an object literal specifying item:value pairs
-myCheckboxGroup.setValue({
-    'cb-col-2': false,
-    'cb-col-3': true
-});
-// use comma separated string to set items with name to true (checked)
-myCheckboxGroup.setValue('cb-col-1,cb-col-3');
-     * 
-     * See {@link Ext.form.Checkbox#setValue} for additional information.
-     * @param {Mixed} id The checkbox to check, or as described by example shown.
-     * @param {Boolean} value (optional) The value to set the item.
+
+    // private override
+    resetOriginalValue: function() {
+        // Defer resetting of originalValue until after all sub-checkboxes have been reset so we get
+        // the correct data from getValue()
+        Ext.defer(function() {
+            this.callParent();
+        }, 1, this);
+    },
+
+
+    /**
+     * Sets the value(s) of all checkboxes in the group. The expected format is an Object of name-value pairs
+     * corresponding to the names of the checkboxes in the group. Each pair can have either a single or multiple values:
+     *
+     *   - A single Boolean or String value will be passed to the `setValue` method of the checkbox with that name.
+     *     See the rules in {@link Ext.form.field.Checkbox#setValue} for accepted values.
+     *   - An Array of String values will be matched against the {@link Ext.form.field.Checkbox#inputValue inputValue}
+     *     of checkboxes in the group with that name; those checkboxes whose inputValue exists in the array will be
+     *     checked and others will be unchecked.
+     *
+     * If a checkbox's name is not in the mapping at all, it will be unchecked.
+     *
+     * An example:
+     *
+     *     var myCheckboxGroup = new Ext.form.CheckboxGroup({
+     *         columns: 3,
+     *         items: [{
+     *             name: 'cb1',
+     *             boxLabel: 'Single 1'
+     *         }, {
+     *             name: 'cb2',
+     *             boxLabel: 'Single 2'
+     *         }, {
+     *             name: 'cb3',
+     *             boxLabel: 'Single 3'
+     *         }, {
+     *             name: 'cbGroup',
+     *             boxLabel: 'Grouped 1'
+     *             inputValue: 'value1'
+     *         }, {
+     *             name: 'cbGroup',
+     *             boxLabel: 'Grouped 2'
+     *             inputValue: 'value2'
+     *         }, {
+     *             name: 'cbGroup',
+     *             boxLabel: 'Grouped 3'
+     *             inputValue: 'value3'
+     *         }]
+     *     });
+     *
+     *     myCheckboxGroup.setValue({
+     *         cb1: true,
+     *         cb3: false,
+     *         cbGroup: ['value1', 'value3']
+     *     });
+     *
+     * The above code will cause the checkbox named 'cb1' to be checked, as well as the first and third checkboxes named
+     * 'cbGroup'. The other three checkboxes will be unchecked.
+     *
+     * @param {Object} value The mapping of checkbox names to values.
      * @return {Ext.form.CheckboxGroup} this
      */
-    setValue : function(id, value){
-        if(this.rendered){
-            if(arguments.length == 1){
-                if(Ext.isArray(id)){
-                    //an array of boolean values
-                    Ext.each(id, function(val, idx){
-                        var item = this.items.itemAt(idx);
-                        if(item){
-                            item.setValue(val);
-                        }
-                    }, this);
-                }else if(Ext.isObject(id)){
-                    //set of name/value pairs
-                    for(var i in id){
-                        var f = this.getBox(i);
-                        if(f){
-                            f.setValue(id[i]);
-                        }
+    setValue: function(value) {
+        var me = this;
+        me.batchChanges(function() {
+            me.eachBox(function(cb) {
+                var name = cb.getName(),
+                    cbValue = false;
+                if (value && name in value) {
+                    if (Ext.isArray(value[name])) {
+                        cbValue = Ext.Array.contains(value[name], cb.inputValue);
+                    } else {
+                        // single value, let the checkbox's own setValue handle conversion
+                        cbValue = value[name];
                     }
-                }else{
-                    this.setValueForItem(id);
                 }
-            }else{
-                var f = this.getBox(id);
-                if(f){
-                    f.setValue(value);
-                }
-            }
-        }else{
-            this.values = arguments;
-        }
-        return this;
+                cb.setValue(cbValue);
+            });
+        });
+        return me;
     },
-    
-    // private
-    onDestroy: function(){
-        Ext.destroy(this.panel);
-        Ext.form.CheckboxGroup.superclass.onDestroy.call(this);
 
-    },
-    
-    setValueForItem : function(val){
-        val = String(val).split(',');
-        this.eachItem(function(item){
-            if(val.indexOf(item.inputValue)> -1){
-                item.setValue(true);
+
+    /**
+     * Returns an object containing the values of all checked checkboxes within the group. Each key-value pair in the
+     * object corresponds to a checkbox {@link Ext.form.field.Checkbox#name name}. If there is only one checked checkbox
+     * with a particular name, the value of that pair will be the String {@link Ext.form.field.Checkbox#inputValue
+     * inputValue} of that checkbox. If there are multiple checked checkboxes with that name, the value of that pair
+     * will be an Array of the selected inputValues.
+     *
+     * The object format returned from this method can also be passed directly to the {@link #setValue} method.
+     *
+     * NOTE: In Ext 3, this method returned an array of Checkbox components; this was changed to make it more consistent
+     * with other field components and with the {@link #setValue} argument signature. If you need the old behavior in
+     * Ext 4+, use the {@link #getChecked} method instead.
+     */
+    getValue: function() {
+        var values = {};
+        this.eachBox(function(cb) {
+            var name = cb.getName(),
+                inputValue = cb.inputValue,
+                bucket;
+            if (cb.getValue()) {
+                if (name in values) {
+                    bucket = values[name];
+                    if (!Ext.isArray(bucket)) {
+                        bucket = values[name] = [bucket];
+                    }
+                    bucket.push(inputValue);
+                } else {
+                    values[name] = inputValue;
+                }
             }
         });
+        return values;
     },
-    
-    // private
-    getBox : function(id){
-        var box = null;
-        this.eachItem(function(f){
-            if(id == f || f.dataIndex == id || f.id == id || f.getName() == id){
-                box = f;
-                return false;
-            }
-        });
-        return box;
+
+    /*
+     * Don't return any data for submit; the form will get the info from the individual checkboxes themselves.
+     */
+    getSubmitData: function() {
+        return null;
     },
-    
-    /**
-     * Gets an array of the selected {@link Ext.form.Checkbox} in the group.
-     * @return {Array} An array of the selected checkboxes.
+
+    /*
+     * Don't return any data for the model; the form will get the info from the individual checkboxes themselves.
      */
-    getValue : function(){
-        var out = [];
-        this.eachItem(function(item){
-            if(item.checked){
-                out.push(item);
-            }
-        });
-        return out;
+    getModelData: function() {
+        return null;
     },
-    
-    // private
-    eachItem: function(fn){
-        if(this.items && this.items.each){
-            this.items.each(fn, this);
+
+    validate: function() {
+        var me = this,
+            errors = me.getErrors(),
+            isValid = Ext.isEmpty(errors),
+            wasValid = !me.hasActiveError();
+
+        if (isValid) {
+            me.unsetActiveError();
+        } else {
+            me.setActiveError(errors);
         }
-    },
-    
-    /**
-     * @cfg {String} name
-     * @hide
-     */
-    /**
-     * @method initValue
-     * @hide
-     */
-    initValue : Ext.emptyFn,
-    /**
-     * @method getValue
-     * @hide
-     */
-    getValue : Ext.emptyFn,
-    /**
-     * @method getRawValue
-     * @hide
-     */
-    getRawValue : Ext.emptyFn,
-    
-    /**
-     * @method setRawValue
-     * @hide
-     */
-    setRawValue : Ext.emptyFn
-    
+        if (isValid !== wasValid) {
+            me.fireEvent('validitychange', me, isValid);
+            me.doComponentLayout();
+        }
+
+        return isValid;
+    }
+
+}, function() {
+
+    this.borrow(Ext.form.field.Base, ['markInvalid', 'clearInvalid']);
+
 });
 
-Ext.reg('checkboxgroup', Ext.form.CheckboxGroup);
-    
-
-
\ No newline at end of file
+
+ +