/**
 * This is the base class for {@link Ext.grid.Grid grid} cells that contain only text.
 *
 * {@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.Text', {
    extend: 'Ext.grid.cell.Base',
    xtype: 'textcell',
 
    config: {
        /**
         * @cfg {Boolean} encodeHtml
         * Specify `false` to write HTML directly to the cell. Be aware that doing this
         * can expose your application to security issues if that content is not known to
         * be safe. User input can contain malicious content such as `script` tags and
         * should be scrubbed before directly rendering that HTML.
         */
        encodeHtml: true,
 
        /**
         * @cfg {String} rawValue
         * The text value of the cell. This value will be written to the cell differently
         * based on the {@link #encodeHtml} config. This config is automatically set as a
         * result of setting the {@link #value} config and is rarely set directly. This is
         * a separate config to avoid writting the same formatted result to the DOM.
         * @protected
         */
        rawValue: null,
 
        /**
         * @cfg {String} zeroValue
         *
         * A replacement value for 0.
         *
         * If the cell value is 0 and you want to display it or hide it then you can define
         * a not null value here.
         *
         * Set it as an empty string if you want to hide cells that have 0s.
         */
        zeroValue: null
    },
 
    getTemplate: function() {
        var template = this.callParent();
 
        template[0]["data-qoverflow"] = true;
 
        return template;
    },
 
    formatValue: function (v) {
        var me = this,
            context = me.refreshContext,
            column = context.column,
            zeroValue = me.getZeroValue(),
            format = column.getFormatter(),
            renderer, scope;
 
        if (context.summary) {
            renderer = column.getSummaryRenderer();
 
            if (renderer) {
                format = null; // ignore the non-summary formatter
                scope = context.scope;
 
                if (typeof renderer === 'string') {
                    v = Ext.callback(renderer, scope, [ v, context ], 0, column);
                }
                else {
                    v = renderer.call(scope || me, v, context);
                }
            }
 
            format = column.getSummaryFormatter() || format;
        }
        else if (v === 0 && zeroValue !== null) {
            v = zeroValue;
            format = null;
        }
 
        if (format) {
            v = format(v);
        }
 
        if (v != null) {
            v = String(v);
        } else {
            v = '';
        }
 
        return v;
    },
 
    printValue: function (v) {
        var me = this,
            was = me.refreshContext,
            s;
 
        // This method is mostly called outside row.refresh(), so we need to spin
        // up a context...
        me.refreshContext = me.beginRefresh(was);
 
        s = me.formatValue(v);
 
        if (me.getEncodeHtml()) {
            s = Ext.htmlEncode(s);
        }
 
        me.refreshContext = was;
 
        return s;
    },
 
    updateRawValue: function (rawValue) {
        var dom = this.bodyElement.dom,
            value = rawValue == null ? '' : rawValue;
 
        if (this.getEncodeHtml()) {
            dom.textContent = value;
        } else {
            dom.innerHTML = value;
        }
    },
 
    updateValue: function () {
            var me = this,
                was = me.refreshContext,
                row = me.row;
 
        // We may be called by binding after the store has already been nullified.
        // This can happen when binding to an association store if the parent record
        // is dropped.  If that is the case the row will have been removed from the grid
        // and cached for later use, so we can skip updating the dom.
        if (row && row.parent) {
            // We can be called by refresh() or directly such as when binding.
            // Make sure we have a context spun up...
            if (!was) {
                me.refreshContext = me.beginRefresh();
            }
 
            me.writeValue();
 
            me.refreshContext = was;
        }
    },
 
    updateZeroValue: function () {
        if (!this.isConfiguring) {
            this.refresh();
        }
    },
 
    writeValue: function () {
        var me = this,
            value = me.getValue();
 
        if (!(value = me.formatValue(value))) {
            // formatValue returns a string, so ! means '' not 0.
            value = me.getColumn().getEmptyText();
        }
 
        me.setRawValue(value);
    }
});