+<!DOCTYPE html>
<html>
<head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The source code</title>
- <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
- <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
+ <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
+ <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
+ <style type="text/css">
+ .highlight { display: block; background-color: #ddd; }
+ </style>
+ <script type="text/javascript">
+ function highlight() {
+ document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
+ }
+ </script>
</head>
-<body onload="prettyPrint();">
- <pre class="prettyprint lang-js">/*!
- * Ext JS Library 3.3.0
- * Copyright(c) 2006-2010 Ext JS, Inc.
- * licensing@extjs.com
- * http://www.extjs.com/license
+<body onload="prettyPrint(); highlight();">
+ <pre class="prettyprint lang-js"><span id='Ext-form-CheckboxGroup'>/**
+</span> * 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' }
+ * ]
+ * }]
+ * });
*/
-<div id="cls-Ext.form.CheckboxGroup"></div>/**
- * @class Ext.form.CheckboxGroup
- * @extends Ext.form.Field
- * <p>A grouping container for {@link Ext.form.Checkbox} controls.</p>
- * <p>Sample usage:</p>
- * <pre><code>
-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'}
- ]
-});
- * </code></pre>
- * @constructor
- * Creates a new CheckboxGroup
- * @param {Object} config Configuration options
- * @xtype checkboxgroup
- */
-Ext.form.CheckboxGroup = Ext.extend(Ext.form.Field, {
- <div id="cfg-Ext.form.CheckboxGroup-items"></div>/**
- * @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'],
+
+<span id='Ext-form-CheckboxGroup-cfg-name'> /**
+</span> * @cfg {String} name
+ * @hide
+ */
+
+<span id='Ext-form-CheckboxGroup-cfg-items'> /**
+</span> * @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.
*/
- <div id="cfg-Ext.form.CheckboxGroup-columns"></div>/**
- * @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:
- * <ul><li><b>'auto'</b> : <p class="sub-desc">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.</p></li>
- * <li><b>Number</b> : <p class="sub-desc">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}.</p></li>
- * <li><b>Array</b> : Object<p class="sub-desc">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.</p></li></ul>
+
+<span id='Ext-form-CheckboxGroup-cfg-columns'> /**
+</span> * @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',
- <div id="cfg-Ext.form.CheckboxGroup-vertical"></div>/**
- * @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.
+
+<span id='Ext-form-CheckboxGroup-cfg-vertical'> /**
+</span> * @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,
- <div id="cfg-Ext.form.CheckboxGroup-allowBlank"></div>/**
- * @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.
+
+<span id='Ext-form-CheckboxGroup-cfg-allowBlank'> /**
+</span> * @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,
- <div id="cfg-Ext.form.CheckboxGroup-blankText"></div>/**
- * @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")
+
+<span id='Ext-form-CheckboxGroup-cfg-blankText'> /**
+</span> * @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',
- // private
- initComponent: function(){
- this.addEvents(
- <div id="event-Ext.form.CheckboxGroup-change"></div>/**
- * @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'
- );
- this.on('change', this.validate, this);
- Ext.form.CheckboxGroup.superclass.initComponent.call(this);
- },
+<span id='Ext-form-CheckboxGroup-cfg-fieldBodyCls'> /**
+</span> * @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
- onRender : function(ct, position){
- if(!this.el){
- var panelCfg = {
- autoEl: {
- id: this.id
- },
- cls: this.groupCls,
- layout: 'column',
- renderTo: ct,
- bufferResize: false // Default this to false, since it doesn't really have a proper ownerCt.
- };
- var colCfg = {
- xtype: 'container',
- defaultType: this.defaultType,
- layout: 'form',
- 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; i<len; i++){
- Ext.applyIf(this.items[i], colCfg);
- }
-
- }else{
-
- // The container has field item configs, so we have to generate the column
- // panels first then move the items into the columns as needed.
-
- var numCols, cols = [];
-
- if(typeof this.columns == 'string'){ // 'auto' so create a col per item
- this.columns = this.items.length;
- }
- if(!Ext.isArray(this.columns)){
- var cs = [];
- for(var i=0; i<this.columns; i++){
- cs.push((100/this.columns)*.01); // distribute by even %
- }
- this.columns = cs;
- }
-
- numCols = this.columns.length;
-
- // Generate the column configs with the correct width setting
- for(var i=0; i<numCols; i++){
- var cc = Ext.apply({items:[]}, colCfg);
- cc[this.columns[i] <= 1 ? 'columnWidth' : 'width'] = this.columns[i];
- if(this.defaults){
- cc.defaults = Ext.apply(cc.defaults || {}, this.defaults);
- }
- cols.push(cc);
- };
-
- // Distribute the original items into the columns
- if(this.vertical){
- var rows = Math.ceil(this.items.length / numCols), ri = 0;
- for(var i=0, len=this.items.length; i<len; i++){
- if(i>0 && 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<len; i++){
- var ci = i % numCols;
- if(this.items[i].fieldLabel){
- this.items[i].hideLabel = false;
- }
- cols[ci].items.push(this.items[i]);
- };
- }
-
- Ext.apply(panelCfg, {
- layoutConfig: {columns: numCols},
- items: cols
- });
- }
-
- this.panel = new Ext.Container(panelCfg);
- this.panel.ownerCt = this;
- this.el = this.panel.getEl();
-
- if(this.forId && this.itemCls){
- var l = this.el.up(this.itemCls).child('label', true);
- if(l){
- l.setAttribute('htmlFor', this.forId);
- }
- }
-
- var fields = this.panel.findBy(function(c){
- return c.isFormField;
- }, this);
+ layout: 'checkboxgroup',
- this.items = new Ext.util.MixedCollection();
- this.items.addAll(fields);
- }
- Ext.form.CheckboxGroup.superclass.onRender.call(this, ct, position);
+ initComponent: function() {
+ var me = this;
+ me.callParent();
+ me.initField();
},
- initValue : function(){
- if(this.value){
- this.setValue.apply(this, this.buffered ? this.value : [this.value]);
- delete this.buffered;
- delete this.value;
+<span id='Ext-form-CheckboxGroup-method-initValue'> /**
+</span> * 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);
}
},
- afterRender : function(){
- Ext.form.CheckboxGroup.superclass.afterRender.call(this);
- this.eachItem(function(item){
- item.on('check', this.fireChecked, this);
- item.inGroup = true;
- });
+<span id='Ext-form-CheckboxGroup-method-onFieldAdded'> /**
+</span> * 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);
+ }
+ 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);
},
-
- <div id="method-Ext.form.CheckboxGroup-getErrors"></div>/**
- * 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 {Array} Array of all validation errors
+
+<span id='Ext-form-CheckboxGroup-method-getErrors'> /**
+</span> * 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 = Ext.form.CheckboxGroup.superclass.getErrors.apply(this, arguments);
-
- if (!this.allowBlank) {
- var blank = true;
-
- this.eachItem(function(f){
- if (f.checked) {
- return (blank = false);
- }
- });
-
- if (blank) errors.push(this.blankText);
+ var errors = [];
+ if (!this.allowBlank && Ext.isEmpty(this.getChecked())) {
+ errors.push(this.blankText);
}
-
return errors;
},
- // private
- isDirty: function(){
- //override the behaviour to check sub items.
- if (this.disabled || !this.rendered) {
- return false;
- }
-
- var dirty = false;
-
- this.eachItem(function(item){
- if(item.isDirty()){
- dirty = true;
- return false;
- }
- });
-
- return dirty;
+<span id='Ext-form-CheckboxGroup-method-getBoxes'> /**
+</span> * @private Returns all checkbox components within the container
+ */
+ getBoxes: function() {
+ return this.query('[isCheckbox]');
},
- // private
- setReadOnly : function(readOnly){
- if(this.rendered){
- this.eachItem(function(item){
- item.setReadOnly(readOnly);
- });
- }
- this.readOnly = readOnly;
+<span id='Ext-form-CheckboxGroup-method-eachBox'> /**
+</span> * @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);
},
- // private
- onDisable : function(){
- this.eachItem(function(item){
- item.disable();
+<span id='Ext-form-CheckboxGroup-method-getChecked'> /**
+</span> * 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
- onEnable : function(){
- this.eachItem(function(item){
- item.enable();
+ // 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(){
- if (this.originalValue) {
- // Clear all items
- this.eachItem(function(c){
- if(c.setValue){
- c.setValue(false);
- c.originalValue = c.getValue();
- }
- });
- // Set items stored in originalValue, ugly - set a flag to reset the originalValue
- // during the horrible onSetValue. This will allow trackResetOnLoad to function.
- this.resetOriginal = true;
- this.setValue(this.originalValue);
- delete this.resetOriginal;
- } else {
- this.eachItem(function(c){
- if(c.reset){
- c.reset();
- }
+<span id='Ext-form-CheckboxGroup-method-reset'> /**
+</span> * 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();
}
- // Defer the clearInvalid so if BaseForm's collection is being iterated it will be called AFTER it is complete.
- // Important because reset is being called on both the group and the individual items.
- (function() {
- this.clearInvalid();
- }).defer(50, this);
},
- <div id="method-Ext.form.CheckboxGroup-setValue"></div>/**
- * {@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:
- * <pre><code>
-// 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');
- * </code></pre>
- * 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.
- * @return {Ext.form.CheckboxGroup} this
- */
- setValue: function(){
- if(this.rendered){
- this.onSetValue.apply(this, arguments);
- }else{
- this.buffered = true;
- this.value = arguments;
- }
- return this;
+ // 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);
},
- /**
- * @private
- * Sets the values of one or more of the items within the CheckboxGroup
- * @param {String|Array|Object} id Can take multiple forms. Can be optionally:
- * <ul>
- * <li>An ID string to be used with a second argument</li>
- * <li>An array of the form ['some', 'list', 'of', 'ids', 'to', 'mark', 'checked']</li>
- * <li>An array in the form [true, true, false, true, false] etc, where each item relates to the check status of
- * the checkbox at the same index</li>
- * <li>An object containing ids of the checkboxes as keys and check values as properties</li>
- * </ul>
- * @param {String} value The value to set the field to if the first argument was a string
+
+<span id='Ext-form-CheckboxGroup-method-setValue'> /**
+</span> * 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
*/
- onSetValue: function(id, value){
- if(arguments.length == 1){
- if(Ext.isArray(id)){
- Ext.each(id, function(val, idx){
- if (Ext.isObject(val) && val.setValue){ // array of checkbox components to be checked
- val.setValue(true);
- if (this.resetOriginal === true) {
- val.originalValue = val.getValue();
- }
- } else { // an array of boolean values
- 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);
- }
- }
+ cb.setValue(cbValue);
+ });
+ });
+ return me;
},
- // private
- beforeDestroy: function(){
- Ext.destroy(this.panel);
- if (!this.rendered) {
- Ext.destroy(this.items);
- }
- Ext.form.CheckboxGroup.superclass.beforeDestroy.call(this);
-
- },
- setValueForItem : function(val){
- val = String(val).split(',');
- this.eachItem(function(item){
- if(val.indexOf(item.inputValue)> -1){
- item.setValue(true);
+<span id='Ext-form-CheckboxGroup-method-getValue'> /**
+</span> * 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;
},
- <div id="method-Ext.form.CheckboxGroup-getValue"></div>/**
- * 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
- * Convenience function which passes the given function to every item in the composite
- * @param {Function} fn The function to call
- * @param {Object} scope Optional scope object
- */
- eachItem: function(fn, scope) {
- if(this.items && this.items.each){
- this.items.each(fn, scope || this);
+ validate: function() {
+ var me = this,
+ errors = me.getErrors(),
+ isValid = Ext.isEmpty(errors),
+ wasValid = !me.hasActiveError();
+
+ if (isValid) {
+ me.unsetActiveError();
+ } else {
+ me.setActiveError(errors);
+ }
+ if (isValid !== wasValid) {
+ me.fireEvent('validitychange', me, isValid);
+ me.doComponentLayout();
}
- },
- <div id="cfg-Ext.form.CheckboxGroup-name"></div>/**
- * @cfg {String} name
- * @hide
- */
+ return isValid;
+ }
- <div id="method-Ext.form.CheckboxGroup-getRawValue"></div>/**
- * @method getRawValue
- * @hide
- */
- getRawValue : Ext.emptyFn,
+}, function() {
- <div id="method-Ext.form.CheckboxGroup-setRawValue"></div>/**
- * @method setRawValue
- * @hide
- */
- setRawValue : Ext.emptyFn
+ this.borrow(Ext.form.field.Base, ['markInvalid', 'clearInvalid']);
});
-Ext.reg('checkboxgroup', Ext.form.CheckboxGroup);
-</pre>
+</pre>
</body>
-</html>
\ No newline at end of file
+</html>
git.ithinksw.org / extjs.git / blobdiff