echarts 3.5.1 → 3.6.0

package/lib/component/helper/RoamController.js

@@ -3,163 +3,34 @@
  */
 
 
-
     var Eventful = require('zrender/lib/mixin/Eventful');
     var zrUtil = require('zrender/lib/core/util');
     var eventTool = require('zrender/lib/core/event');
     var interactionMutex = require('./interactionMutex');
 
-    function mousedown(e) {
-        if (e.target && e.target.draggable) {
-            return;
-        }
-
-        var x = e.offsetX;
-        var y = e.offsetY;
-
-        if (this.containsPoint && this.containsPoint(x, y)) {
-            this._x = x;
-            this._y = y;
-            this._dragging = true;
-        }
-    }
-
-    function mousemove(e) {
-        if (!this._dragging) {
-            return;
-        }
-
-        eventTool.stop(e.event);
-
-        if (e.gestureEvent !== 'pinch') {
-
-            if (interactionMutex.isTaken(this._zr, 'globalPan')) {
-                return;
-            }
-
-            var x = e.offsetX;
-            var y = e.offsetY;
-
-            var oldX = this._x;
-            var oldY = this._y;
-
-            var dx = x - oldX;
-            var dy = y - oldY;
-
-            this._x = x;
-            this._y = y;
-
-            var target = this.target;
-
-            if (target) {
-                var pos = target.position;
-                pos[0] += dx;
-                pos[1] += dy;
-                target.dirty();
-            }
-
-            eventTool.stop(e.event);
-            this.trigger('pan', dx, dy, oldX, oldY, x, y);
-        }
-    }
-
-    function mouseup(e) {
-        this._dragging = false;
-    }
-
-    function mousewheel(e) {
-        // wheelDelta maybe -0 in chrome mac.
-        if (e.wheelDelta === 0) {
-            return;
-        }
-        // Convenience:
-        // Mac and VM Windows on Mac: scroll up: zoom out.
-        // Windows: scroll up: zoom in.
-        var zoomDelta = e.wheelDelta > 0 ? 1.1 : 1 / 1.1;
-        zoom.call(this, e, zoomDelta, e.offsetX, e.offsetY);
-    }
-
-    function pinch(e) {
-        if (interactionMutex.isTaken(this._zr, 'globalPan')) {
-            return;
-        }
-        var zoomDelta = e.pinchScale > 1 ? 1.1 : 1 / 1.1;
-        zoom.call(this, e, zoomDelta, e.pinchX, e.pinchY);
-    }
-
-    function zoom(e, zoomDelta, zoomX, zoomY) {
-        if (this.containsPoint && this.containsPoint(zoomX, zoomY)) {
-            // When mouse is out of roamController rect,
-            // default befavoius should be be disabled, otherwise
-            // page sliding is disabled, contrary to expectation.
-            eventTool.stop(e.event);
-
-            var target = this.target;
-            var zoomLimit = this.zoomLimit;
-
-            if (target) {
-                var pos = target.position;
-                var scale = target.scale;
-
-                var newZoom = this.zoom = this.zoom || 1;
-                newZoom *= zoomDelta;
-                if (zoomLimit) {
-                    var zoomMin = zoomLimit.min || 0;
-                    var zoomMax = zoomLimit.max || Infinity;
-                    newZoom = Math.max(
-                        Math.min(zoomMax, newZoom),
-                        zoomMin
-                    );
-                }
-                var zoomScale = newZoom / this.zoom;
-                this.zoom = newZoom;
-                // Keep the mouse center when scaling
-                pos[0] -= (zoomX - pos[0]) * (zoomScale - 1);
-                pos[1] -= (zoomY - pos[1]) * (zoomScale - 1);
-                scale[0] *= zoomScale;
-                scale[1] *= zoomScale;
-
-                target.dirty();
-            }
-
-            this.trigger('zoom', zoomDelta, zoomX, zoomY);
-        }
-    }
-
     /**
      * @alias module:echarts/component/helper/RoamController
      * @constructor
      * @mixin {module:zrender/mixin/Eventful}
      *
      * @param {module:zrender/zrender~ZRender} zr
-     * @param {module:zrender/Element} target
      */
