~admin/apache-tomcat-8.5.78.git

<!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-field-Checkbox'>/**
</span> * @docauthor Robert Dougan &lt;rob@sencha.com&gt;
 *
 * Single checkbox field. Can be used as a direct replacement for traditional checkbox fields. Also serves as a
 * parent class for {@link Ext.form.field.Radio radio buttons}.
 *
 * # Labeling
 *
 * In addition to the {@link Ext.form.Labelable standard field labeling options}, checkboxes
 * may be given an optional {@link #boxLabel} which will be displayed immediately after checkbox. Also see
 * {@link Ext.form.CheckboxGroup} for a convenient method of grouping related checkboxes.
 *
 * # Values
 *
 * The main value of a checkbox is a boolean, indicating whether or not the checkbox is checked.
 * The following values will check the checkbox:
 *
 * - `true`
 * - `'true'`
 * - `'1'`
 * - `'on'`
 *
 * Any other value will uncheck the checkbox.
 *
 * In addition to the main boolean value, you may also specify a separate {@link #inputValue}. This will be
 * sent as the parameter value when the form is {@link Ext.form.Basic#submit submitted}. You will want to set
 * this value if you have multiple checkboxes with the same {@link #name}. If not specified, the value `on`
 * will be used.
 *
 * # Example usage
 *
 *     @example
 *     Ext.create('Ext.form.Panel', {
 *         bodyPadding: 10,
 *         width: 300,
 *         title: 'Pizza Order',
 *         items: [
 *             {
 *                 xtype: 'fieldcontainer',
 *                 fieldLabel: 'Toppings',
 *                 defaultType: 'checkboxfield',
 *                 items: [
 *                     {
 *                         boxLabel  : 'Anchovies',
 *                         name      : 'topping',
 *                         inputValue: '1',
 *                         id        : 'checkbox1'
 *                     }, {
 *                         boxLabel  : 'Artichoke Hearts',
 *                         name      : 'topping',
 *                         inputValue: '2',
 *                         checked   : true,
 *                         id        : 'checkbox2'
 *                     }, {
 *                         boxLabel  : 'Bacon',
 *                         name      : 'topping',
 *                         inputValue: '3',
 *                         id        : 'checkbox3'
 *                     }
 *                 ]
 *             }
 *         ],
 *         bbar: [
 *             {
 *                 text: 'Select Bacon',
 *                 handler: function() {
 *                     Ext.getCmp('checkbox3').setValue(true);
 *                 }
 *             },
 *             '-',
 *             {
 *                 text: 'Select All',
 *                 handler: function() {
 *                     Ext.getCmp('checkbox1').setValue(true);
 *                     Ext.getCmp('checkbox2').setValue(true);
 *                     Ext.getCmp('checkbox3').setValue(true);
 *                 }
 *             },
 *             {
 *                 text: 'Deselect All',
 *                 handler: function() {
 *                     Ext.getCmp('checkbox1').setValue(false);
 *                     Ext.getCmp('checkbox2').setValue(false);
 *                     Ext.getCmp('checkbox3').setValue(false);
 *                 }
 *             }
 *         ],
 *         renderTo: Ext.getBody()
 *     });
 */
Ext.define('Ext.form.field.Checkbox', {
    extend: 'Ext.form.field.Base',
    alias: ['widget.checkboxfield', 'widget.checkbox'],
    alternateClassName: 'Ext.form.Checkbox',
    requires: ['Ext.XTemplate', 'Ext.form.CheckboxManager' ],
 
<span id='Ext-form-field-Checkbox-cfg-componentLayout'>    componentLayout: 'field',
</span>    
<span id='Ext-form-field-Checkbox-property-stretchInputElFixed'>    // inputEl should always retain the same size, never stretch
</span>    stretchInputElFixed: false,
 
<span id='Ext-form-field-Checkbox-property-childEls'>    childEls: [
</span><span id='Ext-form-field-Checkbox-property-boxLabelEl'>        /**
</span>         * @property {Ext.Element} boxLabelEl
         * A reference to the label element created for the {@link #boxLabel}. Only present if the component has been
         * rendered and has a boxLabel configured.
         */
        'boxLabelEl'
    ],
 
<span id='Ext-form-field-Checkbox-cfg-fieldSubTpl'>    // note: {id} here is really {inputId}, but {cmpId} is available
</span>    fieldSubTpl: [
        '&lt;tpl if=&quot;boxLabel &amp;&amp; boxLabelAlign == \'before\'&quot;&gt;',
            '{beforeBoxLabelTpl}',
            '&lt;label id=&quot;{cmpId}-boxLabelEl&quot; {boxLabelAttrTpl} class=&quot;{boxLabelCls} {boxLabelCls}-{boxLabelAlign}&quot; for=&quot;{id}&quot;&gt;',
                '{beforeBoxLabelTextTpl}',
                '{boxLabel}',
                '{afterBoxLabelTextTpl}',
            '&lt;/label&gt;',
            '{afterBoxLabelTpl}',
        '&lt;/tpl&gt;',
        // Creates an input of the configured type. By default, this is &quot;button&quot; to enable theming.
        // When ARIA is enabled, this reverts to a &quot;checkbox&quot;
        '&lt;input type=&quot;{inputTypeAttr}&quot; id=&quot;{id}&quot; {inputAttrTpl}',
            '&lt;tpl if=&quot;tabIdx&quot;&gt; tabIndex=&quot;{tabIdx}&quot;&lt;/tpl&gt;',
            '&lt;tpl if=&quot;disabled&quot;&gt; disabled=&quot;disabled&quot;&lt;/tpl&gt;',
            '&lt;tpl if=&quot;fieldStyle&quot;&gt; style=&quot;{fieldStyle}&quot;&lt;/tpl&gt;',
            '&lt;tpl if=&quot;ariaAttrs&quot;&gt; {ariaAttrs}&lt;/tpl&gt;',
            ' class=&quot;{fieldCls} {typeCls} {inputCls} {childElCls}&quot; autocomplete=&quot;off&quot; hidefocus=&quot;true&quot; /&gt;',
        '&lt;tpl if=&quot;boxLabel &amp;&amp; boxLabelAlign == \'after\'&quot;&gt;',
            '{beforeBoxLabelTpl}',
            '&lt;label id=&quot;{cmpId}-boxLabelEl&quot; {boxLabelAttrTpl} class=&quot;{boxLabelCls} {boxLabelCls}-{boxLabelAlign}&quot; for=&quot;{id}&quot;&gt;',
                '{beforeBoxLabelTextTpl}',
                '{boxLabel}',
                '{afterBoxLabelTextTpl}',
            '&lt;/label&gt;',
            '{afterBoxLabelTpl}',
        '&lt;/tpl&gt;',
        {
            disableFormats: true,
            compiled: true
        }
    ],
 
<span id='Ext-form-field-Checkbox-property-subTplInsertions'>    subTplInsertions: [
</span><span id='Ext-form-field-Checkbox-cfg-beforeBoxLabelTpl'>        /**
</span>         * @cfg {String/Array/Ext.XTemplate} beforeBoxLabelTpl
         * An optional string or `XTemplate` configuration to insert in the field markup
         * before the box label element. If an `XTemplate` is used, the component's
         * {@link Ext.form.field.Base#getSubTplData subTpl data} serves as the context.
         */
        'beforeBoxLabelTpl',
 
<span id='Ext-form-field-Checkbox-cfg-afterBoxLabelTpl'>        /**
</span>         * @cfg {String/Array/Ext.XTemplate} afterBoxLabelTpl
         * An optional string or `XTemplate` configuration to insert in the field markup
         * after the box label element. If an `XTemplate` is used, the component's
         * {@link Ext.form.field.Base#getSubTplData subTpl data} serves as the context.
         */
        'afterBoxLabelTpl',
 
<span id='Ext-form-field-Checkbox-cfg-beforeBoxLabelTextTpl'>        /**
</span>         * @cfg {String/Array/Ext.XTemplate} beforeBoxLabelTextTpl
         * An optional string or `XTemplate` configuration to insert in the field markup
         * before the box label text. If an `XTemplate` is used, the component's
         * {@link Ext.form.field.Base#getSubTplData subTpl data} serves as the context.
         */
        'beforeBoxLabelTextTpl',
 
<span id='Ext-form-field-Checkbox-cfg-afterBoxLabelTextTpl'>        /**
</span>         * @cfg {String/Array/Ext.XTemplate} afterBoxLabelTextTpl
         * An optional string or `XTemplate` configuration to insert in the field markup
         * after the box label text. If an `XTemplate` is used, the component's
         * {@link Ext.form.field.Base#getSubTplData subTpl data} serves as the context.
         */
        'afterBoxLabelTextTpl',
 
<span id='Ext-form-field-Checkbox-cfg-boxLabelAttrTpl'>        /**
</span>         * @cfg {String/Array/Ext.XTemplate} boxLabelAttrTpl
         * An optional string or `XTemplate` configuration to insert in the field markup
         * inside the box label element (as attributes). If an `XTemplate` is used, the component's
         * {@link Ext.form.field.Base#getSubTplData subTpl data} serves as the context.
         */
        'boxLabelAttrTpl',
 
        // inherited
        'inputAttrTpl'
    ],
 
<span id='Ext-form-field-Checkbox-property-isCheckbox'>    /*
</span>     * @property {Boolean} isCheckbox
     * `true` in this class to identify an object as an instantiated Checkbox, or subclass thereof.
     */
    isCheckbox: true,
 
<span id='Ext-form-field-Checkbox-cfg-focusCls'>    /**
</span>     * @cfg {String} [focusCls='x-form-checkbox-focus']
     * The CSS class to use when the checkbox receives focus
     */
    focusCls: 'form-checkbox-focus',
 
<span id='Ext-form-field-Checkbox-cfg-fieldCls'>    /**
</span>     * @cfg {String} [fieldCls='x-form-field']
     * The default CSS class for the checkbox
     */
    
<span id='Ext-form-field-Checkbox-property-extraFieldBodyCls'>    // private
</span>    extraFieldBodyCls: Ext.baseCSSPrefix + 'form-cb-wrap',
 
<span id='Ext-form-field-Checkbox-cfg-checked'>    /**
</span>     * @cfg {Boolean} checked
     * true if the checkbox should render initially checked
     */
    checked: false,
 
<span id='Ext-form-field-Checkbox-cfg-checkedCls'>    /**
</span>     * @cfg {String} [checkedCls='x-form-cb-checked']
     * The CSS class(es) added to the component's main element when it is in the checked state.
     * You can add your own class (checkedCls='myClass x-form-cb-checked') or replace the default 
     * class altogether (checkedCls='myClass').
     */
    checkedCls: Ext.baseCSSPrefix + 'form-cb-checked',
 
<span id='Ext-form-field-Checkbox-cfg-boxLabel'>    /**
</span>     * @cfg {String} boxLabel
     * An optional text label that will appear next to the checkbox. Whether it appears before or after the checkbox is
     * determined by the {@link #boxLabelAlign} config.
     */
 
<span id='Ext-form-field-Checkbox-cfg-boxLabelCls'>    /**
</span>     * @cfg {String} [boxLabelCls='x-form-cb-label']
     * The CSS class to be applied to the {@link #boxLabel} element
     */
    boxLabelCls: Ext.baseCSSPrefix + 'form-cb-label',
 
<span id='Ext-form-field-Checkbox-cfg-boxLabelAlign'>    /**
</span>     * @cfg {String} boxLabelAlign
     * The position relative to the checkbox where the {@link #boxLabel} should appear. Recognized values are 'before'
     * and 'after'.
     */
    boxLabelAlign: 'after',
 
<span id='Ext-form-field-Checkbox-cfg-inputValue'>    /**
</span>     * @cfg {String} inputValue
     * The value that should go into the generated input element's value attribute and should be used as the parameter
     * value when submitting as part of a form.
     */
    inputValue: 'on',
 
<span id='Ext-form-field-Checkbox-cfg-uncheckedValue'>    /**
</span>     * @cfg {String} uncheckedValue
     * If configured, this will be submitted as the checkbox's value during form submit if the checkbox is unchecked. By
     * default this is undefined, which results in nothing being submitted for the checkbox field when the form is
     * submitted (the default behavior of HTML checkboxes).
     */
 
<span id='Ext-form-field-Checkbox-cfg-handler'>    /**
</span>     * @cfg {Function} handler
     * A function called when the {@link #checked} value changes (can be used instead of handling the {@link #change
     * change event}).
     * @cfg {Ext.form.field.Checkbox} handler.checkbox The Checkbox being toggled.
     * @cfg {Boolean} handler.checked The new checked state of the checkbox.
     */
 
<span id='Ext-form-field-Checkbox-cfg-scope'>    /**
</span>     * @cfg {Object} scope
     * An object to use as the scope ('this' reference) of the {@link #handler} function.
     *
     * Defaults to this Checkbox.
     */
 
<span id='Ext-form-field-Checkbox-cfg-checkChangeEvents'>    // private overrides
</span>    checkChangeEvents: [],
<span id='Ext-form-field-Checkbox-cfg-inputType'>    inputType: 'checkbox',
</span>    
<span id='Ext-form-field-Checkbox-property-inputTypeAttr'>    // private - the actual input type to use. inputType is just used to generate a class name
</span>    inputTypeAttr: 'button',
 
 
<span id='Ext-form-field-Checkbox-property-onRe'>    // private
</span>    onRe: /^on$/i,
 
<span id='Ext-form-field-Checkbox-property-inputCls'>    // the form-cb css class is for styling shared between checkbox and subclasses (radio)
</span>    inputCls: Ext.baseCSSPrefix + 'form-cb',
 
<span id='Ext-form-field-Checkbox-method-initComponent'>    initComponent: function() {
</span>        this.callParent(arguments);
        this.getManager().add(this);
    },
 
<span id='Ext-form-field-Checkbox-method-initValue'>    initValue: function() {
</span>        var me = this,
            checked = !!me.checked;
 
<span id='Ext-form-field-Checkbox-property-originalValue'>        /**
</span>         * @property {Object} originalValue
         * The original value of the field as configured in the {@link #checked} configuration, or as loaded by the last
         * form load operation if the form's {@link Ext.form.Basic#trackResetOnLoad trackResetOnLoad} setting is `true`.
         */
        me.originalValue = me.lastValue = checked;
 
        // Set the initial checked state
        me.setValue(checked);
    },
 
<span id='Ext-form-field-Checkbox-method-getElConfig'>    getElConfig: function() {
</span>        var me = this;
 
        // Add the checked class if this begins checked
        if (me.isChecked(me.rawValue, me.inputValue)) {
            me.addCls(me.checkedCls);
        }
        return me.callParent();
    },
 
<span id='Ext-form-field-Checkbox-method-getFieldStyle'>    getFieldStyle: function() {
</span>        return Ext.isObject(this.fieldStyle) ? Ext.DomHelper.generateStyles(this.fieldStyle) : this.fieldStyle ||'';
    },
 
<span id='Ext-form-field-Checkbox-method-getSubTplData'>    getSubTplData: function() {
</span>        var me = this;
        return Ext.apply(me.callParent(), {
            disabled      : me.readOnly || me.disabled,
            boxLabel      : me.boxLabel,
            boxLabelCls   : me.boxLabelCls,
            boxLabelAlign : me.boxLabelAlign,
            inputTypeAttr : me.inputTypeAttr
        });
    },
 
<span id='Ext-form-field-Checkbox-method-initEvents'>    initEvents: function() {
</span>        var me = this;
        me.callParent();
        me.mon(me.inputEl, 'click', me.onBoxClick, me);
    },
    
<span id='Ext-form-field-Checkbox-method-setBoxLabel'>    /**
</span>     * Sets the {@link #boxLabel} for this checkbox.
     * @param {String} boxLabel The new label
     */
    setBoxLabel: function(boxLabel){
        var me = this;
        
        me.boxLabel = boxLabel;
        if (me.rendered) {
            me.boxLabelEl.update(boxLabel);
        }
    },
 
<span id='Ext-form-field-Checkbox-method-onBoxClick'>    /**
</span>     * @private Handle click on the checkbox button
     */
    onBoxClick: function(e) {
        var me = this;
        if (!me.disabled &amp;&amp; !me.readOnly) {
            this.setValue(!this.checked);
        }
    },
 
<span id='Ext-form-field-Checkbox-method-getRawValue'>    /**
</span>     * Returns the checked state of the checkbox.
     * @return {Boolean} True if checked, else false
     */
    getRawValue: function() {
        return this.checked;
    },
 
<span id='Ext-form-field-Checkbox-method-getValue'>    /**
</span>     * Returns the checked state of the checkbox.
     * @return {Boolean} True if checked, else false
     */
    getValue: function() {
        return this.checked;
    },
 
<span id='Ext-form-field-Checkbox-method-getSubmitValue'>    /**
</span>     * Returns the submit value for the checkbox which can be used when submitting forms.
     * @return {String} If checked the {@link #inputValue} is returned; otherwise the {@link #uncheckedValue}
     * (or null if the latter is not configured).
     */
    getSubmitValue: function() {
        var unchecked = this.uncheckedValue,
            uncheckedVal = Ext.isDefined(unchecked) ? unchecked : null;
        return this.checked ? this.inputValue : uncheckedVal;
    },
 
<span id='Ext-form-field-Checkbox-method-isChecked'>    isChecked: function(rawValue, inputValue) {
</span>        return (rawValue === true || rawValue === 'true' || rawValue === '1' || rawValue === 1 ||
                      (((Ext.isString(rawValue) || Ext.isNumber(rawValue)) &amp;&amp; inputValue) ? rawValue == inputValue : this.onRe.test(rawValue)));
    },
 
<span id='Ext-form-field-Checkbox-method-setRawValue'>    /**
</span>     * Sets the checked state of the checkbox.
     *
     * @param {Boolean/String/Number} value The following values will check the checkbox:
     * `true, 'true', '1', 1, or 'on'`, as well as a String that matches the {@link #inputValue}.
     * Any other value will uncheck the checkbox.
     * @return {Boolean} the new checked state of the checkbox
     */
    setRawValue: function(value) {
        var me = this,
            inputEl = me.inputEl,
            checked = me.isChecked(value, me.inputValue);
 
        if (inputEl) {
            me[checked ? 'addCls' : 'removeCls'](me.checkedCls);
        }
 
        me.checked = me.rawValue = checked;
        return checked;
    },
 
<span id='Ext-form-field-Checkbox-method-setValue'>    /**
</span>     * Sets the checked state of the checkbox, and invokes change detection.
     * @param {Boolean/String} checked The following values will check the checkbox: `true, 'true', '1', or 'on'`, as
     * well as a String that matches the {@link #inputValue}. Any other value will uncheck the checkbox.
     * @return {Ext.form.field.Checkbox} this
     */
    setValue: function(checked) {
        var me = this,
            boxes, i, len, box;
 
        // If an array of strings is passed, find all checkboxes in the group with the same name as this
        // one and check all those whose inputValue is in the array, unchecking all the others. This is to
        // facilitate setting values from Ext.form.Basic#setValues, but is not publicly documented as we
        // don't want users depending on this behavior.
        if (Ext.isArray(checked)) {
            boxes = me.getManager().getByName(me.name, me.getFormId()).items;
            len = boxes.length;
 
            for (i = 0; i &lt; len; ++i) {
                box = boxes[i];
                box.setValue(Ext.Array.contains(checked, box.inputValue));
            }
        } else {
            me.callParent(arguments);
        }
 
        return me;
    },
 
<span id='Ext-form-field-Checkbox-method-valueToRaw'>    // private
</span>    valueToRaw: function(value) {
        // No extra conversion for checkboxes
        return value;
    },
 
<span id='Ext-form-field-Checkbox-method-onChange'>    /**
</span>     * @private
     * Called when the checkbox's checked state changes. Invokes the {@link #handler} callback
     * function if specified.
     */
    onChange: function(newVal, oldVal) {
        var me = this,
            handler = me.handler;
        if (handler) {
            handler.call(me.scope || me, me, newVal);
        }
        me.callParent(arguments);
    },
    
<span id='Ext-form-field-Checkbox-method-resetOriginalValue'>    resetOriginalValue: function(/* private */ fromBoxInGroup){
</span>        var me = this,
            boxes,
            box,
            len,
            i;
            
        // If we're resetting the value of a field in a group, also reset the others.
        if (!fromBoxInGroup) {
            boxes = me.getManager().getByName(me.name, me.getFormId()).items;
            len  = boxes.length;
            
            for (i = 0; i &lt; len; ++i) {
                box = boxes[i];
                if (box !== me) {
                    boxes[i].resetOriginalValue(true);
                }
            }
        }
        me.callParent();
    },
 
<span id='Ext-form-field-Checkbox-method-beforeDestroy'>    // inherit docs
</span>    beforeDestroy: function(){
        this.callParent();
        this.getManager().removeAtKey(this.id);
    },
 
<span id='Ext-form-field-Checkbox-method-getManager'>    // inherit docs
</span>    getManager: function() {
        return Ext.form.CheckboxManager;
    },
 
<span id='Ext-form-field-Checkbox-method-onEnable'>    onEnable: function() {
</span>        var me = this,
            inputEl = me.inputEl;
        me.callParent();
        if (inputEl) {
            // Can still be disabled if the field is readOnly
            inputEl.dom.disabled = me.readOnly;
        }
    },
 
<span id='Ext-form-field-Checkbox-method-setReadOnly'>    setReadOnly: function(readOnly) {
</span>        var me = this,
            inputEl = me.inputEl;
        if (inputEl) {
            // Set the button to disabled when readonly
            inputEl.dom.disabled = !!readOnly || me.disabled;
        }
        me.callParent(arguments);
    },
 
<span id='Ext-form-field-Checkbox-method-getFormId'>    getFormId: function(){
</span>        var me = this,
            form;
 
        if (!me.formId) {
            form = me.up('form');
            if (form) {
                me.formId = form.id;
            }
        }
        return me.formId;
    }
});
</pre>
</body>
</html>