|
/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
|
/**
|
* AUTO-GENERATED FILE. DO NOT MODIFY.
|
*/
|
|
/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
import * as pathTool from 'zrender/lib/tool/path.js';
|
import * as matrix from 'zrender/lib/core/matrix.js';
|
import * as vector from 'zrender/lib/core/vector.js';
|
import Path from 'zrender/lib/graphic/Path.js';
|
import Transformable from 'zrender/lib/core/Transformable.js';
|
import ZRImage from 'zrender/lib/graphic/Image.js';
|
import Group from 'zrender/lib/graphic/Group.js';
|
import ZRText from 'zrender/lib/graphic/Text.js';
|
import Circle from 'zrender/lib/graphic/shape/Circle.js';
|
import Ellipse from 'zrender/lib/graphic/shape/Ellipse.js';
|
import Sector from 'zrender/lib/graphic/shape/Sector.js';
|
import Ring from 'zrender/lib/graphic/shape/Ring.js';
|
import Polygon from 'zrender/lib/graphic/shape/Polygon.js';
|
import Polyline from 'zrender/lib/graphic/shape/Polyline.js';
|
import Rect from 'zrender/lib/graphic/shape/Rect.js';
|
import Line from 'zrender/lib/graphic/shape/Line.js';
|
import BezierCurve from 'zrender/lib/graphic/shape/BezierCurve.js';
|
import Arc from 'zrender/lib/graphic/shape/Arc.js';
|
import CompoundPath from 'zrender/lib/graphic/CompoundPath.js';
|
import LinearGradient from 'zrender/lib/graphic/LinearGradient.js';
|
import RadialGradient from 'zrender/lib/graphic/RadialGradient.js';
|
import BoundingRect from 'zrender/lib/core/BoundingRect.js';
|
import OrientedBoundingRect from 'zrender/lib/core/OrientedBoundingRect.js';
|
import Point from 'zrender/lib/core/Point.js';
|
import IncrementalDisplayable from 'zrender/lib/graphic/IncrementalDisplayable.js';
|
import * as subPixelOptimizeUtil from 'zrender/lib/graphic/helper/subPixelOptimize.js';
|
import { extend, isArrayLike, map, defaults, isString, keys, each, hasOwn, isArray } from 'zrender/lib/core/util.js';
|
import { getECData } from './innerStore.js';
|
import { updateProps, initProps, removeElement, removeElementWithFadeOut, isElementRemoved } from '../animation/basicTransition.js';
|
/**
|
* @deprecated export for compatitable reason
|
*/
|
|
export { updateProps, initProps, removeElement, removeElementWithFadeOut, isElementRemoved };
|
var mathMax = Math.max;
|
var mathMin = Math.min;
|
var _customShapeMap = {};
|
/**
|
* Extend shape with parameters
|
*/
|
|
export function extendShape(opts) {
|
return Path.extend(opts);
|
}
|
var extendPathFromString = pathTool.extendFromString;
|
/**
|
* Extend path
|
*/
|
|
export function extendPath(pathData, opts) {
|
return extendPathFromString(pathData, opts);
|
}
|
/**
|
* Register a user defined shape.
|
* The shape class can be fetched by `getShapeClass`
|
* This method will overwrite the registered shapes, including
|
* the registered built-in shapes, if using the same `name`.
|
* The shape can be used in `custom series` and
|
* `graphic component` by declaring `{type: name}`.
|
*
|
* @param name
|
* @param ShapeClass Can be generated by `extendShape`.
|
*/
|
|
export function registerShape(name, ShapeClass) {
|
_customShapeMap[name] = ShapeClass;
|
}
|
/**
|
* Find shape class registered by `registerShape`. Usually used in
|
* fetching user defined shape.
|
*
|
* [Caution]:
|
* (1) This method **MUST NOT be used inside echarts !!!**, unless it is prepared
|
* to use user registered shapes.
|
* Because the built-in shape (see `getBuiltInShape`) will be registered by
|
* `registerShape` by default. That enables users to get both built-in
|
* shapes as well as the shapes belonging to themsleves. But users can overwrite
|
* the built-in shapes by using names like 'circle', 'rect' via calling
|
* `registerShape`. So the echarts inner featrues should not fetch shapes from here
|
* in case that it is overwritten by users, except that some features, like
|
* `custom series`, `graphic component`, do it deliberately.
|
*
|
* (2) In the features like `custom series`, `graphic component`, the user input
|
* `{tpye: 'xxx'}` does not only specify shapes but also specify other graphic
|
* elements like `'group'`, `'text'`, `'image'` or event `'path'`. Those names
|
* are reserved names, that is, if some user register a shape named `'image'`,
|
* the shape will not be used. If we intending to add some more reserved names
|
* in feature, that might bring break changes (disable some existing user shape
|
* names). But that case probably rearly happen. So we dont make more mechanism
|
* to resolve this issue here.
|
*
|
* @param name
|
* @return The shape class. If not found, return nothing.
|
*/
|
|
export function getShapeClass(name) {
|
if (_customShapeMap.hasOwnProperty(name)) {
|
return _customShapeMap[name];
|
}
|
}
|
/**
|
* Create a path element from path data string
|
* @param pathData
|
* @param opts
|
* @param rect
|
* @param layout 'center' or 'cover' default to be cover
|
*/
|
|
export function makePath(pathData, opts, rect, layout) {
|
var path = pathTool.createFromString(pathData, opts);
|
|
if (rect) {
|
if (layout === 'center') {
|
rect = centerGraphic(rect, path.getBoundingRect());
|
}
|
|
resizePath(path, rect);
|
}
|
|
return path;
|
}
|
/**
|
* Create a image element from image url
|
* @param imageUrl image url
|
* @param opts options
|
* @param rect constrain rect
|
* @param layout 'center' or 'cover'. Default to be 'cover'
|
*/
|
|
export function makeImage(imageUrl, rect, layout) {
|
var zrImg = new ZRImage({
|
style: {
|
image: imageUrl,
|
x: rect.x,
|
y: rect.y,
|
width: rect.width,
|
height: rect.height
|
},
|
onload: function (img) {
|
if (layout === 'center') {
|
var boundingRect = {
|
width: img.width,
|
height: img.height
|
};
|
zrImg.setStyle(centerGraphic(rect, boundingRect));
|
}
|
}
|
});
|
return zrImg;
|
}
|
/**
|
* Get position of centered element in bounding box.
|
*
|
* @param rect element local bounding box
|
* @param boundingRect constraint bounding box
|
* @return element position containing x, y, width, and height
|
*/
|
|
function centerGraphic(rect, boundingRect) {
|
// Set rect to center, keep width / height ratio.
|
var aspect = boundingRect.width / boundingRect.height;
|
var width = rect.height * aspect;
|
var height;
|
|
if (width <= rect.width) {
|
height = rect.height;
|
} else {
|
width = rect.width;
|
height = width / aspect;
|
}
|
|
var cx = rect.x + rect.width / 2;
|
var cy = rect.y + rect.height / 2;
|
return {
|
x: cx - width / 2,
|
y: cy - height / 2,
|
width: width,
|
height: height
|
};
|
}
|
|
export var mergePath = pathTool.mergePath;
|
/**
|
* Resize a path to fit the rect
|
* @param path
|
* @param rect
|
*/
|
|
export function resizePath(path, rect) {
|
if (!path.applyTransform) {
|
return;
|
}
|
|
var pathRect = path.getBoundingRect();
|
var m = pathRect.calculateTransform(rect);
|
path.applyTransform(m);
|
}
|
/**
|
* Sub pixel optimize line for canvas
|
*/
|
|
export function subPixelOptimizeLine(shape, lineWidth) {
|
subPixelOptimizeUtil.subPixelOptimizeLine(shape, shape, {
|
lineWidth: lineWidth
|
});
|
return shape;
|
}
|
/**
|
* Sub pixel optimize rect for canvas
|
*/
|
|
export function subPixelOptimizeRect(param) {
|
subPixelOptimizeUtil.subPixelOptimizeRect(param.shape, param.shape, param.style);
|
return param;
|
}
|
/**
|
* Sub pixel optimize for canvas
|
*
|
* @param position Coordinate, such as x, y
|
* @param lineWidth Should be nonnegative integer.
|
* @param positiveOrNegative Default false (negative).
|
* @return Optimized position.
|
*/
|
|
export var subPixelOptimize = subPixelOptimizeUtil.subPixelOptimize;
|
/**
|
* Get transform matrix of target (param target),
|
* in coordinate of its ancestor (param ancestor)
|
*
|
* @param target
|
* @param [ancestor]
|
*/
|
|
export function getTransform(target, ancestor) {
|
var mat = matrix.identity([]);
|
|
while (target && target !== ancestor) {
|
matrix.mul(mat, target.getLocalTransform(), mat);
|
target = target.parent;
|
}
|
|
return mat;
|
}
|
/**
|
* Apply transform to an vertex.
|
* @param target [x, y]
|
* @param transform Can be:
|
* + Transform matrix: like [1, 0, 0, 1, 0, 0]
|
* + {position, rotation, scale}, the same as `zrender/Transformable`.
|
* @param invert Whether use invert matrix.
|
* @return [x, y]
|
*/
|
|
export function applyTransform(target, transform, invert) {
|
if (transform && !isArrayLike(transform)) {
|
transform = Transformable.getLocalTransform(transform);
|
}
|
|
if (invert) {
|
transform = matrix.invert([], transform);
|
}
|
|
return vector.applyTransform([], target, transform);
|
}
|
/**
|
* @param direction 'left' 'right' 'top' 'bottom'
|
* @param transform Transform matrix: like [1, 0, 0, 1, 0, 0]
|
* @param invert Whether use invert matrix.
|
* @return Transformed direction. 'left' 'right' 'top' 'bottom'
|
*/
|
|
export function transformDirection(direction, transform, invert) {
|
// Pick a base, ensure that transform result will not be (0, 0).
|
var hBase = transform[4] === 0 || transform[5] === 0 || transform[0] === 0 ? 1 : Math.abs(2 * transform[4] / transform[0]);
|
var vBase = transform[4] === 0 || transform[5] === 0 || transform[2] === 0 ? 1 : Math.abs(2 * transform[4] / transform[2]);
|
var vertex = [direction === 'left' ? -hBase : direction === 'right' ? hBase : 0, direction === 'top' ? -vBase : direction === 'bottom' ? vBase : 0];
|
vertex = applyTransform(vertex, transform, invert);
|
return Math.abs(vertex[0]) > Math.abs(vertex[1]) ? vertex[0] > 0 ? 'right' : 'left' : vertex[1] > 0 ? 'bottom' : 'top';
|
}
|
|
function isNotGroup(el) {
|
return !el.isGroup;
|
}
|
|
function isPath(el) {
|
return el.shape != null;
|
}
|
/**
|
* Apply group transition animation from g1 to g2.
|
* If no animatableModel, no animation.
|
*/
|
|
|
export function groupTransition(g1, g2, animatableModel) {
|
if (!g1 || !g2) {
|
return;
|
}
|
|
function getElMap(g) {
|
var elMap = {};
|
g.traverse(function (el) {
|
if (isNotGroup(el) && el.anid) {
|
elMap[el.anid] = el;
|
}
|
});
|
return elMap;
|
}
|
|
function getAnimatableProps(el) {
|
var obj = {
|
x: el.x,
|
y: el.y,
|
rotation: el.rotation
|
};
|
|
if (isPath(el)) {
|
obj.shape = extend({}, el.shape);
|
}
|
|
return obj;
|
}
|
|
var elMap1 = getElMap(g1);
|
g2.traverse(function (el) {
|
if (isNotGroup(el) && el.anid) {
|
var oldEl = elMap1[el.anid];
|
|
if (oldEl) {
|
var newProp = getAnimatableProps(el);
|
el.attr(getAnimatableProps(oldEl));
|
updateProps(el, newProp, animatableModel, getECData(el).dataIndex);
|
}
|
}
|
});
|
}
|
export function clipPointsByRect(points, rect) {
|
// FIXME: this way migth be incorrect when grpahic clipped by a corner.
|
// and when element have border.
|
return map(points, function (point) {
|
var x = point[0];
|
x = mathMax(x, rect.x);
|
x = mathMin(x, rect.x + rect.width);
|
var y = point[1];
|
y = mathMax(y, rect.y);
|
y = mathMin(y, rect.y + rect.height);
|
return [x, y];
|
});
|
}
|
/**
|
* Return a new clipped rect. If rect size are negative, return undefined.
|
*/
|
|
export function clipRectByRect(targetRect, rect) {
|
var x = mathMax(targetRect.x, rect.x);
|
var x2 = mathMin(targetRect.x + targetRect.width, rect.x + rect.width);
|
var y = mathMax(targetRect.y, rect.y);
|
var y2 = mathMin(targetRect.y + targetRect.height, rect.y + rect.height); // If the total rect is cliped, nothing, including the border,
|
// should be painted. So return undefined.
|
|
if (x2 >= x && y2 >= y) {
|
return {
|
x: x,
|
y: y,
|
width: x2 - x,
|
height: y2 - y
|
};
|
}
|
}
|
export function createIcon(iconStr, // Support 'image://' or 'path://' or direct svg path.
|
opt, rect) {
|
var innerOpts = extend({
|
rectHover: true
|
}, opt);
|
var style = innerOpts.style = {
|
strokeNoScale: true
|
};
|
rect = rect || {
|
x: -1,
|
y: -1,
|
width: 2,
|
height: 2
|
};
|
|
if (iconStr) {
|
return iconStr.indexOf('image://') === 0 ? (style.image = iconStr.slice(8), defaults(style, rect), new ZRImage(innerOpts)) : makePath(iconStr.replace('path://', ''), innerOpts, rect, 'center');
|
}
|
}
|
/**
|
* Return `true` if the given line (line `a`) and the given polygon
|
* are intersect.
|
* Note that we do not count colinear as intersect here because no
|
* requirement for that. We could do that if required in future.
|
*/
|
|
export function linePolygonIntersect(a1x, a1y, a2x, a2y, points) {
|
for (var i = 0, p2 = points[points.length - 1]; i < points.length; i++) {
|
var p = points[i];
|
|
if (lineLineIntersect(a1x, a1y, a2x, a2y, p[0], p[1], p2[0], p2[1])) {
|
return true;
|
}
|
|
p2 = p;
|
}
|
}
|
/**
|
* Return `true` if the given two lines (line `a` and line `b`)
|
* are intersect.
|
* Note that we do not count colinear as intersect here because no
|
* requirement for that. We could do that if required in future.
|
*/
|
|
export function lineLineIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
|
// let `vec_m` to be `vec_a2 - vec_a1` and `vec_n` to be `vec_b2 - vec_b1`.
|
var mx = a2x - a1x;
|
var my = a2y - a1y;
|
var nx = b2x - b1x;
|
var ny = b2y - b1y; // `vec_m` and `vec_n` are parallel iff
|
// exising `k` such that `vec_m = k · vec_n`, equivalent to `vec_m X vec_n = 0`.
|
|
var nmCrossProduct = crossProduct2d(nx, ny, mx, my);
|
|
if (nearZero(nmCrossProduct)) {
|
return false;
|
} // `vec_m` and `vec_n` are intersect iff
|
// existing `p` and `q` in [0, 1] such that `vec_a1 + p * vec_m = vec_b1 + q * vec_n`,
|
// such that `q = ((vec_a1 - vec_b1) X vec_m) / (vec_n X vec_m)`
|
// and `p = ((vec_a1 - vec_b1) X vec_n) / (vec_n X vec_m)`.
|
|
|
var b1a1x = a1x - b1x;
|
var b1a1y = a1y - b1y;
|
var q = crossProduct2d(b1a1x, b1a1y, mx, my) / nmCrossProduct;
|
|
if (q < 0 || q > 1) {
|
return false;
|
}
|
|
var p = crossProduct2d(b1a1x, b1a1y, nx, ny) / nmCrossProduct;
|
|
if (p < 0 || p > 1) {
|
return false;
|
}
|
|
return true;
|
}
|
/**
|
* Cross product of 2-dimension vector.
|
*/
|
|
function crossProduct2d(x1, y1, x2, y2) {
|
return x1 * y2 - x2 * y1;
|
}
|
|
function nearZero(val) {
|
return val <= 1e-6 && val >= -1e-6;
|
}
|
|
export function setTooltipConfig(opt) {
|
var itemTooltipOption = opt.itemTooltipOption;
|
var componentModel = opt.componentModel;
|
var itemName = opt.itemName;
|
var itemTooltipOptionObj = isString(itemTooltipOption) ? {
|
formatter: itemTooltipOption
|
} : itemTooltipOption;
|
var mainType = componentModel.mainType;
|
var componentIndex = componentModel.componentIndex;
|
var formatterParams = {
|
componentType: mainType,
|
name: itemName,
|
$vars: ['name']
|
};
|
formatterParams[mainType + 'Index'] = componentIndex;
|
var formatterParamsExtra = opt.formatterParamsExtra;
|
|
if (formatterParamsExtra) {
|
each(keys(formatterParamsExtra), function (key) {
|
if (!hasOwn(formatterParams, key)) {
|
formatterParams[key] = formatterParamsExtra[key];
|
formatterParams.$vars.push(key);
|
}
|
});
|
}
|
|
var ecData = getECData(opt.el);
|
ecData.componentMainType = mainType;
|
ecData.componentIndex = componentIndex;
|
ecData.tooltipConfig = {
|
name: itemName,
|
option: defaults({
|
content: itemName,
|
formatterParams: formatterParams
|
}, itemTooltipOptionObj)
|
};
|
}
|
|
function traverseElement(el, cb) {
|
var stopped; // TODO
|
// Polyfill for fixing zrender group traverse don't visit it's root issue.
|
|
if (el.isGroup) {
|
stopped = cb(el);
|
}
|
|
if (!stopped) {
|
el.traverse(cb);
|
}
|
}
|
|
export function traverseElements(els, cb) {
|
if (els) {
|
if (isArray(els)) {
|
for (var i = 0; i < els.length; i++) {
|
traverseElement(els[i], cb);
|
}
|
} else {
|
traverseElement(els, cb);
|
}
|
}
|
} // Register built-in shapes. These shapes might be overwirtten
|
// by users, although we do not recommend that.
|
|
registerShape('circle', Circle);
|
registerShape('ellipse', Ellipse);
|
registerShape('sector', Sector);
|
registerShape('ring', Ring);
|
registerShape('polygon', Polygon);
|
registerShape('polyline', Polyline);
|
registerShape('rect', Rect);
|
registerShape('line', Line);
|
registerShape('bezierCurve', BezierCurve);
|
registerShape('arc', Arc);
|
export { Group, ZRImage as Image, ZRText as Text, Circle, Ellipse, Sector, Ring, Polygon, Polyline, Rect, Line, BezierCurve, Arc, IncrementalDisplayable, CompoundPath, LinearGradient, RadialGradient, BoundingRect, OrientedBoundingRect, Point, Path };
|
