echarts 3.5.1 → 3.6.0

package/src/component/helper/RoamController.js

@@ -1,7 +1,6 @@
 /**
  * @module echarts/component/helper/RoamController
  */
-
 define(function (require) {
 
     var Eventful = require('zrender/mixin/Eventful');
@@ -9,157 +8,29 @@ define(function (require) {
     var eventTool = require('zrender/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 @@ define(function (require) {
         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 @@ define(function (require) {
          * @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,5 +111,95 @@ define(function (require) {
 
     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']);
+    }
+
     return RoamController;
 });

package/src/component/helper/brushHelper.js

@@ -0,0 +1,41 @@
+define(function (require) {
+
+    var cursorHelper = require('./cursorHelper');
+    var BoundingRect = require('zrender/core/BoundingRect');
+    var graphicUtil = require('../../util/graphic');
+
+    var helper = {};
+
+    helper.makeRectPanelClipPath = function (rect) {
+        rect = normalizeRect(rect);
+        return function (localPoints, transform) {
+            return graphicUtil.clipPointsByRect(localPoints, rect);
+        };
+    };
+
+    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.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);
+        };
+    };
+
+    // Consider width/height is negative.
+    function normalizeRect(rect) {
+        return BoundingRect.create(rect);
+    }
+
+    return helper;
+
+});

package/src/component/helper/cursorHelper.js

@@ -0,0 +1,22 @@
+define(function (require) {
+
+    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);
+    };
+
+    return helper;
+});

package/src/component/helper/roamHelper.js

@@ -0,0 +1,55 @@
+define(function (require) {
+
+    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();
+    };
+
+    return helper;
+});

package/src/component/helper/selectableMixin.js

