510 lines
19 KiB
HTML
510 lines
19 KiB
HTML
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<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>
|
|
<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(); highlight();">
|
|
<pre class="prettyprint lang-js"><span id='Ext-form-CheckboxGroup-method-constructor'><span id='Ext-form-CheckboxGroup'>/**
|
|
</span></span> * @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, {
|
|
<span id='Ext-form-CheckboxGroup-cfg-items'> /**
|
|
</span> * @cfg {Array} items An Array of {@link Ext.form.Checkbox Checkbox}es or Checkbox config objects
|
|
* to arrange in the group.
|
|
*/
|
|
<span id='Ext-form-CheckboxGroup-cfg-columns'> /**
|
|
</span> * @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>
|
|
*/
|
|
columns : 'auto',
|
|
<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,
|
|
<span id='Ext-form-CheckboxGroup-cfg-allowBlank'> /**
|
|
</span> * @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.
|
|
*/
|
|
allowBlank : true,
|
|
<span id='Ext-form-CheckboxGroup-cfg-blankText'> /**
|
|
</span> * @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")
|
|
*/
|
|
blankText : "You must select at least one item in this group",
|
|
|
|
<span id='Ext-form-CheckboxGroup-property-defaultType'> // private
|
|
</span> defaultType : 'checkbox',
|
|
|
|
<span id='Ext-form-CheckboxGroup-property-groupCls'> // private
|
|
</span> groupCls : 'x-form-check-group',
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-initComponent'> // private
|
|
</span> initComponent: function(){
|
|
this.addEvents(
|
|
<span id='Ext-form-CheckboxGroup-event-change'> /**
|
|
</span> * @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-method-onRender'> // private
|
|
</span> 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);
|
|
|
|
this.items = new Ext.util.MixedCollection();
|
|
this.items.addAll(fields);
|
|
}
|
|
Ext.form.CheckboxGroup.superclass.onRender.call(this, ct, position);
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-initValue'> initValue : function(){
|
|
</span> 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-afterRender'> afterRender : function(){
|
|
</span> 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-doLayout'> // private
|
|
</span> doLayout: function(){
|
|
//ugly method required to layout hidden items
|
|
if(this.rendered){
|
|
this.panel.forceLayout = this.ownerCt.forceLayout;
|
|
this.panel.doLayout();
|
|
}
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-fireChecked'> // private
|
|
</span> fireChecked: function(){
|
|
var arr = [];
|
|
this.eachItem(function(item){
|
|
if(item.checked){
|
|
arr.push(item);
|
|
}
|
|
});
|
|
this.fireEvent('change', this, arr);
|
|
},
|
|
|
|
<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 {Array} 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);
|
|
}
|
|
|
|
return errors;
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-isDirty'> // private
|
|
</span> 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-setReadOnly'> // private
|
|
</span> setReadOnly : function(readOnly){
|
|
if(this.rendered){
|
|
this.eachItem(function(item){
|
|
item.setReadOnly(readOnly);
|
|
});
|
|
}
|
|
this.readOnly = readOnly;
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-onDisable'> // private
|
|
</span> onDisable : function(){
|
|
this.eachItem(function(item){
|
|
item.disable();
|
|
});
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-onEnable'> // private
|
|
</span> onEnable : function(){
|
|
this.eachItem(function(item){
|
|
item.enable();
|
|
});
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-onResize'> // private
|
|
</span> onResize : function(w, h){
|
|
this.panel.setSize(w, h);
|
|
this.panel.doLayout();
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-reset'> // inherit docs from Field
|
|
</span> 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();
|
|
}
|
|
});
|
|
}
|
|
// 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);
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-setValue'> /**
|
|
</span> * {@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;
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-onSetValue'> /**
|
|
</span> * @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
|
|
*/
|
|
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]);
|
|
}
|
|
}
|
|
}else{
|
|
this.setValueForItem(id);
|
|
}
|
|
}else{
|
|
var f = this.getBox(id);
|
|
if(f){
|
|
f.setValue(value);
|
|
}
|
|
}
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-beforeDestroy'> // private
|
|
</span> beforeDestroy: function(){
|
|
Ext.destroy(this.panel);
|
|
if (!this.rendered) {
|
|
Ext.destroy(this.items);
|
|
}
|
|
Ext.form.CheckboxGroup.superclass.beforeDestroy.call(this);
|
|
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-setValueForItem'> setValueForItem : function(val){
|
|
</span> val = String(val).split(',');
|
|
this.eachItem(function(item){
|
|
if(val.indexOf(item.inputValue)> -1){
|
|
item.setValue(true);
|
|
}
|
|
});
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-getBox'> // private
|
|
</span> 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;
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-getValue'> /**
|
|
</span> * Gets an array of the selected {@link Ext.form.Checkbox} in the group.
|
|
* @return {Array} An array of the selected checkboxes.
|
|
*/
|
|
getValue : function(){
|
|
var out = [];
|
|
this.eachItem(function(item){
|
|
if(item.checked){
|
|
out.push(item);
|
|
}
|
|
});
|
|
return out;
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-eachItem'> /**
|
|
</span> * @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);
|
|
}
|
|
},
|
|
|
|
<span id='Ext-form-CheckboxGroup-cfg-name'> /**
|
|
</span> * @cfg {String} name
|
|
* @hide
|
|
*/
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-getRawValue'> /**
|
|
</span> * @method getRawValue
|
|
* @hide
|
|
*/
|
|
getRawValue : Ext.emptyFn,
|
|
|
|
<span id='Ext-form-CheckboxGroup-method-setRawValue'> /**
|
|
</span> * @method setRawValue
|
|
* @hide
|
|
*/
|
|
setRawValue : Ext.emptyFn
|
|
|
|
});
|
|
|
|
Ext.reg('checkboxgroup', Ext.form.CheckboxGroup);
|
|
</pre>
|
|
</body>
|
|
</html>
|