echarts 3.5.1 → 3.6.0

package/lib/data/helper/completeDimensions.js

@@ -4,42 +4,202 @@
 
 
     var zrUtil = require('zrender/lib/core/util');
+    var modelUtil = require('../../util/model');
+    var each = zrUtil.each;
+    var isString = zrUtil.isString;
+    var defaults = zrUtil.defaults;
+    var normalizeToArray = modelUtil.normalizeToArray;
+
+    var OTHER_DIMS = {tooltip: 1, label: 1, itemName: 1};
 
     /**
-     * Complete the dimensions array guessed from the data structure.
-     * @param  {Array.<string>} dimensions Necessary dimensions, like ['x', 'y']
-     * @param  {Array} data Data list. [[1, 2, 3], [2, 3, 4]]
-     * @param  {Object} [opt]
-     * @param  {Array.<string>} [opt.defaultNames] Default names to fill not necessary dimensions, like ['value']
-     * @param  {string} [opt.extraPrefix] Prefix of name when filling the left dimensions.
-     * @param  {number} [opt.dimCount] If not specified, guess by the first data item.
-     * @return {Array.<string>}
+     * Complete the dimensions array, by user defined `dimension` and `encode`,
+     * and guessing from the data structure.
+     * If no 'value' dimension specified, the first no-named dimension will be
+     * named as 'value'.
+     *
+     * @param {Array.<string>} sysDims Necessary dimensions, like ['x', 'y'], which
+     *      provides not only dim template, but also default order.
+     *      `name` of each item provides default coord name.
+     *      [{dimsDef: []}, ...] can be specified to give names.
+     * @param {Array} data Data list. [[1, 2, 3], [2, 3, 4]].
+     * @param {Object} [opt]
+     * @param {Array.<Object|string>} [opt.dimsDef] option.series.dimensions User defined dimensions
+     *      For example: ['asdf', {name, type}, ...].
+     * @param {Object} [opt.encodeDef] option.series.encode {x: 2, y: [3, 1], tooltip: [1, 2], label: 3}
+     * @param {string} [opt.extraPrefix] Prefix of name when filling the left dimensions.
+     * @param {string} [opt.extraFromZero] If specified, extra dim names will be:
+     *                      extraPrefix + 0, extraPrefix + extraBaseIndex + 1 ...
+     *                      If not specified, extra dim names will be:
+     *                      extraPrefix, extraPrefix + 0, extraPrefix + 1 ...
+     * @param {number} [opt.dimCount] If not specified, guess by the first data item.
+     * @return {Array.<Object>} [{
+     *      name: string mandatory,
+     *      coordDim: string mandatory,
+     *      coordDimIndex: number mandatory,
+     *      type: string optional,
+     *      tooltipName: string optional,
+     *      otherDims: {
+     *          tooltip: number optional,
+     *          label: number optional
+     *      },
+     *      isExtraCoord: boolean true or undefined.
+     *      other props ...
+     * }]
      */