@@ -13,9 +13,9 @@ define(function (require) {
 
         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 @@ define(function (require) {
         // 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 @@ define(function (require) {
          * @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 @@ define(function (require) {
          * @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 @@ define(function (require) {
          * @param {string} name
          */
         isSelected: function (name) {
-            var target = this._selectTargetMap[name];
+            var target = this._selectTargetMap.get(name);
             return target && target.selected;
         }
     };

package/src/component/helper/sliderMove.js

@@ -2,53 +2,82 @@ define(function (require) {
 
     /**
      * Calculate slider move result.
+     * Usage:
+     * (1) If both handle0 and handle1 are needed to be moved, set minSpan the same as
+     * maxSpan and the same as `Math.abs(handleEnd[1] - handleEnds[0])`.
+     * (2) If handle0 is forbidden to cross handle1, set minSpan as `0`.
      *
      * @param {number} delta Move length.
-     * @param {Array.<number>} handleEnds handleEnds[0] and be bigger then handleEnds[1].
-     *                                    handleEnds will be modified in this method.
+     * @param {Array.<number>} handleEnds handleEnds[0] can be bigger then handleEnds[1].
+     *              handleEnds will be modified in this method.
      * @param {Array.<number>} extent handleEnds is restricted by extent.
-     *                                extent[0] should less or equals than extent[1].
-     * @param {string} mode 'rigid': Math.abs(handleEnds[0] - handleEnds[1]) remain unchanged,
-     *                      'cross' handleEnds[0] can be bigger then handleEnds[1],
-     *                      'push' handleEnds[0] can not be bigger then handleEnds[1],
-     *                              when they touch, one push other.
-     * @param {number} handleIndex If mode is 'rigid', handleIndex is not required.
-     * @param {Array.<number>} The input handleEnds.
+     *              extent[0] should less or equals than extent[1].
+     * @param {number|string} handleIndex Can be 'all', means that both move the two handleEnds,
+     *              where the input minSpan and maxSpan will not work.
+     * @param {number} [minSpan] The range of dataZoom can not be smaller than that.
+     *              If not set, handle0 and cross handle1. If set as a non-negative
+     *              number (including `0`), handles will push each other when reaching
+     *              the minSpan.
+     * @param {number} [maxSpan] The range of dataZoom can not be larger than that.
+     * @return {Array.<number>} The input handleEnds.
      */
-    return function (delta, handleEnds, extent, mode, handleIndex) {
-        if (!delta) {
-            return handleEnds;
+    return function (delta, handleEnds, extent, handleIndex, minSpan, maxSpan) {
+        // Normalize firstly.
+        handleEnds[0] = restrict(handleEnds[0], extent);
+        handleEnds[1] = restrict(handleEnds[1], extent);
+
+        delta = delta || 0;
+
+        var extentSpan = extent[1] - extent[0];
+
+        // Notice maxSpan and minSpan can be null/undefined.
+        if (minSpan != null) {
+            minSpan = restrict(minSpan, [0, extentSpan]);
         }
+        if (maxSpan != null) {
+            maxSpan = Math.max(maxSpan, minSpan != null ? minSpan : 0);
+        }
+        if (handleIndex === 'all') {
+            minSpan = maxSpan = Math.abs(handleEnds[1] - handleEnds[0]);
+            handleIndex = 0;
+        }
+
+        var originalDistSign = getSpanSign(handleEnds, handleIndex);
 
-        if (mode === 'rigid') {
-            delta = getRealDelta(delta, handleEnds, extent);
-            handleEnds[0] += delta;
-            handleEnds[1] += delta;
+        handleEnds[handleIndex] += delta;
+
+        // Restrict in extent.
+        var extentMinSpan = minSpan || 0;
+        var realExtent = extent.slice();
+        originalDistSign.sign < 0 ? (realExtent[0] += extentMinSpan) : (realExtent[1] -= extentMinSpan);
+        handleEnds[handleIndex] = restrict(handleEnds[handleIndex], realExtent);
+
+        // Expand span.
+        var currDistSign = getSpanSign(handleEnds, handleIndex);
+        if (minSpan != null && (
+            currDistSign.sign !== originalDistSign.sign || currDistSign.span < minSpan
+        )) {
+            // If minSpan exists, 'cross' is forbinden.
+            handleEnds[1 - handleIndex] = handleEnds[handleIndex] + originalDistSign.sign * minSpan;
         }
-        else {
-            delta = getRealDelta(delta, handleEnds[handleIndex], extent);
-            handleEnds[handleIndex] += delta;
 
-            if (mode === 'push' && handleEnds[0] > handleEnds[1]) {
-                handleEnds[1 - handleIndex] = handleEnds[handleIndex];
-            }
+        // Shrink span.
+        var currDistSign = getSpanSign(handleEnds, handleIndex);
+        if (maxSpan != null && currDistSign.span > maxSpan) {
+            handleEnds[1 - handleIndex] = handleEnds[handleIndex] + currDistSign.sign * maxSpan;
         }
 
         return handleEnds;
-
-        function getRealDelta(delta, handleEnds, extent) {
-            var handleMinMax = !handleEnds.length
-                ? [handleEnds, handleEnds]
-                : handleEnds.slice();
-            handleEnds[0] > handleEnds[1] && handleMinMax.reverse();
-
-            if (delta < 0 && handleMinMax[0] + delta < extent[0]) {
-                delta = extent[0] - handleMinMax[0];
-            }
-            if (delta > 0 && handleMinMax[1] + delta > extent[1]) {
-                delta = extent[1] - handleMinMax[1];
-            }
-            return delta;
-        }
     };
+
+    function getSpanSign(handleEnds, handleIndex) {
+        var dist = handleEnds[handleIndex] - handleEnds[1 - handleIndex];
+        // If `handleEnds[0] === handleEnds[1]`, always believe that handleEnd[0]
+        // is at left of handleEnds[1] for non-cross case.
+        return {span: Math.abs(dist), sign: dist > 0 ? -1 : dist < 0 ? 1 : handleIndex ? -1 : 1};
+    }
+
+    function restrict(value, extend) {
+        return Math.min(extend[1], Math.max(extend[0], value));
+    }
 });

package/src/component/legend/LegendView.js

@@ -63,7 +63,7 @@ define(function (require) {
                     ? 'right' : 'left';
             }
 
-            var legendDrawedMap = {};
+            var legendDrawedMap = zrUtil.createHashMap();
 
             zrUtil.each(legendModel.getData(), function (itemModel) {
                 var name = itemModel.get('name');
@@ -78,7 +78,7 @@ define(function (require) {
 
                 var seriesModel = ecModel.getSeriesByName(name)[0];
 
-                if (legendDrawedMap[name]) {
+                if (legendDrawedMap.get(name)) {
                     // Have been drawed
                     return;
                 }
@@ -109,13 +109,13 @@ define(function (require) {
                         .on('mouseover', curry(dispatchHighlightAction, seriesModel, null, api))
                         .on('mouseout', curry(dispatchDownplayAction, seriesModel, null, api));
 
-                    legendDrawedMap[name] = true;
+                    legendDrawedMap.set(name, true);
                 }
                 else {
                     // Data legend of pie, funnel
                     ecModel.eachRawSeries(function (seriesModel) {
                         // In case multiple series has same data name
-                        if (legendDrawedMap[name]) {
+                        if (legendDrawedMap.get(name)) {
                             return;
                         }
                         if (seriesModel.legendDataProvider) {
@@ -141,13 +141,13 @@ define(function (require) {
                                 .on('mouseover', curry(dispatchHighlightAction, seriesModel, name, api))
                                 .on('mouseout', curry(dispatchDownplayAction, seriesModel, name, api));
 
-                            legendDrawedMap[name] = true;
+                            legendDrawedMap.set(name, true);
                         }
                     }, this);
                 }
 
                 if (__DEV__) {
-                    if (!legendDrawedMap[name]) {
+                    if (!legendDrawedMap.get(name)) {
                         console.warn(name + ' series not exists. Legend data should be same with series name or data name.');
                     }
                 }

package/src/component/legend/legendAction.js

@@ -31,7 +31,7 @@ define(function(require) {
                     return;
                 }
                 var isItemSelected = legendModel.isSelected(name);
-                if (name in selectedMap) {
+                if (selectedMap.hasOwnProperty(name)) {
                     // Unselected if any legend is unselected
                     selectedMap[name] = selectedMap[name] && isItemSelected;
                 }

package/src/component/marker/MarkAreaView.js

@@ -155,12 +155,9 @@ define(function (require) {
             var seriesData = seriesModel.getData();
 
             var areaGroupMap = this.markerGroupMap;
-            var polygonGroup = areaGroupMap[seriesName];
-            if (!polygonGroup) {
-                polygonGroup = areaGroupMap[seriesName] = {
-                    group: new graphic.Group()
-                };
-            }
+            var polygonGroup = areaGroupMap.get(seriesName)
+                || areaGroupMap.set(seriesName, {group: new graphic.Group()});
+
             this.group.add(polygonGroup.group);
             polygonGroup.__keep = true;