    /** * This class is used for {@link Ext.grid.Grid grid} cells that contain a child * {@link Ext.Component} or {@link Ext.Widget}. This cell type is typically used by * specifying {@link Ext.grid.column.Widget} column type. * * {@link Ext.grid.Row Rows} create cells based on the {@link Ext.grid.column.Column#cell} * config. Application code would rarely create cells directly. */Ext.define('Ext.grid.cell.Widget', {    extend: 'Ext.grid.cell.Base',    xtype: 'widgetcell',     config: {        /**         * @cfg {Boolean} forceWidth          * `true` to measure the available width of the cell and set that         * width on the underlying widget. If `false`, the widget width will auto         * size.         */        forceWidth: false,         /**         * @cfg {Object} widget (required)         * The config object for a {@link Ext.Component} or {@link Ext.Widget}.         *         * @cfg {String} widget.xtype (required) The type of component or widget to create.         */        widget: null    },     align: 'center',     classCls: Ext.baseCSSPrefix + 'widgetcell',     updateColumn: function(column, oldColumn) {        var me = this,            parent, firstCell;         me.callParent([column, oldColumn]);         if (!column || !me.getForceWidth()) {            return;        }         // We need to be able to measure some dimensions of the cells         // to be able to size the widgets if forceWidth is true. We can         // only do this once we hit the DOM. However, we only want to do this         // for the first cell because it can be expensive. If we've already         // done it, no need to do so again.          firstCell = column.firstCell;        if (firstCell && firstCell.measured) {            me.measured = true;            return;        }         parent = me.getParent();        if (parent && !parent.isSpecialRow && !column.firstCell) {            column.firstCell = me;            me.element.on('resize', 'handleFirstResize', me, {single: true});        }    },     updateValue: function(value) {        var widget = this.getWidget(),            defaultBindProperty;                    if (widget) {            defaultBindProperty = widget.defaultBindProperty;             if (defaultBindProperty) {                widget.setConfig(defaultBindProperty, value);            }        }    },     applyWidget: function(widget) {        if (widget) {            var parent = this.getParent();             if (parent && !parent.isSpecialRow) {                widget = Ext.apply({                    parent: this                }, widget);                widget = Ext.widget(widget);            } else {                widget = undefined;            }        }        return widget;    },     updateWidget: function(widget, oldWidget) {        var me = this;         if (oldWidget) {            oldWidget.measurer = null;            oldWidget.destroy();        }         if (widget) {            me.innerElement.appendChild(widget.element);            if (me.getForceWidth()) {                me.setWidgetWidth(me.getWidth());            }        }    },     updateWidth: function(width, oldWidth) {        this.callParent([width, oldWidth]);        this.setWidgetWidth(width);    },     doDestroy: function() {        this.setWidget(null);        this.callParent();    },     privates: {        handleFirstResize: function() {            var me = this,                width = me.getWidth(),                cells, len, i, cell;             // Once we have the measurement available for the first cell,              // go and cascade it for other cells.             cells = me.getColumn().getCells();             for (i = 0, len = cells.length; i < len; ++i) {                cell = cells[i];                cell.measured = true;                cell.setWidgetWidth(width);            }        },         setWidgetWidth: function(width) {            var me = this,                el = me.innerElement,                widget, column, leftPad, rightPad;             if (!me.measured) {                return;            }             widget = me.getWidget();            if (widget) {                column = me.getColumn();                leftPad = parseInt(column.getCachedStyle(el, 'padding-left'), 10) || 0;                rightPad = parseInt(column.getCachedStyle(el, 'padding-right'), 10) || 0;                // Give the widget a reference to ourself to allow it to do any extra measuring                 widget.measurer = column;                widget.setWidth(width - leftPad - rightPad);                widget.redraw();            }        }    }});