-    function completeDimensions(dimensions, data, opt) {
-        if (!data) {
-            return dimensions;
-        }
-
+    function completeDimensions(sysDims, data, opt) {
+        data = data || [];
         opt = opt || {};
+        sysDims = (sysDims || []).slice();
+        var dimsDef = (opt.dimsDef || []).slice();
+        var encodeDef = zrUtil.createHashMap(opt.encodeDef);
+        var dataDimNameMap = zrUtil.createHashMap();
+        var coordDimNameMap = zrUtil.createHashMap();
+        // var valueCandidate;
+        var result = [];
 
         var dimCount = opt.dimCount;
         if (dimCount == null) {
             var value0 = retrieveValue(data[0]);
-            dimCount = zrUtil.isArray(value0) && value0.length || 1;
+            dimCount = Math.max(
+                zrUtil.isArray(value0) && value0.length || 1,
+                sysDims.length,
+                dimsDef.length
+            );
+            each(sysDims, function (sysDimItem) {
+                var sysDimItemDimsDef = sysDimItem.dimsDef;
+                sysDimItemDimsDef && (dimCount = Math.max(dimCount, sysDimItemDimsDef.length));
+            });
         }
 
-        var defaultNames = opt.defaultNames || [];
-        var extraPrefix = opt.extraPrefix || 'extra';
+        // Apply user defined dims (`name` and `type`) and init result.
         for (var i = 0; i < dimCount; i++) {
-            if (!dimensions[i]) {
-                var name = defaultNames[i] || (extraPrefix + (i - defaultNames.length));
-                dimensions[i] = guessOrdinal(data, i)
-                    ? {type: 'ordinal', name: name}
-                    : name;
+            var dimDefItem = isString(dimsDef[i]) ? {name: dimsDef[i]} : (dimsDef[i] || {});
+            var userDimName = dimDefItem.name;
+            var resultItem = result[i] = {otherDims: {}};
+            // Name will be applied later for avoiding duplication.
+            if (userDimName != null && dataDimNameMap.get(userDimName) == null) {
+                // Only if `series.dimensions` is defined in option, tooltipName
+                // will be set, and dimension will be diplayed vertically in
+                // tooltip by default.
+                resultItem.name = resultItem.tooltipName = userDimName;
+                dataDimNameMap.set(userDimName, i);
+            }
+            dimDefItem.type != null && (resultItem.type = dimDefItem.type);
+        }
+
+        // Set `coordDim` and `coordDimIndex` by `encodeDef` and normalize `encodeDef`.
+        encodeDef.each(function (dataDims, coordDim) {
+            dataDims = encodeDef.set(coordDim, normalizeToArray(dataDims).slice());
+            each(dataDims, function (resultDimIdx, coordDimIndex) {
+                // The input resultDimIdx can be dim name or index.
+                isString(resultDimIdx) && (resultDimIdx = dataDimNameMap.get(resultDimIdx));
+                if (resultDimIdx != null && resultDimIdx < dimCount) {
+                    dataDims[coordDimIndex] = resultDimIdx;
+                    applyDim(result[resultDimIdx], coordDim, coordDimIndex);
+                    // coordDim === 'value' && valueCandidate == null && (valueCandidate = resultDimIdx);
+                }
+            });
+        });
+
+        // Apply templetes and default order from `sysDims`.
+        var availDimIdx = 0;
+        each(sysDims, function (sysDimItem, sysDimIndex) {
+            var coordDim;
+            var sysDimItem;
+            var sysDimItemDimsDef;
+            var sysDimItemOtherDims;
+            if (isString(sysDimItem)) {
+                coordDim = sysDimItem;
+                sysDimItem = {};
+            }
+            else {
+                coordDim = sysDimItem.name;
+                sysDimItem = zrUtil.clone(sysDimItem);
+                // `coordDimIndex` should not be set directly.
+                sysDimItemDimsDef = sysDimItem.dimsDef;
+                sysDimItemOtherDims = sysDimItem.otherDims;
+                sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex
+                    = sysDimItem.dimsDef = sysDimItem.otherDims = null;
+            }
+
+            var dataDims = normalizeToArray(encodeDef.get(coordDim));
+            // dimensions provides default dim sequences.
+            if (!dataDims.length) {
+                for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {
+                    while (availDimIdx < result.length && result[availDimIdx].coordDim != null) {
+                        availDimIdx++;
+                    }
+                    availDimIdx < result.length && dataDims.push(availDimIdx++);
+                }
+            }
+            // Apply templates.
+            each(dataDims, function (resultDimIdx, coordDimIndex) {
+                var resultItem = result[resultDimIdx];
+                applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);
+                // coordDim === 'value' && valueCandidate == null && (valueCandidate = resultDimIdx);
+                if (resultItem.name == null && sysDimItemDimsDef) {
+                    resultItem.name = resultItem.tooltipName = sysDimItemDimsDef[coordDimIndex];
+                }
+                sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);
+            });
+        });
+
+        // Make sure the first extra dim is 'value'.
+        var extra = opt.extraPrefix || 'value';
+
+        // Set dim `name` and other `coordDim` and other props.
+        for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
+            var resultItem = result[resultDimIdx] = result[resultDimIdx] || {};
+            var coordDim = resultItem.coordDim;
+
+            coordDim == null && (
+                resultItem.coordDim = genName(extra, coordDimNameMap, opt.extraFromZero),
+                resultItem.coordDimIndex = 0,
+                resultItem.isExtraCoord = true
+            );
+
+            resultItem.name == null && (resultItem.name = genName(
+                // Ensure At least one value dim.
+                // (dataDimNameMap.get('value') == null
+                //     && (valueCandidate == null || valueCandidate === resultDimIdx)
+                //     // Try to set as 'value' only if coordDim is not set as 'extra'.
+                //     && coordDim == null
+                // )
+                // ? 'value'
+                // :
+                resultItem.coordDim,
+                dataDimNameMap
+            ));
+
+            resultItem.type == null && guessOrdinal(data, resultDimIdx)
+                && (resultItem.type = 'ordinal');
+        }
+
+        return result;
+
+        function applyDim(resultItem, coordDim, coordDimIndex) {
+            if (OTHER_DIMS[coordDim]) {
+                resultItem.otherDims[coordDim] = coordDimIndex;
+            }
+            else {
+                resultItem.coordDim = coordDim;
+                resultItem.coordDimIndex = coordDimIndex;
+                coordDimNameMap.set(coordDim, true);
             }
         }
 