-    function RoamController(zr, target) {
-
-        /**
-         * @type {module:zrender/Element}
-         */
-        this.target = target;
+    function RoamController(zr) {
 
         /**
          * @type {Function}
          */
-        this.containsPoint;
+        this.pointerChecker;
 
         /**
-         * { min: 1, max: 2 }
-         * @type {Object}
+         * @type {module:zrender}
          */
-        this.zoomLimit;
+        this._zr = zr;
 
         /**
-         * @type {number}
-         */
-        this.zoom;
-        /**
-         * @type {module:zrender}
+         * @type {Object}
          */
-        this._zr = zr;
+        this._opt = {};
 
         // Avoid two roamController bind the same handler
         var bind = zrUtil.bind;
@@ -172,12 +43,12 @@
         Eventful.call(this);
 
         /**
-         * @param {Function} containsPoint
+         * @param {Function} pointerChecker
          *                   input: x, y
          *                   output: boolean
          */
-        this.setContainsPoint = function (containsPoint) {
-            this.containsPoint = containsPoint;
+        this.setPointerChecker = function (pointerChecker) {
+            this.pointerChecker = pointerChecker;
         };
 
         /**
@@ -188,11 +59,22 @@
          * @param  {boolean|string} [controlType=true] Specify the control type,
          *                          which can be null/undefined or true/false
          *                          or 'pan/move' or 'zoom'/'scale'
+         * @param {Object} [opt]
+         * @param {Object} [opt.zoomOnMouseWheel=true]
+         * @param {Object} [opt.moveOnMouseMove=true]
+         * @param {Object} [opt.preventDefaultMouseMove=true] When pan.
          */
-        this.enable = function (controlType) {
+        this.enable = function (controlType, opt) {
+
             // Disable previous first
             this.disable();
 
+            this._opt = zrUtil.defaults(zrUtil.clone(opt) || {}, {
+                zoomOnMouseWheel: true,
+                moveOnMouseMove: true,
+                preventDefaultMouseMove: true
+            });
+
             if (controlType == null) {
                 controlType = true;
             }
@@ -229,4 +111,94 @@
 
     zrUtil.mixin(RoamController, Eventful);
 
+
+    function mousedown(e) {
+        if (e.target && e.target.draggable) {
+            return;
+        }
+
+        var x = e.offsetX;
+        var y = e.offsetY;
+
+        // Only check on mosedown, but not mousemove.
+        // Mouse can be out of target when mouse moving.
+        if (this.pointerChecker && this.pointerChecker(e, x, y)) {
+            this._x = x;
+            this._y = y;
+            this._dragging = true;
+        }
+    }
+
+    function mousemove(e) {
+        if (!checkKeyBinding(this, 'moveOnMouseMove', e) || !this._dragging) {
+            return;
+        }
+
+        if (e.gestureEvent === 'pinch') {
+            return;
+        }
+
+        if (interactionMutex.isTaken(this._zr, 'globalPan')) {
+            return;
+        }
+
+        var x = e.offsetX;
+        var y = e.offsetY;
+
+        var oldX = this._x;
+        var oldY = this._y;
+
+        var dx = x - oldX;
+        var dy = y - oldY;
+
+        this._x = x;
+        this._y = y;
+
+        this._opt.preventDefaultMouseMove && eventTool.stop(e.event);
+
+        this.trigger('pan', dx, dy, oldX, oldY, x, y);
+    }
+
+    function mouseup(e) {
+        this._dragging = false;
+    }
+
+    function mousewheel(e) {
+        // wheelDelta maybe -0 in chrome mac.
+        if (!checkKeyBinding(this, 'zoomOnMouseWheel', e) || e.wheelDelta === 0) {
+            return;
+        }
+
+        // Convenience:
+        // Mac and VM Windows on Mac: scroll up: zoom out.
+        // Windows: scroll up: zoom in.
+        var zoomDelta = e.wheelDelta > 0 ? 1.1 : 1 / 1.1;
+        zoom.call(this, e, zoomDelta, e.offsetX, e.offsetY);
+    }
+
+    function pinch(e) {
+        if (interactionMutex.isTaken(this._zr, 'globalPan')) {
+            return;
+        }
+        var zoomDelta = e.pinchScale > 1 ? 1.1 : 1 / 1.1;
+        zoom.call(this, e, zoomDelta, e.pinchX, e.pinchY);
+    }
+
+    function zoom(e, zoomDelta, zoomX, zoomY) {
+        if (this.pointerChecker && this.pointerChecker(e, zoomX, zoomY)) {
+            // When mouse is out of roamController rect,
+            // default befavoius should not be be disabled, otherwise
+            // page sliding is disabled, contrary to expectation.
+            eventTool.stop(e.event);
+
+            this.trigger('zoom', zoomDelta, zoomX, zoomY);
+        }
+    }
+
+    function checkKeyBinding(roamController, prop, e) {
+        var setting = roamController._opt[prop];
+        return setting
+            && (!zrUtil.isString(setting) || e.event[setting + 'Key']);
+    }
+
     module.exports = RoamController;

package/lib/component/helper/brushHelper.js

@@ -1,228 +1,40 @@
 
 
-    var zrUtil = require('zrender/lib/core/util');
-    var graphic = require('../../util/graphic');
-
-    var each = zrUtil.each;
+    var cursorHelper = require('./cursorHelper');
+    var BoundingRect = require('zrender/lib/core/BoundingRect');
+    var graphicUtil = require('../../util/graphic');
 
     var helper = {};
 
-    var COMPONENT_NAMES = ['geo', 'xAxis', 'yAxis'];
-    var PANEL_ID_SPLIT = '--';
-    var COORD_CONVERTS = ['dataToPoint', 'pointToData'];
-
-    helper.parseOutputRanges = function (areas, coordInfoList, ecModel, rangesCoordInfo) {
-        each(areas, function (area, index) {
-            var panelId = area.panelId;
-
-            if (panelId) {
-                panelId = panelId.split(PANEL_ID_SPLIT);
-
-                area[panelId[0] + 'Index'] = +panelId[1];
-
-                var coordInfo = findCoordInfo(area, coordInfoList);
-                area.coordRange = coordConvert[area.brushType](
-                    1, coordInfo, area.range
-                );
-                rangesCoordInfo && (rangesCoordInfo[index] = coordInfo);
-            }
-        });
-    };
-
-    helper.parseInputRanges = function (brushModel, ecModel) {
-        each(brushModel.areas, function (area) {
-            var coordInfo = findCoordInfo(area, brushModel.coordInfoList);
-
-            if (__DEV__) {
-                zrUtil.assert(
-                    !coordInfo || coordInfo === true || area.coordRange,
-                    'coordRange must be specified when coord index specified.'
-                );
-                zrUtil.assert(
-                    !coordInfo || coordInfo !== true || area.range,
-                    'range must be specified.'
-                );
-            }
-
-            area.range = area.range || [];
-
-            // convert coordRange to global range and set panelId.
-            if (coordInfo && coordInfo !== true) {
-                area.range = coordConvert[area.brushType](
-                    0, coordInfo, area.coordRange
-                );
-                area.panelId = coordInfo.panelId;
-            }
-        });
+    helper.makeRectPanelClipPath = function (rect) {
+        rect = normalizeRect(rect);
+        return function (localPoints, transform) {
+            return graphicUtil.clipPointsByRect(localPoints, rect);
+        };
     };
 
-    helper.makePanelOpts = function (coordInfoList) {
-        var panelOpts = [];
-
-        each(coordInfoList, function (coordInfo) {
-            var coordSys = coordInfo.coordSys;
-            var rect;
-
-            if (coordInfo.geoIndex >= 0) {
-                rect = coordSys.getBoundingRect().clone();
-                // geo roam and zoom transform
-                rect.applyTransform(graphic.getTransform(coordSys));
-            }
-            else { // xAxis or yAxis
-                // grid is not Transformable.
-                rect = coordSys.grid.getRect().clone();
-            }
-
-            panelOpts.push({panelId: coordInfo.panelId, rect: rect});
-        });
-
-        return panelOpts;
-    };
-
-    /**
-     * @param {Object} option {xAxisIndex, yAxisIndex, geoIndex}
-     * @param {module:echarts/model/Global} ecModel
-     * @return {Array.<Obejct>} coordInfoList
-     */
-    helper.makeCoordInfoList = function (option, ecModel) {
-        var coordInfoList = [];
-
-        each(COMPONENT_NAMES, function (componentName) {
-            var componentIndices = option[componentName + 'Index'];
-            if (componentIndices == null || componentIndices === 'none') {
-                return;
-            }
-            if (componentIndices !== 'all' && !zrUtil.isArray(componentIndices)) {
-                componentIndices = [componentIndices];
-            }
-
-            ecModel.eachComponent({mainType: componentName}, function (componentModel, index) {
-                if (componentIndices !== 'all' && zrUtil.indexOf(componentIndices, index) < 0) {
-                    return;
-                }
-
-                var grid;
-                var coordSys;
-
-                (componentName === 'xAxis' || componentName === 'yAxis')
-                    ? (grid = componentModel.axis.grid)
-                    : (coordSys = componentModel.coordinateSystem); // geo
-
-                var coordInfo;
-
-                // Check duplicate and find cartesian when tranval to yAxis.
-                for (var i = 0, len = coordInfoList.length; i < len; i++) {
-                    var cInfo = coordInfoList[i];
-                    if (__DEV__) {
-                        zrUtil.assert(
-                            cInfo[componentName + 'Index'] != index,
-                            'Coord should not be defined duplicately: ' + componentName + index
-                        );
-                    }
-                    // CoordSys is always required for `rect brush` or `polygon brush`.
-                    // If both xAxisIndex and yAxisIndex specified, fetch cartesian by them.
-                    if (componentName === 'yAxis' && !cInfo.yAxis && cInfo.xAxis) {
-                        var aCoordSys = grid.getCartesian(cInfo.xAxisIndex, index);
-                        if (aCoordSys) { // The yAxis and xAxis are in the same cartesian.
-                            coordSys = aCoordSys;
-                            coordInfo = cInfo;
-                            break;
-                        }
-                    }
-                }
-
-                !coordInfo && coordInfoList.push(coordInfo = {});
-
-                coordInfo[componentName] = componentModel;
-                coordInfo[componentName + 'Index'] = index;
-                // If both xAxisIndex and yAxisIndex specified, panelId only use yAxisIndex,
-                // which is enough to index panel.
-                coordInfo.panelId = componentName + PANEL_ID_SPLIT + index;
-                coordInfo.coordSys = coordSys
-                    // If only xAxisIndex or only yAxisIndex specified, find its first cartesian.
-                    || grid.getCartesian(coordInfo.xAxisIndex, coordInfo.yAxisIndex);
-
-                coordInfo.coordSys
-                    ? (coordInfoList[componentName + 'Has'] = true)
-                    : coordInfoList.pop(); // If a coordInfo exists originally, existance of coordSys is ensured.
-            });
-        });
-
-        return coordInfoList;
+    helper.makeLinearBrushOtherExtent = function (rect, specifiedXYIndex) {
+        rect = normalizeRect(rect);
+        return function (xyIndex) {
+            var idx = specifiedXYIndex != null ? specifiedXYIndex : xyIndex;
+            var brushWidth = idx ? rect.width : rect.height;
+            var base = idx ? rect.x : rect.y;
+            return [base, base + (brushWidth || 0)];
+        };
     };
 
-    helper.controlSeries = function (area, brushModel, seriesModel) {
-        // Check whether area is bound in coord, and series do not belong to that coord.
-        // If do not do this check, some brush (like lineX) will controll all axes.
-        var coordInfo = findCoordInfo(area, brushModel.coordInfoList);
-        return coordInfo === true || (coordInfo && coordInfo.coordSys === seriesModel.coordinateSystem);
+    helper.makeRectIsTargetByCursor = function (rect, api, targetModel) {
+        rect = normalizeRect(rect);
+        return function (e, localCursorPoint, transform) {
+            return rect.contain(localCursorPoint[0], localCursorPoint[1])
+                && !cursorHelper.onIrrelevantElement(e, api, targetModel);
+        };
     };
 
-    function formatMinMax(minMax) {
-        minMax[0] > minMax[1] && minMax.reverse();
-        return minMax;
+    // Consider width/height is negative.
+    function normalizeRect(rect) {
+        return BoundingRect.create(rect);
     }
 
-    /**
-     * If return Object, a coord found.
-     * If reutrn true, global found.
-     * Otherwise nothing found.
-     *
-     * @param {Object} area {<componentName>Index}
-     * @param {Array} coordInfoList
-     * @return {Obejct|boolean}
-     */
-    function findCoordInfo(area, coordInfoList) {
-        var isGlobal = true;
-        for (var j = 0; j < COMPONENT_NAMES.length; j++) {
-            var indexAttr = COMPONENT_NAMES[j] + 'Index';
-            if (area[indexAttr] >= 0) {
-                isGlobal = false;
-                for (var i = 0; i < coordInfoList.length; i++) {
-                    if (coordInfoList[i][indexAttr] === area[indexAttr]) {
-                        return coordInfoList[i];
-                    }
-                }
-            }
-        }
-        return isGlobal;
-    }
-
-    function axisConvert(axisName, to, coordInfo, coordRange) {
-        var axis = coordInfo.coordSys.getAxis(axisName);
-
-        if (__DEV__) {
-            zrUtil.assert(axis, 'line brush is only available in cartesian (grid).');
-        }
-
-        return formatMinMax(zrUtil.map([0, 1], function (i) {
-            return to
-                ? axis.coordToData(axis.toLocalCoord(coordRange[i]))
-                : axis.toGlobalCoord(axis.dataToCoord(coordRange[i]));
-        }));
-    }
-
-    var coordConvert = {
-
-        lineX: zrUtil.curry(axisConvert, 'x'),
-
-        lineY: zrUtil.curry(axisConvert, 'y'),
-
-        rect: function (to, coordInfo, coordRange) {
-            var coordSys = coordInfo.coordSys;
-            var xminymin = coordSys[COORD_CONVERTS[to]]([coordRange[0][0], coordRange[1][0]]);
-            var xmaxymax = coordSys[COORD_CONVERTS[to]]([coordRange[0][1], coordRange[1][1]]);
-            return [
-                formatMinMax([xminymin[0], xmaxymax[0]]),
-                formatMinMax([xminymin[1], xmaxymax[1]])
-            ];
-        },
-
-        polygon: function (to, coordInfo, coordRange) {
-            var coordSys = coordInfo.coordSys;
-            return zrUtil.map(coordRange, coordSys[COORD_CONVERTS[to]], coordSys);
-        }
-    };
-
     module.exports = helper;
 

package/lib/component/helper/cursorHelper.js

@@ -0,0 +1,21 @@
+
+
+    var helper = {};
+
+    var IRRELEVANT_EXCLUDES = {'axisPointer': 1, 'tooltip': 1, 'brush': 1};
+
+    /**
+     * Avoid that: mouse click on a elements that is over geo or graph,
+     * but roam is triggered.
+     */
+    helper.onIrrelevantElement = function (e, api, targetCoordSysModel) {
+        var model = api.getComponentByElement(e.topTarget);
+        // If model is axisModel, it works only if it is injected with coordinateSystem.
+        var coordSys = model && model.coordinateSystem;
+        return model
+            && model !== targetCoordSysModel
+            && !IRRELEVANT_EXCLUDES[model.mainType]
+            && (coordSys && coordSys.model !== targetCoordSysModel);
+    };
+
+    module.exports = helper;

package/lib/component/helper/roamHelper.js

@@ -0,0 +1,54 @@
+
+
+    var helper = {};
+
+    /**
+     * For geo and graph.
+     *
+     * @param {Object} controllerHost
+     * @param {module:zrender/Element} controllerHost.target
+     */
+    helper.updateViewOnPan = function (controllerHost, dx, dy) {
+        var target = controllerHost.target;
+        var pos = target.position;
+        pos[0] += dx;
+        pos[1] += dy;
+        target.dirty();
+    };
+
+    /**
+     * For geo and graph.
+     *
+     * @param {Object} controllerHost
+     * @param {module:zrender/Element} controllerHost.target
+     * @param {number} controllerHost.zoom
+     * @param {number} controllerHost.zoomLimit like: {min: 1, max: 2}
+     */
+    helper.updateViewOnZoom = function (controllerHost, zoomDelta, zoomX, zoomY) {
+        var target = controllerHost.target;
+        var zoomLimit = controllerHost.zoomLimit;
+        var pos = target.position;
+        var scale = target.scale;
+
+        var newZoom = controllerHost.zoom = controllerHost.zoom || 1;
+        newZoom *= zoomDelta;
+        if (zoomLimit) {
+            var zoomMin = zoomLimit.min || 0;
+            var zoomMax = zoomLimit.max || Infinity;
+            newZoom = Math.max(
+                Math.min(zoomMax, newZoom),
+                zoomMin
+            );
+        }
+        var zoomScale = newZoom / controllerHost.zoom;
+        controllerHost.zoom = newZoom;
+        // Keep the mouse center when scaling
+        pos[0] -= (zoomX - pos[0]) * (zoomScale - 1);
+        pos[1] -= (zoomY - pos[1]) * (zoomScale - 1);
+        scale[0] *= zoomScale;
+        scale[1] *= zoomScale;
+
+        target.dirty();
+    };
+
+    module.exports = helper;

package/lib/component/helper/selectableMixin.js

@@ -13,9 +13,9 @@
 
         updateSelectedMap: function (targetList) {
             this._selectTargetMap = zrUtil.reduce(targetList || [], function (targetMap, target) {
-                targetMap[target.name] = target;
+                targetMap.set(target.name, target);
                 return targetMap;
-            }, {});
+            }, zrUtil.createHashMap());
         },
         /**
          * @param {string} name
@@ -23,10 +23,10 @@
         // PENGING If selectedMode is null ?
         select: function (name) {
             var targetMap = this._selectTargetMap;
-            var target = targetMap[name];
+            var target = targetMap.get(name);
             var selectedMode = this.get('selectedMode');
             if (selectedMode === 'single') {
-                zrUtil.each(targetMap, function (target) {
+                targetMap.each(function (target) {
                     target.selected = false;
                 });
             }
@@ -37,7 +37,7 @@
          * @param {string} name
          */
         unSelect: function (name) {
-            var target = this._selectTargetMap[name];
+            var target = this._selectTargetMap.get(name);
             // var selectedMode = this.get('selectedMode');
             // selectedMode !== 'single' && target && (target.selected = false);
             target && (target.selected = false);
@@ -47,7 +47,7 @@
          * @param {string} name
          */
         toggleSelected: function (name) {
-            var target = this._selectTargetMap[name];
+            var target = this._selectTargetMap.get(name);
             if (target != null) {
                 this[target.selected ? 'unSelect' : 'select'](name);
                 return target.selected;
@@ -58,7 +58,7 @@
          * @param {string} name
          */
         isSelected: function (name) {
-            var target = this._selectTargetMap[name];
+            var target = this._selectTargetMap.get(name);
             return target && target.selected;
         }
     };