-        return dimensions;
+        function genName(name, map, fromZero) {
+            if (fromZero || map.get(name) != null) {
+                var i = 0;
+                while (map.get(name + i) != null) {
+                    i++;
+                }
+                name += i;
+            }
+            map.set(name, true);
+            return name;
+        }
     }
 
     // The rule should not be complex, otherwise user might not
@@ -53,10 +213,11 @@
             }
 
             var value = value[dimIndex];
+            // Consider usage convenience, '1', '2' will be treated as "number".
             if (value != null && isFinite(value)) {
                 return false;
             }
-            else if (zrUtil.isString(value) && value !== '-') {
+            else if (isString(value) && value !== '-') {
                 return true;
             }
         }

package/lib/echarts.js

@@ -176,7 +176,7 @@ if (typeof __DEV__ === 'undefined') {
          * @type {module:echarts/ExtensionAPI}
          * @private
          */
-        this._api = new ExtensionAPI(this, this._coordSysMgr);
+        this._api = createExtensionAPI(this);
 
         Eventful.call(this);
 
@@ -276,14 +276,7 @@ if (typeof __DEV__ === 'undefined') {
             ecModel.init(null, null, theme, optionManager);
         }
 
-        // FIXME
-        // ugly
-        this.__lastOnlyGraphic = !!(option && option.graphic);
-        zrUtil.each(option, function (o, mainType) {
-            mainType !== 'graphic' && (this.__lastOnlyGraphic = false);
-        }, this);
-
-        this._model.setOption(option, optionPreprocessorFuncs, this.__lastOnlyGraphic);
+        this._model.setOption(option, optionPreprocessorFuncs);
 
         if (lazyUpdate) {
             this[OPTION_UPDATED] = {silent: silent};
@@ -809,21 +802,7 @@ if (typeof __DEV__ === 'undefined') {
 
             prepareView.call(this, 'chart', ecModel);
 
-            // FIXME
-            // ugly
-            if (this.__lastOnlyGraphic) {
-                each(this._componentsViews, function (componentView) {
-                    var componentModel = componentView.__model;
-                    if (componentModel && componentModel.mainType === 'graphic') {
-                        componentView.render(componentModel, ecModel, this._api, payload);
-                        updateZ(componentModel, componentView);
-                    }
-                }, this);
-                this.__lastOnlyGraphic = false;
-            }
-            else {
-                updateMethods.update.call(this, payload);
-            }
+            updateMethods.update.call(this, payload);
         }
     };
 
@@ -1140,7 +1119,7 @@ if (typeof __DEV__ === 'undefined') {
             }
 
             // Consider: id same and type changed.
-            var viewId = model.id + '_' + model.type;
+            var viewId = '_ec_' + model.id + '_' + model.type;
             var view = viewMap[viewId];
             if (!view) {
                 var classType = parseClassType(model.type);
@@ -1160,10 +1139,13 @@ if (typeof __DEV__ === 'undefined') {
                 }
             }
 
-            model.__viewId = viewId;
+            model.__viewId = view.__id = viewId;
             view.__alive = true;
-            view.__id = viewId;
             view.__model = model;
+            view.group.__ecComponentInfo = {
+                mainType: model.mainType,
+                index: model.componentIndex
+            };
         }, this);
 
         for (var i = 0; i < viewList.length;) {
@@ -1173,6 +1155,7 @@ if (typeof __DEV__ === 'undefined') {
                 view.dispose(ecModel, this._api);
                 viewList.splice(i, 1);
                 delete viewMap[view.__id];
+                view.__id = view.group.__ecComponentInfo = null;
             }
             else {
                 i++;
@@ -1202,7 +1185,8 @@ if (typeof __DEV__ === 'undefined') {
             var data = series.getData();
             if (stack && data.type === 'list') {
                 var previousStack = stackedDataMap[stack];
-                if (previousStack) {
+                // Avoid conflict with Object.prototype
+                if (stackedDataMap.hasOwnProperty(stack) && previousStack) {
                     data.stackedOn = previousStack;
                 }
                 stackedDataMap[stack] = data;
@@ -1344,6 +1328,7 @@ if (typeof __DEV__ === 'undefined') {
     echartsProto.clear = function () {
         this.setOption({ series: [] }, true);
     };
+
     /**
      * Dispose instance
      */
@@ -1390,6 +1375,7 @@ if (typeof __DEV__ === 'undefined') {
             });
         }
     }
+
     /**
      * Update chart progressive and blend.
      * @param {module:echarts/model/Series|module:echarts/model/Component} model
@@ -1432,6 +1418,7 @@ if (typeof __DEV__ === 'undefined') {
             }
         });
     }
+
     /**
      * @param {module:echarts/model/Series|module:echarts/model/Component} model
      * @param {module:echarts/view/Component|module:echarts/view/Chart} view
@@ -1447,6 +1434,26 @@ if (typeof __DEV__ === 'undefined') {
             }
         });
     }
+
+    function createExtensionAPI(ecInstance) {
+        var coordSysMgr = ecInstance._coordSysMgr;
+        return zrUtil.extend(new ExtensionAPI(ecInstance), {
+            // Inject methods
+            getCoordinateSystems: zrUtil.bind(
+                coordSysMgr.getCoordinateSystems, coordSysMgr
+            ),
+            getComponentByElement: function (el) {
+                while (el) {
+                    var modelInfo = el.__ecComponentInfo;
+                    if (modelInfo != null) {
+                        return ecInstance._model.getComponent(modelInfo.mainType, modelInfo.index);
+                    }
+                    el = el.parent;
+                }
+            }
+        });
+    }
+
     /**
      * @type {Object} key: actionType.
      * @inner
@@ -1501,6 +1508,7 @@ if (typeof __DEV__ === 'undefined') {
     var idBase = new Date() - 0;
     var groupIdBase = new Date() - 0;
     var DOM_ATTRIBUTE_KEY = '_echarts_instance_';
+
     /**
      * @alias module:echarts
      */
@@ -1508,9 +1516,9 @@ if (typeof __DEV__ === 'undefined') {
         /**
          * @type {number}
          */
-        version: '3.5.1',
+        version: '3.6.0',
         dependencies: {
-            zrender: '3.4.1'
+            zrender: '3.5.0'
         }
     };
 
@@ -1577,9 +1585,21 @@ if (typeof __DEV__ === 'undefined') {
                     + echarts.dependencies.zrender + '+'
                 );
             }
+
             if (!dom) {
                 throw new Error('Initialize failed: invalid dom.');
             }
+        }
+
+        var existInstance = echarts.getInstanceByDom(dom);
+        if (existInstance) {
+            if (__DEV__) {
+                console.warn('There is a chart instance already initialized on the dom.');
+            }
+            return existInstance;
+        }
+
+        if (__DEV__) {
             if (zrUtil.isDom(dom)
                 && dom.nodeName.toUpperCase() !== 'CANVAS'
                 && (
@@ -1595,8 +1615,12 @@ if (typeof __DEV__ === 'undefined') {
         chart.id = 'ec_' + idBase++;
         instances[chart.id] = chart;
 
-        dom.setAttribute &&
+        if (dom.setAttribute) {
             dom.setAttribute(DOM_ATTRIBUTE_KEY, chart.id);
+        }
+        else {
+            dom[DOM_ATTRIBUTE_KEY] = chart.id;
+        }
 
         enableConnect(chart);
 
@@ -1644,12 +1668,13 @@ if (typeof __DEV__ === 'undefined') {
      * @param  {module:echarts~ECharts|HTMLDomElement|string} chart
      */
     echarts.dispose = function (chart) {
-        if (zrUtil.isDom(chart)) {
-            chart = echarts.getInstanceByDom(chart);
-        }
-        else if (typeof chart === 'string') {
+        if (typeof chart === 'string') {
             chart = instances[chart];
         }
+        else if (!(chart instanceof ECharts)){
+            // Try to treat as dom
+            chart = echarts.getInstanceByDom(chart);
+        }
         if ((chart instanceof ECharts) && !chart.isDisposed()) {
             chart.dispose();
         }
@@ -1660,9 +1685,16 @@ if (typeof __DEV__ === 'undefined') {
      * @return {echarts~ECharts}
      */
     echarts.getInstanceByDom = function (dom) {
-        var key = dom.getAttribute(DOM_ATTRIBUTE_KEY);
+        var key;
+        if (dom.getAttribute) {
+            key = dom.getAttribute(DOM_ATTRIBUTE_KEY);
+        }
+        else {
+            key = dom[DOM_ATTRIBUTE_KEY];
+        }
         return instances[key];
     };
+
     /**
      * @param {string} key
      * @return {echarts~ECharts}

package/lib/helper.js

@@ -19,14 +19,7 @@
         },
 
         /**
-         * Complete the dimensions array guessed from the data structure.
-         * @param  {Array.<string>} dimensions Necessary dimensions, like ['x', 'y']
-         * @param  {Array} data Data list. [[1, 2, 3], [2, 3, 4]]
-         * @param  {Object} [opt]
-         * @param  {Array.<string>} [opt.defaultNames] Default names to fill not necessary dimensions, like ['value']
-         * @param  {string} [opt.extraPrefix] Prefix of name when filling the left dimensions.
-         * @param  {number} [opt.dimCount] If not specified, guess by the first data item.
-         * @return {Array.<string>}
+         * @see {module:echarts/data/helper/completeDimensions}
          */
         completeDimensions: require('./data/helper/completeDimensions'),
 

package/lib/layout/barGrid.js

@@ -5,29 +5,96 @@
     var numberUtil = require('../util/number');
     var parsePercent = numberUtil.parsePercent;
 
+    var STACK_PREFIX = '__ec_stack_';
+
     function getSeriesStackId(seriesModel) {
-        return seriesModel.get('stack') || '__ec_stack_' + seriesModel.seriesIndex;
+        return seriesModel.get('stack') || STACK_PREFIX + seriesModel.seriesIndex;
     }
 
     function getAxisKey(axis) {
         return axis.dim + axis.index;
     }
 
-    function calBarWidthAndOffset(barSeries, api) {
-        // Columns info on each category axis. Key is cartesian name
-        var columnsMap = {};
+    /**
+     * @param {Object} opt
+     * @param {module:echarts/coord/Axis} opt.axis Only support category axis currently.
+     * @param {number} opt.count Positive interger.
+     * @param {number} [opt.barWidth]
+     * @param {number} [opt.barMaxWidth]
+     * @param {number} [opt.barGap]
+     * @param {number} [opt.barCategoryGap]
+     * @return {Object} {width, offset, offsetCenter} If axis.type is not 'category', return undefined.
+     */
+    function getLayoutOnAxis(opt, api) {
+        var params = [];
+        var baseAxis = opt.axis;
+        var axisKey = 'axis0';
+
+        if (baseAxis.type !== 'category') {
+            return;
+        }
+        var bandWidth = baseAxis.getBandWidth();
+
+        for (var i = 0; i < opt.count || 0; i++) {
+            params.push(zrUtil.defaults({
+                bandWidth: bandWidth,
+                axisKey: axisKey,
+                stackId: STACK_PREFIX + i
+            }, opt));
+        }
+        var widthAndOffsets = doCalBarWidthAndOffset(params, api);
+
+        var result = [];
+        for (var i = 0; i < opt.count; i++) {
+            var item = widthAndOffsets[axisKey][STACK_PREFIX + i];
+            item.offsetCenter = item.offset + item.width / 2;
+            result.push(item);
+        }
 
-        zrUtil.each(barSeries, function (seriesModel, idx) {
+        return result;
+    }
+
+    function calBarWidthAndOffset(barSeries, api) {
+        var seriesInfoList = zrUtil.map(barSeries, function (seriesModel) {
             var data = seriesModel.getData();
             var cartesian = seriesModel.coordinateSystem;
-
             var baseAxis = cartesian.getBaseAxis();
             var axisExtent = baseAxis.getExtent();
             var bandWidth = baseAxis.type === 'category'
                 ? baseAxis.getBandWidth()
                 : (Math.abs(axisExtent[1] - axisExtent[0]) / data.count());
 
-            var columnsOnAxis = columnsMap[getAxisKey(baseAxis)] || {
+            var barWidth = parsePercent(
+                seriesModel.get('barWidth'), bandWidth
+            );
+            var barMaxWidth = parsePercent(
+                seriesModel.get('barMaxWidth'), bandWidth
+            );
+            var barGap = seriesModel.get('barGap');
+            var barCategoryGap = seriesModel.get('barCategoryGap');
+
+            return {
+                bandWidth: bandWidth,
+                barWidth: barWidth,
+                barMaxWidth: barMaxWidth,
+                barGap: barGap,
+                barCategoryGap: barCategoryGap,
+                axisKey: getAxisKey(baseAxis),
+                stackId: getSeriesStackId(seriesModel)
+            };
+        });
+
+        return doCalBarWidthAndOffset(seriesInfoList, api);
+    }
+
+    function doCalBarWidthAndOffset(seriesInfoList, api) {
+        // Columns info on each category axis. Key is cartesian name
+        var columnsMap = {};
+
+        zrUtil.each(seriesInfoList, function (seriesInfo, idx) {
+            var axisKey = seriesInfo.axisKey;
+            var bandWidth = seriesInfo.bandWidth;
+            var columnsOnAxis = columnsMap[axisKey] || {
                 bandWidth: bandWidth,
                 remainedWidth: bandWidth,
                 autoWidthCount: 0,
@@ -36,9 +103,9 @@
                 stacks: {}
             };
             var stacks = columnsOnAxis.stacks;
-            columnsMap[getAxisKey(baseAxis)] = columnsOnAxis;
+            columnsMap[axisKey] = columnsOnAxis;
 
-            var stackId = getSeriesStackId(seriesModel);
+            var stackId = seriesInfo.stackId;
 
             if (!stacks[stackId]) {
                 columnsOnAxis.autoWidthCount++;
@@ -48,29 +115,24 @@
                 maxWidth: 0
             };
 
-            var barWidth = parsePercent(
-                seriesModel.get('barWidth'), bandWidth
-            );
-            var barMaxWidth = parsePercent(
-                seriesModel.get('barMaxWidth'), bandWidth
-            );
-            var barGap = seriesModel.get('barGap');
-            var barCategoryGap = seriesModel.get('barCategoryGap');
-
             // Caution: In a single coordinate system, these barGrid attributes
             // will be shared by series. Consider that they have default values,
             // only the attributes set on the last series will work.
             // Do not change this fact unless there will be a break change.
 
             // TODO
+            var barWidth = seriesInfo.barWidth;
             if (barWidth && !stacks[stackId].width) {
                 barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
                 stacks[stackId].width = barWidth;
                 columnsOnAxis.remainedWidth -= barWidth;
             }
 
+            var barMaxWidth = seriesInfo.barMaxWidth;
             barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+            var barGap = seriesInfo.barGap;
             (barGap != null) && (columnsOnAxis.gap = barGap);
+            var barCategoryGap = seriesInfo.barCategoryGap;
             (barCategoryGap != null) && (columnsOnAxis.categoryGap = barCategoryGap);
         });
 
@@ -94,8 +156,11 @@
             // Find if any auto calculated bar exceeded maxBarWidth
             zrUtil.each(stacks, function (column, stack) {
                 var maxWidth = column.maxWidth;
-                if (!column.width && maxWidth && maxWidth < autoWidth) {
+                if (maxWidth && maxWidth < autoWidth) {
                     maxWidth = Math.min(maxWidth, remainedWidth);
+                    if (column.width) {
+                        maxWidth = Math.min(maxWidth, column.width);
+                    }
                     remainedWidth -= maxWidth;
                     column.width = maxWidth;
                     autoWidthCount--;
@@ -157,6 +222,11 @@
 
         ecModel.eachSeriesByType(seriesType, function (seriesModel) {
 
+            // Check series coordinate, do layout for cartesian2d only
+            if (seriesModel.coordinateSystem.type !== 'cartesian2d') {
+                return;
+            }
+
             var data = seriesModel.getData();
             var cartesian = seriesModel.coordinateSystem;
             var baseAxis = cartesian.getBaseAxis();
@@ -243,4 +313,6 @@
         }, this);
     }
 
+    barLayoutGrid.getLayoutOnAxis = getLayoutOnAxis;
+
     module.exports = barLayoutGrid;