95172 lines
3.2 MiB
95172 lines
3.2 MiB
|
||
/*
|
||
* 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.
|
||
*/
|
||
|
||
(function (global, factory) {
|
||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.echarts = {}));
|
||
}(this, (function (exports) { 'use strict';
|
||
|
||
/*! *****************************************************************************
|
||
Copyright (c) Microsoft Corporation.
|
||
|
||
Permission to use, copy, modify, and/or distribute this software for any
|
||
purpose with or without fee is hereby granted.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||
PERFORMANCE OF THIS SOFTWARE.
|
||
***************************************************************************** */
|
||
/* global Reflect, Promise */
|
||
|
||
var extendStatics = function(d, b) {
|
||
extendStatics = Object.setPrototypeOf ||
|
||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||
return extendStatics(d, b);
|
||
};
|
||
|
||
function __extends(d, b) {
|
||
if (typeof b !== "function" && b !== null)
|
||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||
extendStatics(d, b);
|
||
function __() { this.constructor = d; }
|
||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||
}
|
||
|
||
var Browser = (function () {
|
||
function Browser() {
|
||
this.firefox = false;
|
||
this.ie = false;
|
||
this.edge = false;
|
||
this.newEdge = false;
|
||
this.weChat = false;
|
||
}
|
||
return Browser;
|
||
}());
|
||
var Env = (function () {
|
||
function Env() {
|
||
this.browser = new Browser();
|
||
this.node = false;
|
||
this.wxa = false;
|
||
this.worker = false;
|
||
this.svgSupported = false;
|
||
this.touchEventsSupported = false;
|
||
this.pointerEventsSupported = false;
|
||
this.domSupported = false;
|
||
this.transformSupported = false;
|
||
this.transform3dSupported = false;
|
||
this.hasGlobalWindow = typeof window !== 'undefined';
|
||
}
|
||
return Env;
|
||
}());
|
||
var env = new Env();
|
||
if (typeof wx === 'object' && typeof wx.getSystemInfoSync === 'function') {
|
||
env.wxa = true;
|
||
env.touchEventsSupported = true;
|
||
}
|
||
else if (typeof document === 'undefined' && typeof self !== 'undefined') {
|
||
env.worker = true;
|
||
}
|
||
else if (typeof navigator === 'undefined') {
|
||
env.node = true;
|
||
env.svgSupported = true;
|
||
}
|
||
else {
|
||
detect(navigator.userAgent, env);
|
||
}
|
||
function detect(ua, env) {
|
||
var browser = env.browser;
|
||
var firefox = ua.match(/Firefox\/([\d.]+)/);
|
||
var ie = ua.match(/MSIE\s([\d.]+)/)
|
||
|| ua.match(/Trident\/.+?rv:(([\d.]+))/);
|
||
var edge = ua.match(/Edge?\/([\d.]+)/);
|
||
var weChat = (/micromessenger/i).test(ua);
|
||
if (firefox) {
|
||
browser.firefox = true;
|
||
browser.version = firefox[1];
|
||
}
|
||
if (ie) {
|
||
browser.ie = true;
|
||
browser.version = ie[1];
|
||
}
|
||
if (edge) {
|
||
browser.edge = true;
|
||
browser.version = edge[1];
|
||
browser.newEdge = +edge[1].split('.')[0] > 18;
|
||
}
|
||
if (weChat) {
|
||
browser.weChat = true;
|
||
}
|
||
env.svgSupported = typeof SVGRect !== 'undefined';
|
||
env.touchEventsSupported = 'ontouchstart' in window && !browser.ie && !browser.edge;
|
||
env.pointerEventsSupported = 'onpointerdown' in window
|
||
&& (browser.edge || (browser.ie && +browser.version >= 11));
|
||
env.domSupported = typeof document !== 'undefined';
|
||
var style = document.documentElement.style;
|
||
env.transform3dSupported = ((browser.ie && 'transition' in style)
|
||
|| browser.edge
|
||
|| (('WebKitCSSMatrix' in window) && ('m11' in new WebKitCSSMatrix()))
|
||
|| 'MozPerspective' in style)
|
||
&& !('OTransition' in style);
|
||
env.transformSupported = env.transform3dSupported
|
||
|| (browser.ie && +browser.version >= 9);
|
||
}
|
||
|
||
var DEFAULT_FONT_SIZE = 12;
|
||
var DEFAULT_FONT_FAMILY = 'sans-serif';
|
||
var DEFAULT_FONT = DEFAULT_FONT_SIZE + "px " + DEFAULT_FONT_FAMILY;
|
||
var OFFSET = 20;
|
||
var SCALE = 100;
|
||
var defaultWidthMapStr = "007LLmW'55;N0500LLLLLLLLLL00NNNLzWW\\\\WQb\\0FWLg\\bWb\\WQ\\WrWWQ000CL5LLFLL0LL**F*gLLLL5F0LF\\FFF5.5N";
|
||
function getTextWidthMap(mapStr) {
|
||
var map = {};
|
||
if (typeof JSON === 'undefined') {
|
||
return map;
|
||
}
|
||
for (var i = 0; i < mapStr.length; i++) {
|
||
var char = String.fromCharCode(i + 32);
|
||
var size = (mapStr.charCodeAt(i) - OFFSET) / SCALE;
|
||
map[char] = size;
|
||
}
|
||
return map;
|
||
}
|
||
var DEFAULT_TEXT_WIDTH_MAP = getTextWidthMap(defaultWidthMapStr);
|
||
var platformApi = {
|
||
createCanvas: function () {
|
||
return typeof document !== 'undefined'
|
||
&& document.createElement('canvas');
|
||
},
|
||
measureText: (function () {
|
||
var _ctx;
|
||
var _cachedFont;
|
||
return function (text, font) {
|
||
if (!_ctx) {
|
||
var canvas = platformApi.createCanvas();
|
||
_ctx = canvas && canvas.getContext('2d');
|
||
}
|
||
if (_ctx) {
|
||
if (_cachedFont !== font) {
|
||
_cachedFont = _ctx.font = font || DEFAULT_FONT;
|
||
}
|
||
return _ctx.measureText(text);
|
||
}
|
||
else {
|
||
text = text || '';
|
||
font = font || DEFAULT_FONT;
|
||
var res = /^([0-9]*?)px$/.exec(font);
|
||
var fontSize = +(res && res[1]) || DEFAULT_FONT_SIZE;
|
||
var width = 0;
|
||
if (font.indexOf('mono') >= 0) {
|
||
width = fontSize * text.length;
|
||
}
|
||
else {
|
||
for (var i = 0; i < text.length; i++) {
|
||
var preCalcWidth = DEFAULT_TEXT_WIDTH_MAP[text[i]];
|
||
width += preCalcWidth == null ? fontSize : (preCalcWidth * fontSize);
|
||
}
|
||
}
|
||
return { width: width };
|
||
}
|
||
};
|
||
})(),
|
||
loadImage: function (src, onload, onerror) {
|
||
var image = new Image();
|
||
image.onload = onload;
|
||
image.onerror = onerror;
|
||
image.src = src;
|
||
return image;
|
||
}
|
||
};
|
||
function setPlatformAPI(newPlatformApis) {
|
||
for (var key in platformApi) {
|
||
if (newPlatformApis[key]) {
|
||
platformApi[key] = newPlatformApis[key];
|
||
}
|
||
}
|
||
}
|
||
|
||
var BUILTIN_OBJECT = reduce([
|
||
'Function',
|
||
'RegExp',
|
||
'Date',
|
||
'Error',
|
||
'CanvasGradient',
|
||
'CanvasPattern',
|
||
'Image',
|
||
'Canvas'
|
||
], function (obj, val) {
|
||
obj['[object ' + val + ']'] = true;
|
||
return obj;
|
||
}, {});
|
||
var TYPED_ARRAY = reduce([
|
||
'Int8',
|
||
'Uint8',
|
||
'Uint8Clamped',
|
||
'Int16',
|
||
'Uint16',
|
||
'Int32',
|
||
'Uint32',
|
||
'Float32',
|
||
'Float64'
|
||
], function (obj, val) {
|
||
obj['[object ' + val + 'Array]'] = true;
|
||
return obj;
|
||
}, {});
|
||
var objToString = Object.prototype.toString;
|
||
var arrayProto = Array.prototype;
|
||
var nativeForEach = arrayProto.forEach;
|
||
var nativeFilter = arrayProto.filter;
|
||
var nativeSlice = arrayProto.slice;
|
||
var nativeMap = arrayProto.map;
|
||
var ctorFunction = function () { }.constructor;
|
||
var protoFunction = ctorFunction ? ctorFunction.prototype : null;
|
||
var protoKey = '__proto__';
|
||
var idStart = 0x0907;
|
||
function guid() {
|
||
return idStart++;
|
||
}
|
||
function logError() {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
if (typeof console !== 'undefined') {
|
||
console.error.apply(console, args);
|
||
}
|
||
}
|
||
function clone(source) {
|
||
if (source == null || typeof source !== 'object') {
|
||
return source;
|
||
}
|
||
var result = source;
|
||
var typeStr = objToString.call(source);
|
||
if (typeStr === '[object Array]') {
|
||
if (!isPrimitive(source)) {
|
||
result = [];
|
||
for (var i = 0, len = source.length; i < len; i++) {
|
||
result[i] = clone(source[i]);
|
||
}
|
||
}
|
||
}
|
||
else if (TYPED_ARRAY[typeStr]) {
|
||
if (!isPrimitive(source)) {
|
||
var Ctor = source.constructor;
|
||
if (Ctor.from) {
|
||
result = Ctor.from(source);
|
||
}
|
||
else {
|
||
result = new Ctor(source.length);
|
||
for (var i = 0, len = source.length; i < len; i++) {
|
||
result[i] = source[i];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {
|
||
result = {};
|
||
for (var key in source) {
|
||
if (source.hasOwnProperty(key) && key !== protoKey) {
|
||
result[key] = clone(source[key]);
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
function merge(target, source, overwrite) {
|
||
if (!isObject(source) || !isObject(target)) {
|
||
return overwrite ? clone(source) : target;
|
||
}
|
||
for (var key in source) {
|
||
if (source.hasOwnProperty(key) && key !== protoKey) {
|
||
var targetProp = target[key];
|
||
var sourceProp = source[key];
|
||
if (isObject(sourceProp)
|
||
&& isObject(targetProp)
|
||
&& !isArray(sourceProp)
|
||
&& !isArray(targetProp)
|
||
&& !isDom(sourceProp)
|
||
&& !isDom(targetProp)
|
||
&& !isBuiltInObject(sourceProp)
|
||
&& !isBuiltInObject(targetProp)
|
||
&& !isPrimitive(sourceProp)
|
||
&& !isPrimitive(targetProp)) {
|
||
merge(targetProp, sourceProp, overwrite);
|
||
}
|
||
else if (overwrite || !(key in target)) {
|
||
target[key] = clone(source[key]);
|
||
}
|
||
}
|
||
}
|
||
return target;
|
||
}
|
||
function mergeAll(targetAndSources, overwrite) {
|
||
var result = targetAndSources[0];
|
||
for (var i = 1, len = targetAndSources.length; i < len; i++) {
|
||
result = merge(result, targetAndSources[i], overwrite);
|
||
}
|
||
return result;
|
||
}
|
||
function extend(target, source) {
|
||
if (Object.assign) {
|
||
Object.assign(target, source);
|
||
}
|
||
else {
|
||
for (var key in source) {
|
||
if (source.hasOwnProperty(key) && key !== protoKey) {
|
||
target[key] = source[key];
|
||
}
|
||
}
|
||
}
|
||
return target;
|
||
}
|
||
function defaults(target, source, overlay) {
|
||
var keysArr = keys(source);
|
||
for (var i = 0; i < keysArr.length; i++) {
|
||
var key = keysArr[i];
|
||
if ((overlay ? source[key] != null : target[key] == null)) {
|
||
target[key] = source[key];
|
||
}
|
||
}
|
||
return target;
|
||
}
|
||
var createCanvas = platformApi.createCanvas;
|
||
function indexOf(array, value) {
|
||
if (array) {
|
||
if (array.indexOf) {
|
||
return array.indexOf(value);
|
||
}
|
||
for (var i = 0, len = array.length; i < len; i++) {
|
||
if (array[i] === value) {
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
function inherits(clazz, baseClazz) {
|
||
var clazzPrototype = clazz.prototype;
|
||
function F() { }
|
||
F.prototype = baseClazz.prototype;
|
||
clazz.prototype = new F();
|
||
for (var prop in clazzPrototype) {
|
||
if (clazzPrototype.hasOwnProperty(prop)) {
|
||
clazz.prototype[prop] = clazzPrototype[prop];
|
||
}
|
||
}
|
||
clazz.prototype.constructor = clazz;
|
||
clazz.superClass = baseClazz;
|
||
}
|
||
function mixin(target, source, override) {
|
||
target = 'prototype' in target ? target.prototype : target;
|
||
source = 'prototype' in source ? source.prototype : source;
|
||
if (Object.getOwnPropertyNames) {
|
||
var keyList = Object.getOwnPropertyNames(source);
|
||
for (var i = 0; i < keyList.length; i++) {
|
||
var key = keyList[i];
|
||
if (key !== 'constructor') {
|
||
if ((override ? source[key] != null : target[key] == null)) {
|
||
target[key] = source[key];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
defaults(target, source, override);
|
||
}
|
||
}
|
||
function isArrayLike(data) {
|
||
if (!data) {
|
||
return false;
|
||
}
|
||
if (typeof data === 'string') {
|
||
return false;
|
||
}
|
||
return typeof data.length === 'number';
|
||
}
|
||
function each(arr, cb, context) {
|
||
if (!(arr && cb)) {
|
||
return;
|
||
}
|
||
if (arr.forEach && arr.forEach === nativeForEach) {
|
||
arr.forEach(cb, context);
|
||
}
|
||
else if (arr.length === +arr.length) {
|
||
for (var i = 0, len = arr.length; i < len; i++) {
|
||
cb.call(context, arr[i], i, arr);
|
||
}
|
||
}
|
||
else {
|
||
for (var key in arr) {
|
||
if (arr.hasOwnProperty(key)) {
|
||
cb.call(context, arr[key], key, arr);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function map(arr, cb, context) {
|
||
if (!arr) {
|
||
return [];
|
||
}
|
||
if (!cb) {
|
||
return slice(arr);
|
||
}
|
||
if (arr.map && arr.map === nativeMap) {
|
||
return arr.map(cb, context);
|
||
}
|
||
else {
|
||
var result = [];
|
||
for (var i = 0, len = arr.length; i < len; i++) {
|
||
result.push(cb.call(context, arr[i], i, arr));
|
||
}
|
||
return result;
|
||
}
|
||
}
|
||
function reduce(arr, cb, memo, context) {
|
||
if (!(arr && cb)) {
|
||
return;
|
||
}
|
||
for (var i = 0, len = arr.length; i < len; i++) {
|
||
memo = cb.call(context, memo, arr[i], i, arr);
|
||
}
|
||
return memo;
|
||
}
|
||
function filter(arr, cb, context) {
|
||
if (!arr) {
|
||
return [];
|
||
}
|
||
if (!cb) {
|
||
return slice(arr);
|
||
}
|
||
if (arr.filter && arr.filter === nativeFilter) {
|
||
return arr.filter(cb, context);
|
||
}
|
||
else {
|
||
var result = [];
|
||
for (var i = 0, len = arr.length; i < len; i++) {
|
||
if (cb.call(context, arr[i], i, arr)) {
|
||
result.push(arr[i]);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
}
|
||
function find(arr, cb, context) {
|
||
if (!(arr && cb)) {
|
||
return;
|
||
}
|
||
for (var i = 0, len = arr.length; i < len; i++) {
|
||
if (cb.call(context, arr[i], i, arr)) {
|
||
return arr[i];
|
||
}
|
||
}
|
||
}
|
||
function keys(obj) {
|
||
if (!obj) {
|
||
return [];
|
||
}
|
||
if (Object.keys) {
|
||
return Object.keys(obj);
|
||
}
|
||
var keyList = [];
|
||
for (var key in obj) {
|
||
if (obj.hasOwnProperty(key)) {
|
||
keyList.push(key);
|
||
}
|
||
}
|
||
return keyList;
|
||
}
|
||
function bindPolyfill(func, context) {
|
||
var args = [];
|
||
for (var _i = 2; _i < arguments.length; _i++) {
|
||
args[_i - 2] = arguments[_i];
|
||
}
|
||
return function () {
|
||
return func.apply(context, args.concat(nativeSlice.call(arguments)));
|
||
};
|
||
}
|
||
var bind = (protoFunction && isFunction(protoFunction.bind))
|
||
? protoFunction.call.bind(protoFunction.bind)
|
||
: bindPolyfill;
|
||
function curry(func) {
|
||
var args = [];
|
||
for (var _i = 1; _i < arguments.length; _i++) {
|
||
args[_i - 1] = arguments[_i];
|
||
}
|
||
return function () {
|
||
return func.apply(this, args.concat(nativeSlice.call(arguments)));
|
||
};
|
||
}
|
||
function isArray(value) {
|
||
if (Array.isArray) {
|
||
return Array.isArray(value);
|
||
}
|
||
return objToString.call(value) === '[object Array]';
|
||
}
|
||
function isFunction(value) {
|
||
return typeof value === 'function';
|
||
}
|
||
function isString(value) {
|
||
return typeof value === 'string';
|
||
}
|
||
function isStringSafe(value) {
|
||
return objToString.call(value) === '[object String]';
|
||
}
|
||
function isNumber(value) {
|
||
return typeof value === 'number';
|
||
}
|
||
function isObject(value) {
|
||
var type = typeof value;
|
||
return type === 'function' || (!!value && type === 'object');
|
||
}
|
||
function isBuiltInObject(value) {
|
||
return !!BUILTIN_OBJECT[objToString.call(value)];
|
||
}
|
||
function isTypedArray(value) {
|
||
return !!TYPED_ARRAY[objToString.call(value)];
|
||
}
|
||
function isDom(value) {
|
||
return typeof value === 'object'
|
||
&& typeof value.nodeType === 'number'
|
||
&& typeof value.ownerDocument === 'object';
|
||
}
|
||
function isGradientObject(value) {
|
||
return value.colorStops != null;
|
||
}
|
||
function isImagePatternObject(value) {
|
||
return value.image != null;
|
||
}
|
||
function isRegExp(value) {
|
||
return objToString.call(value) === '[object RegExp]';
|
||
}
|
||
function eqNaN(value) {
|
||
return value !== value;
|
||
}
|
||
function retrieve() {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
for (var i = 0, len = args.length; i < len; i++) {
|
||
if (args[i] != null) {
|
||
return args[i];
|
||
}
|
||
}
|
||
}
|
||
function retrieve2(value0, value1) {
|
||
return value0 != null
|
||
? value0
|
||
: value1;
|
||
}
|
||
function retrieve3(value0, value1, value2) {
|
||
return value0 != null
|
||
? value0
|
||
: value1 != null
|
||
? value1
|
||
: value2;
|
||
}
|
||
function slice(arr) {
|
||
var args = [];
|
||
for (var _i = 1; _i < arguments.length; _i++) {
|
||
args[_i - 1] = arguments[_i];
|
||
}
|
||
return nativeSlice.apply(arr, args);
|
||
}
|
||
function normalizeCssArray(val) {
|
||
if (typeof (val) === 'number') {
|
||
return [val, val, val, val];
|
||
}
|
||
var len = val.length;
|
||
if (len === 2) {
|
||
return [val[0], val[1], val[0], val[1]];
|
||
}
|
||
else if (len === 3) {
|
||
return [val[0], val[1], val[2], val[1]];
|
||
}
|
||
return val;
|
||
}
|
||
function assert(condition, message) {
|
||
if (!condition) {
|
||
throw new Error(message);
|
||
}
|
||
}
|
||
function trim(str) {
|
||
if (str == null) {
|
||
return null;
|
||
}
|
||
else if (typeof str.trim === 'function') {
|
||
return str.trim();
|
||
}
|
||
else {
|
||
return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
|
||
}
|
||
}
|
||
var primitiveKey = '__ec_primitive__';
|
||
function setAsPrimitive(obj) {
|
||
obj[primitiveKey] = true;
|
||
}
|
||
function isPrimitive(obj) {
|
||
return obj[primitiveKey];
|
||
}
|
||
var HashMap = (function () {
|
||
function HashMap(obj) {
|
||
this.data = {};
|
||
var isArr = isArray(obj);
|
||
this.data = {};
|
||
var thisMap = this;
|
||
(obj instanceof HashMap)
|
||
? obj.each(visit)
|
||
: (obj && each(obj, visit));
|
||
function visit(value, key) {
|
||
isArr ? thisMap.set(value, key) : thisMap.set(key, value);
|
||
}
|
||
}
|
||
HashMap.prototype.get = function (key) {
|
||
return this.data.hasOwnProperty(key) ? this.data[key] : null;
|
||
};
|
||
HashMap.prototype.set = function (key, value) {
|
||
return (this.data[key] = value);
|
||
};
|
||
HashMap.prototype.each = function (cb, context) {
|
||
for (var key in this.data) {
|
||
if (this.data.hasOwnProperty(key)) {
|
||
cb.call(context, this.data[key], key);
|
||
}
|
||
}
|
||
};
|
||
HashMap.prototype.keys = function () {
|
||
return keys(this.data);
|
||
};
|
||
HashMap.prototype.removeKey = function (key) {
|
||
delete this.data[key];
|
||
};
|
||
return HashMap;
|
||
}());
|
||
function createHashMap(obj) {
|
||
return new HashMap(obj);
|
||
}
|
||
function concatArray(a, b) {
|
||
var newArray = new a.constructor(a.length + b.length);
|
||
for (var i = 0; i < a.length; i++) {
|
||
newArray[i] = a[i];
|
||
}
|
||
var offset = a.length;
|
||
for (var i = 0; i < b.length; i++) {
|
||
newArray[i + offset] = b[i];
|
||
}
|
||
return newArray;
|
||
}
|
||
function createObject(proto, properties) {
|
||
var obj;
|
||
if (Object.create) {
|
||
obj = Object.create(proto);
|
||
}
|
||
else {
|
||
var StyleCtor = function () { };
|
||
StyleCtor.prototype = proto;
|
||
obj = new StyleCtor();
|
||
}
|
||
if (properties) {
|
||
extend(obj, properties);
|
||
}
|
||
return obj;
|
||
}
|
||
function disableUserSelect(dom) {
|
||
var domStyle = dom.style;
|
||
domStyle.webkitUserSelect = 'none';
|
||
domStyle.userSelect = 'none';
|
||
domStyle.webkitTapHighlightColor = 'rgba(0,0,0,0)';
|
||
domStyle['-webkit-touch-callout'] = 'none';
|
||
}
|
||
function hasOwn(own, prop) {
|
||
return own.hasOwnProperty(prop);
|
||
}
|
||
function noop() { }
|
||
var RADIAN_TO_DEGREE = 180 / Math.PI;
|
||
|
||
var util = /*#__PURE__*/Object.freeze({
|
||
__proto__: null,
|
||
guid: guid,
|
||
logError: logError,
|
||
clone: clone,
|
||
merge: merge,
|
||
mergeAll: mergeAll,
|
||
extend: extend,
|
||
defaults: defaults,
|
||
createCanvas: createCanvas,
|
||
indexOf: indexOf,
|
||
inherits: inherits,
|
||
mixin: mixin,
|
||
isArrayLike: isArrayLike,
|
||
each: each,
|
||
map: map,
|
||
reduce: reduce,
|
||
filter: filter,
|
||
find: find,
|
||
keys: keys,
|
||
bind: bind,
|
||
curry: curry,
|
||
isArray: isArray,
|
||
isFunction: isFunction,
|
||
isString: isString,
|
||
isStringSafe: isStringSafe,
|
||
isNumber: isNumber,
|
||
isObject: isObject,
|
||
isBuiltInObject: isBuiltInObject,
|
||
isTypedArray: isTypedArray,
|
||
isDom: isDom,
|
||
isGradientObject: isGradientObject,
|
||
isImagePatternObject: isImagePatternObject,
|
||
isRegExp: isRegExp,
|
||
eqNaN: eqNaN,
|
||
retrieve: retrieve,
|
||
retrieve2: retrieve2,
|
||
retrieve3: retrieve3,
|
||
slice: slice,
|
||
normalizeCssArray: normalizeCssArray,
|
||
assert: assert,
|
||
trim: trim,
|
||
setAsPrimitive: setAsPrimitive,
|
||
isPrimitive: isPrimitive,
|
||
HashMap: HashMap,
|
||
createHashMap: createHashMap,
|
||
concatArray: concatArray,
|
||
createObject: createObject,
|
||
disableUserSelect: disableUserSelect,
|
||
hasOwn: hasOwn,
|
||
noop: noop,
|
||
RADIAN_TO_DEGREE: RADIAN_TO_DEGREE
|
||
});
|
||
|
||
function create(x, y) {
|
||
if (x == null) {
|
||
x = 0;
|
||
}
|
||
if (y == null) {
|
||
y = 0;
|
||
}
|
||
return [x, y];
|
||
}
|
||
function copy(out, v) {
|
||
out[0] = v[0];
|
||
out[1] = v[1];
|
||
return out;
|
||
}
|
||
function clone$1(v) {
|
||
return [v[0], v[1]];
|
||
}
|
||
function set(out, a, b) {
|
||
out[0] = a;
|
||
out[1] = b;
|
||
return out;
|
||
}
|
||
function add(out, v1, v2) {
|
||
out[0] = v1[0] + v2[0];
|
||
out[1] = v1[1] + v2[1];
|
||
return out;
|
||
}
|
||
function scaleAndAdd(out, v1, v2, a) {
|
||
out[0] = v1[0] + v2[0] * a;
|
||
out[1] = v1[1] + v2[1] * a;
|
||
return out;
|
||
}
|
||
function sub(out, v1, v2) {
|
||
out[0] = v1[0] - v2[0];
|
||
out[1] = v1[1] - v2[1];
|
||
return out;
|
||
}
|
||
function len(v) {
|
||
return Math.sqrt(lenSquare(v));
|
||
}
|
||
var length = len;
|
||
function lenSquare(v) {
|
||
return v[0] * v[0] + v[1] * v[1];
|
||
}
|
||
var lengthSquare = lenSquare;
|
||
function mul(out, v1, v2) {
|
||
out[0] = v1[0] * v2[0];
|
||
out[1] = v1[1] * v2[1];
|
||
return out;
|
||
}
|
||
function div(out, v1, v2) {
|
||
out[0] = v1[0] / v2[0];
|
||
out[1] = v1[1] / v2[1];
|
||
return out;
|
||
}
|
||
function dot(v1, v2) {
|
||
return v1[0] * v2[0] + v1[1] * v2[1];
|
||
}
|
||
function scale(out, v, s) {
|
||
out[0] = v[0] * s;
|
||
out[1] = v[1] * s;
|
||
return out;
|
||
}
|
||
function normalize(out, v) {
|
||
var d = len(v);
|
||
if (d === 0) {
|
||
out[0] = 0;
|
||
out[1] = 0;
|
||
}
|
||
else {
|
||
out[0] = v[0] / d;
|
||
out[1] = v[1] / d;
|
||
}
|
||
return out;
|
||
}
|
||
function distance(v1, v2) {
|
||
return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0])
|
||
+ (v1[1] - v2[1]) * (v1[1] - v2[1]));
|
||
}
|
||
var dist = distance;
|
||
function distanceSquare(v1, v2) {
|
||
return (v1[0] - v2[0]) * (v1[0] - v2[0])
|
||
+ (v1[1] - v2[1]) * (v1[1] - v2[1]);
|
||
}
|
||
var distSquare = distanceSquare;
|
||
function negate(out, v) {
|
||
out[0] = -v[0];
|
||
out[1] = -v[1];
|
||
return out;
|
||
}
|
||
function lerp(out, v1, v2, t) {
|
||
out[0] = v1[0] + t * (v2[0] - v1[0]);
|
||
out[1] = v1[1] + t * (v2[1] - v1[1]);
|
||
return out;
|
||
}
|
||
function applyTransform(out, v, m) {
|
||
var x = v[0];
|
||
var y = v[1];
|
||
out[0] = m[0] * x + m[2] * y + m[4];
|
||
out[1] = m[1] * x + m[3] * y + m[5];
|
||
return out;
|
||
}
|
||
function min(out, v1, v2) {
|
||
out[0] = Math.min(v1[0], v2[0]);
|
||
out[1] = Math.min(v1[1], v2[1]);
|
||
return out;
|
||
}
|
||
function max(out, v1, v2) {
|
||
out[0] = Math.max(v1[0], v2[0]);
|
||
out[1] = Math.max(v1[1], v2[1]);
|
||
return out;
|
||
}
|
||
|
||
var vector = /*#__PURE__*/Object.freeze({
|
||
__proto__: null,
|
||
create: create,
|
||
copy: copy,
|
||
clone: clone$1,
|
||
set: set,
|
||
add: add,
|
||
scaleAndAdd: scaleAndAdd,
|
||
sub: sub,
|
||
len: len,
|
||
length: length,
|
||
lenSquare: lenSquare,
|
||
lengthSquare: lengthSquare,
|
||
mul: mul,
|
||
div: div,
|
||
dot: dot,
|
||
scale: scale,
|
||
normalize: normalize,
|
||
distance: distance,
|
||
dist: dist,
|
||
distanceSquare: distanceSquare,
|
||
distSquare: distSquare,
|
||
negate: negate,
|
||
lerp: lerp,
|
||
applyTransform: applyTransform,
|
||
min: min,
|
||
max: max
|
||
});
|
||
|
||
var Param = (function () {
|
||
function Param(target, e) {
|
||
this.target = target;
|
||
this.topTarget = e && e.topTarget;
|
||
}
|
||
return Param;
|
||
}());
|
||
var Draggable = (function () {
|
||
function Draggable(handler) {
|
||
this.handler = handler;
|
||
handler.on('mousedown', this._dragStart, this);
|
||
handler.on('mousemove', this._drag, this);
|
||
handler.on('mouseup', this._dragEnd, this);
|
||
}
|
||
Draggable.prototype._dragStart = function (e) {
|
||
var draggingTarget = e.target;
|
||
while (draggingTarget && !draggingTarget.draggable) {
|
||
draggingTarget = draggingTarget.parent || draggingTarget.__hostTarget;
|
||
}
|
||
if (draggingTarget) {
|
||
this._draggingTarget = draggingTarget;
|
||
draggingTarget.dragging = true;
|
||
this._x = e.offsetX;
|
||
this._y = e.offsetY;
|
||
this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragstart', e.event);
|
||
}
|
||
};
|
||
Draggable.prototype._drag = function (e) {
|
||
var draggingTarget = this._draggingTarget;
|
||
if (draggingTarget) {
|
||
var x = e.offsetX;
|
||
var y = e.offsetY;
|
||
var dx = x - this._x;
|
||
var dy = y - this._y;
|
||
this._x = x;
|
||
this._y = y;
|
||
draggingTarget.drift(dx, dy, e);
|
||
this.handler.dispatchToElement(new Param(draggingTarget, e), 'drag', e.event);
|
||
var dropTarget = this.handler.findHover(x, y, draggingTarget).target;
|
||
var lastDropTarget = this._dropTarget;
|
||
this._dropTarget = dropTarget;
|
||
if (draggingTarget !== dropTarget) {
|
||
if (lastDropTarget && dropTarget !== lastDropTarget) {
|
||
this.handler.dispatchToElement(new Param(lastDropTarget, e), 'dragleave', e.event);
|
||
}
|
||
if (dropTarget && dropTarget !== lastDropTarget) {
|
||
this.handler.dispatchToElement(new Param(dropTarget, e), 'dragenter', e.event);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
Draggable.prototype._dragEnd = function (e) {
|
||
var draggingTarget = this._draggingTarget;
|
||
if (draggingTarget) {
|
||
draggingTarget.dragging = false;
|
||
}
|
||
this.handler.dispatchToElement(new Param(draggingTarget, e), 'dragend', e.event);
|
||
if (this._dropTarget) {
|
||
this.handler.dispatchToElement(new Param(this._dropTarget, e), 'drop', e.event);
|
||
}
|
||
this._draggingTarget = null;
|
||
this._dropTarget = null;
|
||
};
|
||
return Draggable;
|
||
}());
|
||
|
||
var Eventful = (function () {
|
||
function Eventful(eventProcessors) {
|
||
if (eventProcessors) {
|
||
this._$eventProcessor = eventProcessors;
|
||
}
|
||
}
|
||
Eventful.prototype.on = function (event, query, handler, context) {
|
||
if (!this._$handlers) {
|
||
this._$handlers = {};
|
||
}
|
||
var _h = this._$handlers;
|
||
if (typeof query === 'function') {
|
||
context = handler;
|
||
handler = query;
|
||
query = null;
|
||
}
|
||
if (!handler || !event) {
|
||
return this;
|
||
}
|
||
var eventProcessor = this._$eventProcessor;
|
||
if (query != null && eventProcessor && eventProcessor.normalizeQuery) {
|
||
query = eventProcessor.normalizeQuery(query);
|
||
}
|
||
if (!_h[event]) {
|
||
_h[event] = [];
|
||
}
|
||
for (var i = 0; i < _h[event].length; i++) {
|
||
if (_h[event][i].h === handler) {
|
||
return this;
|
||
}
|
||
}
|
||
var wrap = {
|
||
h: handler,
|
||
query: query,
|
||
ctx: (context || this),
|
||
callAtLast: handler.zrEventfulCallAtLast
|
||
};
|
||
var lastIndex = _h[event].length - 1;
|
||
var lastWrap = _h[event][lastIndex];
|
||
(lastWrap && lastWrap.callAtLast)
|
||
? _h[event].splice(lastIndex, 0, wrap)
|
||
: _h[event].push(wrap);
|
||
return this;
|
||
};
|
||
Eventful.prototype.isSilent = function (eventName) {
|
||
var _h = this._$handlers;
|
||
return !_h || !_h[eventName] || !_h[eventName].length;
|
||
};
|
||
Eventful.prototype.off = function (eventType, handler) {
|
||
var _h = this._$handlers;
|
||
if (!_h) {
|
||
return this;
|
||
}
|
||
if (!eventType) {
|
||
this._$handlers = {};
|
||
return this;
|
||
}
|
||
if (handler) {
|
||
if (_h[eventType]) {
|
||
var newList = [];
|
||
for (var i = 0, l = _h[eventType].length; i < l; i++) {
|
||
if (_h[eventType][i].h !== handler) {
|
||
newList.push(_h[eventType][i]);
|
||
}
|
||
}
|
||
_h[eventType] = newList;
|
||
}
|
||
if (_h[eventType] && _h[eventType].length === 0) {
|
||
delete _h[eventType];
|
||
}
|
||
}
|
||
else {
|
||
delete _h[eventType];
|
||
}
|
||
return this;
|
||
};
|
||
Eventful.prototype.trigger = function (eventType) {
|
||
var args = [];
|
||
for (var _i = 1; _i < arguments.length; _i++) {
|
||
args[_i - 1] = arguments[_i];
|
||
}
|
||
if (!this._$handlers) {
|
||
return this;
|
||
}
|
||
var _h = this._$handlers[eventType];
|
||
var eventProcessor = this._$eventProcessor;
|
||
if (_h) {
|
||
var argLen = args.length;
|
||
var len = _h.length;
|
||
for (var i = 0; i < len; i++) {
|
||
var hItem = _h[i];
|
||
if (eventProcessor
|
||
&& eventProcessor.filter
|
||
&& hItem.query != null
|
||
&& !eventProcessor.filter(eventType, hItem.query)) {
|
||
continue;
|
||
}
|
||
switch (argLen) {
|
||
case 0:
|
||
hItem.h.call(hItem.ctx);
|
||
break;
|
||
case 1:
|
||
hItem.h.call(hItem.ctx, args[0]);
|
||
break;
|
||
case 2:
|
||
hItem.h.call(hItem.ctx, args[0], args[1]);
|
||
break;
|
||
default:
|
||
hItem.h.apply(hItem.ctx, args);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
eventProcessor && eventProcessor.afterTrigger
|
||
&& eventProcessor.afterTrigger(eventType);
|
||
return this;
|
||
};
|
||
Eventful.prototype.triggerWithContext = function (type) {
|
||
var args = [];
|
||
for (var _i = 1; _i < arguments.length; _i++) {
|
||
args[_i - 1] = arguments[_i];
|
||
}
|
||
if (!this._$handlers) {
|
||
return this;
|
||
}
|
||
var _h = this._$handlers[type];
|
||
var eventProcessor = this._$eventProcessor;
|
||
if (_h) {
|
||
var argLen = args.length;
|
||
var ctx = args[argLen - 1];
|
||
var len = _h.length;
|
||
for (var i = 0; i < len; i++) {
|
||
var hItem = _h[i];
|
||
if (eventProcessor
|
||
&& eventProcessor.filter
|
||
&& hItem.query != null
|
||
&& !eventProcessor.filter(type, hItem.query)) {
|
||
continue;
|
||
}
|
||
switch (argLen) {
|
||
case 0:
|
||
hItem.h.call(ctx);
|
||
break;
|
||
case 1:
|
||
hItem.h.call(ctx, args[0]);
|
||
break;
|
||
case 2:
|
||
hItem.h.call(ctx, args[0], args[1]);
|
||
break;
|
||
default:
|
||
hItem.h.apply(ctx, args.slice(1, argLen - 1));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
eventProcessor && eventProcessor.afterTrigger
|
||
&& eventProcessor.afterTrigger(type);
|
||
return this;
|
||
};
|
||
return Eventful;
|
||
}());
|
||
|
||
var LN2 = Math.log(2);
|
||
function determinant(rows, rank, rowStart, rowMask, colMask, detCache) {
|
||
var cacheKey = rowMask + '-' + colMask;
|
||
var fullRank = rows.length;
|
||
if (detCache.hasOwnProperty(cacheKey)) {
|
||
return detCache[cacheKey];
|
||
}
|
||
if (rank === 1) {
|
||
var colStart = Math.round(Math.log(((1 << fullRank) - 1) & ~colMask) / LN2);
|
||
return rows[rowStart][colStart];
|
||
}
|
||
var subRowMask = rowMask | (1 << rowStart);
|
||
var subRowStart = rowStart + 1;
|
||
while (rowMask & (1 << subRowStart)) {
|
||
subRowStart++;
|
||
}
|
||
var sum = 0;
|
||
for (var j = 0, colLocalIdx = 0; j < fullRank; j++) {
|
||
var colTag = 1 << j;
|
||
if (!(colTag & colMask)) {
|
||
sum += (colLocalIdx % 2 ? -1 : 1) * rows[rowStart][j]
|
||
* determinant(rows, rank - 1, subRowStart, subRowMask, colMask | colTag, detCache);
|
||
colLocalIdx++;
|
||
}
|
||
}
|
||
detCache[cacheKey] = sum;
|
||
return sum;
|
||
}
|
||
function buildTransformer(src, dest) {
|
||
var mA = [
|
||
[src[0], src[1], 1, 0, 0, 0, -dest[0] * src[0], -dest[0] * src[1]],
|
||
[0, 0, 0, src[0], src[1], 1, -dest[1] * src[0], -dest[1] * src[1]],
|
||
[src[2], src[3], 1, 0, 0, 0, -dest[2] * src[2], -dest[2] * src[3]],
|
||
[0, 0, 0, src[2], src[3], 1, -dest[3] * src[2], -dest[3] * src[3]],
|
||
[src[4], src[5], 1, 0, 0, 0, -dest[4] * src[4], -dest[4] * src[5]],
|
||
[0, 0, 0, src[4], src[5], 1, -dest[5] * src[4], -dest[5] * src[5]],
|
||
[src[6], src[7], 1, 0, 0, 0, -dest[6] * src[6], -dest[6] * src[7]],
|
||
[0, 0, 0, src[6], src[7], 1, -dest[7] * src[6], -dest[7] * src[7]]
|
||
];
|
||
var detCache = {};
|
||
var det = determinant(mA, 8, 0, 0, 0, detCache);
|
||
if (det === 0) {
|
||
return;
|
||
}
|
||
var vh = [];
|
||
for (var i = 0; i < 8; i++) {
|
||
for (var j = 0; j < 8; j++) {
|
||
vh[j] == null && (vh[j] = 0);
|
||
vh[j] += ((i + j) % 2 ? -1 : 1)
|
||
* determinant(mA, 7, i === 0 ? 1 : 0, 1 << i, 1 << j, detCache)
|
||
/ det * dest[i];
|
||
}
|
||
}
|
||
return function (out, srcPointX, srcPointY) {
|
||
var pk = srcPointX * vh[6] + srcPointY * vh[7] + 1;
|
||
out[0] = (srcPointX * vh[0] + srcPointY * vh[1] + vh[2]) / pk;
|
||
out[1] = (srcPointX * vh[3] + srcPointY * vh[4] + vh[5]) / pk;
|
||
};
|
||
}
|
||
|
||
var EVENT_SAVED_PROP = '___zrEVENTSAVED';
|
||
var _calcOut = [];
|
||
function transformLocalCoord(out, elFrom, elTarget, inX, inY) {
|
||
return transformCoordWithViewport(_calcOut, elFrom, inX, inY, true)
|
||
&& transformCoordWithViewport(out, elTarget, _calcOut[0], _calcOut[1]);
|
||
}
|
||
function transformCoordWithViewport(out, el, inX, inY, inverse) {
|
||
if (el.getBoundingClientRect && env.domSupported && !isCanvasEl(el)) {
|
||
var saved = el[EVENT_SAVED_PROP] || (el[EVENT_SAVED_PROP] = {});
|
||
var markers = prepareCoordMarkers(el, saved);
|
||
var transformer = preparePointerTransformer(markers, saved, inverse);
|
||
if (transformer) {
|
||
transformer(out, inX, inY);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
function prepareCoordMarkers(el, saved) {
|
||
var markers = saved.markers;
|
||
if (markers) {
|
||
return markers;
|
||
}
|
||
markers = saved.markers = [];
|
||
var propLR = ['left', 'right'];
|
||
var propTB = ['top', 'bottom'];
|
||
for (var i = 0; i < 4; i++) {
|
||
var marker = document.createElement('div');
|
||
var stl = marker.style;
|
||
var idxLR = i % 2;
|
||
var idxTB = (i >> 1) % 2;
|
||
stl.cssText = [
|
||
'position: absolute',
|
||
'visibility: hidden',
|
||
'padding: 0',
|
||
'margin: 0',
|
||
'border-width: 0',
|
||
'user-select: none',
|
||
'width:0',
|
||
'height:0',
|
||
propLR[idxLR] + ':0',
|
||
propTB[idxTB] + ':0',
|
||
propLR[1 - idxLR] + ':auto',
|
||
propTB[1 - idxTB] + ':auto',
|
||
''
|
||
].join('!important;');
|
||
el.appendChild(marker);
|
||
markers.push(marker);
|
||
}
|
||
return markers;
|
||
}
|
||
function preparePointerTransformer(markers, saved, inverse) {
|
||
var transformerName = inverse ? 'invTrans' : 'trans';
|
||
var transformer = saved[transformerName];
|
||
var oldSrcCoords = saved.srcCoords;
|
||
var srcCoords = [];
|
||
var destCoords = [];
|
||
var oldCoordTheSame = true;
|
||
for (var i = 0; i < 4; i++) {
|
||
var rect = markers[i].getBoundingClientRect();
|
||
var ii = 2 * i;
|
||
var x = rect.left;
|
||
var y = rect.top;
|
||
srcCoords.push(x, y);
|
||
oldCoordTheSame = oldCoordTheSame && oldSrcCoords && x === oldSrcCoords[ii] && y === oldSrcCoords[ii + 1];
|
||
destCoords.push(markers[i].offsetLeft, markers[i].offsetTop);
|
||
}
|
||
return (oldCoordTheSame && transformer)
|
||
? transformer
|
||
: (saved.srcCoords = srcCoords,
|
||
saved[transformerName] = inverse
|
||
? buildTransformer(destCoords, srcCoords)
|
||
: buildTransformer(srcCoords, destCoords));
|
||
}
|
||
function isCanvasEl(el) {
|
||
return el.nodeName.toUpperCase() === 'CANVAS';
|
||
}
|
||
|
||
var MOUSE_EVENT_REG = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
|
||
var _calcOut$1 = [];
|
||
var firefoxNotSupportOffsetXY = env.browser.firefox
|
||
&& +env.browser.version.split('.')[0] < 39;
|
||
function clientToLocal(el, e, out, calculate) {
|
||
out = out || {};
|
||
if (calculate) {
|
||
calculateZrXY(el, e, out);
|
||
}
|
||
else if (firefoxNotSupportOffsetXY
|
||
&& e.layerX != null
|
||
&& e.layerX !== e.offsetX) {
|
||
out.zrX = e.layerX;
|
||
out.zrY = e.layerY;
|
||
}
|
||
else if (e.offsetX != null) {
|
||
out.zrX = e.offsetX;
|
||
out.zrY = e.offsetY;
|
||
}
|
||
else {
|
||
calculateZrXY(el, e, out);
|
||
}
|
||
return out;
|
||
}
|
||
function calculateZrXY(el, e, out) {
|
||
if (env.domSupported && el.getBoundingClientRect) {
|
||
var ex = e.clientX;
|
||
var ey = e.clientY;
|
||
if (isCanvasEl(el)) {
|
||
var box = el.getBoundingClientRect();
|
||
out.zrX = ex - box.left;
|
||
out.zrY = ey - box.top;
|
||
return;
|
||
}
|
||
else {
|
||
if (transformCoordWithViewport(_calcOut$1, el, ex, ey)) {
|
||
out.zrX = _calcOut$1[0];
|
||
out.zrY = _calcOut$1[1];
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
out.zrX = out.zrY = 0;
|
||
}
|
||
function getNativeEvent(e) {
|
||
return e
|
||
|| window.event;
|
||
}
|
||
function normalizeEvent(el, e, calculate) {
|
||
e = getNativeEvent(e);
|
||
if (e.zrX != null) {
|
||
return e;
|
||
}
|
||
var eventType = e.type;
|
||
var isTouch = eventType && eventType.indexOf('touch') >= 0;
|
||
if (!isTouch) {
|
||
clientToLocal(el, e, e, calculate);
|
||
var wheelDelta = getWheelDeltaMayPolyfill(e);
|
||
e.zrDelta = wheelDelta ? wheelDelta / 120 : -(e.detail || 0) / 3;
|
||
}
|
||
else {
|
||
var touch = eventType !== 'touchend'
|
||
? e.targetTouches[0]
|
||
: e.changedTouches[0];
|
||
touch && clientToLocal(el, touch, e, calculate);
|
||
}
|
||
var button = e.button;
|
||
if (e.which == null && button !== undefined && MOUSE_EVENT_REG.test(e.type)) {
|
||
e.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
|
||
}
|
||
return e;
|
||
}
|
||
function getWheelDeltaMayPolyfill(e) {
|
||
var rawWheelDelta = e.wheelDelta;
|
||
if (rawWheelDelta) {
|
||
return rawWheelDelta;
|
||
}
|
||
var deltaX = e.deltaX;
|
||
var deltaY = e.deltaY;
|
||
if (deltaX == null || deltaY == null) {
|
||
return rawWheelDelta;
|
||
}
|
||
var delta = deltaY !== 0 ? Math.abs(deltaY) : Math.abs(deltaX);
|
||
var sign = deltaY > 0 ? -1
|
||
: deltaY < 0 ? 1
|
||
: deltaX > 0 ? -1
|
||
: 1;
|
||
return 3 * delta * sign;
|
||
}
|
||
function addEventListener(el, name, handler, opt) {
|
||
el.addEventListener(name, handler, opt);
|
||
}
|
||
function removeEventListener(el, name, handler, opt) {
|
||
el.removeEventListener(name, handler, opt);
|
||
}
|
||
var stop = function (e) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
e.cancelBubble = true;
|
||
};
|
||
function isMiddleOrRightButtonOnMouseUpDown(e) {
|
||
return e.which === 2 || e.which === 3;
|
||
}
|
||
|
||
var GestureMgr = (function () {
|
||
function GestureMgr() {
|
||
this._track = [];
|
||
}
|
||
GestureMgr.prototype.recognize = function (event, target, root) {
|
||
this._doTrack(event, target, root);
|
||
return this._recognize(event);
|
||
};
|
||
GestureMgr.prototype.clear = function () {
|
||
this._track.length = 0;
|
||
return this;
|
||
};
|
||
GestureMgr.prototype._doTrack = function (event, target, root) {
|
||
var touches = event.touches;
|
||
if (!touches) {
|
||
return;
|
||
}
|
||
var trackItem = {
|
||
points: [],
|
||
touches: [],
|
||
target: target,
|
||
event: event
|
||
};
|
||
for (var i = 0, len = touches.length; i < len; i++) {
|
||
var touch = touches[i];
|
||
var pos = clientToLocal(root, touch, {});
|
||
trackItem.points.push([pos.zrX, pos.zrY]);
|
||
trackItem.touches.push(touch);
|
||
}
|
||
this._track.push(trackItem);
|
||
};
|
||
GestureMgr.prototype._recognize = function (event) {
|
||
for (var eventName in recognizers) {
|
||
if (recognizers.hasOwnProperty(eventName)) {
|
||
var gestureInfo = recognizers[eventName](this._track, event);
|
||
if (gestureInfo) {
|
||
return gestureInfo;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
return GestureMgr;
|
||
}());
|
||
function dist$1(pointPair) {
|
||
var dx = pointPair[1][0] - pointPair[0][0];
|
||
var dy = pointPair[1][1] - pointPair[0][1];
|
||
return Math.sqrt(dx * dx + dy * dy);
|
||
}
|
||
function center(pointPair) {
|
||
return [
|
||
(pointPair[0][0] + pointPair[1][0]) / 2,
|
||
(pointPair[0][1] + pointPair[1][1]) / 2
|
||
];
|
||
}
|
||
var recognizers = {
|
||
pinch: function (tracks, event) {
|
||
var trackLen = tracks.length;
|
||
if (!trackLen) {
|
||
return;
|
||
}
|
||
var pinchEnd = (tracks[trackLen - 1] || {}).points;
|
||
var pinchPre = (tracks[trackLen - 2] || {}).points || pinchEnd;
|
||
if (pinchPre
|
||
&& pinchPre.length > 1
|
||
&& pinchEnd
|
||
&& pinchEnd.length > 1) {
|
||
var pinchScale = dist$1(pinchEnd) / dist$1(pinchPre);
|
||
!isFinite(pinchScale) && (pinchScale = 1);
|
||
event.pinchScale = pinchScale;
|
||
var pinchCenter = center(pinchEnd);
|
||
event.pinchX = pinchCenter[0];
|
||
event.pinchY = pinchCenter[1];
|
||
return {
|
||
type: 'pinch',
|
||
target: tracks[0].target,
|
||
event: event
|
||
};
|
||
}
|
||
}
|
||
};
|
||
|
||
var SILENT = 'silent';
|
||
function makeEventPacket(eveType, targetInfo, event) {
|
||
return {
|
||
type: eveType,
|
||
event: event,
|
||
target: targetInfo.target,
|
||
topTarget: targetInfo.topTarget,
|
||
cancelBubble: false,
|
||
offsetX: event.zrX,
|
||
offsetY: event.zrY,
|
||
gestureEvent: event.gestureEvent,
|
||
pinchX: event.pinchX,
|
||
pinchY: event.pinchY,
|
||
pinchScale: event.pinchScale,
|
||
wheelDelta: event.zrDelta,
|
||
zrByTouch: event.zrByTouch,
|
||
which: event.which,
|
||
stop: stopEvent
|
||
};
|
||
}
|
||
function stopEvent() {
|
||
stop(this.event);
|
||
}
|
||
var EmptyProxy = (function (_super) {
|
||
__extends(EmptyProxy, _super);
|
||
function EmptyProxy() {
|
||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||
_this.handler = null;
|
||
return _this;
|
||
}
|
||
EmptyProxy.prototype.dispose = function () { };
|
||
EmptyProxy.prototype.setCursor = function () { };
|
||
return EmptyProxy;
|
||
}(Eventful));
|
||
var HoveredResult = (function () {
|
||
function HoveredResult(x, y) {
|
||
this.x = x;
|
||
this.y = y;
|
||
}
|
||
return HoveredResult;
|
||
}());
|
||
var handlerNames = [
|
||
'click', 'dblclick', 'mousewheel', 'mouseout',
|
||
'mouseup', 'mousedown', 'mousemove', 'contextmenu'
|
||
];
|
||
var Handler = (function (_super) {
|
||
__extends(Handler, _super);
|
||
function Handler(storage, painter, proxy, painterRoot) {
|
||
var _this = _super.call(this) || this;
|
||
_this._hovered = new HoveredResult(0, 0);
|
||
_this.storage = storage;
|
||
_this.painter = painter;
|
||
_this.painterRoot = painterRoot;
|
||
proxy = proxy || new EmptyProxy();
|
||
_this.proxy = null;
|
||
_this.setHandlerProxy(proxy);
|
||
_this._draggingMgr = new Draggable(_this);
|
||
return _this;
|
||
}
|
||
Handler.prototype.setHandlerProxy = function (proxy) {
|
||
if (this.proxy) {
|
||
this.proxy.dispose();
|
||
}
|
||
if (proxy) {
|
||
each(handlerNames, function (name) {
|
||
proxy.on && proxy.on(name, this[name], this);
|
||
}, this);
|
||
proxy.handler = this;
|
||
}
|
||
this.proxy = proxy;
|
||
};
|
||
Handler.prototype.mousemove = function (event) {
|
||
var x = event.zrX;
|
||
var y = event.zrY;
|
||
var isOutside = isOutsideBoundary(this, x, y);
|
||
var lastHovered = this._hovered;
|
||
var lastHoveredTarget = lastHovered.target;
|
||
if (lastHoveredTarget && !lastHoveredTarget.__zr) {
|
||
lastHovered = this.findHover(lastHovered.x, lastHovered.y);
|
||
lastHoveredTarget = lastHovered.target;
|
||
}
|
||
var hovered = this._hovered = isOutside ? new HoveredResult(x, y) : this.findHover(x, y);
|
||
var hoveredTarget = hovered.target;
|
||
var proxy = this.proxy;
|
||
proxy.setCursor && proxy.setCursor(hoveredTarget ? hoveredTarget.cursor : 'default');
|
||
if (lastHoveredTarget && hoveredTarget !== lastHoveredTarget) {
|
||
this.dispatchToElement(lastHovered, 'mouseout', event);
|
||
}
|
||
this.dispatchToElement(hovered, 'mousemove', event);
|
||
if (hoveredTarget && hoveredTarget !== lastHoveredTarget) {
|
||
this.dispatchToElement(hovered, 'mouseover', event);
|
||
}
|
||
};
|
||
Handler.prototype.mouseout = function (event) {
|
||
var eventControl = event.zrEventControl;
|
||
if (eventControl !== 'only_globalout') {
|
||
this.dispatchToElement(this._hovered, 'mouseout', event);
|
||
}
|
||
if (eventControl !== 'no_globalout') {
|
||
this.trigger('globalout', { type: 'globalout', event: event });
|
||
}
|
||
};
|
||
Handler.prototype.resize = function () {
|
||
this._hovered = new HoveredResult(0, 0);
|
||
};
|
||
Handler.prototype.dispatch = function (eventName, eventArgs) {
|
||
var handler = this[eventName];
|
||
handler && handler.call(this, eventArgs);
|
||
};
|
||
Handler.prototype.dispose = function () {
|
||
this.proxy.dispose();
|
||
this.storage = null;
|
||
this.proxy = null;
|
||
this.painter = null;
|
||
};
|
||
Handler.prototype.setCursorStyle = function (cursorStyle) {
|
||
var proxy = this.proxy;
|
||
proxy.setCursor && proxy.setCursor(cursorStyle);
|
||
};
|
||
Handler.prototype.dispatchToElement = function (targetInfo, eventName, event) {
|
||
targetInfo = targetInfo || {};
|
||
var el = targetInfo.target;
|
||
if (el && el.silent) {
|
||
return;
|
||
}
|
||
var eventKey = ('on' + eventName);
|
||
var eventPacket = makeEventPacket(eventName, targetInfo, event);
|
||
while (el) {
|
||
el[eventKey]
|
||
&& (eventPacket.cancelBubble = !!el[eventKey].call(el, eventPacket));
|
||
el.trigger(eventName, eventPacket);
|
||
el = el.__hostTarget ? el.__hostTarget : el.parent;
|
||
if (eventPacket.cancelBubble) {
|
||
break;
|
||
}
|
||
}
|
||
if (!eventPacket.cancelBubble) {
|
||
this.trigger(eventName, eventPacket);
|
||
if (this.painter && this.painter.eachOtherLayer) {
|
||
this.painter.eachOtherLayer(function (layer) {
|
||
if (typeof (layer[eventKey]) === 'function') {
|
||
layer[eventKey].call(layer, eventPacket);
|
||
}
|
||
if (layer.trigger) {
|
||
layer.trigger(eventName, eventPacket);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
};
|
||
Handler.prototype.findHover = function (x, y, exclude) {
|
||
var list = this.storage.getDisplayList();
|
||
var out = new HoveredResult(x, y);
|
||
for (var i = list.length - 1; i >= 0; i--) {
|
||
var hoverCheckResult = void 0;
|
||
if (list[i] !== exclude
|
||
&& !list[i].ignore
|
||
&& (hoverCheckResult = isHover(list[i], x, y))) {
|
||
!out.topTarget && (out.topTarget = list[i]);
|
||
if (hoverCheckResult !== SILENT) {
|
||
out.target = list[i];
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return out;
|
||
};
|
||
Handler.prototype.processGesture = function (event, stage) {
|
||
if (!this._gestureMgr) {
|
||
this._gestureMgr = new GestureMgr();
|
||
}
|
||
var gestureMgr = this._gestureMgr;
|
||
stage === 'start' && gestureMgr.clear();
|
||
var gestureInfo = gestureMgr.recognize(event, this.findHover(event.zrX, event.zrY, null).target, this.proxy.dom);
|
||
stage === 'end' && gestureMgr.clear();
|
||
if (gestureInfo) {
|
||
var type = gestureInfo.type;
|
||
event.gestureEvent = type;
|
||
var res = new HoveredResult();
|
||
res.target = gestureInfo.target;
|
||
this.dispatchToElement(res, type, gestureInfo.event);
|
||
}
|
||
};
|
||
return Handler;
|
||
}(Eventful));
|
||
each(['click', 'mousedown', 'mouseup', 'mousewheel', 'dblclick', 'contextmenu'], function (name) {
|
||
Handler.prototype[name] = function (event) {
|
||
var x = event.zrX;
|
||
var y = event.zrY;
|
||
var isOutside = isOutsideBoundary(this, x, y);
|
||
var hovered;
|
||
var hoveredTarget;
|
||
if (name !== 'mouseup' || !isOutside) {
|
||
hovered = this.findHover(x, y);
|
||
hoveredTarget = hovered.target;
|
||
}
|
||
if (name === 'mousedown') {
|
||
this._downEl = hoveredTarget;
|
||
this._downPoint = [event.zrX, event.zrY];
|
||
this._upEl = hoveredTarget;
|
||
}
|
||
else if (name === 'mouseup') {
|
||
this._upEl = hoveredTarget;
|
||
}
|
||
else if (name === 'click') {
|
||
if (this._downEl !== this._upEl
|
||
|| !this._downPoint
|
||
|| dist(this._downPoint, [event.zrX, event.zrY]) > 4) {
|
||
return;
|
||
}
|
||
this._downPoint = null;
|
||
}
|
||
this.dispatchToElement(hovered, name, event);
|
||
};
|
||
});
|
||
function isHover(displayable, x, y) {
|
||
if (displayable[displayable.rectHover ? 'rectContain' : 'contain'](x, y)) {
|
||
var el = displayable;
|
||
var isSilent = void 0;
|
||
var ignoreClip = false;
|
||
while (el) {
|
||
if (el.ignoreClip) {
|
||
ignoreClip = true;
|
||
}
|
||
if (!ignoreClip) {
|
||
var clipPath = el.getClipPath();
|
||
if (clipPath && !clipPath.contain(x, y)) {
|
||
return false;
|
||
}
|
||
if (el.silent) {
|
||
isSilent = true;
|
||
}
|
||
}
|
||
var hostEl = el.__hostTarget;
|
||
el = hostEl ? hostEl : el.parent;
|
||
}
|
||
return isSilent ? SILENT : true;
|
||
}
|
||
return false;
|
||
}
|
||
function isOutsideBoundary(handlerInstance, x, y) {
|
||
var painter = handlerInstance.painter;
|
||
return x < 0 || x > painter.getWidth() || y < 0 || y > painter.getHeight();
|
||
}
|
||
|
||
var DEFAULT_MIN_MERGE = 32;
|
||
var DEFAULT_MIN_GALLOPING = 7;
|
||
function minRunLength(n) {
|
||
var r = 0;
|
||
while (n >= DEFAULT_MIN_MERGE) {
|
||
r |= n & 1;
|
||
n >>= 1;
|
||
}
|
||
return n + r;
|
||
}
|
||
function makeAscendingRun(array, lo, hi, compare) {
|
||
var runHi = lo + 1;
|
||
if (runHi === hi) {
|
||
return 1;
|
||
}
|
||
if (compare(array[runHi++], array[lo]) < 0) {
|
||
while (runHi < hi && compare(array[runHi], array[runHi - 1]) < 0) {
|
||
runHi++;
|
||
}
|
||
reverseRun(array, lo, runHi);
|
||
}
|
||
else {
|
||
while (runHi < hi && compare(array[runHi], array[runHi - 1]) >= 0) {
|
||
runHi++;
|
||
}
|
||
}
|
||
return runHi - lo;
|
||
}
|
||
function reverseRun(array, lo, hi) {
|
||
hi--;
|
||
while (lo < hi) {
|
||
var t = array[lo];
|
||
array[lo++] = array[hi];
|
||
array[hi--] = t;
|
||
}
|
||
}
|
||
function binaryInsertionSort(array, lo, hi, start, compare) {
|
||
if (start === lo) {
|
||
start++;
|
||
}
|
||
for (; start < hi; start++) {
|
||
var pivot = array[start];
|
||
var left = lo;
|
||
var right = start;
|
||
var mid;
|
||
while (left < right) {
|
||
mid = left + right >>> 1;
|
||
if (compare(pivot, array[mid]) < 0) {
|
||
right = mid;
|
||
}
|
||
else {
|
||
left = mid + 1;
|
||
}
|
||
}
|
||
var n = start - left;
|
||
switch (n) {
|
||
case 3:
|
||
array[left + 3] = array[left + 2];
|
||
case 2:
|
||
array[left + 2] = array[left + 1];
|
||
case 1:
|
||
array[left + 1] = array[left];
|
||
break;
|
||
default:
|
||
while (n > 0) {
|
||
array[left + n] = array[left + n - 1];
|
||
n--;
|
||
}
|
||
}
|
||
array[left] = pivot;
|
||
}
|
||
}
|
||
function gallopLeft(value, array, start, length, hint, compare) {
|
||
var lastOffset = 0;
|
||
var maxOffset = 0;
|
||
var offset = 1;
|
||
if (compare(value, array[start + hint]) > 0) {
|
||
maxOffset = length - hint;
|
||
while (offset < maxOffset && compare(value, array[start + hint + offset]) > 0) {
|
||
lastOffset = offset;
|
||
offset = (offset << 1) + 1;
|
||
if (offset <= 0) {
|
||
offset = maxOffset;
|
||
}
|
||
}
|
||
if (offset > maxOffset) {
|
||
offset = maxOffset;
|
||
}
|
||
lastOffset += hint;
|
||
offset += hint;
|
||
}
|
||
else {
|
||
maxOffset = hint + 1;
|
||
while (offset < maxOffset && compare(value, array[start + hint - offset]) <= 0) {
|
||
lastOffset = offset;
|
||
offset = (offset << 1) + 1;
|
||
if (offset <= 0) {
|
||
offset = maxOffset;
|
||
}
|
||
}
|
||
if (offset > maxOffset) {
|
||
offset = maxOffset;
|
||
}
|
||
var tmp = lastOffset;
|
||
lastOffset = hint - offset;
|
||
offset = hint - tmp;
|
||
}
|
||
lastOffset++;
|
||
while (lastOffset < offset) {
|
||
var m = lastOffset + (offset - lastOffset >>> 1);
|
||
if (compare(value, array[start + m]) > 0) {
|
||
lastOffset = m + 1;
|
||
}
|
||
else {
|
||
offset = m;
|
||
}
|
||
}
|
||
return offset;
|
||
}
|
||
function gallopRight(value, array, start, length, hint, compare) {
|
||
var lastOffset = 0;
|
||
var maxOffset = 0;
|
||
var offset = 1;
|
||
if (compare(value, array[start + hint]) < 0) {
|
||
maxOffset = hint + 1;
|
||
while (offset < maxOffset && compare(value, array[start + hint - offset]) < 0) {
|
||
lastOffset = offset;
|
||
offset = (offset << 1) + 1;
|
||
if (offset <= 0) {
|
||
offset = maxOffset;
|
||
}
|
||
}
|
||
if (offset > maxOffset) {
|
||
offset = maxOffset;
|
||
}
|
||
var tmp = lastOffset;
|
||
lastOffset = hint - offset;
|
||
offset = hint - tmp;
|
||
}
|
||
else {
|
||
maxOffset = length - hint;
|
||
while (offset < maxOffset && compare(value, array[start + hint + offset]) >= 0) {
|
||
lastOffset = offset;
|
||
offset = (offset << 1) + 1;
|
||
if (offset <= 0) {
|
||
offset = maxOffset;
|
||
}
|
||
}
|
||
if (offset > maxOffset) {
|
||
offset = maxOffset;
|
||
}
|
||
lastOffset += hint;
|
||
offset += hint;
|
||
}
|
||
lastOffset++;
|
||
while (lastOffset < offset) {
|
||
var m = lastOffset + (offset - lastOffset >>> 1);
|
||
if (compare(value, array[start + m]) < 0) {
|
||
offset = m;
|
||
}
|
||
else {
|
||
lastOffset = m + 1;
|
||
}
|
||
}
|
||
return offset;
|
||
}
|
||
function TimSort(array, compare) {
|
||
var minGallop = DEFAULT_MIN_GALLOPING;
|
||
var length = 0;
|
||
var runStart;
|
||
var runLength;
|
||
var stackSize = 0;
|
||
length = array.length;
|
||
var tmp = [];
|
||
runStart = [];
|
||
runLength = [];
|
||
function pushRun(_runStart, _runLength) {
|
||
runStart[stackSize] = _runStart;
|
||
runLength[stackSize] = _runLength;
|
||
stackSize += 1;
|
||
}
|
||
function mergeRuns() {
|
||
while (stackSize > 1) {
|
||
var n = stackSize - 2;
|
||
if ((n >= 1 && runLength[n - 1] <= runLength[n] + runLength[n + 1])
|
||
|| (n >= 2 && runLength[n - 2] <= runLength[n] + runLength[n - 1])) {
|
||
if (runLength[n - 1] < runLength[n + 1]) {
|
||
n--;
|
||
}
|
||
}
|
||
else if (runLength[n] > runLength[n + 1]) {
|
||
break;
|
||
}
|
||
mergeAt(n);
|
||
}
|
||
}
|
||
function forceMergeRuns() {
|
||
while (stackSize > 1) {
|
||
var n = stackSize - 2;
|
||
if (n > 0 && runLength[n - 1] < runLength[n + 1]) {
|
||
n--;
|
||
}
|
||
mergeAt(n);
|
||
}
|
||
}
|
||
function mergeAt(i) {
|
||
var start1 = runStart[i];
|
||
var length1 = runLength[i];
|
||
var start2 = runStart[i + 1];
|
||
var length2 = runLength[i + 1];
|
||
runLength[i] = length1 + length2;
|
||
if (i === stackSize - 3) {
|
||
runStart[i + 1] = runStart[i + 2];
|
||
runLength[i + 1] = runLength[i + 2];
|
||
}
|
||
stackSize--;
|
||
var k = gallopRight(array[start2], array, start1, length1, 0, compare);
|
||
start1 += k;
|
||
length1 -= k;
|
||
if (length1 === 0) {
|
||
return;
|
||
}
|
||
length2 = gallopLeft(array[start1 + length1 - 1], array, start2, length2, length2 - 1, compare);
|
||
if (length2 === 0) {
|
||
return;
|
||
}
|
||
if (length1 <= length2) {
|
||
mergeLow(start1, length1, start2, length2);
|
||
}
|
||
else {
|
||
mergeHigh(start1, length1, start2, length2);
|
||
}
|
||
}
|
||
function mergeLow(start1, length1, start2, length2) {
|
||
var i = 0;
|
||
for (i = 0; i < length1; i++) {
|
||
tmp[i] = array[start1 + i];
|
||
}
|
||
var cursor1 = 0;
|
||
var cursor2 = start2;
|
||
var dest = start1;
|
||
array[dest++] = array[cursor2++];
|
||
if (--length2 === 0) {
|
||
for (i = 0; i < length1; i++) {
|
||
array[dest + i] = tmp[cursor1 + i];
|
||
}
|
||
return;
|
||
}
|
||
if (length1 === 1) {
|
||
for (i = 0; i < length2; i++) {
|
||
array[dest + i] = array[cursor2 + i];
|
||
}
|
||
array[dest + length2] = tmp[cursor1];
|
||
return;
|
||
}
|
||
var _minGallop = minGallop;
|
||
var count1;
|
||
var count2;
|
||
var exit;
|
||
while (1) {
|
||
count1 = 0;
|
||
count2 = 0;
|
||
exit = false;
|
||
do {
|
||
if (compare(array[cursor2], tmp[cursor1]) < 0) {
|
||
array[dest++] = array[cursor2++];
|
||
count2++;
|
||
count1 = 0;
|
||
if (--length2 === 0) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
}
|
||
else {
|
||
array[dest++] = tmp[cursor1++];
|
||
count1++;
|
||
count2 = 0;
|
||
if (--length1 === 1) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
}
|
||
} while ((count1 | count2) < _minGallop);
|
||
if (exit) {
|
||
break;
|
||
}
|
||
do {
|
||
count1 = gallopRight(array[cursor2], tmp, cursor1, length1, 0, compare);
|
||
if (count1 !== 0) {
|
||
for (i = 0; i < count1; i++) {
|
||
array[dest + i] = tmp[cursor1 + i];
|
||
}
|
||
dest += count1;
|
||
cursor1 += count1;
|
||
length1 -= count1;
|
||
if (length1 <= 1) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
}
|
||
array[dest++] = array[cursor2++];
|
||
if (--length2 === 0) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
count2 = gallopLeft(tmp[cursor1], array, cursor2, length2, 0, compare);
|
||
if (count2 !== 0) {
|
||
for (i = 0; i < count2; i++) {
|
||
array[dest + i] = array[cursor2 + i];
|
||
}
|
||
dest += count2;
|
||
cursor2 += count2;
|
||
length2 -= count2;
|
||
if (length2 === 0) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
}
|
||
array[dest++] = tmp[cursor1++];
|
||
if (--length1 === 1) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
_minGallop--;
|
||
} while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
|
||
if (exit) {
|
||
break;
|
||
}
|
||
if (_minGallop < 0) {
|
||
_minGallop = 0;
|
||
}
|
||
_minGallop += 2;
|
||
}
|
||
minGallop = _minGallop;
|
||
minGallop < 1 && (minGallop = 1);
|
||
if (length1 === 1) {
|
||
for (i = 0; i < length2; i++) {
|
||
array[dest + i] = array[cursor2 + i];
|
||
}
|
||
array[dest + length2] = tmp[cursor1];
|
||
}
|
||
else if (length1 === 0) {
|
||
throw new Error();
|
||
}
|
||
else {
|
||
for (i = 0; i < length1; i++) {
|
||
array[dest + i] = tmp[cursor1 + i];
|
||
}
|
||
}
|
||
}
|
||
function mergeHigh(start1, length1, start2, length2) {
|
||
var i = 0;
|
||
for (i = 0; i < length2; i++) {
|
||
tmp[i] = array[start2 + i];
|
||
}
|
||
var cursor1 = start1 + length1 - 1;
|
||
var cursor2 = length2 - 1;
|
||
var dest = start2 + length2 - 1;
|
||
var customCursor = 0;
|
||
var customDest = 0;
|
||
array[dest--] = array[cursor1--];
|
||
if (--length1 === 0) {
|
||
customCursor = dest - (length2 - 1);
|
||
for (i = 0; i < length2; i++) {
|
||
array[customCursor + i] = tmp[i];
|
||
}
|
||
return;
|
||
}
|
||
if (length2 === 1) {
|
||
dest -= length1;
|
||
cursor1 -= length1;
|
||
customDest = dest + 1;
|
||
customCursor = cursor1 + 1;
|
||
for (i = length1 - 1; i >= 0; i--) {
|
||
array[customDest + i] = array[customCursor + i];
|
||
}
|
||
array[dest] = tmp[cursor2];
|
||
return;
|
||
}
|
||
var _minGallop = minGallop;
|
||
while (true) {
|
||
var count1 = 0;
|
||
var count2 = 0;
|
||
var exit = false;
|
||
do {
|
||
if (compare(tmp[cursor2], array[cursor1]) < 0) {
|
||
array[dest--] = array[cursor1--];
|
||
count1++;
|
||
count2 = 0;
|
||
if (--length1 === 0) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
}
|
||
else {
|
||
array[dest--] = tmp[cursor2--];
|
||
count2++;
|
||
count1 = 0;
|
||
if (--length2 === 1) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
}
|
||
} while ((count1 | count2) < _minGallop);
|
||
if (exit) {
|
||
break;
|
||
}
|
||
do {
|
||
count1 = length1 - gallopRight(tmp[cursor2], array, start1, length1, length1 - 1, compare);
|
||
if (count1 !== 0) {
|
||
dest -= count1;
|
||
cursor1 -= count1;
|
||
length1 -= count1;
|
||
customDest = dest + 1;
|
||
customCursor = cursor1 + 1;
|
||
for (i = count1 - 1; i >= 0; i--) {
|
||
array[customDest + i] = array[customCursor + i];
|
||
}
|
||
if (length1 === 0) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
}
|
||
array[dest--] = tmp[cursor2--];
|
||
if (--length2 === 1) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
count2 = length2 - gallopLeft(array[cursor1], tmp, 0, length2, length2 - 1, compare);
|
||
if (count2 !== 0) {
|
||
dest -= count2;
|
||
cursor2 -= count2;
|
||
length2 -= count2;
|
||
customDest = dest + 1;
|
||
customCursor = cursor2 + 1;
|
||
for (i = 0; i < count2; i++) {
|
||
array[customDest + i] = tmp[customCursor + i];
|
||
}
|
||
if (length2 <= 1) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
}
|
||
array[dest--] = array[cursor1--];
|
||
if (--length1 === 0) {
|
||
exit = true;
|
||
break;
|
||
}
|
||
_minGallop--;
|
||
} while (count1 >= DEFAULT_MIN_GALLOPING || count2 >= DEFAULT_MIN_GALLOPING);
|
||
if (exit) {
|
||
break;
|
||
}
|
||
if (_minGallop < 0) {
|
||
_minGallop = 0;
|
||
}
|
||
_minGallop += 2;
|
||
}
|
||
minGallop = _minGallop;
|
||
if (minGallop < 1) {
|
||
minGallop = 1;
|
||
}
|
||
if (length2 === 1) {
|
||
dest -= length1;
|
||
cursor1 -= length1;
|
||
customDest = dest + 1;
|
||
customCursor = cursor1 + 1;
|
||
for (i = length1 - 1; i >= 0; i--) {
|
||
array[customDest + i] = array[customCursor + i];
|
||
}
|
||
array[dest] = tmp[cursor2];
|
||
}
|
||
else if (length2 === 0) {
|
||
throw new Error();
|
||
}
|
||
else {
|
||
customCursor = dest - (length2 - 1);
|
||
for (i = 0; i < length2; i++) {
|
||
array[customCursor + i] = tmp[i];
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
mergeRuns: mergeRuns,
|
||
forceMergeRuns: forceMergeRuns,
|
||
pushRun: pushRun
|
||
};
|
||
}
|
||
function sort(array, compare, lo, hi) {
|
||
if (!lo) {
|
||
lo = 0;
|
||
}
|
||
if (!hi) {
|
||
hi = array.length;
|
||
}
|
||
var remaining = hi - lo;
|
||
if (remaining < 2) {
|
||
return;
|
||
}
|
||
var runLength = 0;
|
||
if (remaining < DEFAULT_MIN_MERGE) {
|
||
runLength = makeAscendingRun(array, lo, hi, compare);
|
||
binaryInsertionSort(array, lo, hi, lo + runLength, compare);
|
||
return;
|
||
}
|
||
var ts = TimSort(array, compare);
|
||
var minRun = minRunLength(remaining);
|
||
do {
|
||
runLength = makeAscendingRun(array, lo, hi, compare);
|
||
if (runLength < minRun) {
|
||
var force = remaining;
|
||
if (force > minRun) {
|
||
force = minRun;
|
||
}
|
||
binaryInsertionSort(array, lo, lo + force, lo + runLength, compare);
|
||
runLength = force;
|
||
}
|
||
ts.pushRun(lo, runLength);
|
||
ts.mergeRuns();
|
||
remaining -= runLength;
|
||
lo += runLength;
|
||
} while (remaining !== 0);
|
||
ts.forceMergeRuns();
|
||
}
|
||
|
||
var REDRAW_BIT = 1;
|
||
var STYLE_CHANGED_BIT = 2;
|
||
var SHAPE_CHANGED_BIT = 4;
|
||
|
||
var invalidZErrorLogged = false;
|
||
function logInvalidZError() {
|
||
if (invalidZErrorLogged) {
|
||
return;
|
||
}
|
||
invalidZErrorLogged = true;
|
||
console.warn('z / z2 / zlevel of displayable is invalid, which may cause unexpected errors');
|
||
}
|
||
function shapeCompareFunc(a, b) {
|
||
if (a.zlevel === b.zlevel) {
|
||
if (a.z === b.z) {
|
||
return a.z2 - b.z2;
|
||
}
|
||
return a.z - b.z;
|
||
}
|
||
return a.zlevel - b.zlevel;
|
||
}
|
||
var Storage = (function () {
|
||
function Storage() {
|
||
this._roots = [];
|
||
this._displayList = [];
|
||
this._displayListLen = 0;
|
||
this.displayableSortFunc = shapeCompareFunc;
|
||
}
|
||
Storage.prototype.traverse = function (cb, context) {
|
||
for (var i = 0; i < this._roots.length; i++) {
|
||
this._roots[i].traverse(cb, context);
|
||
}
|
||
};
|
||
Storage.prototype.getDisplayList = function (update, includeIgnore) {
|
||
includeIgnore = includeIgnore || false;
|
||
var displayList = this._displayList;
|
||
if (update || !displayList.length) {
|
||
this.updateDisplayList(includeIgnore);
|
||
}
|
||
return displayList;
|
||
};
|
||
Storage.prototype.updateDisplayList = function (includeIgnore) {
|
||
this._displayListLen = 0;
|
||
var roots = this._roots;
|
||
var displayList = this._displayList;
|
||
for (var i = 0, len = roots.length; i < len; i++) {
|
||
this._updateAndAddDisplayable(roots[i], null, includeIgnore);
|
||
}
|
||
displayList.length = this._displayListLen;
|
||
sort(displayList, shapeCompareFunc);
|
||
};
|
||
Storage.prototype._updateAndAddDisplayable = function (el, clipPaths, includeIgnore) {
|
||
if (el.ignore && !includeIgnore) {
|
||
return;
|
||
}
|
||
el.beforeUpdate();
|
||
el.update();
|
||
el.afterUpdate();
|
||
var userSetClipPath = el.getClipPath();
|
||
if (el.ignoreClip) {
|
||
clipPaths = null;
|
||
}
|
||
else if (userSetClipPath) {
|
||
if (clipPaths) {
|
||
clipPaths = clipPaths.slice();
|
||
}
|
||
else {
|
||
clipPaths = [];
|
||
}
|
||
var currentClipPath = userSetClipPath;
|
||
var parentClipPath = el;
|
||
while (currentClipPath) {
|
||
currentClipPath.parent = parentClipPath;
|
||
currentClipPath.updateTransform();
|
||
clipPaths.push(currentClipPath);
|
||
parentClipPath = currentClipPath;
|
||
currentClipPath = currentClipPath.getClipPath();
|
||
}
|
||
}
|
||
if (el.childrenRef) {
|
||
var children = el.childrenRef();
|
||
for (var i = 0; i < children.length; i++) {
|
||
var child = children[i];
|
||
if (el.__dirty) {
|
||
child.__dirty |= REDRAW_BIT;
|
||
}
|
||
this._updateAndAddDisplayable(child, clipPaths, includeIgnore);
|
||
}
|
||
el.__dirty = 0;
|
||
}
|
||
else {
|
||
var disp = el;
|
||
if (clipPaths && clipPaths.length) {
|
||
disp.__clipPaths = clipPaths;
|
||
}
|
||
else if (disp.__clipPaths && disp.__clipPaths.length > 0) {
|
||
disp.__clipPaths = [];
|
||
}
|
||
if (isNaN(disp.z)) {
|
||
logInvalidZError();
|
||
disp.z = 0;
|
||
}
|
||
if (isNaN(disp.z2)) {
|
||
logInvalidZError();
|
||
disp.z2 = 0;
|
||
}
|
||
if (isNaN(disp.zlevel)) {
|
||
logInvalidZError();
|
||
disp.zlevel = 0;
|
||
}
|
||
this._displayList[this._displayListLen++] = disp;
|
||
}
|
||
var decalEl = el.getDecalElement && el.getDecalElement();
|
||
if (decalEl) {
|
||
this._updateAndAddDisplayable(decalEl, clipPaths, includeIgnore);
|
||
}
|
||
var textGuide = el.getTextGuideLine();
|
||
if (textGuide) {
|
||
this._updateAndAddDisplayable(textGuide, clipPaths, includeIgnore);
|
||
}
|
||
var textEl = el.getTextContent();
|
||
if (textEl) {
|
||
this._updateAndAddDisplayable(textEl, clipPaths, includeIgnore);
|
||
}
|
||
};
|
||
Storage.prototype.addRoot = function (el) {
|
||
if (el.__zr && el.__zr.storage === this) {
|
||
return;
|
||
}
|
||
this._roots.push(el);
|
||
};
|
||
Storage.prototype.delRoot = function (el) {
|
||
if (el instanceof Array) {
|
||
for (var i = 0, l = el.length; i < l; i++) {
|
||
this.delRoot(el[i]);
|
||
}
|
||
return;
|
||
}
|
||
var idx = indexOf(this._roots, el);
|
||
if (idx >= 0) {
|
||
this._roots.splice(idx, 1);
|
||
}
|
||
};
|
||
Storage.prototype.delAllRoots = function () {
|
||
this._roots = [];
|
||
this._displayList = [];
|
||
this._displayListLen = 0;
|
||
return;
|
||
};
|
||
Storage.prototype.getRoots = function () {
|
||
return this._roots;
|
||
};
|
||
Storage.prototype.dispose = function () {
|
||
this._displayList = null;
|
||
this._roots = null;
|
||
};
|
||
return Storage;
|
||
}());
|
||
|
||
var requestAnimationFrame;
|
||
requestAnimationFrame = (env.hasGlobalWindow
|
||
&& ((window.requestAnimationFrame && window.requestAnimationFrame.bind(window))
|
||
|| (window.msRequestAnimationFrame && window.msRequestAnimationFrame.bind(window))
|
||
|| window.mozRequestAnimationFrame
|
||
|| window.webkitRequestAnimationFrame)) || function (func) {
|
||
return setTimeout(func, 16);
|
||
};
|
||
var requestAnimationFrame$1 = requestAnimationFrame;
|
||
|
||
var easingFuncs = {
|
||
linear: function (k) {
|
||
return k;
|
||
},
|
||
quadraticIn: function (k) {
|
||
return k * k;
|
||
},
|
||
quadraticOut: function (k) {
|
||
return k * (2 - k);
|
||
},
|
||
quadraticInOut: function (k) {
|
||
if ((k *= 2) < 1) {
|
||
return 0.5 * k * k;
|
||
}
|
||
return -0.5 * (--k * (k - 2) - 1);
|
||
},
|
||
cubicIn: function (k) {
|
||
return k * k * k;
|
||
},
|
||
cubicOut: function (k) {
|
||
return --k * k * k + 1;
|
||
},
|
||
cubicInOut: function (k) {
|
||
if ((k *= 2) < 1) {
|
||
return 0.5 * k * k * k;
|
||
}
|
||
return 0.5 * ((k -= 2) * k * k + 2);
|
||
},
|
||
quarticIn: function (k) {
|
||
return k * k * k * k;
|
||
},
|
||
quarticOut: function (k) {
|
||
return 1 - (--k * k * k * k);
|
||
},
|
||
quarticInOut: function (k) {
|
||
if ((k *= 2) < 1) {
|
||
return 0.5 * k * k * k * k;
|
||
}
|
||
return -0.5 * ((k -= 2) * k * k * k - 2);
|
||
},
|
||
quinticIn: function (k) {
|
||
return k * k * k * k * k;
|
||
},
|
||
quinticOut: function (k) {
|
||
return --k * k * k * k * k + 1;
|
||
},
|
||
quinticInOut: function (k) {
|
||
if ((k *= 2) < 1) {
|
||
return 0.5 * k * k * k * k * k;
|
||
}
|
||
return 0.5 * ((k -= 2) * k * k * k * k + 2);
|
||
},
|
||
sinusoidalIn: function (k) {
|
||
return 1 - Math.cos(k * Math.PI / 2);
|
||
},
|
||
sinusoidalOut: function (k) {
|
||
return Math.sin(k * Math.PI / 2);
|
||
},
|
||
sinusoidalInOut: function (k) {
|
||
return 0.5 * (1 - Math.cos(Math.PI * k));
|
||
},
|
||
exponentialIn: function (k) {
|
||
return k === 0 ? 0 : Math.pow(1024, k - 1);
|
||
},
|
||
exponentialOut: function (k) {
|
||
return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);
|
||
},
|
||
exponentialInOut: function (k) {
|
||
if (k === 0) {
|
||
return 0;
|
||
}
|
||
if (k === 1) {
|
||
return 1;
|
||
}
|
||
if ((k *= 2) < 1) {
|
||
return 0.5 * Math.pow(1024, k - 1);
|
||
}
|
||
return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
|
||
},
|
||
circularIn: function (k) {
|
||
return 1 - Math.sqrt(1 - k * k);
|
||
},
|
||
circularOut: function (k) {
|
||
return Math.sqrt(1 - (--k * k));
|
||
},
|
||
circularInOut: function (k) {
|
||
if ((k *= 2) < 1) {
|
||
return -0.5 * (Math.sqrt(1 - k * k) - 1);
|
||
}
|
||
return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
|
||
},
|
||
elasticIn: function (k) {
|
||
var s;
|
||
var a = 0.1;
|
||
var p = 0.4;
|
||
if (k === 0) {
|
||
return 0;
|
||
}
|
||
if (k === 1) {
|
||
return 1;
|
||
}
|
||
if (!a || a < 1) {
|
||
a = 1;
|
||
s = p / 4;
|
||
}
|
||
else {
|
||
s = p * Math.asin(1 / a) / (2 * Math.PI);
|
||
}
|
||
return -(a * Math.pow(2, 10 * (k -= 1))
|
||
* Math.sin((k - s) * (2 * Math.PI) / p));
|
||
},
|
||
elasticOut: function (k) {
|
||
var s;
|
||
var a = 0.1;
|
||
var p = 0.4;
|
||
if (k === 0) {
|
||
return 0;
|
||
}
|
||
if (k === 1) {
|
||
return 1;
|
||
}
|
||
if (!a || a < 1) {
|
||
a = 1;
|
||
s = p / 4;
|
||
}
|
||
else {
|
||
s = p * Math.asin(1 / a) / (2 * Math.PI);
|
||
}
|
||
return (a * Math.pow(2, -10 * k)
|
||
* Math.sin((k - s) * (2 * Math.PI) / p) + 1);
|
||
},
|
||
elasticInOut: function (k) {
|
||
var s;
|
||
var a = 0.1;
|
||
var p = 0.4;
|
||
if (k === 0) {
|
||
return 0;
|
||
}
|
||
if (k === 1) {
|
||
return 1;
|
||
}
|
||
if (!a || a < 1) {
|
||
a = 1;
|
||
s = p / 4;
|
||
}
|
||
else {
|
||
s = p * Math.asin(1 / a) / (2 * Math.PI);
|
||
}
|
||
if ((k *= 2) < 1) {
|
||
return -0.5 * (a * Math.pow(2, 10 * (k -= 1))
|
||
* Math.sin((k - s) * (2 * Math.PI) / p));
|
||
}
|
||
return a * Math.pow(2, -10 * (k -= 1))
|
||
* Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;
|
||
},
|
||
backIn: function (k) {
|
||
var s = 1.70158;
|
||
return k * k * ((s + 1) * k - s);
|
||
},
|
||
backOut: function (k) {
|
||
var s = 1.70158;
|
||
return --k * k * ((s + 1) * k + s) + 1;
|
||
},
|
||
backInOut: function (k) {
|
||
var s = 1.70158 * 1.525;
|
||
if ((k *= 2) < 1) {
|
||
return 0.5 * (k * k * ((s + 1) * k - s));
|
||
}
|
||
return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
|
||
},
|
||
bounceIn: function (k) {
|
||
return 1 - easingFuncs.bounceOut(1 - k);
|
||
},
|
||
bounceOut: function (k) {
|
||
if (k < (1 / 2.75)) {
|
||
return 7.5625 * k * k;
|
||
}
|
||
else if (k < (2 / 2.75)) {
|
||
return 7.5625 * (k -= (1.5 / 2.75)) * k + 0.75;
|
||
}
|
||
else if (k < (2.5 / 2.75)) {
|
||
return 7.5625 * (k -= (2.25 / 2.75)) * k + 0.9375;
|
||
}
|
||
else {
|
||
return 7.5625 * (k -= (2.625 / 2.75)) * k + 0.984375;
|
||
}
|
||
},
|
||
bounceInOut: function (k) {
|
||
if (k < 0.5) {
|
||
return easingFuncs.bounceIn(k * 2) * 0.5;
|
||
}
|
||
return easingFuncs.bounceOut(k * 2 - 1) * 0.5 + 0.5;
|
||
}
|
||
};
|
||
|
||
var mathPow = Math.pow;
|
||
var mathSqrt = Math.sqrt;
|
||
var EPSILON = 1e-8;
|
||
var EPSILON_NUMERIC = 1e-4;
|
||
var THREE_SQRT = mathSqrt(3);
|
||
var ONE_THIRD = 1 / 3;
|
||
var _v0 = create();
|
||
var _v1 = create();
|
||
var _v2 = create();
|
||
function isAroundZero(val) {
|
||
return val > -EPSILON && val < EPSILON;
|
||
}
|
||
function isNotAroundZero(val) {
|
||
return val > EPSILON || val < -EPSILON;
|
||
}
|
||
function cubicAt(p0, p1, p2, p3, t) {
|
||
var onet = 1 - t;
|
||
return onet * onet * (onet * p0 + 3 * t * p1)
|
||
+ t * t * (t * p3 + 3 * onet * p2);
|
||
}
|
||
function cubicDerivativeAt(p0, p1, p2, p3, t) {
|
||
var onet = 1 - t;
|
||
return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet
|
||
+ (p3 - p2) * t * t);
|
||
}
|
||
function cubicRootAt(p0, p1, p2, p3, val, roots) {
|
||
var a = p3 + 3 * (p1 - p2) - p0;
|
||
var b = 3 * (p2 - p1 * 2 + p0);
|
||
var c = 3 * (p1 - p0);
|
||
var d = p0 - val;
|
||
var A = b * b - 3 * a * c;
|
||
var B = b * c - 9 * a * d;
|
||
var C = c * c - 3 * b * d;
|
||
var n = 0;
|
||
if (isAroundZero(A) && isAroundZero(B)) {
|
||
if (isAroundZero(b)) {
|
||
roots[0] = 0;
|
||
}
|
||
else {
|
||
var t1 = -c / b;
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
roots[n++] = t1;
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
var disc = B * B - 4 * A * C;
|
||
if (isAroundZero(disc)) {
|
||
var K = B / A;
|
||
var t1 = -b / a + K;
|
||
var t2 = -K / 2;
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
roots[n++] = t1;
|
||
}
|
||
if (t2 >= 0 && t2 <= 1) {
|
||
roots[n++] = t2;
|
||
}
|
||
}
|
||
else if (disc > 0) {
|
||
var discSqrt = mathSqrt(disc);
|
||
var Y1 = A * b + 1.5 * a * (-B + discSqrt);
|
||
var Y2 = A * b + 1.5 * a * (-B - discSqrt);
|
||
if (Y1 < 0) {
|
||
Y1 = -mathPow(-Y1, ONE_THIRD);
|
||
}
|
||
else {
|
||
Y1 = mathPow(Y1, ONE_THIRD);
|
||
}
|
||
if (Y2 < 0) {
|
||
Y2 = -mathPow(-Y2, ONE_THIRD);
|
||
}
|
||
else {
|
||
Y2 = mathPow(Y2, ONE_THIRD);
|
||
}
|
||
var t1 = (-b - (Y1 + Y2)) / (3 * a);
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
roots[n++] = t1;
|
||
}
|
||
}
|
||
else {
|
||
var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt(A * A * A));
|
||
var theta = Math.acos(T) / 3;
|
||
var ASqrt = mathSqrt(A);
|
||
var tmp = Math.cos(theta);
|
||
var t1 = (-b - 2 * ASqrt * tmp) / (3 * a);
|
||
var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a);
|
||
var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a);
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
roots[n++] = t1;
|
||
}
|
||
if (t2 >= 0 && t2 <= 1) {
|
||
roots[n++] = t2;
|
||
}
|
||
if (t3 >= 0 && t3 <= 1) {
|
||
roots[n++] = t3;
|
||
}
|
||
}
|
||
}
|
||
return n;
|
||
}
|
||
function cubicExtrema(p0, p1, p2, p3, extrema) {
|
||
var b = 6 * p2 - 12 * p1 + 6 * p0;
|
||
var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2;
|
||
var c = 3 * p1 - 3 * p0;
|
||
var n = 0;
|
||
if (isAroundZero(a)) {
|
||
if (isNotAroundZero(b)) {
|
||
var t1 = -c / b;
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
extrema[n++] = t1;
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
var disc = b * b - 4 * a * c;
|
||
if (isAroundZero(disc)) {
|
||
extrema[0] = -b / (2 * a);
|
||
}
|
||
else if (disc > 0) {
|
||
var discSqrt = mathSqrt(disc);
|
||
var t1 = (-b + discSqrt) / (2 * a);
|
||
var t2 = (-b - discSqrt) / (2 * a);
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
extrema[n++] = t1;
|
||
}
|
||
if (t2 >= 0 && t2 <= 1) {
|
||
extrema[n++] = t2;
|
||
}
|
||
}
|
||
}
|
||
return n;
|
||
}
|
||
function cubicSubdivide(p0, p1, p2, p3, t, out) {
|
||
var p01 = (p1 - p0) * t + p0;
|
||
var p12 = (p2 - p1) * t + p1;
|
||
var p23 = (p3 - p2) * t + p2;
|
||
var p012 = (p12 - p01) * t + p01;
|
||
var p123 = (p23 - p12) * t + p12;
|
||
var p0123 = (p123 - p012) * t + p012;
|
||
out[0] = p0;
|
||
out[1] = p01;
|
||
out[2] = p012;
|
||
out[3] = p0123;
|
||
out[4] = p0123;
|
||
out[5] = p123;
|
||
out[6] = p23;
|
||
out[7] = p3;
|
||
}
|
||
function cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) {
|
||
var t;
|
||
var interval = 0.005;
|
||
var d = Infinity;
|
||
var prev;
|
||
var next;
|
||
var d1;
|
||
var d2;
|
||
_v0[0] = x;
|
||
_v0[1] = y;
|
||
for (var _t = 0; _t < 1; _t += 0.05) {
|
||
_v1[0] = cubicAt(x0, x1, x2, x3, _t);
|
||
_v1[1] = cubicAt(y0, y1, y2, y3, _t);
|
||
d1 = distSquare(_v0, _v1);
|
||
if (d1 < d) {
|
||
t = _t;
|
||
d = d1;
|
||
}
|
||
}
|
||
d = Infinity;
|
||
for (var i = 0; i < 32; i++) {
|
||
if (interval < EPSILON_NUMERIC) {
|
||
break;
|
||
}
|
||
prev = t - interval;
|
||
next = t + interval;
|
||
_v1[0] = cubicAt(x0, x1, x2, x3, prev);
|
||
_v1[1] = cubicAt(y0, y1, y2, y3, prev);
|
||
d1 = distSquare(_v1, _v0);
|
||
if (prev >= 0 && d1 < d) {
|
||
t = prev;
|
||
d = d1;
|
||
}
|
||
else {
|
||
_v2[0] = cubicAt(x0, x1, x2, x3, next);
|
||
_v2[1] = cubicAt(y0, y1, y2, y3, next);
|
||
d2 = distSquare(_v2, _v0);
|
||
if (next <= 1 && d2 < d) {
|
||
t = next;
|
||
d = d2;
|
||
}
|
||
else {
|
||
interval *= 0.5;
|
||
}
|
||
}
|
||
}
|
||
if (out) {
|
||
out[0] = cubicAt(x0, x1, x2, x3, t);
|
||
out[1] = cubicAt(y0, y1, y2, y3, t);
|
||
}
|
||
return mathSqrt(d);
|
||
}
|
||
function cubicLength(x0, y0, x1, y1, x2, y2, x3, y3, iteration) {
|
||
var px = x0;
|
||
var py = y0;
|
||
var d = 0;
|
||
var step = 1 / iteration;
|
||
for (var i = 1; i <= iteration; i++) {
|
||
var t = i * step;
|
||
var x = cubicAt(x0, x1, x2, x3, t);
|
||
var y = cubicAt(y0, y1, y2, y3, t);
|
||
var dx = x - px;
|
||
var dy = y - py;
|
||
d += Math.sqrt(dx * dx + dy * dy);
|
||
px = x;
|
||
py = y;
|
||
}
|
||
return d;
|
||
}
|
||
function quadraticAt(p0, p1, p2, t) {
|
||
var onet = 1 - t;
|
||
return onet * (onet * p0 + 2 * t * p1) + t * t * p2;
|
||
}
|
||
function quadraticDerivativeAt(p0, p1, p2, t) {
|
||
return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1));
|
||
}
|
||
function quadraticRootAt(p0, p1, p2, val, roots) {
|
||
var a = p0 - 2 * p1 + p2;
|
||
var b = 2 * (p1 - p0);
|
||
var c = p0 - val;
|
||
var n = 0;
|
||
if (isAroundZero(a)) {
|
||
if (isNotAroundZero(b)) {
|
||
var t1 = -c / b;
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
roots[n++] = t1;
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
var disc = b * b - 4 * a * c;
|
||
if (isAroundZero(disc)) {
|
||
var t1 = -b / (2 * a);
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
roots[n++] = t1;
|
||
}
|
||
}
|
||
else if (disc > 0) {
|
||
var discSqrt = mathSqrt(disc);
|
||
var t1 = (-b + discSqrt) / (2 * a);
|
||
var t2 = (-b - discSqrt) / (2 * a);
|
||
if (t1 >= 0 && t1 <= 1) {
|
||
roots[n++] = t1;
|
||
}
|
||
if (t2 >= 0 && t2 <= 1) {
|
||
roots[n++] = t2;
|
||
}
|
||
}
|
||
}
|
||
return n;
|
||
}
|
||
function quadraticExtremum(p0, p1, p2) {
|
||
var divider = p0 + p2 - 2 * p1;
|
||
if (divider === 0) {
|
||
return 0.5;
|
||
}
|
||
else {
|
||
return (p0 - p1) / divider;
|
||
}
|
||
}
|
||
function quadraticSubdivide(p0, p1, p2, t, out) {
|
||
var p01 = (p1 - p0) * t + p0;
|
||
var p12 = (p2 - p1) * t + p1;
|
||
var p012 = (p12 - p01) * t + p01;
|
||
out[0] = p0;
|
||
out[1] = p01;
|
||
out[2] = p012;
|
||
out[3] = p012;
|
||
out[4] = p12;
|
||
out[5] = p2;
|
||
}
|
||
function quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) {
|
||
var t;
|
||
var interval = 0.005;
|
||
var d = Infinity;
|
||
_v0[0] = x;
|
||
_v0[1] = y;
|
||
for (var _t = 0; _t < 1; _t += 0.05) {
|
||
_v1[0] = quadraticAt(x0, x1, x2, _t);
|
||
_v1[1] = quadraticAt(y0, y1, y2, _t);
|
||
var d1 = distSquare(_v0, _v1);
|
||
if (d1 < d) {
|
||
t = _t;
|
||
d = d1;
|
||
}
|
||
}
|
||
d = Infinity;
|
||
for (var i = 0; i < 32; i++) {
|
||
if (interval < EPSILON_NUMERIC) {
|
||
break;
|
||
}
|
||
var prev = t - interval;
|
||
var next = t + interval;
|
||
_v1[0] = quadraticAt(x0, x1, x2, prev);
|
||
_v1[1] = quadraticAt(y0, y1, y2, prev);
|
||
var d1 = distSquare(_v1, _v0);
|
||
if (prev >= 0 && d1 < d) {
|
||
t = prev;
|
||
d = d1;
|
||
}
|
||
else {
|
||
_v2[0] = quadraticAt(x0, x1, x2, next);
|
||
_v2[1] = quadraticAt(y0, y1, y2, next);
|
||
var d2 = distSquare(_v2, _v0);
|
||
if (next <= 1 && d2 < d) {
|
||
t = next;
|
||
d = d2;
|
||
}
|
||
else {
|
||
interval *= 0.5;
|
||
}
|
||
}
|
||
}
|
||
if (out) {
|
||
out[0] = quadraticAt(x0, x1, x2, t);
|
||
out[1] = quadraticAt(y0, y1, y2, t);
|
||
}
|
||
return mathSqrt(d);
|
||
}
|
||
function quadraticLength(x0, y0, x1, y1, x2, y2, iteration) {
|
||
var px = x0;
|
||
var py = y0;
|
||
var d = 0;
|
||
var step = 1 / iteration;
|
||
for (var i = 1; i <= iteration; i++) {
|
||
var t = i * step;
|
||
var x = quadraticAt(x0, x1, x2, t);
|
||
var y = quadraticAt(y0, y1, y2, t);
|
||
var dx = x - px;
|
||
var dy = y - py;
|
||
d += Math.sqrt(dx * dx + dy * dy);
|
||
px = x;
|
||
py = y;
|
||
}
|
||
return d;
|
||
}
|
||
|
||
var regexp = /cubic-bezier\(([0-9,\.e ]+)\)/;
|
||
function createCubicEasingFunc(cubicEasingStr) {
|
||
var cubic = cubicEasingStr && regexp.exec(cubicEasingStr);
|
||
if (cubic) {
|
||
var points = cubic[1].split(',');
|
||
var a_1 = +trim(points[0]);
|
||
var b_1 = +trim(points[1]);
|
||
var c_1 = +trim(points[2]);
|
||
var d_1 = +trim(points[3]);
|
||
if (isNaN(a_1 + b_1 + c_1 + d_1)) {
|
||
return;
|
||
}
|
||
var roots_1 = [];
|
||
return function (p) {
|
||
return p <= 0
|
||
? 0 : p >= 1
|
||
? 1
|
||
: cubicRootAt(0, a_1, c_1, 1, p, roots_1) && cubicAt(0, b_1, d_1, 1, roots_1[0]);
|
||
};
|
||
}
|
||
}
|
||
|
||
var Clip = (function () {
|
||
function Clip(opts) {
|
||
this._inited = false;
|
||
this._startTime = 0;
|
||
this._pausedTime = 0;
|
||
this._paused = false;
|
||
this._life = opts.life || 1000;
|
||
this._delay = opts.delay || 0;
|
||
this.loop = opts.loop || false;
|
||
this.onframe = opts.onframe || noop;
|
||
this.ondestroy = opts.ondestroy || noop;
|
||
this.onrestart = opts.onrestart || noop;
|
||
opts.easing && this.setEasing(opts.easing);
|
||
}
|
||
Clip.prototype.step = function (globalTime, deltaTime) {
|
||
if (!this._inited) {
|
||
this._startTime = globalTime + this._delay;
|
||
this._inited = true;
|
||
}
|
||
if (this._paused) {
|
||
this._pausedTime += deltaTime;
|
||
return;
|
||
}
|
||
var life = this._life;
|
||
var elapsedTime = globalTime - this._startTime - this._pausedTime;
|
||
var percent = elapsedTime / life;
|
||
if (percent < 0) {
|
||
percent = 0;
|
||
}
|
||
percent = Math.min(percent, 1);
|
||
var easingFunc = this.easingFunc;
|
||
var schedule = easingFunc ? easingFunc(percent) : percent;
|
||
this.onframe(schedule);
|
||
if (percent === 1) {
|
||
if (this.loop) {
|
||
var remainder = elapsedTime % life;
|
||
this._startTime = globalTime - remainder;
|
||
this._pausedTime = 0;
|
||
this.onrestart();
|
||
}
|
||
else {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
Clip.prototype.pause = function () {
|
||
this._paused = true;
|
||
};
|
||
Clip.prototype.resume = function () {
|
||
this._paused = false;
|
||
};
|
||
Clip.prototype.setEasing = function (easing) {
|
||
this.easing = easing;
|
||
this.easingFunc = isFunction(easing)
|
||
? easing
|
||
: easingFuncs[easing] || createCubicEasingFunc(easing);
|
||
};
|
||
return Clip;
|
||
}());
|
||
|
||
var Entry = (function () {
|
||
function Entry(val) {
|
||
this.value = val;
|
||
}
|
||
return Entry;
|
||
}());
|
||
var LinkedList = (function () {
|
||
function LinkedList() {
|
||
this._len = 0;
|
||
}
|
||
LinkedList.prototype.insert = function (val) {
|
||
var entry = new Entry(val);
|
||
this.insertEntry(entry);
|
||
return entry;
|
||
};
|
||
LinkedList.prototype.insertEntry = function (entry) {
|
||
if (!this.head) {
|
||
this.head = this.tail = entry;
|
||
}
|
||
else {
|
||
this.tail.next = entry;
|
||
entry.prev = this.tail;
|
||
entry.next = null;
|
||
this.tail = entry;
|
||
}
|
||
this._len++;
|
||
};
|
||
LinkedList.prototype.remove = function (entry) {
|
||
var prev = entry.prev;
|
||
var next = entry.next;
|
||
if (prev) {
|
||
prev.next = next;
|
||
}
|
||
else {
|
||
this.head = next;
|
||
}
|
||
if (next) {
|
||
next.prev = prev;
|
||
}
|
||
else {
|
||
this.tail = prev;
|
||
}
|
||
entry.next = entry.prev = null;
|
||
this._len--;
|
||
};
|
||
LinkedList.prototype.len = function () {
|
||
return this._len;
|
||
};
|
||
LinkedList.prototype.clear = function () {
|
||
this.head = this.tail = null;
|
||
this._len = 0;
|
||
};
|
||
return LinkedList;
|
||
}());
|
||
var LRU = (function () {
|
||
function LRU(maxSize) {
|
||
this._list = new LinkedList();
|
||
this._maxSize = 10;
|
||
this._map = {};
|
||
this._maxSize = maxSize;
|
||
}
|
||
LRU.prototype.put = function (key, value) {
|
||
var list = this._list;
|
||
var map = this._map;
|
||
var removed = null;
|
||
if (map[key] == null) {
|
||
var len = list.len();
|
||
var entry = this._lastRemovedEntry;
|
||
if (len >= this._maxSize && len > 0) {
|
||
var leastUsedEntry = list.head;
|
||
list.remove(leastUsedEntry);
|
||
delete map[leastUsedEntry.key];
|
||
removed = leastUsedEntry.value;
|
||
this._lastRemovedEntry = leastUsedEntry;
|
||
}
|
||
if (entry) {
|
||
entry.value = value;
|
||
}
|
||
else {
|
||
entry = new Entry(value);
|
||
}
|
||
entry.key = key;
|
||
list.insertEntry(entry);
|
||
map[key] = entry;
|
||
}
|
||
return removed;
|
||
};
|
||
LRU.prototype.get = function (key) {
|
||
var entry = this._map[key];
|
||
var list = this._list;
|
||
if (entry != null) {
|
||
if (entry !== list.tail) {
|
||
list.remove(entry);
|
||
list.insertEntry(entry);
|
||
}
|
||
return entry.value;
|
||
}
|
||
};
|
||
LRU.prototype.clear = function () {
|
||
this._list.clear();
|
||
this._map = {};
|
||
};
|
||
LRU.prototype.len = function () {
|
||
return this._list.len();
|
||
};
|
||
return LRU;
|
||
}());
|
||
|
||
var kCSSColorTable = {
|
||
'transparent': [0, 0, 0, 0], 'aliceblue': [240, 248, 255, 1],
|
||
'antiquewhite': [250, 235, 215, 1], 'aqua': [0, 255, 255, 1],
|
||
'aquamarine': [127, 255, 212, 1], 'azure': [240, 255, 255, 1],
|
||
'beige': [245, 245, 220, 1], 'bisque': [255, 228, 196, 1],
|
||
'black': [0, 0, 0, 1], 'blanchedalmond': [255, 235, 205, 1],
|
||
'blue': [0, 0, 255, 1], 'blueviolet': [138, 43, 226, 1],
|
||
'brown': [165, 42, 42, 1], 'burlywood': [222, 184, 135, 1],
|
||
'cadetblue': [95, 158, 160, 1], 'chartreuse': [127, 255, 0, 1],
|
||
'chocolate': [210, 105, 30, 1], 'coral': [255, 127, 80, 1],
|
||
'cornflowerblue': [100, 149, 237, 1], 'cornsilk': [255, 248, 220, 1],
|
||
'crimson': [220, 20, 60, 1], 'cyan': [0, 255, 255, 1],
|
||
'darkblue': [0, 0, 139, 1], 'darkcyan': [0, 139, 139, 1],
|
||
'darkgoldenrod': [184, 134, 11, 1], 'darkgray': [169, 169, 169, 1],
|
||
'darkgreen': [0, 100, 0, 1], 'darkgrey': [169, 169, 169, 1],
|
||
'darkkhaki': [189, 183, 107, 1], 'darkmagenta': [139, 0, 139, 1],
|
||
'darkolivegreen': [85, 107, 47, 1], 'darkorange': [255, 140, 0, 1],
|
||
'darkorchid': [153, 50, 204, 1], 'darkred': [139, 0, 0, 1],
|
||
'darksalmon': [233, 150, 122, 1], 'darkseagreen': [143, 188, 143, 1],
|
||
'darkslateblue': [72, 61, 139, 1], 'darkslategray': [47, 79, 79, 1],
|
||
'darkslategrey': [47, 79, 79, 1], 'darkturquoise': [0, 206, 209, 1],
|
||
'darkviolet': [148, 0, 211, 1], 'deeppink': [255, 20, 147, 1],
|
||
'deepskyblue': [0, 191, 255, 1], 'dimgray': [105, 105, 105, 1],
|
||
'dimgrey': [105, 105, 105, 1], 'dodgerblue': [30, 144, 255, 1],
|
||
'firebrick': [178, 34, 34, 1], 'floralwhite': [255, 250, 240, 1],
|
||
'forestgreen': [34, 139, 34, 1], 'fuchsia': [255, 0, 255, 1],
|
||
'gainsboro': [220, 220, 220, 1], 'ghostwhite': [248, 248, 255, 1],
|
||
'gold': [255, 215, 0, 1], 'goldenrod': [218, 165, 32, 1],
|
||
'gray': [128, 128, 128, 1], 'green': [0, 128, 0, 1],
|
||
'greenyellow': [173, 255, 47, 1], 'grey': [128, 128, 128, 1],
|
||
'honeydew': [240, 255, 240, 1], 'hotpink': [255, 105, 180, 1],
|
||
'indianred': [205, 92, 92, 1], 'indigo': [75, 0, 130, 1],
|
||
'ivory': [255, 255, 240, 1], 'khaki': [240, 230, 140, 1],
|
||
'lavender': [230, 230, 250, 1], 'lavenderblush': [255, 240, 245, 1],
|
||
'lawngreen': [124, 252, 0, 1], 'lemonchiffon': [255, 250, 205, 1],
|
||
'lightblue': [173, 216, 230, 1], 'lightcoral': [240, 128, 128, 1],
|
||
'lightcyan': [224, 255, 255, 1], 'lightgoldenrodyellow': [250, 250, 210, 1],
|
||
'lightgray': [211, 211, 211, 1], 'lightgreen': [144, 238, 144, 1],
|
||
'lightgrey': [211, 211, 211, 1], 'lightpink': [255, 182, 193, 1],
|
||
'lightsalmon': [255, 160, 122, 1], 'lightseagreen': [32, 178, 170, 1],
|
||
'lightskyblue': [135, 206, 250, 1], 'lightslategray': [119, 136, 153, 1],
|
||
'lightslategrey': [119, 136, 153, 1], 'lightsteelblue': [176, 196, 222, 1],
|
||
'lightyellow': [255, 255, 224, 1], 'lime': [0, 255, 0, 1],
|
||
'limegreen': [50, 205, 50, 1], 'linen': [250, 240, 230, 1],
|
||
'magenta': [255, 0, 255, 1], 'maroon': [128, 0, 0, 1],
|
||
'mediumaquamarine': [102, 205, 170, 1], 'mediumblue': [0, 0, 205, 1],
|
||
'mediumorchid': [186, 85, 211, 1], 'mediumpurple': [147, 112, 219, 1],
|
||
'mediumseagreen': [60, 179, 113, 1], 'mediumslateblue': [123, 104, 238, 1],
|
||
'mediumspringgreen': [0, 250, 154, 1], 'mediumturquoise': [72, 209, 204, 1],
|
||
'mediumvioletred': [199, 21, 133, 1], 'midnightblue': [25, 25, 112, 1],
|
||
'mintcream': [245, 255, 250, 1], 'mistyrose': [255, 228, 225, 1],
|
||
'moccasin': [255, 228, 181, 1], 'navajowhite': [255, 222, 173, 1],
|
||
'navy': [0, 0, 128, 1], 'oldlace': [253, 245, 230, 1],
|
||
'olive': [128, 128, 0, 1], 'olivedrab': [107, 142, 35, 1],
|
||
'orange': [255, 165, 0, 1], 'orangered': [255, 69, 0, 1],
|
||
'orchid': [218, 112, 214, 1], 'palegoldenrod': [238, 232, 170, 1],
|
||
'palegreen': [152, 251, 152, 1], 'paleturquoise': [175, 238, 238, 1],
|
||
'palevioletred': [219, 112, 147, 1], 'papayawhip': [255, 239, 213, 1],
|
||
'peachpuff': [255, 218, 185, 1], 'peru': [205, 133, 63, 1],
|
||
'pink': [255, 192, 203, 1], 'plum': [221, 160, 221, 1],
|
||
'powderblue': [176, 224, 230, 1], 'purple': [128, 0, 128, 1],
|
||
'red': [255, 0, 0, 1], 'rosybrown': [188, 143, 143, 1],
|
||
'royalblue': [65, 105, 225, 1], 'saddlebrown': [139, 69, 19, 1],
|
||
'salmon': [250, 128, 114, 1], 'sandybrown': [244, 164, 96, 1],
|
||
'seagreen': [46, 139, 87, 1], 'seashell': [255, 245, 238, 1],
|
||
'sienna': [160, 82, 45, 1], 'silver': [192, 192, 192, 1],
|
||
'skyblue': [135, 206, 235, 1], 'slateblue': [106, 90, 205, 1],
|
||
'slategray': [112, 128, 144, 1], 'slategrey': [112, 128, 144, 1],
|
||
'snow': [255, 250, 250, 1], 'springgreen': [0, 255, 127, 1],
|
||
'steelblue': [70, 130, 180, 1], 'tan': [210, 180, 140, 1],
|
||
'teal': [0, 128, 128, 1], 'thistle': [216, 191, 216, 1],
|
||
'tomato': [255, 99, 71, 1], 'turquoise': [64, 224, 208, 1],
|
||
'violet': [238, 130, 238, 1], 'wheat': [245, 222, 179, 1],
|
||
'white': [255, 255, 255, 1], 'whitesmoke': [245, 245, 245, 1],
|
||
'yellow': [255, 255, 0, 1], 'yellowgreen': [154, 205, 50, 1]
|
||
};
|
||
function clampCssByte(i) {
|
||
i = Math.round(i);
|
||
return i < 0 ? 0 : i > 255 ? 255 : i;
|
||
}
|
||
function clampCssAngle(i) {
|
||
i = Math.round(i);
|
||
return i < 0 ? 0 : i > 360 ? 360 : i;
|
||
}
|
||
function clampCssFloat(f) {
|
||
return f < 0 ? 0 : f > 1 ? 1 : f;
|
||
}
|
||
function parseCssInt(val) {
|
||
var str = val;
|
||
if (str.length && str.charAt(str.length - 1) === '%') {
|
||
return clampCssByte(parseFloat(str) / 100 * 255);
|
||
}
|
||
return clampCssByte(parseInt(str, 10));
|
||
}
|
||
function parseCssFloat(val) {
|
||
var str = val;
|
||
if (str.length && str.charAt(str.length - 1) === '%') {
|
||
return clampCssFloat(parseFloat(str) / 100);
|
||
}
|
||
return clampCssFloat(parseFloat(str));
|
||
}
|
||
function cssHueToRgb(m1, m2, h) {
|
||
if (h < 0) {
|
||
h += 1;
|
||
}
|
||
else if (h > 1) {
|
||
h -= 1;
|
||
}
|
||
if (h * 6 < 1) {
|
||
return m1 + (m2 - m1) * h * 6;
|
||
}
|
||
if (h * 2 < 1) {
|
||
return m2;
|
||
}
|
||
if (h * 3 < 2) {
|
||
return m1 + (m2 - m1) * (2 / 3 - h) * 6;
|
||
}
|
||
return m1;
|
||
}
|
||
function lerpNumber(a, b, p) {
|
||
return a + (b - a) * p;
|
||
}
|
||
function setRgba(out, r, g, b, a) {
|
||
out[0] = r;
|
||
out[1] = g;
|
||
out[2] = b;
|
||
out[3] = a;
|
||
return out;
|
||
}
|
||
function copyRgba(out, a) {
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
out[2] = a[2];
|
||
out[3] = a[3];
|
||
return out;
|
||
}
|
||
var colorCache = new LRU(20);
|
||
var lastRemovedArr = null;
|
||
function putToCache(colorStr, rgbaArr) {
|
||
if (lastRemovedArr) {
|
||
copyRgba(lastRemovedArr, rgbaArr);
|
||
}
|
||
lastRemovedArr = colorCache.put(colorStr, lastRemovedArr || (rgbaArr.slice()));
|
||
}
|
||
function parse(colorStr, rgbaArr) {
|
||
if (!colorStr) {
|
||
return;
|
||
}
|
||
rgbaArr = rgbaArr || [];
|
||
var cached = colorCache.get(colorStr);
|
||
if (cached) {
|
||
return copyRgba(rgbaArr, cached);
|
||
}
|
||
colorStr = colorStr + '';
|
||
var str = colorStr.replace(/ /g, '').toLowerCase();
|
||
if (str in kCSSColorTable) {
|
||
copyRgba(rgbaArr, kCSSColorTable[str]);
|
||
putToCache(colorStr, rgbaArr);
|
||
return rgbaArr;
|
||
}
|
||
var strLen = str.length;
|
||
if (str.charAt(0) === '#') {
|
||
if (strLen === 4 || strLen === 5) {
|
||
var iv = parseInt(str.slice(1, 4), 16);
|
||
if (!(iv >= 0 && iv <= 0xfff)) {
|
||
setRgba(rgbaArr, 0, 0, 0, 1);
|
||
return;
|
||
}
|
||
setRgba(rgbaArr, ((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8), (iv & 0xf0) | ((iv & 0xf0) >> 4), (iv & 0xf) | ((iv & 0xf) << 4), strLen === 5 ? parseInt(str.slice(4), 16) / 0xf : 1);
|
||
putToCache(colorStr, rgbaArr);
|
||
return rgbaArr;
|
||
}
|
||
else if (strLen === 7 || strLen === 9) {
|
||
var iv = parseInt(str.slice(1, 7), 16);
|
||
if (!(iv >= 0 && iv <= 0xffffff)) {
|
||
setRgba(rgbaArr, 0, 0, 0, 1);
|
||
return;
|
||
}
|
||
setRgba(rgbaArr, (iv & 0xff0000) >> 16, (iv & 0xff00) >> 8, iv & 0xff, strLen === 9 ? parseInt(str.slice(7), 16) / 0xff : 1);
|
||
putToCache(colorStr, rgbaArr);
|
||
return rgbaArr;
|
||
}
|
||
return;
|
||
}
|
||
var op = str.indexOf('(');
|
||
var ep = str.indexOf(')');
|
||
if (op !== -1 && ep + 1 === strLen) {
|
||
var fname = str.substr(0, op);
|
||
var params = str.substr(op + 1, ep - (op + 1)).split(',');
|
||
var alpha = 1;
|
||
switch (fname) {
|
||
case 'rgba':
|
||
if (params.length !== 4) {
|
||
return params.length === 3
|
||
? setRgba(rgbaArr, +params[0], +params[1], +params[2], 1)
|
||
: setRgba(rgbaArr, 0, 0, 0, 1);
|
||
}
|
||
alpha = parseCssFloat(params.pop());
|
||
case 'rgb':
|
||
if (params.length !== 3) {
|
||
setRgba(rgbaArr, 0, 0, 0, 1);
|
||
return;
|
||
}
|
||
setRgba(rgbaArr, parseCssInt(params[0]), parseCssInt(params[1]), parseCssInt(params[2]), alpha);
|
||
putToCache(colorStr, rgbaArr);
|
||
return rgbaArr;
|
||
case 'hsla':
|
||
if (params.length !== 4) {
|
||
setRgba(rgbaArr, 0, 0, 0, 1);
|
||
return;
|
||
}
|
||
params[3] = parseCssFloat(params[3]);
|
||
hsla2rgba(params, rgbaArr);
|
||
putToCache(colorStr, rgbaArr);
|
||
return rgbaArr;
|
||
case 'hsl':
|
||
if (params.length !== 3) {
|
||
setRgba(rgbaArr, 0, 0, 0, 1);
|
||
return;
|
||
}
|
||
hsla2rgba(params, rgbaArr);
|
||
putToCache(colorStr, rgbaArr);
|
||
return rgbaArr;
|
||
default:
|
||
return;
|
||
}
|
||
}
|
||
setRgba(rgbaArr, 0, 0, 0, 1);
|
||
return;
|
||
}
|
||
function hsla2rgba(hsla, rgba) {
|
||
var h = (((parseFloat(hsla[0]) % 360) + 360) % 360) / 360;
|
||
var s = parseCssFloat(hsla[1]);
|
||
var l = parseCssFloat(hsla[2]);
|
||
var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
|
||
var m1 = l * 2 - m2;
|
||
rgba = rgba || [];
|
||
setRgba(rgba, clampCssByte(cssHueToRgb(m1, m2, h + 1 / 3) * 255), clampCssByte(cssHueToRgb(m1, m2, h) * 255), clampCssByte(cssHueToRgb(m1, m2, h - 1 / 3) * 255), 1);
|
||
if (hsla.length === 4) {
|
||
rgba[3] = hsla[3];
|
||
}
|
||
return rgba;
|
||
}
|
||
function rgba2hsla(rgba) {
|
||
if (!rgba) {
|
||
return;
|
||
}
|
||
var R = rgba[0] / 255;
|
||
var G = rgba[1] / 255;
|
||
var B = rgba[2] / 255;
|
||
var vMin = Math.min(R, G, B);
|
||
var vMax = Math.max(R, G, B);
|
||
var delta = vMax - vMin;
|
||
var L = (vMax + vMin) / 2;
|
||
var H;
|
||
var S;
|
||
if (delta === 0) {
|
||
H = 0;
|
||
S = 0;
|
||
}
|
||
else {
|
||
if (L < 0.5) {
|
||
S = delta / (vMax + vMin);
|
||
}
|
||
else {
|
||
S = delta / (2 - vMax - vMin);
|
||
}
|
||
var deltaR = (((vMax - R) / 6) + (delta / 2)) / delta;
|
||
var deltaG = (((vMax - G) / 6) + (delta / 2)) / delta;
|
||
var deltaB = (((vMax - B) / 6) + (delta / 2)) / delta;
|
||
if (R === vMax) {
|
||
H = deltaB - deltaG;
|
||
}
|
||
else if (G === vMax) {
|
||
H = (1 / 3) + deltaR - deltaB;
|
||
}
|
||
else if (B === vMax) {
|
||
H = (2 / 3) + deltaG - deltaR;
|
||
}
|
||
if (H < 0) {
|
||
H += 1;
|
||
}
|
||
if (H > 1) {
|
||
H -= 1;
|
||
}
|
||
}
|
||
var hsla = [H * 360, S, L];
|
||
if (rgba[3] != null) {
|
||
hsla.push(rgba[3]);
|
||
}
|
||
return hsla;
|
||
}
|
||
function lift(color, level) {
|
||
var colorArr = parse(color);
|
||
if (colorArr) {
|
||
for (var i = 0; i < 3; i++) {
|
||
if (level < 0) {
|
||
colorArr[i] = colorArr[i] * (1 - level) | 0;
|
||
}
|
||
else {
|
||
colorArr[i] = ((255 - colorArr[i]) * level + colorArr[i]) | 0;
|
||
}
|
||
if (colorArr[i] > 255) {
|
||
colorArr[i] = 255;
|
||
}
|
||
else if (colorArr[i] < 0) {
|
||
colorArr[i] = 0;
|
||
}
|
||
}
|
||
return stringify(colorArr, colorArr.length === 4 ? 'rgba' : 'rgb');
|
||
}
|
||
}
|
||
function toHex(color) {
|
||
var colorArr = parse(color);
|
||
if (colorArr) {
|
||
return ((1 << 24) + (colorArr[0] << 16) + (colorArr[1] << 8) + (+colorArr[2])).toString(16).slice(1);
|
||
}
|
||
}
|
||
function fastLerp(normalizedValue, colors, out) {
|
||
if (!(colors && colors.length)
|
||
|| !(normalizedValue >= 0 && normalizedValue <= 1)) {
|
||
return;
|
||
}
|
||
out = out || [];
|
||
var value = normalizedValue * (colors.length - 1);
|
||
var leftIndex = Math.floor(value);
|
||
var rightIndex = Math.ceil(value);
|
||
var leftColor = colors[leftIndex];
|
||
var rightColor = colors[rightIndex];
|
||
var dv = value - leftIndex;
|
||
out[0] = clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv));
|
||
out[1] = clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv));
|
||
out[2] = clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv));
|
||
out[3] = clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv));
|
||
return out;
|
||
}
|
||
var fastMapToColor = fastLerp;
|
||
function lerp$1(normalizedValue, colors, fullOutput) {
|
||
if (!(colors && colors.length)
|
||
|| !(normalizedValue >= 0 && normalizedValue <= 1)) {
|
||
return;
|
||
}
|
||
var value = normalizedValue * (colors.length - 1);
|
||
var leftIndex = Math.floor(value);
|
||
var rightIndex = Math.ceil(value);
|
||
var leftColor = parse(colors[leftIndex]);
|
||
var rightColor = parse(colors[rightIndex]);
|
||
var dv = value - leftIndex;
|
||
var color = stringify([
|
||
clampCssByte(lerpNumber(leftColor[0], rightColor[0], dv)),
|
||
clampCssByte(lerpNumber(leftColor[1], rightColor[1], dv)),
|
||
clampCssByte(lerpNumber(leftColor[2], rightColor[2], dv)),
|
||
clampCssFloat(lerpNumber(leftColor[3], rightColor[3], dv))
|
||
], 'rgba');
|
||
return fullOutput
|
||
? {
|
||
color: color,
|
||
leftIndex: leftIndex,
|
||
rightIndex: rightIndex,
|
||
value: value
|
||
}
|
||
: color;
|
||
}
|
||
var mapToColor = lerp$1;
|
||
function modifyHSL(color, h, s, l) {
|
||
var colorArr = parse(color);
|
||
if (color) {
|
||
colorArr = rgba2hsla(colorArr);
|
||
h != null && (colorArr[0] = clampCssAngle(h));
|
||
s != null && (colorArr[1] = parseCssFloat(s));
|
||
l != null && (colorArr[2] = parseCssFloat(l));
|
||
return stringify(hsla2rgba(colorArr), 'rgba');
|
||
}
|
||
}
|
||
function modifyAlpha(color, alpha) {
|
||
var colorArr = parse(color);
|
||
if (colorArr && alpha != null) {
|
||
colorArr[3] = clampCssFloat(alpha);
|
||
return stringify(colorArr, 'rgba');
|
||
}
|
||
}
|
||
function stringify(arrColor, type) {
|
||
if (!arrColor || !arrColor.length) {
|
||
return;
|
||
}
|
||
var colorStr = arrColor[0] + ',' + arrColor[1] + ',' + arrColor[2];
|
||
if (type === 'rgba' || type === 'hsva' || type === 'hsla') {
|
||
colorStr += ',' + arrColor[3];
|
||
}
|
||
return type + '(' + colorStr + ')';
|
||
}
|
||
function lum(color, backgroundLum) {
|
||
var arr = parse(color);
|
||
return arr
|
||
? (0.299 * arr[0] + 0.587 * arr[1] + 0.114 * arr[2]) * arr[3] / 255
|
||
+ (1 - arr[3]) * backgroundLum
|
||
: 0;
|
||
}
|
||
function random() {
|
||
return stringify([
|
||
Math.round(Math.random() * 255),
|
||
Math.round(Math.random() * 255),
|
||
Math.round(Math.random() * 255)
|
||
], 'rgb');
|
||
}
|
||
|
||
var color = /*#__PURE__*/Object.freeze({
|
||
__proto__: null,
|
||
parse: parse,
|
||
lift: lift,
|
||
toHex: toHex,
|
||
fastLerp: fastLerp,
|
||
fastMapToColor: fastMapToColor,
|
||
lerp: lerp$1,
|
||
mapToColor: mapToColor,
|
||
modifyHSL: modifyHSL,
|
||
modifyAlpha: modifyAlpha,
|
||
stringify: stringify,
|
||
lum: lum,
|
||
random: random
|
||
});
|
||
|
||
var mathRound = Math.round;
|
||
function normalizeColor(color) {
|
||
var opacity;
|
||
if (!color || color === 'transparent') {
|
||
color = 'none';
|
||
}
|
||
else if (typeof color === 'string' && color.indexOf('rgba') > -1) {
|
||
var arr = parse(color);
|
||
if (arr) {
|
||
color = 'rgb(' + arr[0] + ',' + arr[1] + ',' + arr[2] + ')';
|
||
opacity = arr[3];
|
||
}
|
||
}
|
||
return {
|
||
color: color,
|
||
opacity: opacity == null ? 1 : opacity
|
||
};
|
||
}
|
||
var EPSILON$1 = 1e-4;
|
||
function isAroundZero$1(transform) {
|
||
return transform < EPSILON$1 && transform > -EPSILON$1;
|
||
}
|
||
function round3(transform) {
|
||
return mathRound(transform * 1e3) / 1e3;
|
||
}
|
||
function round4(transform) {
|
||
return mathRound(transform * 1e4) / 1e4;
|
||
}
|
||
function getMatrixStr(m) {
|
||
return 'matrix('
|
||
+ round3(m[0]) + ','
|
||
+ round3(m[1]) + ','
|
||
+ round3(m[2]) + ','
|
||
+ round3(m[3]) + ','
|
||
+ round4(m[4]) + ','
|
||
+ round4(m[5])
|
||
+ ')';
|
||
}
|
||
var TEXT_ALIGN_TO_ANCHOR = {
|
||
left: 'start',
|
||
right: 'end',
|
||
center: 'middle',
|
||
middle: 'middle'
|
||
};
|
||
function adjustTextY(y, lineHeight, textBaseline) {
|
||
if (textBaseline === 'top') {
|
||
y += lineHeight / 2;
|
||
}
|
||
else if (textBaseline === 'bottom') {
|
||
y -= lineHeight / 2;
|
||
}
|
||
return y;
|
||
}
|
||
function hasShadow(style) {
|
||
return style
|
||
&& (style.shadowBlur || style.shadowOffsetX || style.shadowOffsetY);
|
||
}
|
||
function getShadowKey(displayable) {
|
||
var style = displayable.style;
|
||
var globalScale = displayable.getGlobalScale();
|
||
return [
|
||
style.shadowColor,
|
||
(style.shadowBlur || 0).toFixed(2),
|
||
(style.shadowOffsetX || 0).toFixed(2),
|
||
(style.shadowOffsetY || 0).toFixed(2),
|
||
globalScale[0],
|
||
globalScale[1]
|
||
].join(',');
|
||
}
|
||
function isImagePattern(val) {
|
||
return val && (!!val.image);
|
||
}
|
||
function isSVGPattern(val) {
|
||
return val && (!!val.svgElement);
|
||
}
|
||
function isPattern(val) {
|
||
return isImagePattern(val) || isSVGPattern(val);
|
||
}
|
||
function isLinearGradient(val) {
|
||
return val.type === 'linear';
|
||
}
|
||
function isRadialGradient(val) {
|
||
return val.type === 'radial';
|
||
}
|
||
function isGradient(val) {
|
||
return val && (val.type === 'linear'
|
||
|| val.type === 'radial');
|
||
}
|
||
function getIdURL(id) {
|
||
return "url(#" + id + ")";
|
||
}
|
||
function getPathPrecision(el) {
|
||
var scale = el.getGlobalScale();
|
||
var size = Math.max(scale[0], scale[1]);
|
||
return Math.max(Math.ceil(Math.log(size) / Math.log(10)), 1);
|
||
}
|
||
function getSRTTransformString(transform) {
|
||
var x = transform.x || 0;
|
||
var y = transform.y || 0;
|
||
var rotation = (transform.rotation || 0) * RADIAN_TO_DEGREE;
|
||
var scaleX = retrieve2(transform.scaleX, 1);
|
||
var scaleY = retrieve2(transform.scaleY, 1);
|
||
var skewX = transform.skewX || 0;
|
||
var skewY = transform.skewY || 0;
|
||
var res = [];
|
||
if (x || y) {
|
||
res.push("translate(" + x + "px," + y + "px)");
|
||
}
|
||
if (rotation) {
|
||
res.push("rotate(" + rotation + ")");
|
||
}
|
||
if (scaleX !== 1 || scaleY !== 1) {
|
||
res.push("scale(" + scaleX + "," + scaleY + ")");
|
||
}
|
||
if (skewX || skewY) {
|
||
res.push("skew(" + mathRound(skewX * RADIAN_TO_DEGREE) + "deg, " + mathRound(skewY * RADIAN_TO_DEGREE) + "deg)");
|
||
}
|
||
return res.join(' ');
|
||
}
|
||
var encodeBase64 = (function () {
|
||
if (env.hasGlobalWindow && isFunction(window.btoa)) {
|
||
return function (str) {
|
||
return window.btoa(unescape(str));
|
||
};
|
||
}
|
||
if (typeof Buffer !== 'undefined') {
|
||
return function (str) {
|
||
return Buffer.from(str).toString('base64');
|
||
};
|
||
}
|
||
return function (str) {
|
||
if ("development" !== 'production') {
|
||
logError('Base64 isn\'t natively supported in the current environment.');
|
||
}
|
||
return null;
|
||
};
|
||
})();
|
||
|
||
var arraySlice = Array.prototype.slice;
|
||
function interpolateNumber(p0, p1, percent) {
|
||
return (p1 - p0) * percent + p0;
|
||
}
|
||
function interpolate1DArray(out, p0, p1, percent) {
|
||
var len = p0.length;
|
||
for (var i = 0; i < len; i++) {
|
||
out[i] = interpolateNumber(p0[i], p1[i], percent);
|
||
}
|
||
return out;
|
||
}
|
||
function interpolate2DArray(out, p0, p1, percent) {
|
||
var len = p0.length;
|
||
var len2 = len && p0[0].length;
|
||
for (var i = 0; i < len; i++) {
|
||
if (!out[i]) {
|
||
out[i] = [];
|
||
}
|
||
for (var j = 0; j < len2; j++) {
|
||
out[i][j] = interpolateNumber(p0[i][j], p1[i][j], percent);
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
function add1DArray(out, p0, p1, sign) {
|
||
var len = p0.length;
|
||
for (var i = 0; i < len; i++) {
|
||
out[i] = p0[i] + p1[i] * sign;
|
||
}
|
||
return out;
|
||
}
|
||
function add2DArray(out, p0, p1, sign) {
|
||
var len = p0.length;
|
||
var len2 = len && p0[0].length;
|
||
for (var i = 0; i < len; i++) {
|
||
if (!out[i]) {
|
||
out[i] = [];
|
||
}
|
||
for (var j = 0; j < len2; j++) {
|
||
out[i][j] = p0[i][j] + p1[i][j] * sign;
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
function fillColorStops(val0, val1) {
|
||
var len0 = val0.length;
|
||
var len1 = val1.length;
|
||
var shorterArr = len0 > len1 ? val1 : val0;
|
||
var shorterLen = Math.min(len0, len1);
|
||
var last = shorterArr[shorterLen - 1] || { color: [0, 0, 0, 0], offset: 0 };
|
||
for (var i = shorterLen; i < Math.max(len0, len1); i++) {
|
||
shorterArr.push({
|
||
offset: last.offset,
|
||
color: last.color.slice()
|
||
});
|
||
}
|
||
}
|
||
function fillArray(val0, val1, arrDim) {
|
||
var arr0 = val0;
|
||
var arr1 = val1;
|
||
if (!arr0.push || !arr1.push) {
|
||
return;
|
||
}
|
||
var arr0Len = arr0.length;
|
||
var arr1Len = arr1.length;
|
||
if (arr0Len !== arr1Len) {
|
||
var isPreviousLarger = arr0Len > arr1Len;
|
||
if (isPreviousLarger) {
|
||
arr0.length = arr1Len;
|
||
}
|
||
else {
|
||
for (var i = arr0Len; i < arr1Len; i++) {
|
||
arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i]));
|
||
}
|
||
}
|
||
}
|
||
var len2 = arr0[0] && arr0[0].length;
|
||
for (var i = 0; i < arr0.length; i++) {
|
||
if (arrDim === 1) {
|
||
if (isNaN(arr0[i])) {
|
||
arr0[i] = arr1[i];
|
||
}
|
||
}
|
||
else {
|
||
for (var j = 0; j < len2; j++) {
|
||
if (isNaN(arr0[i][j])) {
|
||
arr0[i][j] = arr1[i][j];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function cloneValue(value) {
|
||
if (isArrayLike(value)) {
|
||
var len = value.length;
|
||
if (isArrayLike(value[0])) {
|
||
var ret = [];
|
||
for (var i = 0; i < len; i++) {
|
||
ret.push(arraySlice.call(value[i]));
|
||
}
|
||
return ret;
|
||
}
|
||
return arraySlice.call(value);
|
||
}
|
||
return value;
|
||
}
|
||
function rgba2String(rgba) {
|
||
rgba[0] = Math.floor(rgba[0]) || 0;
|
||
rgba[1] = Math.floor(rgba[1]) || 0;
|
||
rgba[2] = Math.floor(rgba[2]) || 0;
|
||
rgba[3] = rgba[3] == null ? 1 : rgba[3];
|
||
return 'rgba(' + rgba.join(',') + ')';
|
||
}
|
||
function guessArrayDim(value) {
|
||
return isArrayLike(value && value[0]) ? 2 : 1;
|
||
}
|
||
var VALUE_TYPE_NUMBER = 0;
|
||
var VALUE_TYPE_1D_ARRAY = 1;
|
||
var VALUE_TYPE_2D_ARRAY = 2;
|
||
var VALUE_TYPE_COLOR = 3;
|
||
var VALUE_TYPE_LINEAR_GRADIENT = 4;
|
||
var VALUE_TYPE_RADIAL_GRADIENT = 5;
|
||
var VALUE_TYPE_UNKOWN = 6;
|
||
function isGradientValueType(valType) {
|
||
return valType === VALUE_TYPE_LINEAR_GRADIENT || valType === VALUE_TYPE_RADIAL_GRADIENT;
|
||
}
|
||
function isArrayValueType(valType) {
|
||
return valType === VALUE_TYPE_1D_ARRAY || valType === VALUE_TYPE_2D_ARRAY;
|
||
}
|
||
var tmpRgba = [0, 0, 0, 0];
|
||
var Track = (function () {
|
||
function Track(propName) {
|
||
this.keyframes = [];
|
||
this.discrete = false;
|
||
this._invalid = false;
|
||
this._needsSort = false;
|
||
this._lastFr = 0;
|
||
this._lastFrP = 0;
|
||
this.propName = propName;
|
||
}
|
||
Track.prototype.isFinished = function () {
|
||
return this._finished;
|
||
};
|
||
Track.prototype.setFinished = function () {
|
||
this._finished = true;
|
||
if (this._additiveTrack) {
|
||
this._additiveTrack.setFinished();
|
||
}
|
||
};
|
||
Track.prototype.needsAnimate = function () {
|
||
return this.keyframes.length >= 1;
|
||
};
|
||
Track.prototype.getAdditiveTrack = function () {
|
||
return this._additiveTrack;
|
||
};
|
||
Track.prototype.addKeyframe = function (time, rawValue, easing) {
|
||
this._needsSort = true;
|
||
var keyframes = this.keyframes;
|
||
var len = keyframes.length;
|
||
var discrete = false;
|
||
var valType = VALUE_TYPE_UNKOWN;
|
||
var value = rawValue;
|
||
if (isArrayLike(rawValue)) {
|
||
var arrayDim = guessArrayDim(rawValue);
|
||
valType = arrayDim;
|
||
if (arrayDim === 1 && !isNumber(rawValue[0])
|
||
|| arrayDim === 2 && !isNumber(rawValue[0][0])) {
|
||
discrete = true;
|
||
}
|
||
}
|
||
else {
|
||
if (isNumber(rawValue) && !eqNaN(rawValue)) {
|
||
valType = VALUE_TYPE_NUMBER;
|
||
}
|
||
else if (isString(rawValue)) {
|
||
if (!isNaN(+rawValue)) {
|
||
valType = VALUE_TYPE_NUMBER;
|
||
}
|
||
else {
|
||
var colorArray = parse(rawValue);
|
||
if (colorArray) {
|
||
value = colorArray;
|
||
valType = VALUE_TYPE_COLOR;
|
||
}
|
||
}
|
||
}
|
||
else if (isGradientObject(rawValue)) {
|
||
var parsedGradient = extend({}, value);
|
||
parsedGradient.colorStops = map(rawValue.colorStops, function (colorStop) { return ({
|
||
offset: colorStop.offset,
|
||
color: parse(colorStop.color)
|
||
}); });
|
||
if (isLinearGradient(rawValue)) {
|
||
valType = VALUE_TYPE_LINEAR_GRADIENT;
|
||
}
|
||
else if (isRadialGradient(rawValue)) {
|
||
valType = VALUE_TYPE_RADIAL_GRADIENT;
|
||
}
|
||
value = parsedGradient;
|
||
}
|
||
}
|
||
if (len === 0) {
|
||
this.valType = valType;
|
||
}
|
||
else if (valType !== this.valType || valType === VALUE_TYPE_UNKOWN) {
|
||
discrete = true;
|
||
}
|
||
this.discrete = this.discrete || discrete;
|
||
var kf = {
|
||
time: time,
|
||
value: value,
|
||
rawValue: rawValue,
|
||
percent: 0
|
||
};
|
||
if (easing) {
|
||
kf.easing = easing;
|
||
kf.easingFunc = isFunction(easing)
|
||
? easing
|
||
: easingFuncs[easing] || createCubicEasingFunc(easing);
|
||
}
|
||
keyframes.push(kf);
|
||
return kf;
|
||
};
|
||
Track.prototype.prepare = function (maxTime, additiveTrack) {
|
||
var kfs = this.keyframes;
|
||
if (this._needsSort) {
|
||
kfs.sort(function (a, b) {
|
||
return a.time - b.time;
|
||
});
|
||
}
|
||
var valType = this.valType;
|
||
var kfsLen = kfs.length;
|
||
var lastKf = kfs[kfsLen - 1];
|
||
var isDiscrete = this.discrete;
|
||
var isArr = isArrayValueType(valType);
|
||
var isGradient = isGradientValueType(valType);
|
||
for (var i = 0; i < kfsLen; i++) {
|
||
var kf = kfs[i];
|
||
var value = kf.value;
|
||
var lastValue = lastKf.value;
|
||
kf.percent = kf.time / maxTime;
|
||
if (!isDiscrete) {
|
||
if (isArr && i !== kfsLen - 1) {
|
||
fillArray(value, lastValue, valType);
|
||
}
|
||
else if (isGradient) {
|
||
fillColorStops(value.colorStops, lastValue.colorStops);
|
||
}
|
||
}
|
||
}
|
||
if (!isDiscrete
|
||
&& valType !== VALUE_TYPE_RADIAL_GRADIENT
|
||
&& additiveTrack
|
||
&& this.needsAnimate()
|
||
&& additiveTrack.needsAnimate()
|
||
&& valType === additiveTrack.valType
|
||
&& !additiveTrack._finished) {
|
||
this._additiveTrack = additiveTrack;
|
||
var startValue = kfs[0].value;
|
||
for (var i = 0; i < kfsLen; i++) {
|
||
if (valType === VALUE_TYPE_NUMBER) {
|
||
kfs[i].additiveValue = kfs[i].value - startValue;
|
||
}
|
||
else if (valType === VALUE_TYPE_COLOR) {
|
||
kfs[i].additiveValue =
|
||
add1DArray([], kfs[i].value, startValue, -1);
|
||
}
|
||
else if (isArrayValueType(valType)) {
|
||
kfs[i].additiveValue = valType === VALUE_TYPE_1D_ARRAY
|
||
? add1DArray([], kfs[i].value, startValue, -1)
|
||
: add2DArray([], kfs[i].value, startValue, -1);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
Track.prototype.step = function (target, percent) {
|
||
if (this._finished) {
|
||
return;
|
||
}
|
||
if (this._additiveTrack && this._additiveTrack._finished) {
|
||
this._additiveTrack = null;
|
||
}
|
||
var isAdditive = this._additiveTrack != null;
|
||
var valueKey = isAdditive ? 'additiveValue' : 'value';
|
||
var valType = this.valType;
|
||
var keyframes = this.keyframes;
|
||
var kfsNum = keyframes.length;
|
||
var propName = this.propName;
|
||
var isValueColor = valType === VALUE_TYPE_COLOR;
|
||
var frameIdx;
|
||
var lastFrame = this._lastFr;
|
||
var mathMin = Math.min;
|
||
var frame;
|
||
var nextFrame;
|
||
if (kfsNum === 1) {
|
||
frame = nextFrame = keyframes[0];
|
||
}
|
||
else {
|
||
if (percent < 0) {
|
||
frameIdx = 0;
|
||
}
|
||
else if (percent < this._lastFrP) {
|
||
var start = mathMin(lastFrame + 1, kfsNum - 1);
|
||
for (frameIdx = start; frameIdx >= 0; frameIdx--) {
|
||
if (keyframes[frameIdx].percent <= percent) {
|
||
break;
|
||
}
|
||
}
|
||
frameIdx = mathMin(frameIdx, kfsNum - 2);
|
||
}
|
||
else {
|
||
for (frameIdx = lastFrame; frameIdx < kfsNum; frameIdx++) {
|
||
if (keyframes[frameIdx].percent > percent) {
|
||
break;
|
||
}
|
||
}
|
||
frameIdx = mathMin(frameIdx - 1, kfsNum - 2);
|
||
}
|
||
nextFrame = keyframes[frameIdx + 1];
|
||
frame = keyframes[frameIdx];
|
||
}
|
||
if (!(frame && nextFrame)) {
|
||
return;
|
||
}
|
||
this._lastFr = frameIdx;
|
||
this._lastFrP = percent;
|
||
var interval = (nextFrame.percent - frame.percent);
|
||
var w = interval === 0 ? 1 : mathMin((percent - frame.percent) / interval, 1);
|
||
if (nextFrame.easingFunc) {
|
||
w = nextFrame.easingFunc(w);
|
||
}
|
||
var targetArr = isAdditive ? this._additiveValue
|
||
: (isValueColor ? tmpRgba : target[propName]);
|
||
if ((isArrayValueType(valType) || isValueColor) && !targetArr) {
|
||
targetArr = this._additiveValue = [];
|
||
}
|
||
if (this.discrete) {
|
||
target[propName] = w < 1 ? frame.rawValue : nextFrame.rawValue;
|
||
}
|
||
else if (isArrayValueType(valType)) {
|
||
valType === VALUE_TYPE_1D_ARRAY
|
||
? interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w)
|
||
: interpolate2DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
|
||
}
|
||
else if (isGradientValueType(valType)) {
|
||
var val = frame[valueKey];
|
||
var nextVal_1 = nextFrame[valueKey];
|
||
var isLinearGradient_1 = valType === VALUE_TYPE_LINEAR_GRADIENT;
|
||
target[propName] = {
|
||
type: isLinearGradient_1 ? 'linear' : 'radial',
|
||
x: interpolateNumber(val.x, nextVal_1.x, w),
|
||
y: interpolateNumber(val.y, nextVal_1.y, w),
|
||
colorStops: map(val.colorStops, function (colorStop, idx) {
|
||
var nextColorStop = nextVal_1.colorStops[idx];
|
||
return {
|
||
offset: interpolateNumber(colorStop.offset, nextColorStop.offset, w),
|
||
color: rgba2String(interpolate1DArray([], colorStop.color, nextColorStop.color, w))
|
||
};
|
||
}),
|
||
global: nextVal_1.global
|
||
};
|
||
if (isLinearGradient_1) {
|
||
target[propName].x2 = interpolateNumber(val.x2, nextVal_1.x2, w);
|
||
target[propName].y2 = interpolateNumber(val.y2, nextVal_1.y2, w);
|
||
}
|
||
else {
|
||
target[propName].r = interpolateNumber(val.r, nextVal_1.r, w);
|
||
}
|
||
}
|
||
else if (isValueColor) {
|
||
interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
|
||
if (!isAdditive) {
|
||
target[propName] = rgba2String(targetArr);
|
||
}
|
||
}
|
||
else {
|
||
var value = interpolateNumber(frame[valueKey], nextFrame[valueKey], w);
|
||
if (isAdditive) {
|
||
this._additiveValue = value;
|
||
}
|
||
else {
|
||
target[propName] = value;
|
||
}
|
||
}
|
||
if (isAdditive) {
|
||
this._addToTarget(target);
|
||
}
|
||
};
|
||
Track.prototype._addToTarget = function (target) {
|
||
var valType = this.valType;
|
||
var propName = this.propName;
|
||
var additiveValue = this._additiveValue;
|
||
if (valType === VALUE_TYPE_NUMBER) {
|
||
target[propName] = target[propName] + additiveValue;
|
||
}
|
||
else if (valType === VALUE_TYPE_COLOR) {
|
||
parse(target[propName], tmpRgba);
|
||
add1DArray(tmpRgba, tmpRgba, additiveValue, 1);
|
||
target[propName] = rgba2String(tmpRgba);
|
||
}
|
||
else if (valType === VALUE_TYPE_1D_ARRAY) {
|
||
add1DArray(target[propName], target[propName], additiveValue, 1);
|
||
}
|
||
else if (valType === VALUE_TYPE_2D_ARRAY) {
|
||
add2DArray(target[propName], target[propName], additiveValue, 1);
|
||
}
|
||
};
|
||
return Track;
|
||
}());
|
||
var Animator = (function () {
|
||
function Animator(target, loop, allowDiscreteAnimation, additiveTo) {
|
||
this._tracks = {};
|
||
this._trackKeys = [];
|
||
this._maxTime = 0;
|
||
this._started = 0;
|
||
this._clip = null;
|
||
this._target = target;
|
||
this._loop = loop;
|
||
if (loop && additiveTo) {
|
||
logError('Can\' use additive animation on looped animation.');
|
||
return;
|
||
}
|
||
this._additiveAnimators = additiveTo;
|
||
this._allowDiscrete = allowDiscreteAnimation;
|
||
}
|
||
Animator.prototype.getMaxTime = function () {
|
||
return this._maxTime;
|
||
};
|
||
Animator.prototype.getDelay = function () {
|
||
return this._delay;
|
||
};
|
||
Animator.prototype.getLoop = function () {
|
||
return this._loop;
|
||
};
|
||
Animator.prototype.getTarget = function () {
|
||
return this._target;
|
||
};
|
||
Animator.prototype.changeTarget = function (target) {
|
||
this._target = target;
|
||
};
|
||
Animator.prototype.when = function (time, props, easing) {
|
||
return this.whenWithKeys(time, props, keys(props), easing);
|
||
};
|
||
Animator.prototype.whenWithKeys = function (time, props, propNames, easing) {
|
||
var tracks = this._tracks;
|
||
for (var i = 0; i < propNames.length; i++) {
|
||
var propName = propNames[i];
|
||
var track = tracks[propName];
|
||
if (!track) {
|
||
track = tracks[propName] = new Track(propName);
|
||
var initialValue = void 0;
|
||
var additiveTrack = this._getAdditiveTrack(propName);
|
||
if (additiveTrack) {
|
||
var addtiveTrackKfs = additiveTrack.keyframes;
|
||
var lastFinalKf = addtiveTrackKfs[addtiveTrackKfs.length - 1];
|
||
initialValue = lastFinalKf && lastFinalKf.value;
|
||
if (additiveTrack.valType === VALUE_TYPE_COLOR && initialValue) {
|
||
initialValue = rgba2String(initialValue);
|
||
}
|
||
}
|
||
else {
|
||
initialValue = this._target[propName];
|
||
}
|
||
if (initialValue == null) {
|
||
continue;
|
||
}
|
||
if (time > 0) {
|
||
track.addKeyframe(0, cloneValue(initialValue), easing);
|
||
}
|
||
this._trackKeys.push(propName);
|
||
}
|
||
track.addKeyframe(time, cloneValue(props[propName]), easing);
|
||
}
|
||
this._maxTime = Math.max(this._maxTime, time);
|
||
return this;
|
||
};
|
||
Animator.prototype.pause = function () {
|
||
this._clip.pause();
|
||
this._paused = true;
|
||
};
|
||
Animator.prototype.resume = function () {
|
||
this._clip.resume();
|
||
this._paused = false;
|
||
};
|
||
Animator.prototype.isPaused = function () {
|
||
return !!this._paused;
|
||
};
|
||
Animator.prototype.duration = function (duration) {
|
||
this._maxTime = duration;
|
||
this._force = true;
|
||
return this;
|
||
};
|
||
Animator.prototype._doneCallback = function () {
|
||
this._setTracksFinished();
|
||
this._clip = null;
|
||
var doneList = this._doneCbs;
|
||
if (doneList) {
|
||
var len = doneList.length;
|
||
for (var i = 0; i < len; i++) {
|
||
doneList[i].call(this);
|
||
}
|
||
}
|
||
};
|
||
Animator.prototype._abortedCallback = function () {
|
||
this._setTracksFinished();
|
||
var animation = this.animation;
|
||
var abortedList = this._abortedCbs;
|
||
if (animation) {
|
||
animation.removeClip(this._clip);
|
||
}
|
||
this._clip = null;
|
||
if (abortedList) {
|
||
for (var i = 0; i < abortedList.length; i++) {
|
||
abortedList[i].call(this);
|
||
}
|
||
}
|
||
};
|
||
Animator.prototype._setTracksFinished = function () {
|
||
var tracks = this._tracks;
|
||
var tracksKeys = this._trackKeys;
|
||
for (var i = 0; i < tracksKeys.length; i++) {
|
||
tracks[tracksKeys[i]].setFinished();
|
||
}
|
||
};
|
||
Animator.prototype._getAdditiveTrack = function (trackName) {
|
||
var additiveTrack;
|
||
var additiveAnimators = this._additiveAnimators;
|
||
if (additiveAnimators) {
|
||
for (var i = 0; i < additiveAnimators.length; i++) {
|
||
var track = additiveAnimators[i].getTrack(trackName);
|
||
if (track) {
|
||
additiveTrack = track;
|
||
}
|
||
}
|
||
}
|
||
return additiveTrack;
|
||
};
|
||
Animator.prototype.start = function (easing) {
|
||
if (this._started > 0) {
|
||
return;
|
||
}
|
||
this._started = 1;
|
||
var self = this;
|
||
var tracks = [];
|
||
var maxTime = this._maxTime || 0;
|
||
for (var i = 0; i < this._trackKeys.length; i++) {
|
||
var propName = this._trackKeys[i];
|
||
var track = this._tracks[propName];
|
||
var additiveTrack = this._getAdditiveTrack(propName);
|
||
var kfs = track.keyframes;
|
||
var kfsNum = kfs.length;
|
||
track.prepare(maxTime, additiveTrack);
|
||
if (track.needsAnimate()) {
|
||
if (!this._allowDiscrete && track.discrete) {
|
||
var lastKf = kfs[kfsNum - 1];
|
||
if (lastKf) {
|
||
self._target[track.propName] = lastKf.rawValue;
|
||
}
|
||
track.setFinished();
|
||
}
|
||
else {
|
||
tracks.push(track);
|
||
}
|
||
}
|
||
}
|
||
if (tracks.length || this._force) {
|
||
var clip = new Clip({
|
||
life: maxTime,
|
||
loop: this._loop,
|
||
delay: this._delay || 0,
|
||
onframe: function (percent) {
|
||
self._started = 2;
|
||
var additiveAnimators = self._additiveAnimators;
|
||
if (additiveAnimators) {
|
||
var stillHasAdditiveAnimator = false;
|
||
for (var i = 0; i < additiveAnimators.length; i++) {
|
||
if (additiveAnimators[i]._clip) {
|
||
stillHasAdditiveAnimator = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!stillHasAdditiveAnimator) {
|
||
self._additiveAnimators = null;
|
||
}
|
||
}
|
||
for (var i = 0; i < tracks.length; i++) {
|
||
tracks[i].step(self._target, percent);
|
||
}
|
||
var onframeList = self._onframeCbs;
|
||
if (onframeList) {
|
||
for (var i = 0; i < onframeList.length; i++) {
|
||
onframeList[i](self._target, percent);
|
||
}
|
||
}
|
||
},
|
||
ondestroy: function () {
|
||
self._doneCallback();
|
||
}
|
||
});
|
||
this._clip = clip;
|
||
if (this.animation) {
|
||
this.animation.addClip(clip);
|
||
}
|
||
if (easing) {
|
||
clip.setEasing(easing);
|
||
}
|
||
}
|
||
else {
|
||
this._doneCallback();
|
||
}
|
||
return this;
|
||
};
|
||
Animator.prototype.stop = function (forwardToLast) {
|
||
if (!this._clip) {
|
||
return;
|
||
}
|
||
var clip = this._clip;
|
||
if (forwardToLast) {
|
||
clip.onframe(1);
|
||
}
|
||
this._abortedCallback();
|
||
};
|
||
Animator.prototype.delay = function (time) {
|
||
this._delay = time;
|
||
return this;
|
||
};
|
||
Animator.prototype.during = function (cb) {
|
||
if (cb) {
|
||
if (!this._onframeCbs) {
|
||
this._onframeCbs = [];
|
||
}
|
||
this._onframeCbs.push(cb);
|
||
}
|
||
return this;
|
||
};
|
||
Animator.prototype.done = function (cb) {
|
||
if (cb) {
|
||
if (!this._doneCbs) {
|
||
this._doneCbs = [];
|
||
}
|
||
this._doneCbs.push(cb);
|
||
}
|
||
return this;
|
||
};
|
||
Animator.prototype.aborted = function (cb) {
|
||
if (cb) {
|
||
if (!this._abortedCbs) {
|
||
this._abortedCbs = [];
|
||
}
|
||
this._abortedCbs.push(cb);
|
||
}
|
||
return this;
|
||
};
|
||
Animator.prototype.getClip = function () {
|
||
return this._clip;
|
||
};
|
||
Animator.prototype.getTrack = function (propName) {
|
||
return this._tracks[propName];
|
||
};
|
||
Animator.prototype.getTracks = function () {
|
||
var _this = this;
|
||
return map(this._trackKeys, function (key) { return _this._tracks[key]; });
|
||
};
|
||
Animator.prototype.stopTracks = function (propNames, forwardToLast) {
|
||
if (!propNames.length || !this._clip) {
|
||
return true;
|
||
}
|
||
var tracks = this._tracks;
|
||
var tracksKeys = this._trackKeys;
|
||
for (var i = 0; i < propNames.length; i++) {
|
||
var track = tracks[propNames[i]];
|
||
if (track && !track.isFinished()) {
|
||
if (forwardToLast) {
|
||
track.step(this._target, 1);
|
||
}
|
||
else if (this._started === 1) {
|
||
track.step(this._target, 0);
|
||
}
|
||
track.setFinished();
|
||
}
|
||
}
|
||
var allAborted = true;
|
||
for (var i = 0; i < tracksKeys.length; i++) {
|
||
if (!tracks[tracksKeys[i]].isFinished()) {
|
||
allAborted = false;
|
||
break;
|
||
}
|
||
}
|
||
if (allAborted) {
|
||
this._abortedCallback();
|
||
}
|
||
return allAborted;
|
||
};
|
||
Animator.prototype.saveTo = function (target, trackKeys, firstOrLast) {
|
||
if (!target) {
|
||
return;
|
||
}
|
||
trackKeys = trackKeys || this._trackKeys;
|
||
for (var i = 0; i < trackKeys.length; i++) {
|
||
var propName = trackKeys[i];
|
||
var track = this._tracks[propName];
|
||
if (!track || track.isFinished()) {
|
||
continue;
|
||
}
|
||
var kfs = track.keyframes;
|
||
var kf = kfs[firstOrLast ? 0 : kfs.length - 1];
|
||
if (kf) {
|
||
target[propName] = cloneValue(kf.rawValue);
|
||
}
|
||
}
|
||
};
|
||
Animator.prototype.__changeFinalValue = function (finalProps, trackKeys) {
|
||
trackKeys = trackKeys || keys(finalProps);
|
||
for (var i = 0; i < trackKeys.length; i++) {
|
||
var propName = trackKeys[i];
|
||
var track = this._tracks[propName];
|
||
if (!track) {
|
||
continue;
|
||
}
|
||
var kfs = track.keyframes;
|
||
if (kfs.length > 1) {
|
||
var lastKf = kfs.pop();
|
||
track.addKeyframe(lastKf.time, finalProps[propName]);
|
||
track.prepare(this._maxTime, track.getAdditiveTrack());
|
||
}
|
||
}
|
||
};
|
||
return Animator;
|
||
}());
|
||
|
||
function getTime() {
|
||
return new Date().getTime();
|
||
}
|
||
var Animation = (function (_super) {
|
||
__extends(Animation, _super);
|
||
function Animation(opts) {
|
||
var _this = _super.call(this) || this;
|
||
_this._running = false;
|
||
_this._time = 0;
|
||
_this._pausedTime = 0;
|
||
_this._pauseStart = 0;
|
||
_this._paused = false;
|
||
opts = opts || {};
|
||
_this.stage = opts.stage || {};
|
||
return _this;
|
||
}
|
||
Animation.prototype.addClip = function (clip) {
|
||
if (clip.animation) {
|
||
this.removeClip(clip);
|
||
}
|
||
if (!this._head) {
|
||
this._head = this._tail = clip;
|
||
}
|
||
else {
|
||
this._tail.next = clip;
|
||
clip.prev = this._tail;
|
||
clip.next = null;
|
||
this._tail = clip;
|
||
}
|
||
clip.animation = this;
|
||
};
|
||
Animation.prototype.addAnimator = function (animator) {
|
||
animator.animation = this;
|
||
var clip = animator.getClip();
|
||
if (clip) {
|
||
this.addClip(clip);
|
||
}
|
||
};
|
||
Animation.prototype.removeClip = function (clip) {
|
||
if (!clip.animation) {
|
||
return;
|
||
}
|
||
var prev = clip.prev;
|
||
var next = clip.next;
|
||
if (prev) {
|
||
prev.next = next;
|
||
}
|
||
else {
|
||
this._head = next;
|
||
}
|
||
if (next) {
|
||
next.prev = prev;
|
||
}
|
||
else {
|
||
this._tail = prev;
|
||
}
|
||
clip.next = clip.prev = clip.animation = null;
|
||
};
|
||
Animation.prototype.removeAnimator = function (animator) {
|
||
var clip = animator.getClip();
|
||
if (clip) {
|
||
this.removeClip(clip);
|
||
}
|
||
animator.animation = null;
|
||
};
|
||
Animation.prototype.update = function (notTriggerFrameAndStageUpdate) {
|
||
var time = getTime() - this._pausedTime;
|
||
var delta = time - this._time;
|
||
var clip = this._head;
|
||
while (clip) {
|
||
var nextClip = clip.next;
|
||
var finished = clip.step(time, delta);
|
||
if (finished) {
|
||
clip.ondestroy();
|
||
this.removeClip(clip);
|
||
clip = nextClip;
|
||
}
|
||
else {
|
||
clip = nextClip;
|
||
}
|
||
}
|
||
this._time = time;
|
||
if (!notTriggerFrameAndStageUpdate) {
|
||
this.trigger('frame', delta);
|
||
this.stage.update && this.stage.update();
|
||
}
|
||
};
|
||
Animation.prototype._startLoop = function () {
|
||
var self = this;
|
||
this._running = true;
|
||
function step() {
|
||
if (self._running) {
|
||
requestAnimationFrame$1(step);
|
||
!self._paused && self.update();
|
||
}
|
||
}
|
||
requestAnimationFrame$1(step);
|
||
};
|
||
Animation.prototype.start = function () {
|
||
if (this._running) {
|
||
return;
|
||
}
|
||
this._time = getTime();
|
||
this._pausedTime = 0;
|
||
this._startLoop();
|
||
};
|
||
Animation.prototype.stop = function () {
|
||
this._running = false;
|
||
};
|
||
Animation.prototype.pause = function () {
|
||
if (!this._paused) {
|
||
this._pauseStart = getTime();
|
||
this._paused = true;
|
||
}
|
||
};
|
||
Animation.prototype.resume = function () {
|
||
if (this._paused) {
|
||
this._pausedTime += getTime() - this._pauseStart;
|
||
this._paused = false;
|
||
}
|
||
};
|
||
Animation.prototype.clear = function () {
|
||
var clip = this._head;
|
||
while (clip) {
|
||
var nextClip = clip.next;
|
||
clip.prev = clip.next = clip.animation = null;
|
||
clip = nextClip;
|
||
}
|
||
this._head = this._tail = null;
|
||
};
|
||
Animation.prototype.isFinished = function () {
|
||
return this._head == null;
|
||
};
|
||
Animation.prototype.animate = function (target, options) {
|
||
options = options || {};
|
||
this.start();
|
||
var animator = new Animator(target, options.loop);
|
||
this.addAnimator(animator);
|
||
return animator;
|
||
};
|
||
return Animation;
|
||
}(Eventful));
|
||
|
||
var TOUCH_CLICK_DELAY = 300;
|
||
var globalEventSupported = env.domSupported;
|
||
var localNativeListenerNames = (function () {
|
||
var mouseHandlerNames = [
|
||
'click', 'dblclick', 'mousewheel', 'wheel', 'mouseout',
|
||
'mouseup', 'mousedown', 'mousemove', 'contextmenu'
|
||
];
|
||
var touchHandlerNames = [
|
||
'touchstart', 'touchend', 'touchmove'
|
||
];
|
||
var pointerEventNameMap = {
|
||
pointerdown: 1, pointerup: 1, pointermove: 1, pointerout: 1
|
||
};
|
||
var pointerHandlerNames = map(mouseHandlerNames, function (name) {
|
||
var nm = name.replace('mouse', 'pointer');
|
||
return pointerEventNameMap.hasOwnProperty(nm) ? nm : name;
|
||
});
|
||
return {
|
||
mouse: mouseHandlerNames,
|
||
touch: touchHandlerNames,
|
||
pointer: pointerHandlerNames
|
||
};
|
||
})();
|
||
var globalNativeListenerNames = {
|
||
mouse: ['mousemove', 'mouseup'],
|
||
pointer: ['pointermove', 'pointerup']
|
||
};
|
||
var wheelEventSupported = false;
|
||
function isPointerFromTouch(event) {
|
||
var pointerType = event.pointerType;
|
||
return pointerType === 'pen' || pointerType === 'touch';
|
||
}
|
||
function setTouchTimer(scope) {
|
||
scope.touching = true;
|
||
if (scope.touchTimer != null) {
|
||
clearTimeout(scope.touchTimer);
|
||
scope.touchTimer = null;
|
||
}
|
||
scope.touchTimer = setTimeout(function () {
|
||
scope.touching = false;
|
||
scope.touchTimer = null;
|
||
}, 700);
|
||
}
|
||
function markTouch(event) {
|
||
event && (event.zrByTouch = true);
|
||
}
|
||
function normalizeGlobalEvent(instance, event) {
|
||
return normalizeEvent(instance.dom, new FakeGlobalEvent(instance, event), true);
|
||
}
|
||
function isLocalEl(instance, el) {
|
||
var elTmp = el;
|
||
var isLocal = false;
|
||
while (elTmp && elTmp.nodeType !== 9
|
||
&& !(isLocal = elTmp.domBelongToZr
|
||
|| (elTmp !== el && elTmp === instance.painterRoot))) {
|
||
elTmp = elTmp.parentNode;
|
||
}
|
||
return isLocal;
|
||
}
|
||
var FakeGlobalEvent = (function () {
|
||
function FakeGlobalEvent(instance, event) {
|
||
this.stopPropagation = noop;
|
||
this.stopImmediatePropagation = noop;
|
||
this.preventDefault = noop;
|
||
this.type = event.type;
|
||
this.target = this.currentTarget = instance.dom;
|
||
this.pointerType = event.pointerType;
|
||
this.clientX = event.clientX;
|
||
this.clientY = event.clientY;
|
||
}
|
||
return FakeGlobalEvent;
|
||
}());
|
||
var localDOMHandlers = {
|
||
mousedown: function (event) {
|
||
event = normalizeEvent(this.dom, event);
|
||
this.__mayPointerCapture = [event.zrX, event.zrY];
|
||
this.trigger('mousedown', event);
|
||
},
|
||
mousemove: function (event) {
|
||
event = normalizeEvent(this.dom, event);
|
||
var downPoint = this.__mayPointerCapture;
|
||
if (downPoint && (event.zrX !== downPoint[0] || event.zrY !== downPoint[1])) {
|
||
this.__togglePointerCapture(true);
|
||
}
|
||
this.trigger('mousemove', event);
|
||
},
|
||
mouseup: function (event) {
|
||
event = normalizeEvent(this.dom, event);
|
||
this.__togglePointerCapture(false);
|
||
this.trigger('mouseup', event);
|
||
},
|
||
mouseout: function (event) {
|
||
event = normalizeEvent(this.dom, event);
|
||
var element = event.toElement || event.relatedTarget;
|
||
if (!isLocalEl(this, element)) {
|
||
if (this.__pointerCapturing) {
|
||
event.zrEventControl = 'no_globalout';
|
||
}
|
||
this.trigger('mouseout', event);
|
||
}
|
||
},
|
||
wheel: function (event) {
|
||
wheelEventSupported = true;
|
||
event = normalizeEvent(this.dom, event);
|
||
this.trigger('mousewheel', event);
|
||
},
|
||
mousewheel: function (event) {
|
||
if (wheelEventSupported) {
|
||
return;
|
||
}
|
||
event = normalizeEvent(this.dom, event);
|
||
this.trigger('mousewheel', event);
|
||
},
|
||
touchstart: function (event) {
|
||
event = normalizeEvent(this.dom, event);
|
||
markTouch(event);
|
||
this.__lastTouchMoment = new Date();
|
||
this.handler.processGesture(event, 'start');
|
||
localDOMHandlers.mousemove.call(this, event);
|
||
localDOMHandlers.mousedown.call(this, event);
|
||
},
|
||
touchmove: function (event) {
|
||
event = normalizeEvent(this.dom, event);
|
||
markTouch(event);
|
||
this.handler.processGesture(event, 'change');
|
||
localDOMHandlers.mousemove.call(this, event);
|
||
},
|
||
touchend: function (event) {
|
||
event = normalizeEvent(this.dom, event);
|
||
markTouch(event);
|
||
this.handler.processGesture(event, 'end');
|
||
localDOMHandlers.mouseup.call(this, event);
|
||
if (+new Date() - (+this.__lastTouchMoment) < TOUCH_CLICK_DELAY) {
|
||
localDOMHandlers.click.call(this, event);
|
||
}
|
||
},
|
||
pointerdown: function (event) {
|
||
localDOMHandlers.mousedown.call(this, event);
|
||
},
|
||
pointermove: function (event) {
|
||
if (!isPointerFromTouch(event)) {
|
||
localDOMHandlers.mousemove.call(this, event);
|
||
}
|
||
},
|
||
pointerup: function (event) {
|
||
localDOMHandlers.mouseup.call(this, event);
|
||
},
|
||
pointerout: function (event) {
|
||
if (!isPointerFromTouch(event)) {
|
||
localDOMHandlers.mouseout.call(this, event);
|
||
}
|
||
}
|
||
};
|
||
each(['click', 'dblclick', 'contextmenu'], function (name) {
|
||
localDOMHandlers[name] = function (event) {
|
||
event = normalizeEvent(this.dom, event);
|
||
this.trigger(name, event);
|
||
};
|
||
});
|
||
var globalDOMHandlers = {
|
||
pointermove: function (event) {
|
||
if (!isPointerFromTouch(event)) {
|
||
globalDOMHandlers.mousemove.call(this, event);
|
||
}
|
||
},
|
||
pointerup: function (event) {
|
||
globalDOMHandlers.mouseup.call(this, event);
|
||
},
|
||
mousemove: function (event) {
|
||
this.trigger('mousemove', event);
|
||
},
|
||
mouseup: function (event) {
|
||
var pointerCaptureReleasing = this.__pointerCapturing;
|
||
this.__togglePointerCapture(false);
|
||
this.trigger('mouseup', event);
|
||
if (pointerCaptureReleasing) {
|
||
event.zrEventControl = 'only_globalout';
|
||
this.trigger('mouseout', event);
|
||
}
|
||
}
|
||
};
|
||
function mountLocalDOMEventListeners(instance, scope) {
|
||
var domHandlers = scope.domHandlers;
|
||
if (env.pointerEventsSupported) {
|
||
each(localNativeListenerNames.pointer, function (nativeEventName) {
|
||
mountSingleDOMEventListener(scope, nativeEventName, function (event) {
|
||
domHandlers[nativeEventName].call(instance, event);
|
||
});
|
||
});
|
||
}
|
||
else {
|
||
if (env.touchEventsSupported) {
|
||
each(localNativeListenerNames.touch, function (nativeEventName) {
|
||
mountSingleDOMEventListener(scope, nativeEventName, function (event) {
|
||
domHandlers[nativeEventName].call(instance, event);
|
||
setTouchTimer(scope);
|
||
});
|
||
});
|
||
}
|
||
each(localNativeListenerNames.mouse, function (nativeEventName) {
|
||
mountSingleDOMEventListener(scope, nativeEventName, function (event) {
|
||
event = getNativeEvent(event);
|
||
if (!scope.touching) {
|
||
domHandlers[nativeEventName].call(instance, event);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
}
|
||
function mountGlobalDOMEventListeners(instance, scope) {
|
||
if (env.pointerEventsSupported) {
|
||
each(globalNativeListenerNames.pointer, mount);
|
||
}
|
||
else if (!env.touchEventsSupported) {
|
||
each(globalNativeListenerNames.mouse, mount);
|
||
}
|
||
function mount(nativeEventName) {
|
||
function nativeEventListener(event) {
|
||
event = getNativeEvent(event);
|
||
if (!isLocalEl(instance, event.target)) {
|
||
event = normalizeGlobalEvent(instance, event);
|
||
scope.domHandlers[nativeEventName].call(instance, event);
|
||
}
|
||
}
|
||
mountSingleDOMEventListener(scope, nativeEventName, nativeEventListener, { capture: true });
|
||
}
|
||
}
|
||
function mountSingleDOMEventListener(scope, nativeEventName, listener, opt) {
|
||
scope.mounted[nativeEventName] = listener;
|
||
scope.listenerOpts[nativeEventName] = opt;
|
||
addEventListener(scope.domTarget, nativeEventName, listener, opt);
|
||
}
|
||
function unmountDOMEventListeners(scope) {
|
||
var mounted = scope.mounted;
|
||
for (var nativeEventName in mounted) {
|
||
if (mounted.hasOwnProperty(nativeEventName)) {
|
||
removeEventListener(scope.domTarget, nativeEventName, mounted[nativeEventName], scope.listenerOpts[nativeEventName]);
|
||
}
|
||
}
|
||
scope.mounted = {};
|
||
}
|
||
var DOMHandlerScope = (function () {
|
||
function DOMHandlerScope(domTarget, domHandlers) {
|
||
this.mounted = {};
|
||
this.listenerOpts = {};
|
||
this.touching = false;
|
||
this.domTarget = domTarget;
|
||
this.domHandlers = domHandlers;
|
||
}
|
||
return DOMHandlerScope;
|
||
}());
|
||
var HandlerDomProxy = (function (_super) {
|
||
__extends(HandlerDomProxy, _super);
|
||
function HandlerDomProxy(dom, painterRoot) {
|
||
var _this = _super.call(this) || this;
|
||
_this.__pointerCapturing = false;
|
||
_this.dom = dom;
|
||
_this.painterRoot = painterRoot;
|
||
_this._localHandlerScope = new DOMHandlerScope(dom, localDOMHandlers);
|
||
if (globalEventSupported) {
|
||
_this._globalHandlerScope = new DOMHandlerScope(document, globalDOMHandlers);
|
||
}
|
||
mountLocalDOMEventListeners(_this, _this._localHandlerScope);
|
||
return _this;
|
||
}
|
||
HandlerDomProxy.prototype.dispose = function () {
|
||
unmountDOMEventListeners(this._localHandlerScope);
|
||
if (globalEventSupported) {
|
||
unmountDOMEventListeners(this._globalHandlerScope);
|
||
}
|
||
};
|
||
HandlerDomProxy.prototype.setCursor = function (cursorStyle) {
|
||
this.dom.style && (this.dom.style.cursor = cursorStyle || 'default');
|
||
};
|
||
HandlerDomProxy.prototype.__togglePointerCapture = function (isPointerCapturing) {
|
||
this.__mayPointerCapture = null;
|
||
if (globalEventSupported
|
||
&& ((+this.__pointerCapturing) ^ (+isPointerCapturing))) {
|
||
this.__pointerCapturing = isPointerCapturing;
|
||
var globalHandlerScope = this._globalHandlerScope;
|
||
isPointerCapturing
|
||
? mountGlobalDOMEventListeners(this, globalHandlerScope)
|
||
: unmountDOMEventListeners(globalHandlerScope);
|
||
}
|
||
};
|
||
return HandlerDomProxy;
|
||
}(Eventful));
|
||
|
||
var dpr = 1;
|
||
if (env.hasGlobalWindow) {
|
||
dpr = Math.max(window.devicePixelRatio
|
||
|| (window.screen && window.screen.deviceXDPI / window.screen.logicalXDPI)
|
||
|| 1, 1);
|
||
}
|
||
var devicePixelRatio = dpr;
|
||
var DARK_MODE_THRESHOLD = 0.4;
|
||
var DARK_LABEL_COLOR = '#333';
|
||
var LIGHT_LABEL_COLOR = '#ccc';
|
||
var LIGHTER_LABEL_COLOR = '#eee';
|
||
|
||
function create$1() {
|
||
return [1, 0, 0, 1, 0, 0];
|
||
}
|
||
function identity(out) {
|
||
out[0] = 1;
|
||
out[1] = 0;
|
||
out[2] = 0;
|
||
out[3] = 1;
|
||
out[4] = 0;
|
||
out[5] = 0;
|
||
return out;
|
||
}
|
||
function copy$1(out, m) {
|
||
out[0] = m[0];
|
||
out[1] = m[1];
|
||
out[2] = m[2];
|
||
out[3] = m[3];
|
||
out[4] = m[4];
|
||
out[5] = m[5];
|
||
return out;
|
||
}
|
||
function mul$1(out, m1, m2) {
|
||
var out0 = m1[0] * m2[0] + m1[2] * m2[1];
|
||
var out1 = m1[1] * m2[0] + m1[3] * m2[1];
|
||
var out2 = m1[0] * m2[2] + m1[2] * m2[3];
|
||
var out3 = m1[1] * m2[2] + m1[3] * m2[3];
|
||
var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];
|
||
var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];
|
||
out[0] = out0;
|
||
out[1] = out1;
|
||
out[2] = out2;
|
||
out[3] = out3;
|
||
out[4] = out4;
|
||
out[5] = out5;
|
||
return out;
|
||
}
|
||
function translate(out, a, v) {
|
||
out[0] = a[0];
|
||
out[1] = a[1];
|
||
out[2] = a[2];
|
||
out[3] = a[3];
|
||
out[4] = a[4] + v[0];
|
||
out[5] = a[5] + v[1];
|
||
return out;
|
||
}
|
||
function rotate(out, a, rad) {
|
||
var aa = a[0];
|
||
var ac = a[2];
|
||
var atx = a[4];
|
||
var ab = a[1];
|
||
var ad = a[3];
|
||
var aty = a[5];
|
||
var st = Math.sin(rad);
|
||
var ct = Math.cos(rad);
|
||
out[0] = aa * ct + ab * st;
|
||
out[1] = -aa * st + ab * ct;
|
||
out[2] = ac * ct + ad * st;
|
||
out[3] = -ac * st + ct * ad;
|
||
out[4] = ct * atx + st * aty;
|
||
out[5] = ct * aty - st * atx;
|
||
return out;
|
||
}
|
||
function scale$1(out, a, v) {
|
||
var vx = v[0];
|
||
var vy = v[1];
|
||
out[0] = a[0] * vx;
|
||
out[1] = a[1] * vy;
|
||
out[2] = a[2] * vx;
|
||
out[3] = a[3] * vy;
|
||
out[4] = a[4] * vx;
|
||
out[5] = a[5] * vy;
|
||
return out;
|
||
}
|
||
function invert(out, a) {
|
||
var aa = a[0];
|
||
var ac = a[2];
|
||
var atx = a[4];
|
||
var ab = a[1];
|
||
var ad = a[3];
|
||
var aty = a[5];
|
||
var det = aa * ad - ab * ac;
|
||
if (!det) {
|
||
return null;
|
||
}
|
||
det = 1.0 / det;
|
||
out[0] = ad * det;
|
||
out[1] = -ab * det;
|
||
out[2] = -ac * det;
|
||
out[3] = aa * det;
|
||
out[4] = (ac * aty - ad * atx) * det;
|
||
out[5] = (ab * atx - aa * aty) * det;
|
||
return out;
|
||
}
|
||
function clone$2(a) {
|
||
var b = create$1();
|
||
copy$1(b, a);
|
||
return b;
|
||
}
|
||
|
||
var matrix = /*#__PURE__*/Object.freeze({
|
||
__proto__: null,
|
||
create: create$1,
|
||
identity: identity,
|
||
copy: copy$1,
|
||
mul: mul$1,
|
||
translate: translate,
|
||
rotate: rotate,
|
||
scale: scale$1,
|
||
invert: invert,
|
||
clone: clone$2
|
||
});
|
||
|
||
var mIdentity = identity;
|
||
var EPSILON$2 = 5e-5;
|
||
function isNotAroundZero$1(val) {
|
||
return val > EPSILON$2 || val < -EPSILON$2;
|
||
}
|
||
var scaleTmp = [];
|
||
var tmpTransform = [];
|
||
var originTransform = create$1();
|
||
var abs = Math.abs;
|
||
var Transformable = (function () {
|
||
function Transformable() {
|
||
}
|
||
Transformable.prototype.getLocalTransform = function (m) {
|
||
return Transformable.getLocalTransform(this, m);
|
||
};
|
||
Transformable.prototype.setPosition = function (arr) {
|
||
this.x = arr[0];
|
||
this.y = arr[1];
|
||
};
|
||
Transformable.prototype.setScale = function (arr) {
|
||
this.scaleX = arr[0];
|
||
this.scaleY = arr[1];
|
||
};
|
||
Transformable.prototype.setSkew = function (arr) {
|
||
this.skewX = arr[0];
|
||
this.skewY = arr[1];
|
||
};
|
||
Transformable.prototype.setOrigin = function (arr) {
|
||
this.originX = arr[0];
|
||
this.originY = arr[1];
|
||
};
|
||
Transformable.prototype.needLocalTransform = function () {
|
||
return isNotAroundZero$1(this.rotation)
|
||
|| isNotAroundZero$1(this.x)
|
||
|| isNotAroundZero$1(this.y)
|
||
|| isNotAroundZero$1(this.scaleX - 1)
|
||
|| isNotAroundZero$1(this.scaleY - 1)
|
||
|| isNotAroundZero$1(this.skewX)
|
||
|| isNotAroundZero$1(this.skewY);
|
||
};
|
||
Transformable.prototype.updateTransform = function () {
|
||
var parentTransform = this.parent && this.parent.transform;
|
||
var needLocalTransform = this.needLocalTransform();
|
||
var m = this.transform;
|
||
if (!(needLocalTransform || parentTransform)) {
|
||
m && mIdentity(m);
|
||
return;
|
||
}
|
||
m = m || create$1();
|
||
if (needLocalTransform) {
|
||
this.getLocalTransform(m);
|
||
}
|
||
else {
|
||
mIdentity(m);
|
||
}
|
||
if (parentTransform) {
|
||
if (needLocalTransform) {
|
||
mul$1(m, parentTransform, m);
|
||
}
|
||
else {
|
||
copy$1(m, parentTransform);
|
||
}
|
||
}
|
||
this.transform = m;
|
||
this._resolveGlobalScaleRatio(m);
|
||
};
|
||
Transformable.prototype._resolveGlobalScaleRatio = function (m) {
|
||
var globalScaleRatio = this.globalScaleRatio;
|
||
if (globalScaleRatio != null && globalScaleRatio !== 1) {
|
||
this.getGlobalScale(scaleTmp);
|
||
var relX = scaleTmp[0] < 0 ? -1 : 1;
|
||
var relY = scaleTmp[1] < 0 ? -1 : 1;
|
||
var sx = ((scaleTmp[0] - relX) * globalScaleRatio + relX) / scaleTmp[0] || 0;
|
||
var sy = ((scaleTmp[1] - relY) * globalScaleRatio + relY) / scaleTmp[1] || 0;
|
||
m[0] *= sx;
|
||
m[1] *= sx;
|
||
m[2] *= sy;
|
||
m[3] *= sy;
|
||
}
|
||
this.invTransform = this.invTransform || create$1();
|
||
invert(this.invTransform, m);
|
||
};
|
||
Transformable.prototype.getComputedTransform = function () {
|
||
var transformNode = this;
|
||
var ancestors = [];
|
||
while (transformNode) {
|
||
ancestors.push(transformNode);
|
||
transformNode = transformNode.parent;
|
||
}
|
||
while (transformNode = ancestors.pop()) {
|
||
transformNode.updateTransform();
|
||
}
|
||
return this.transform;
|
||
};
|
||
Transformable.prototype.setLocalTransform = function (m) {
|
||
if (!m) {
|
||
return;
|
||
}
|
||
var sx = m[0] * m[0] + m[1] * m[1];
|
||
var sy = m[2] * m[2] + m[3] * m[3];
|
||
var rotation = Math.atan2(m[1], m[0]);
|
||
var shearX = Math.PI / 2 + rotation - Math.atan2(m[3], m[2]);
|
||
sy = Math.sqrt(sy) * Math.cos(shearX);
|
||
sx = Math.sqrt(sx);
|
||
this.skewX = shearX;
|
||
this.skewY = 0;
|
||
this.rotation = -rotation;
|
||
this.x = +m[4];
|
||
this.y = +m[5];
|
||
this.scaleX = sx;
|
||
this.scaleY = sy;
|
||
this.originX = 0;
|
||
this.originY = 0;
|
||
};
|
||
Transformable.prototype.decomposeTransform = function () {
|
||
if (!this.transform) {
|
||
return;
|
||
}
|
||
var parent = this.parent;
|
||
var m = this.transform;
|
||
if (parent && parent.transform) {
|
||
mul$1(tmpTransform, parent.invTransform, m);
|
||
m = tmpTransform;
|
||
}
|
||
var ox = this.originX;
|
||
var oy = this.originY;
|
||
if (ox || oy) {
|
||
originTransform[4] = ox;
|
||
originTransform[5] = oy;
|
||
mul$1(tmpTransform, m, originTransform);
|
||
tmpTransform[4] -= ox;
|
||
tmpTransform[5] -= oy;
|
||
m = tmpTransform;
|
||
}
|
||
this.setLocalTransform(m);
|
||
};
|
||
Transformable.prototype.getGlobalScale = function (out) {
|
||
var m = this.transform;
|
||
out = out || [];
|
||
if (!m) {
|
||
out[0] = 1;
|
||
out[1] = 1;
|
||
return out;
|
||
}
|
||
out[0] = Math.sqrt(m[0] * m[0] + m[1] * m[1]);
|
||
out[1] = Math.sqrt(m[2] * m[2] + m[3] * m[3]);
|
||
if (m[0] < 0) {
|
||
out[0] = -out[0];
|
||
}
|
||
if (m[3] < 0) {
|
||
out[1] = -out[1];
|
||
}
|
||
return out;
|
||
};
|
||
Transformable.prototype.transformCoordToLocal = function (x, y) {
|
||
var v2 = [x, y];
|
||
var invTransform = this.invTransform;
|
||
if (invTransform) {
|
||
applyTransform(v2, v2, invTransform);
|
||
}
|
||
return v2;
|
||
};
|
||
Transformable.prototype.transformCoordToGlobal = function (x, y) {
|
||
var v2 = [x, y];
|
||
var transform = this.transform;
|
||
if (transform) {
|
||
applyTransform(v2, v2, transform);
|
||
}
|
||
return v2;
|
||
};
|
||
Transformable.prototype.getLineScale = function () {
|
||
var m = this.transform;
|
||
return m && abs(m[0] - 1) > 1e-10 && abs(m[3] - 1) > 1e-10
|
||
? Math.sqrt(abs(m[0] * m[3] - m[2] * m[1]))
|
||
: 1;
|
||
};
|
||
Transformable.prototype.copyTransform = function (source) {
|
||
copyTransform(this, source);
|
||
};
|
||
Transformable.getLocalTransform = function (target, m) {
|
||
m = m || [];
|
||
var ox = target.originX || 0;
|
||
var oy = target.originY || 0;
|
||
var sx = target.scaleX;
|
||
var sy = target.scaleY;
|
||
var ax = target.anchorX;
|
||
var ay = target.anchorY;
|
||
var rotation = target.rotation || 0;
|
||
var x = target.x;
|
||
var y = target.y;
|
||
var skewX = target.skewX ? Math.tan(target.skewX) : 0;
|
||
var skewY = target.skewY ? Math.tan(-target.skewY) : 0;
|
||
if (ox || oy || ax || ay) {
|
||
var dx = ox + ax;
|
||
var dy = oy + ay;
|
||
m[4] = -dx * sx - skewX * dy * sy;
|
||
m[5] = -dy * sy - skewY * dx * sx;
|
||
}
|
||
else {
|
||
m[4] = m[5] = 0;
|
||
}
|
||
m[0] = sx;
|
||
m[3] = sy;
|
||
m[1] = skewY * sx;
|
||
m[2] = skewX * sy;
|
||
rotation && rotate(m, m, rotation);
|
||
m[4] += ox + x;
|
||
m[5] += oy + y;
|
||
return m;
|
||
};
|
||
Transformable.initDefaultProps = (function () {
|
||
var proto = Transformable.prototype;
|
||
proto.scaleX =
|
||
proto.scaleY =
|
||
proto.globalScaleRatio = 1;
|
||
proto.x =
|
||
proto.y =
|
||
proto.originX =
|
||
proto.originY =
|
||
proto.skewX =
|
||
proto.skewY =
|
||
proto.rotation =
|
||
proto.anchorX =
|
||
proto.anchorY = 0;
|
||
})();
|
||
return Transformable;
|
||
}());
|
||
var TRANSFORMABLE_PROPS = [
|
||
'x', 'y', 'originX', 'originY', 'anchorX', 'anchorY', 'rotation', 'scaleX', 'scaleY', 'skewX', 'skewY'
|
||
];
|
||
function copyTransform(target, source) {
|
||
for (var i = 0; i < TRANSFORMABLE_PROPS.length; i++) {
|
||
var propName = TRANSFORMABLE_PROPS[i];
|
||
target[propName] = source[propName];
|
||
}
|
||
}
|
||
|
||
var Point = (function () {
|
||
function Point(x, y) {
|
||
this.x = x || 0;
|
||
this.y = y || 0;
|
||
}
|
||
Point.prototype.copy = function (other) {
|
||
this.x = other.x;
|
||
this.y = other.y;
|
||
return this;
|
||
};
|
||
Point.prototype.clone = function () {
|
||
return new Point(this.x, this.y);
|
||
};
|
||
Point.prototype.set = function (x, y) {
|
||
this.x = x;
|
||
this.y = y;
|
||
return this;
|
||
};
|
||
Point.prototype.equal = function (other) {
|
||
return other.x === this.x && other.y === this.y;
|
||
};
|
||
Point.prototype.add = function (other) {
|
||
this.x += other.x;
|
||
this.y += other.y;
|
||
return this;
|
||
};
|
||
Point.prototype.scale = function (scalar) {
|
||
this.x *= scalar;
|
||
this.y *= scalar;
|
||
};
|
||
Point.prototype.scaleAndAdd = function (other, scalar) {
|
||
this.x += other.x * scalar;
|
||
this.y += other.y * scalar;
|
||
};
|
||
Point.prototype.sub = function (other) {
|
||
this.x -= other.x;
|
||
this.y -= other.y;
|
||
return this;
|
||
};
|
||
Point.prototype.dot = function (other) {
|
||
return this.x * other.x + this.y * other.y;
|
||
};
|
||
Point.prototype.len = function () {
|
||
return Math.sqrt(this.x * this.x + this.y * this.y);
|
||
};
|
||
Point.prototype.lenSquare = function () {
|
||
return this.x * this.x + this.y * this.y;
|
||
};
|
||
Point.prototype.normalize = function () {
|
||
var len = this.len();
|
||
this.x /= len;
|
||
this.y /= len;
|
||
return this;
|
||
};
|
||
Point.prototype.distance = function (other) {
|
||
var dx = this.x - other.x;
|
||
var dy = this.y - other.y;
|
||
return Math.sqrt(dx * dx + dy * dy);
|
||
};
|
||
Point.prototype.distanceSquare = function (other) {
|
||
var dx = this.x - other.x;
|
||
var dy = this.y - other.y;
|
||
return dx * dx + dy * dy;
|
||
};
|
||
Point.prototype.negate = function () {
|
||
this.x = -this.x;
|
||
this.y = -this.y;
|
||
return this;
|
||
};
|
||
Point.prototype.transform = function (m) {
|
||
if (!m) {
|
||
return;
|
||
}
|
||
var x = this.x;
|
||
var y = this.y;
|
||
this.x = m[0] * x + m[2] * y + m[4];
|
||
this.y = m[1] * x + m[3] * y + m[5];
|
||
return this;
|
||
};
|
||
Point.prototype.toArray = function (out) {
|
||
out[0] = this.x;
|
||
out[1] = this.y;
|
||
return out;
|
||
};
|
||
Point.prototype.fromArray = function (input) {
|
||
this.x = input[0];
|
||
this.y = input[1];
|
||
};
|
||
Point.set = function (p, x, y) {
|
||
p.x = x;
|
||
p.y = y;
|
||
};
|
||
Point.copy = function (p, p2) {
|
||
p.x = p2.x;
|
||
p.y = p2.y;
|
||
};
|
||
Point.len = function (p) {
|
||
return Math.sqrt(p.x * p.x + p.y * p.y);
|
||
};
|
||
Point.lenSquare = function (p) {
|
||
return p.x * p.x + p.y * p.y;
|
||
};
|
||
Point.dot = function (p0, p1) {
|
||
return p0.x * p1.x + p0.y * p1.y;
|
||
};
|
||
Point.add = function (out, p0, p1) {
|
||
out.x = p0.x + p1.x;
|
||
out.y = p0.y + p1.y;
|
||
};
|
||
Point.sub = function (out, p0, p1) {
|
||
out.x = p0.x - p1.x;
|
||
out.y = p0.y - p1.y;
|
||
};
|
||
Point.scale = function (out, p0, scalar) {
|
||
out.x = p0.x * scalar;
|
||
out.y = p0.y * scalar;
|
||
};
|
||
Point.scaleAndAdd = function (out, p0, p1, scalar) {
|
||
out.x = p0.x + p1.x * scalar;
|
||
out.y = p0.y + p1.y * scalar;
|
||
};
|
||
Point.lerp = function (out, p0, p1, t) {
|
||
var onet = 1 - t;
|
||
out.x = onet * p0.x + t * p1.x;
|
||
out.y = onet * p0.y + t * p1.y;
|
||
};
|
||
return Point;
|
||
}());
|
||
|
||
var mathMin = Math.min;
|
||
var mathMax = Math.max;
|
||
var lt = new Point();
|
||
var rb = new Point();
|
||
var lb = new Point();
|
||
var rt = new Point();
|
||
var minTv = new Point();
|
||
var maxTv = new Point();
|
||
var BoundingRect = (function () {
|
||
function BoundingRect(x, y, width, height) {
|
||
if (width < 0) {
|
||
x = x + width;
|
||
width = -width;
|
||
}
|
||
if (height < 0) {
|
||
y = y + height;
|
||
height = -height;
|
||
}
|
||
this.x = x;
|
||
this.y = y;
|
||
this.width = width;
|
||
this.height = height;
|
||
}
|
||
BoundingRect.prototype.union = function (other) {
|
||
var x = mathMin(other.x, this.x);
|
||
var y = mathMin(other.y, this.y);
|
||
if (isFinite(this.x) && isFinite(this.width)) {
|
||
this.width = mathMax(other.x + other.width, this.x + this.width) - x;
|
||
}
|
||
else {
|
||
this.width = other.width;
|
||
}
|
||
if (isFinite(this.y) && isFinite(this.height)) {
|
||
this.height = mathMax(other.y + other.height, this.y + this.height) - y;
|
||
}
|
||
else {
|
||
this.height = other.height;
|
||
}
|
||
this.x = x;
|
||
this.y = y;
|
||
};
|
||
BoundingRect.prototype.applyTransform = function (m) {
|
||
BoundingRect.applyTransform(this, this, m);
|
||
};
|
||
BoundingRect.prototype.calculateTransform = function (b) {
|
||
var a = this;
|
||
var sx = b.width / a.width;
|
||
var sy = b.height / a.height;
|
||
var m = create$1();
|
||
translate(m, m, [-a.x, -a.y]);
|
||
scale$1(m, m, [sx, sy]);
|
||
translate(m, m, [b.x, b.y]);
|
||
return m;
|
||
};
|
||
BoundingRect.prototype.intersect = function (b, mtv) {
|
||
if (!b) {
|
||
return false;
|
||
}
|
||
if (!(b instanceof BoundingRect)) {
|
||
b = BoundingRect.create(b);
|
||
}
|
||
var a = this;
|
||
var ax0 = a.x;
|
||
var ax1 = a.x + a.width;
|
||
var ay0 = a.y;
|
||
var ay1 = a.y + a.height;
|
||
var bx0 = b.x;
|
||
var bx1 = b.x + b.width;
|
||
var by0 = b.y;
|
||
var by1 = b.y + b.height;
|
||
var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);
|
||
if (mtv) {
|
||
var dMin = Infinity;
|
||
var dMax = 0;
|
||
var d0 = Math.abs(ax1 - bx0);
|
||
var d1 = Math.abs(bx1 - ax0);
|
||
var d2 = Math.abs(ay1 - by0);
|
||
var d3 = Math.abs(by1 - ay0);
|
||
var dx = Math.min(d0, d1);
|
||
var dy = Math.min(d2, d3);
|
||
if (ax1 < bx0 || bx1 < ax0) {
|
||
if (dx > dMax) {
|
||
dMax = dx;
|
||
if (d0 < d1) {
|
||
Point.set(maxTv, -d0, 0);
|
||
}
|
||
else {
|
||
Point.set(maxTv, d1, 0);
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
if (dx < dMin) {
|
||
dMin = dx;
|
||
if (d0 < d1) {
|
||
Point.set(minTv, d0, 0);
|
||
}
|
||
else {
|
||
Point.set(minTv, -d1, 0);
|
||
}
|
||
}
|
||
}
|
||
if (ay1 < by0 || by1 < ay0) {
|
||
if (dy > dMax) {
|
||
dMax = dy;
|
||
if (d2 < d3) {
|
||
Point.set(maxTv, 0, -d2);
|
||
}
|
||
else {
|
||
Point.set(maxTv, 0, d3);
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
if (dx < dMin) {
|
||
dMin = dx;
|
||
if (d2 < d3) {
|
||
Point.set(minTv, 0, d2);
|
||
}
|
||
else {
|
||
Point.set(minTv, 0, -d3);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (mtv) {
|
||
Point.copy(mtv, overlap ? minTv : maxTv);
|
||
}
|
||
return overlap;
|
||
};
|
||
BoundingRect.prototype.contain = function (x, y) {
|
||
var rect = this;
|
||
return x >= rect.x
|
||
&& x <= (rect.x + rect.width)
|
||
&& y >= rect.y
|
||
&& y <= (rect.y + rect.height);
|
||
};
|
||
BoundingRect.prototype.clone = function () {
|
||
return new BoundingRect(this.x, this.y, this.width, this.height);
|
||
};
|
||
BoundingRect.prototype.copy = function (other) {
|
||
BoundingRect.copy(this, other);
|
||
};
|
||
BoundingRect.prototype.plain = function () {
|
||
return {
|
||
x: this.x,
|
||
y: this.y,
|
||
width: this.width,
|
||
height: this.height
|
||
};
|
||
};
|
||
BoundingRect.prototype.isFinite = function () {
|
||
return isFinite(this.x)
|
||
&& isFinite(this.y)
|
||
&& isFinite(this.width)
|
||
&& isFinite(this.height);
|
||
};
|
||
BoundingRect.prototype.isZero = function () {
|
||
return this.width === 0 || this.height === 0;
|
||
};
|
||
BoundingRect.create = function (rect) {
|
||
return new BoundingRect(rect.x, rect.y, rect.width, rect.height);
|
||
};
|
||
BoundingRect.copy = function (target, source) {
|
||
target.x = source.x;
|
||
target.y = source.y;
|
||
target.width = source.width;
|
||
target.height = source.height;
|
||
};
|
||
BoundingRect.applyTransform = function (target, source, m) {
|
||
if (!m) {
|
||
if (target !== source) {
|
||
BoundingRect.copy(target, source);
|
||
}
|
||
return;
|
||
}
|
||
if (m[1] < 1e-5 && m[1] > -1e-5 && m[2] < 1e-5 && m[2] > -1e-5) {
|
||
var sx = m[0];
|
||
var sy = m[3];
|
||
var tx = m[4];
|
||
var ty = m[5];
|
||
target.x = source.x * sx + tx;
|
||
target.y = source.y * sy + ty;
|
||
target.width = source.width * sx;
|
||
target.height = source.height * sy;
|
||
if (target.width < 0) {
|
||
target.x += target.width;
|
||
target.width = -target.width;
|
||
}
|
||
if (target.height < 0) {
|
||
target.y += target.height;
|
||
target.height = -target.height;
|
||
}
|
||
return;
|
||
}
|
||
lt.x = lb.x = source.x;
|
||
lt.y = rt.y = source.y;
|
||
rb.x = rt.x = source.x + source.width;
|
||
rb.y = lb.y = source.y + source.height;
|
||
lt.transform(m);
|
||
rt.transform(m);
|
||
rb.transform(m);
|
||
lb.transform(m);
|
||
target.x = mathMin(lt.x, rb.x, lb.x, rt.x);
|
||
target.y = mathMin(lt.y, rb.y, lb.y, rt.y);
|
||
var maxX = mathMax(lt.x, rb.x, lb.x, rt.x);
|
||
var maxY = mathMax(lt.y, rb.y, lb.y, rt.y);
|
||
target.width = maxX - target.x;
|
||
target.height = maxY - target.y;
|
||
};
|
||
return BoundingRect;
|
||
}());
|
||
|
||
var textWidthCache = {};
|
||
function getWidth(text, font) {
|
||
font = font || DEFAULT_FONT;
|
||
var cacheOfFont = textWidthCache[font];
|
||
if (!cacheOfFont) {
|
||
cacheOfFont = textWidthCache[font] = new LRU(500);
|
||
}
|
||
var width = cacheOfFont.get(text);
|
||
if (width == null) {
|
||
width = platformApi.measureText(text, font).width;
|
||
cacheOfFont.put(text, width);
|
||
}
|
||
return width;
|
||
}
|
||
function innerGetBoundingRect(text, font, textAlign, textBaseline) {
|
||
var width = getWidth(text, font);
|
||
var height = getLineHeight(font);
|
||
var x = adjustTextX(0, width, textAlign);
|
||
var y = adjustTextY$1(0, height, textBaseline);
|
||
var rect = new BoundingRect(x, y, width, height);
|
||
return rect;
|
||
}
|
||
function getBoundingRect(text, font, textAlign, textBaseline) {
|
||
var textLines = ((text || '') + '').split('\n');
|
||
var len = textLines.length;
|
||
if (len === 1) {
|
||
return innerGetBoundingRect(textLines[0], font, textAlign, textBaseline);
|
||
}
|
||
else {
|
||
var uniondRect = new BoundingRect(0, 0, 0, 0);
|
||
for (var i = 0; i < textLines.length; i++) {
|
||
var rect = innerGetBoundingRect(textLines[i], font, textAlign, textBaseline);
|
||
i === 0 ? uniondRect.copy(rect) : uniondRect.union(rect);
|
||
}
|
||
return uniondRect;
|
||
}
|
||
}
|
||
function adjustTextX(x, width, textAlign) {
|
||
if (textAlign === 'right') {
|
||
x -= width;
|
||
}
|
||
else if (textAlign === 'center') {
|
||
x -= width / 2;
|
||
}
|
||
return x;
|
||
}
|
||
function adjustTextY$1(y, height, verticalAlign) {
|
||
if (verticalAlign === 'middle') {
|
||
y -= height / 2;
|
||
}
|
||
else if (verticalAlign === 'bottom') {
|
||
y -= height;
|
||
}
|
||
return y;
|
||
}
|
||
function getLineHeight(font) {
|
||
return getWidth('国', font);
|
||
}
|
||
function parsePercent(value, maxValue) {
|
||
if (typeof value === 'string') {
|
||
if (value.lastIndexOf('%') >= 0) {
|
||
return parseFloat(value) / 100 * maxValue;
|
||
}
|
||
return parseFloat(value);
|
||
}
|
||
return value;
|
||
}
|
||
function calculateTextPosition(out, opts, rect) {
|
||
var textPosition = opts.position || 'inside';
|
||
var distance = opts.distance != null ? opts.distance : 5;
|
||
var height = rect.height;
|
||
var width = rect.width;
|
||
var halfHeight = height / 2;
|
||
var x = rect.x;
|
||
var y = rect.y;
|
||
var textAlign = 'left';
|
||
var textVerticalAlign = 'top';
|
||
if (textPosition instanceof Array) {
|
||
x += parsePercent(textPosition[0], rect.width);
|
||
y += parsePercent(textPosition[1], rect.height);
|
||
textAlign = null;
|
||
textVerticalAlign = null;
|
||
}
|
||
else {
|
||
switch (textPosition) {
|
||
case 'left':
|
||
x -= distance;
|
||
y += halfHeight;
|
||
textAlign = 'right';
|
||
textVerticalAlign = 'middle';
|
||
break;
|
||
case 'right':
|
||
x += distance + width;
|
||
y += halfHeight;
|
||
textVerticalAlign = 'middle';
|
||
break;
|
||
case 'top':
|
||
x += width / 2;
|
||
y -= distance;
|
||
textAlign = 'center';
|
||
textVerticalAlign = 'bottom';
|
||
break;
|
||
case 'bottom':
|
||
x += width / 2;
|
||
y += height + distance;
|
||
textAlign = 'center';
|
||
break;
|
||
case 'inside':
|
||
x += width / 2;
|
||
y += halfHeight;
|
||
textAlign = 'center';
|
||
textVerticalAlign = 'middle';
|
||
break;
|
||
case 'insideLeft':
|
||
x += distance;
|
||
y += halfHeight;
|
||
textVerticalAlign = 'middle';
|
||
break;
|
||
case 'insideRight':
|
||
x += width - distance;
|
||
y += halfHeight;
|
||
textAlign = 'right';
|
||
textVerticalAlign = 'middle';
|
||
break;
|
||
case 'insideTop':
|
||
x += width / 2;
|
||
y += distance;
|
||
textAlign = 'center';
|
||
break;
|
||
case 'insideBottom':
|
||
x += width / 2;
|
||
y += height - distance;
|
||
textAlign = 'center';
|
||
textVerticalAlign = 'bottom';
|
||
break;
|
||
case 'insideTopLeft':
|
||
x += distance;
|
||
y += distance;
|
||
break;
|
||
case 'insideTopRight':
|
||
x += width - distance;
|
||
y += distance;
|
||
textAlign = 'right';
|
||
break;
|
||
case 'insideBottomLeft':
|
||
x += distance;
|
||
y += height - distance;
|
||
textVerticalAlign = 'bottom';
|
||
break;
|
||
case 'insideBottomRight':
|
||
x += width - distance;
|
||
y += height - distance;
|
||
textAlign = 'right';
|
||
textVerticalAlign = 'bottom';
|
||
break;
|
||
}
|
||
}
|
||
out = out || {};
|
||
out.x = x;
|
||
out.y = y;
|
||
out.align = textAlign;
|
||
out.verticalAlign = textVerticalAlign;
|
||
return out;
|
||
}
|
||
|
||
var PRESERVED_NORMAL_STATE = '__zr_normal__';
|
||
var PRIMARY_STATES_KEYS = TRANSFORMABLE_PROPS.concat(['ignore']);
|
||
var DEFAULT_ANIMATABLE_MAP = reduce(TRANSFORMABLE_PROPS, function (obj, key) {
|
||
obj[key] = true;
|
||
return obj;
|
||
}, { ignore: false });
|
||
var tmpTextPosCalcRes = {};
|
||
var tmpBoundingRect = new BoundingRect(0, 0, 0, 0);
|
||
var Element = (function () {
|
||
function Element(props) {
|
||
this.id = guid();
|
||
this.animators = [];
|
||
this.currentStates = [];
|
||
this.states = {};
|
||
this._init(props);
|
||
}
|
||
Element.prototype._init = function (props) {
|
||
this.attr(props);
|
||
};
|
||
Element.prototype.drift = function (dx, dy, e) {
|
||
switch (this.draggable) {
|
||
case 'horizontal':
|
||
dy = 0;
|
||
break;
|
||
case 'vertical':
|
||
dx = 0;
|
||
break;
|
||
}
|
||
var m = this.transform;
|
||
if (!m) {
|
||
m = this.transform = [1, 0, 0, 1, 0, 0];
|
||
}
|
||
m[4] += dx;
|
||
m[5] += dy;
|
||
this.decomposeTransform();
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.beforeUpdate = function () { };
|
||
Element.prototype.afterUpdate = function () { };
|
||
Element.prototype.update = function () {
|
||
this.updateTransform();
|
||
if (this.__dirty) {
|
||
this.updateInnerText();
|
||
}
|
||
};
|
||
Element.prototype.updateInnerText = function (forceUpdate) {
|
||
var textEl = this._textContent;
|
||
if (textEl && (!textEl.ignore || forceUpdate)) {
|
||
if (!this.textConfig) {
|
||
this.textConfig = {};
|
||
}
|
||
var textConfig = this.textConfig;
|
||
var isLocal = textConfig.local;
|
||
var innerTransformable = textEl.innerTransformable;
|
||
var textAlign = void 0;
|
||
var textVerticalAlign = void 0;
|
||
var textStyleChanged = false;
|
||
innerTransformable.parent = isLocal ? this : null;
|
||
var innerOrigin = false;
|
||
innerTransformable.copyTransform(textEl);
|
||
if (textConfig.position != null) {
|
||
var layoutRect = tmpBoundingRect;
|
||
if (textConfig.layoutRect) {
|
||
layoutRect.copy(textConfig.layoutRect);
|
||
}
|
||
else {
|
||
layoutRect.copy(this.getBoundingRect());
|
||
}
|
||
if (!isLocal) {
|
||
layoutRect.applyTransform(this.transform);
|
||
}
|
||
if (this.calculateTextPosition) {
|
||
this.calculateTextPosition(tmpTextPosCalcRes, textConfig, layoutRect);
|
||
}
|
||
else {
|
||
calculateTextPosition(tmpTextPosCalcRes, textConfig, layoutRect);
|
||
}
|
||
innerTransformable.x = tmpTextPosCalcRes.x;
|
||
innerTransformable.y = tmpTextPosCalcRes.y;
|
||
textAlign = tmpTextPosCalcRes.align;
|
||
textVerticalAlign = tmpTextPosCalcRes.verticalAlign;
|
||
var textOrigin = textConfig.origin;
|
||
if (textOrigin && textConfig.rotation != null) {
|
||
var relOriginX = void 0;
|
||
var relOriginY = void 0;
|
||
if (textOrigin === 'center') {
|
||
relOriginX = layoutRect.width * 0.5;
|
||
relOriginY = layoutRect.height * 0.5;
|
||
}
|
||
else {
|
||
relOriginX = parsePercent(textOrigin[0], layoutRect.width);
|
||
relOriginY = parsePercent(textOrigin[1], layoutRect.height);
|
||
}
|
||
innerOrigin = true;
|
||
innerTransformable.originX = -innerTransformable.x + relOriginX + (isLocal ? 0 : layoutRect.x);
|
||
innerTransformable.originY = -innerTransformable.y + relOriginY + (isLocal ? 0 : layoutRect.y);
|
||
}
|
||
}
|
||
if (textConfig.rotation != null) {
|
||
innerTransformable.rotation = textConfig.rotation;
|
||
}
|
||
var textOffset = textConfig.offset;
|
||
if (textOffset) {
|
||
innerTransformable.x += textOffset[0];
|
||
innerTransformable.y += textOffset[1];
|
||
if (!innerOrigin) {
|
||
innerTransformable.originX = -textOffset[0];
|
||
innerTransformable.originY = -textOffset[1];
|
||
}
|
||
}
|
||
var isInside = textConfig.inside == null
|
||
? (typeof textConfig.position === 'string' && textConfig.position.indexOf('inside') >= 0)
|
||
: textConfig.inside;
|
||
var innerTextDefaultStyle = this._innerTextDefaultStyle || (this._innerTextDefaultStyle = {});
|
||
var textFill = void 0;
|
||
var textStroke = void 0;
|
||
var autoStroke = void 0;
|
||
if (isInside && this.canBeInsideText()) {
|
||
textFill = textConfig.insideFill;
|
||
textStroke = textConfig.insideStroke;
|
||
if (textFill == null || textFill === 'auto') {
|
||
textFill = this.getInsideTextFill();
|
||
}
|
||
if (textStroke == null || textStroke === 'auto') {
|
||
textStroke = this.getInsideTextStroke(textFill);
|
||
autoStroke = true;
|
||
}
|
||
}
|
||
else {
|
||
textFill = textConfig.outsideFill;
|
||
textStroke = textConfig.outsideStroke;
|
||
if (textFill == null || textFill === 'auto') {
|
||
textFill = this.getOutsideFill();
|
||
}
|
||
if (textStroke == null || textStroke === 'auto') {
|
||
textStroke = this.getOutsideStroke(textFill);
|
||
autoStroke = true;
|
||
}
|
||
}
|
||
textFill = textFill || '#000';
|
||
if (textFill !== innerTextDefaultStyle.fill
|
||
|| textStroke !== innerTextDefaultStyle.stroke
|
||
|| autoStroke !== innerTextDefaultStyle.autoStroke
|
||
|| textAlign !== innerTextDefaultStyle.align
|
||
|| textVerticalAlign !== innerTextDefaultStyle.verticalAlign) {
|
||
textStyleChanged = true;
|
||
innerTextDefaultStyle.fill = textFill;
|
||
innerTextDefaultStyle.stroke = textStroke;
|
||
innerTextDefaultStyle.autoStroke = autoStroke;
|
||
innerTextDefaultStyle.align = textAlign;
|
||
innerTextDefaultStyle.verticalAlign = textVerticalAlign;
|
||
textEl.setDefaultTextStyle(innerTextDefaultStyle);
|
||
}
|
||
textEl.__dirty |= REDRAW_BIT;
|
||
if (textStyleChanged) {
|
||
textEl.dirtyStyle(true);
|
||
}
|
||
}
|
||
};
|
||
Element.prototype.canBeInsideText = function () {
|
||
return true;
|
||
};
|
||
Element.prototype.getInsideTextFill = function () {
|
||
return '#fff';
|
||
};
|
||
Element.prototype.getInsideTextStroke = function (textFill) {
|
||
return '#000';
|
||
};
|
||
Element.prototype.getOutsideFill = function () {
|
||
return this.__zr && this.__zr.isDarkMode() ? LIGHT_LABEL_COLOR : DARK_LABEL_COLOR;
|
||
};
|
||
Element.prototype.getOutsideStroke = function (textFill) {
|
||
var backgroundColor = this.__zr && this.__zr.getBackgroundColor();
|
||
var colorArr = typeof backgroundColor === 'string' && parse(backgroundColor);
|
||
if (!colorArr) {
|
||
colorArr = [255, 255, 255, 1];
|
||
}
|
||
var alpha = colorArr[3];
|
||
var isDark = this.__zr.isDarkMode();
|
||
for (var i = 0; i < 3; i++) {
|
||
colorArr[i] = colorArr[i] * alpha + (isDark ? 0 : 255) * (1 - alpha);
|
||
}
|
||
colorArr[3] = 1;
|
||
return stringify(colorArr, 'rgba');
|
||
};
|
||
Element.prototype.traverse = function (cb, context) { };
|
||
Element.prototype.attrKV = function (key, value) {
|
||
if (key === 'textConfig') {
|
||
this.setTextConfig(value);
|
||
}
|
||
else if (key === 'textContent') {
|
||
this.setTextContent(value);
|
||
}
|
||
else if (key === 'clipPath') {
|
||
this.setClipPath(value);
|
||
}
|
||
else if (key === 'extra') {
|
||
this.extra = this.extra || {};
|
||
extend(this.extra, value);
|
||
}
|
||
else {
|
||
this[key] = value;
|
||
}
|
||
};
|
||
Element.prototype.hide = function () {
|
||
this.ignore = true;
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.show = function () {
|
||
this.ignore = false;
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.attr = function (keyOrObj, value) {
|
||
if (typeof keyOrObj === 'string') {
|
||
this.attrKV(keyOrObj, value);
|
||
}
|
||
else if (isObject(keyOrObj)) {
|
||
var obj = keyOrObj;
|
||
var keysArr = keys(obj);
|
||
for (var i = 0; i < keysArr.length; i++) {
|
||
var key = keysArr[i];
|
||
this.attrKV(key, keyOrObj[key]);
|
||
}
|
||
}
|
||
this.markRedraw();
|
||
return this;
|
||
};
|
||
Element.prototype.saveCurrentToNormalState = function (toState) {
|
||
this._innerSaveToNormal(toState);
|
||
var normalState = this._normalState;
|
||
for (var i = 0; i < this.animators.length; i++) {
|
||
var animator = this.animators[i];
|
||
var fromStateTransition = animator.__fromStateTransition;
|
||
if (animator.getLoop() || fromStateTransition && fromStateTransition !== PRESERVED_NORMAL_STATE) {
|
||
continue;
|
||
}
|
||
var targetName = animator.targetName;
|
||
var target = targetName
|
||
? normalState[targetName] : normalState;
|
||
animator.saveTo(target);
|
||
}
|
||
};
|
||
Element.prototype._innerSaveToNormal = function (toState) {
|
||
var normalState = this._normalState;
|
||
if (!normalState) {
|
||
normalState = this._normalState = {};
|
||
}
|
||
if (toState.textConfig && !normalState.textConfig) {
|
||
normalState.textConfig = this.textConfig;
|
||
}
|
||
this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS);
|
||
};
|
||
Element.prototype._savePrimaryToNormal = function (toState, normalState, primaryKeys) {
|
||
for (var i = 0; i < primaryKeys.length; i++) {
|
||
var key = primaryKeys[i];
|
||
if (toState[key] != null && !(key in normalState)) {
|
||
normalState[key] = this[key];
|
||
}
|
||
}
|
||
};
|
||
Element.prototype.hasState = function () {
|
||
return this.currentStates.length > 0;
|
||
};
|
||
Element.prototype.getState = function (name) {
|
||
return this.states[name];
|
||
};
|
||
Element.prototype.ensureState = function (name) {
|
||
var states = this.states;
|
||
if (!states[name]) {
|
||
states[name] = {};
|
||
}
|
||
return states[name];
|
||
};
|
||
Element.prototype.clearStates = function (noAnimation) {
|
||
this.useState(PRESERVED_NORMAL_STATE, false, noAnimation);
|
||
};
|
||
Element.prototype.useState = function (stateName, keepCurrentStates, noAnimation, forceUseHoverLayer) {
|
||
var toNormalState = stateName === PRESERVED_NORMAL_STATE;
|
||
var hasStates = this.hasState();
|
||
if (!hasStates && toNormalState) {
|
||
return;
|
||
}
|
||
var currentStates = this.currentStates;
|
||
var animationCfg = this.stateTransition;
|
||
if (indexOf(currentStates, stateName) >= 0 && (keepCurrentStates || currentStates.length === 1)) {
|
||
return;
|
||
}
|
||
var state;
|
||
if (this.stateProxy && !toNormalState) {
|
||
state = this.stateProxy(stateName);
|
||
}
|
||
if (!state) {
|
||
state = (this.states && this.states[stateName]);
|
||
}
|
||
if (!state && !toNormalState) {
|
||
logError("State " + stateName + " not exists.");
|
||
return;
|
||
}
|
||
if (!toNormalState) {
|
||
this.saveCurrentToNormalState(state);
|
||
}
|
||
var useHoverLayer = !!((state && state.hoverLayer) || forceUseHoverLayer);
|
||
if (useHoverLayer) {
|
||
this._toggleHoverLayerFlag(true);
|
||
}
|
||
this._applyStateObj(stateName, state, this._normalState, keepCurrentStates, !noAnimation && !this.__inHover && animationCfg && animationCfg.duration > 0, animationCfg);
|
||
var textContent = this._textContent;
|
||
var textGuide = this._textGuide;
|
||
if (textContent) {
|
||
textContent.useState(stateName, keepCurrentStates, noAnimation, useHoverLayer);
|
||
}
|
||
if (textGuide) {
|
||
textGuide.useState(stateName, keepCurrentStates, noAnimation, useHoverLayer);
|
||
}
|
||
if (toNormalState) {
|
||
this.currentStates = [];
|
||
this._normalState = {};
|
||
}
|
||
else {
|
||
if (!keepCurrentStates) {
|
||
this.currentStates = [stateName];
|
||
}
|
||
else {
|
||
this.currentStates.push(stateName);
|
||
}
|
||
}
|
||
this._updateAnimationTargets();
|
||
this.markRedraw();
|
||
if (!useHoverLayer && this.__inHover) {
|
||
this._toggleHoverLayerFlag(false);
|
||
this.__dirty &= ~REDRAW_BIT;
|
||
}
|
||
return state;
|
||
};
|
||
Element.prototype.useStates = function (states, noAnimation, forceUseHoverLayer) {
|
||
if (!states.length) {
|
||
this.clearStates();
|
||
}
|
||
else {
|
||
var stateObjects = [];
|
||
var currentStates = this.currentStates;
|
||
var len = states.length;
|
||
var notChange = len === currentStates.length;
|
||
if (notChange) {
|
||
for (var i = 0; i < len; i++) {
|
||
if (states[i] !== currentStates[i]) {
|
||
notChange = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (notChange) {
|
||
return;
|
||
}
|
||
for (var i = 0; i < len; i++) {
|
||
var stateName = states[i];
|
||
var stateObj = void 0;
|
||
if (this.stateProxy) {
|
||
stateObj = this.stateProxy(stateName, states);
|
||
}
|
||
if (!stateObj) {
|
||
stateObj = this.states[stateName];
|
||
}
|
||
if (stateObj) {
|
||
stateObjects.push(stateObj);
|
||
}
|
||
}
|
||
var lastStateObj = stateObjects[len - 1];
|
||
var useHoverLayer = !!((lastStateObj && lastStateObj.hoverLayer) || forceUseHoverLayer);
|
||
if (useHoverLayer) {
|
||
this._toggleHoverLayerFlag(true);
|
||
}
|
||
var mergedState = this._mergeStates(stateObjects);
|
||
var animationCfg = this.stateTransition;
|
||
this.saveCurrentToNormalState(mergedState);
|
||
this._applyStateObj(states.join(','), mergedState, this._normalState, false, !noAnimation && !this.__inHover && animationCfg && animationCfg.duration > 0, animationCfg);
|
||
var textContent = this._textContent;
|
||
var textGuide = this._textGuide;
|
||
if (textContent) {
|
||
textContent.useStates(states, noAnimation, useHoverLayer);
|
||
}
|
||
if (textGuide) {
|
||
textGuide.useStates(states, noAnimation, useHoverLayer);
|
||
}
|
||
this._updateAnimationTargets();
|
||
this.currentStates = states.slice();
|
||
this.markRedraw();
|
||
if (!useHoverLayer && this.__inHover) {
|
||
this._toggleHoverLayerFlag(false);
|
||
this.__dirty &= ~REDRAW_BIT;
|
||
}
|
||
}
|
||
};
|
||
Element.prototype._updateAnimationTargets = function () {
|
||
for (var i = 0; i < this.animators.length; i++) {
|
||
var animator = this.animators[i];
|
||
if (animator.targetName) {
|
||
animator.changeTarget(this[animator.targetName]);
|
||
}
|
||
}
|
||
};
|
||
Element.prototype.removeState = function (state) {
|
||
var idx = indexOf(this.currentStates, state);
|
||
if (idx >= 0) {
|
||
var currentStates = this.currentStates.slice();
|
||
currentStates.splice(idx, 1);
|
||
this.useStates(currentStates);
|
||
}
|
||
};
|
||
Element.prototype.replaceState = function (oldState, newState, forceAdd) {
|
||
var currentStates = this.currentStates.slice();
|
||
var idx = indexOf(currentStates, oldState);
|
||
var newStateExists = indexOf(currentStates, newState) >= 0;
|
||
if (idx >= 0) {
|
||
if (!newStateExists) {
|
||
currentStates[idx] = newState;
|
||
}
|
||
else {
|
||
currentStates.splice(idx, 1);
|
||
}
|
||
}
|
||
else if (forceAdd && !newStateExists) {
|
||
currentStates.push(newState);
|
||
}
|
||
this.useStates(currentStates);
|
||
};
|
||
Element.prototype.toggleState = function (state, enable) {
|
||
if (enable) {
|
||
this.useState(state, true);
|
||
}
|
||
else {
|
||
this.removeState(state);
|
||
}
|
||
};
|
||
Element.prototype._mergeStates = function (states) {
|
||
var mergedState = {};
|
||
var mergedTextConfig;
|
||
for (var i = 0; i < states.length; i++) {
|
||
var state = states[i];
|
||
extend(mergedState, state);
|
||
if (state.textConfig) {
|
||
mergedTextConfig = mergedTextConfig || {};
|
||
extend(mergedTextConfig, state.textConfig);
|
||
}
|
||
}
|
||
if (mergedTextConfig) {
|
||
mergedState.textConfig = mergedTextConfig;
|
||
}
|
||
return mergedState;
|
||
};
|
||
Element.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
|
||
var needsRestoreToNormal = !(state && keepCurrentStates);
|
||
if (state && state.textConfig) {
|
||
this.textConfig = extend({}, keepCurrentStates ? this.textConfig : normalState.textConfig);
|
||
extend(this.textConfig, state.textConfig);
|
||
}
|
||
else if (needsRestoreToNormal) {
|
||
if (normalState.textConfig) {
|
||
this.textConfig = normalState.textConfig;
|
||
}
|
||
}
|
||
var transitionTarget = {};
|
||
var hasTransition = false;
|
||
for (var i = 0; i < PRIMARY_STATES_KEYS.length; i++) {
|
||
var key = PRIMARY_STATES_KEYS[i];
|
||
var propNeedsTransition = transition && DEFAULT_ANIMATABLE_MAP[key];
|
||
if (state && state[key] != null) {
|
||
if (propNeedsTransition) {
|
||
hasTransition = true;
|
||
transitionTarget[key] = state[key];
|
||
}
|
||
else {
|
||
this[key] = state[key];
|
||
}
|
||
}
|
||
else if (needsRestoreToNormal) {
|
||
if (normalState[key] != null) {
|
||
if (propNeedsTransition) {
|
||
hasTransition = true;
|
||
transitionTarget[key] = normalState[key];
|
||
}
|
||
else {
|
||
this[key] = normalState[key];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (!transition) {
|
||
for (var i = 0; i < this.animators.length; i++) {
|
||
var animator = this.animators[i];
|
||
var targetName = animator.targetName;
|
||
if (!animator.getLoop()) {
|
||
animator.__changeFinalValue(targetName
|
||
? (state || normalState)[targetName]
|
||
: (state || normalState));
|
||
}
|
||
}
|
||
}
|
||
if (hasTransition) {
|
||
this._transitionState(stateName, transitionTarget, animationCfg);
|
||
}
|
||
};
|
||
Element.prototype._attachComponent = function (componentEl) {
|
||
if (componentEl.__zr && !componentEl.__hostTarget) {
|
||
if ("development" !== 'production') {
|
||
throw new Error('Text element has been added to zrender.');
|
||
}
|
||
return;
|
||
}
|
||
if (componentEl === this) {
|
||
if ("development" !== 'production') {
|
||
throw new Error('Recursive component attachment.');
|
||
}
|
||
return;
|
||
}
|
||
var zr = this.__zr;
|
||
if (zr) {
|
||
componentEl.addSelfToZr(zr);
|
||
}
|
||
componentEl.__zr = zr;
|
||
componentEl.__hostTarget = this;
|
||
};
|
||
Element.prototype._detachComponent = function (componentEl) {
|
||
if (componentEl.__zr) {
|
||
componentEl.removeSelfFromZr(componentEl.__zr);
|
||
}
|
||
componentEl.__zr = null;
|
||
componentEl.__hostTarget = null;
|
||
};
|
||
Element.prototype.getClipPath = function () {
|
||
return this._clipPath;
|
||
};
|
||
Element.prototype.setClipPath = function (clipPath) {
|
||
if (this._clipPath && this._clipPath !== clipPath) {
|
||
this.removeClipPath();
|
||
}
|
||
this._attachComponent(clipPath);
|
||
this._clipPath = clipPath;
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.removeClipPath = function () {
|
||
var clipPath = this._clipPath;
|
||
if (clipPath) {
|
||
this._detachComponent(clipPath);
|
||
this._clipPath = null;
|
||
this.markRedraw();
|
||
}
|
||
};
|
||
Element.prototype.getTextContent = function () {
|
||
return this._textContent;
|
||
};
|
||
Element.prototype.setTextContent = function (textEl) {
|
||
var previousTextContent = this._textContent;
|
||
if (previousTextContent === textEl) {
|
||
return;
|
||
}
|
||
if (previousTextContent && previousTextContent !== textEl) {
|
||
this.removeTextContent();
|
||
}
|
||
if ("development" !== 'production') {
|
||
if (textEl.__zr && !textEl.__hostTarget) {
|
||
throw new Error('Text element has been added to zrender.');
|
||
}
|
||
}
|
||
textEl.innerTransformable = new Transformable();
|
||
this._attachComponent(textEl);
|
||
this._textContent = textEl;
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.setTextConfig = function (cfg) {
|
||
if (!this.textConfig) {
|
||
this.textConfig = {};
|
||
}
|
||
extend(this.textConfig, cfg);
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.removeTextConfig = function () {
|
||
this.textConfig = null;
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.removeTextContent = function () {
|
||
var textEl = this._textContent;
|
||
if (textEl) {
|
||
textEl.innerTransformable = null;
|
||
this._detachComponent(textEl);
|
||
this._textContent = null;
|
||
this._innerTextDefaultStyle = null;
|
||
this.markRedraw();
|
||
}
|
||
};
|
||
Element.prototype.getTextGuideLine = function () {
|
||
return this._textGuide;
|
||
};
|
||
Element.prototype.setTextGuideLine = function (guideLine) {
|
||
if (this._textGuide && this._textGuide !== guideLine) {
|
||
this.removeTextGuideLine();
|
||
}
|
||
this._attachComponent(guideLine);
|
||
this._textGuide = guideLine;
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.removeTextGuideLine = function () {
|
||
var textGuide = this._textGuide;
|
||
if (textGuide) {
|
||
this._detachComponent(textGuide);
|
||
this._textGuide = null;
|
||
this.markRedraw();
|
||
}
|
||
};
|
||
Element.prototype.markRedraw = function () {
|
||
this.__dirty |= REDRAW_BIT;
|
||
var zr = this.__zr;
|
||
if (zr) {
|
||
if (this.__inHover) {
|
||
zr.refreshHover();
|
||
}
|
||
else {
|
||
zr.refresh();
|
||
}
|
||
}
|
||
if (this.__hostTarget) {
|
||
this.__hostTarget.markRedraw();
|
||
}
|
||
};
|
||
Element.prototype.dirty = function () {
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype._toggleHoverLayerFlag = function (inHover) {
|
||
this.__inHover = inHover;
|
||
var textContent = this._textContent;
|
||
var textGuide = this._textGuide;
|
||
if (textContent) {
|
||
textContent.__inHover = inHover;
|
||
}
|
||
if (textGuide) {
|
||
textGuide.__inHover = inHover;
|
||
}
|
||
};
|
||
Element.prototype.addSelfToZr = function (zr) {
|
||
if (this.__zr === zr) {
|
||
return;
|
||
}
|
||
this.__zr = zr;
|
||
var animators = this.animators;
|
||
if (animators) {
|
||
for (var i = 0; i < animators.length; i++) {
|
||
zr.animation.addAnimator(animators[i]);
|
||
}
|
||
}
|
||
if (this._clipPath) {
|
||
this._clipPath.addSelfToZr(zr);
|
||
}
|
||
if (this._textContent) {
|
||
this._textContent.addSelfToZr(zr);
|
||
}
|
||
if (this._textGuide) {
|
||
this._textGuide.addSelfToZr(zr);
|
||
}
|
||
};
|
||
Element.prototype.removeSelfFromZr = function (zr) {
|
||
if (!this.__zr) {
|
||
return;
|
||
}
|
||
this.__zr = null;
|
||
var animators = this.animators;
|
||
if (animators) {
|
||
for (var i = 0; i < animators.length; i++) {
|
||
zr.animation.removeAnimator(animators[i]);
|
||
}
|
||
}
|
||
if (this._clipPath) {
|
||
this._clipPath.removeSelfFromZr(zr);
|
||
}
|
||
if (this._textContent) {
|
||
this._textContent.removeSelfFromZr(zr);
|
||
}
|
||
if (this._textGuide) {
|
||
this._textGuide.removeSelfFromZr(zr);
|
||
}
|
||
};
|
||
Element.prototype.animate = function (key, loop, allowDiscreteAnimation) {
|
||
var target = key ? this[key] : this;
|
||
if ("development" !== 'production') {
|
||
if (!target) {
|
||
logError('Property "'
|
||
+ key
|
||
+ '" is not existed in element '
|
||
+ this.id);
|
||
return;
|
||
}
|
||
}
|
||
var animator = new Animator(target, loop, allowDiscreteAnimation);
|
||
key && (animator.targetName = key);
|
||
this.addAnimator(animator, key);
|
||
return animator;
|
||
};
|
||
Element.prototype.addAnimator = function (animator, key) {
|
||
var zr = this.__zr;
|
||
var el = this;
|
||
animator.during(function () {
|
||
el.updateDuringAnimation(key);
|
||
}).done(function () {
|
||
var animators = el.animators;
|
||
var idx = indexOf(animators, animator);
|
||
if (idx >= 0) {
|
||
animators.splice(idx, 1);
|
||
}
|
||
});
|
||
this.animators.push(animator);
|
||
if (zr) {
|
||
zr.animation.addAnimator(animator);
|
||
}
|
||
zr && zr.wakeUp();
|
||
};
|
||
Element.prototype.updateDuringAnimation = function (key) {
|
||
this.markRedraw();
|
||
};
|
||
Element.prototype.stopAnimation = function (scope, forwardToLast) {
|
||
var animators = this.animators;
|
||
var len = animators.length;
|
||
var leftAnimators = [];
|
||
for (var i = 0; i < len; i++) {
|
||
var animator = animators[i];
|
||
if (!scope || scope === animator.scope) {
|
||
animator.stop(forwardToLast);
|
||
}
|
||
else {
|
||
leftAnimators.push(animator);
|
||
}
|
||
}
|
||
this.animators = leftAnimators;
|
||
return this;
|
||
};
|
||
Element.prototype.animateTo = function (target, cfg, animationProps) {
|
||
animateTo(this, target, cfg, animationProps);
|
||
};
|
||
Element.prototype.animateFrom = function (target, cfg, animationProps) {
|
||
animateTo(this, target, cfg, animationProps, true);
|
||
};
|
||
Element.prototype._transitionState = function (stateName, target, cfg, animationProps) {
|
||
var animators = animateTo(this, target, cfg, animationProps);
|
||
for (var i = 0; i < animators.length; i++) {
|
||
animators[i].__fromStateTransition = stateName;
|
||
}
|
||
};
|
||
Element.prototype.getBoundingRect = function () {
|
||
return null;
|
||
};
|
||
Element.prototype.getPaintRect = function () {
|
||
return null;
|
||
};
|
||
Element.initDefaultProps = (function () {
|
||
var elProto = Element.prototype;
|
||
elProto.type = 'element';
|
||
elProto.name = '';
|
||
elProto.ignore =
|
||
elProto.silent =
|
||
elProto.isGroup =
|
||
elProto.draggable =
|
||
elProto.dragging =
|
||
elProto.ignoreClip =
|
||
elProto.__inHover = false;
|
||
elProto.__dirty = REDRAW_BIT;
|
||
var logs = {};
|
||
function logDeprecatedError(key, xKey, yKey) {
|
||
if (!logs[key + xKey + yKey]) {
|
||
console.warn("DEPRECATED: '" + key + "' has been deprecated. use '" + xKey + "', '" + yKey + "' instead");
|
||
logs[key + xKey + yKey] = true;
|
||
}
|
||
}
|
||
function createLegacyProperty(key, privateKey, xKey, yKey) {
|
||
Object.defineProperty(elProto, key, {
|
||
get: function () {
|
||
if ("development" !== 'production') {
|
||
logDeprecatedError(key, xKey, yKey);
|
||
}
|
||
if (!this[privateKey]) {
|
||
var pos = this[privateKey] = [];
|
||
enhanceArray(this, pos);
|
||
}
|
||
return this[privateKey];
|
||
},
|
||
set: function (pos) {
|
||
if ("development" !== 'production') {
|
||
logDeprecatedError(key, xKey, yKey);
|
||
}
|
||
this[xKey] = pos[0];
|
||
this[yKey] = pos[1];
|
||
this[privateKey] = pos;
|
||
enhanceArray(this, pos);
|
||
}
|
||
});
|
||
function enhanceArray(self, pos) {
|
||
Object.defineProperty(pos, 0, {
|
||
get: function () {
|
||
return self[xKey];
|
||
},
|
||
set: function (val) {
|
||
self[xKey] = val;
|
||
}
|
||
});
|
||
Object.defineProperty(pos, 1, {
|
||
get: function () {
|
||
return self[yKey];
|
||
},
|
||
set: function (val) {
|
||
self[yKey] = val;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
if (Object.defineProperty) {
|
||
createLegacyProperty('position', '_legacyPos', 'x', 'y');
|
||
createLegacyProperty('scale', '_legacyScale', 'scaleX', 'scaleY');
|
||
createLegacyProperty('origin', '_legacyOrigin', 'originX', 'originY');
|
||
}
|
||
})();
|
||
return Element;
|
||
}());
|
||
mixin(Element, Eventful);
|
||
mixin(Element, Transformable);
|
||
function animateTo(animatable, target, cfg, animationProps, reverse) {
|
||
cfg = cfg || {};
|
||
var animators = [];
|
||
animateToShallow(animatable, '', animatable, target, cfg, animationProps, animators, reverse);
|
||
var finishCount = animators.length;
|
||
var doneHappened = false;
|
||
var cfgDone = cfg.done;
|
||
var cfgAborted = cfg.aborted;
|
||
var doneCb = function () {
|
||
doneHappened = true;
|
||
finishCount--;
|
||
if (finishCount <= 0) {
|
||
doneHappened
|
||
? (cfgDone && cfgDone())
|
||
: (cfgAborted && cfgAborted());
|
||
}
|
||
};
|
||
var abortedCb = function () {
|
||
finishCount--;
|
||
if (finishCount <= 0) {
|
||
doneHappened
|
||
? (cfgDone && cfgDone())
|
||
: (cfgAborted && cfgAborted());
|
||
}
|
||
};
|
||
if (!finishCount) {
|
||
cfgDone && cfgDone();
|
||
}
|
||
if (animators.length > 0 && cfg.during) {
|
||
animators[0].during(function (target, percent) {
|
||
cfg.during(percent);
|
||
});
|
||
}
|
||
for (var i = 0; i < animators.length; i++) {
|
||
var animator = animators[i];
|
||
if (doneCb) {
|
||
animator.done(doneCb);
|
||
}
|
||
if (abortedCb) {
|
||
animator.aborted(abortedCb);
|
||
}
|
||
if (cfg.force) {
|
||
animator.duration(cfg.duration);
|
||
}
|
||
animator.start(cfg.easing);
|
||
}
|
||
return animators;
|
||
}
|
||
function copyArrShallow(source, target, len) {
|
||
for (var i = 0; i < len; i++) {
|
||
source[i] = target[i];
|
||
}
|
||
}
|
||
function is2DArray(value) {
|
||
return isArrayLike(value[0]);
|
||
}
|
||
function copyValue(target, source, key) {
|
||
if (isArrayLike(source[key])) {
|
||
if (!isArrayLike(target[key])) {
|
||
target[key] = [];
|
||
}
|
||
if (isTypedArray(source[key])) {
|
||
var len = source[key].length;
|
||
if (target[key].length !== len) {
|
||
target[key] = new (source[key].constructor)(len);
|
||
copyArrShallow(target[key], source[key], len);
|
||
}
|
||
}
|
||
else {
|
||
var sourceArr = source[key];
|
||
var targetArr = target[key];
|
||
var len0 = sourceArr.length;
|
||
if (is2DArray(sourceArr)) {
|
||
var len1 = sourceArr[0].length;
|
||
for (var i = 0; i < len0; i++) {
|
||
if (!targetArr[i]) {
|
||
targetArr[i] = Array.prototype.slice.call(sourceArr[i]);
|
||
}
|
||
else {
|
||
copyArrShallow(targetArr[i], sourceArr[i], len1);
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
copyArrShallow(targetArr, sourceArr, len0);
|
||
}
|
||
targetArr.length = sourceArr.length;
|
||
}
|
||
}
|
||
else {
|
||
target[key] = source[key];
|
||
}
|
||
}
|
||
function isValueSame(val1, val2) {
|
||
return val1 === val2
|
||
|| isArrayLike(val1) && isArrayLike(val2) && is1DArraySame(val1, val2);
|
||
}
|
||
function is1DArraySame(arr0, arr1) {
|
||
var len = arr0.length;
|
||
if (len !== arr1.length) {
|
||
return false;
|
||
}
|
||
for (var i = 0; i < len; i++) {
|
||
if (arr0[i] !== arr1[i]) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
function animateToShallow(animatable, topKey, animateObj, target, cfg, animationProps, animators, reverse) {
|
||
var targetKeys = keys(target);
|
||
var duration = cfg.duration;
|
||
var delay = cfg.delay;
|
||
var additive = cfg.additive;
|
||
var setToFinal = cfg.setToFinal;
|
||
var animateAll = !isObject(animationProps);
|
||
var existsAnimators = animatable.animators;
|
||
var animationKeys = [];
|
||
for (var k = 0; k < targetKeys.length; k++) {
|
||
var innerKey = targetKeys[k];
|
||
var targetVal = target[innerKey];
|
||
if (targetVal != null && animateObj[innerKey] != null
|
||
&& (animateAll || animationProps[innerKey])) {
|
||
if (isObject(targetVal)
|
||
&& !isArrayLike(targetVal)
|
||
&& !isGradientObject(targetVal)) {
|
||
if (topKey) {
|
||
if (!reverse) {
|
||
animateObj[innerKey] = targetVal;
|
||
animatable.updateDuringAnimation(topKey);
|
||
}
|
||
continue;
|
||
}
|
||
animateToShallow(animatable, innerKey, animateObj[innerKey], targetVal, cfg, animationProps && animationProps[innerKey], animators, reverse);
|
||
}
|
||
else {
|
||
animationKeys.push(innerKey);
|
||
}
|
||
}
|
||
else if (!reverse) {
|
||
animateObj[innerKey] = targetVal;
|
||
animatable.updateDuringAnimation(topKey);
|
||
animationKeys.push(innerKey);
|
||
}
|
||
}
|
||
var keyLen = animationKeys.length;
|
||
if (!additive && keyLen) {
|
||
for (var i = 0; i < existsAnimators.length; i++) {
|
||
var animator = existsAnimators[i];
|
||
if (animator.targetName === topKey) {
|
||
var allAborted = animator.stopTracks(animationKeys);
|
||
if (allAborted) {
|
||
var idx = indexOf(existsAnimators, animator);
|
||
existsAnimators.splice(idx, 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (!cfg.force) {
|
||
animationKeys = filter(animationKeys, function (key) { return !isValueSame(target[key], animateObj[key]); });
|
||
keyLen = animationKeys.length;
|
||
}
|
||
if (keyLen > 0
|
||
|| (cfg.force && !animators.length)) {
|
||
var revertedSource = void 0;
|
||
var reversedTarget = void 0;
|
||
var sourceClone = void 0;
|
||
if (reverse) {
|
||
reversedTarget = {};
|
||
if (setToFinal) {
|
||
revertedSource = {};
|
||
}
|
||
for (var i = 0; i < keyLen; i++) {
|
||
var innerKey = animationKeys[i];
|
||
reversedTarget[innerKey] = animateObj[innerKey];
|
||
if (setToFinal) {
|
||
revertedSource[innerKey] = target[innerKey];
|
||
}
|
||
else {
|
||
animateObj[innerKey] = target[innerKey];
|
||
}
|
||
}
|
||
}
|
||
else if (setToFinal) {
|
||
sourceClone = {};
|
||
for (var i = 0; i < keyLen; i++) {
|
||
var innerKey = animationKeys[i];
|
||
sourceClone[innerKey] = cloneValue(animateObj[innerKey]);
|
||
copyValue(animateObj, target, innerKey);
|
||
}
|
||
}
|
||
var animator = new Animator(animateObj, false, false, additive ? filter(existsAnimators, function (animator) { return animator.targetName === topKey; }) : null);
|
||
animator.targetName = topKey;
|
||
if (cfg.scope) {
|
||
animator.scope = cfg.scope;
|
||
}
|
||
if (setToFinal && revertedSource) {
|
||
animator.whenWithKeys(0, revertedSource, animationKeys);
|
||
}
|
||
if (sourceClone) {
|
||
animator.whenWithKeys(0, sourceClone, animationKeys);
|
||
}
|
||
animator.whenWithKeys(duration == null ? 500 : duration, reverse ? reversedTarget : target, animationKeys).delay(delay || 0);
|
||
animatable.addAnimator(animator, topKey);
|
||
animators.push(animator);
|
||
}
|
||
}
|
||
|
||
var Group = (function (_super) {
|
||
__extends(Group, _super);
|
||
function Group(opts) {
|
||
var _this = _super.call(this) || this;
|
||
_this.isGroup = true;
|
||
_this._children = [];
|
||
_this.attr(opts);
|
||
return _this;
|
||
}
|
||
Group.prototype.childrenRef = function () {
|
||
return this._children;
|
||
};
|
||
Group.prototype.children = function () {
|
||
return this._children.slice();
|
||
};
|
||
Group.prototype.childAt = function (idx) {
|
||
return this._children[idx];
|
||
};
|
||
Group.prototype.childOfName = function (name) {
|
||
var children = this._children;
|
||
for (var i = 0; i < children.length; i++) {
|
||
if (children[i].name === name) {
|
||
return children[i];
|
||
}
|
||
}
|
||
};
|
||
Group.prototype.childCount = function () {
|
||
return this._children.length;
|
||
};
|
||
Group.prototype.add = function (child) {
|
||
if (child) {
|
||
if (child !== this && child.parent !== this) {
|
||
this._children.push(child);
|
||
this._doAdd(child);
|
||
}
|
||
if ("development" !== 'production') {
|
||
if (child.__hostTarget) {
|
||
throw 'This elemenet has been used as an attachment';
|
||
}
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
Group.prototype.addBefore = function (child, nextSibling) {
|
||
if (child && child !== this && child.parent !== this
|
||
&& nextSibling && nextSibling.parent === this) {
|
||
var children = this._children;
|
||
var idx = children.indexOf(nextSibling);
|
||
if (idx >= 0) {
|
||
children.splice(idx, 0, child);
|
||
this._doAdd(child);
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
Group.prototype.replace = function (oldChild, newChild) {
|
||
var idx = indexOf(this._children, oldChild);
|
||
if (idx >= 0) {
|
||
this.replaceAt(newChild, idx);
|
||
}
|
||
return this;
|
||
};
|
||
Group.prototype.replaceAt = function (child, index) {
|
||
var children = this._children;
|
||
var old = children[index];
|
||
if (child && child !== this && child.parent !== this && child !== old) {
|
||
children[index] = child;
|
||
old.parent = null;
|
||
var zr = this.__zr;
|
||
if (zr) {
|
||
old.removeSelfFromZr(zr);
|
||
}
|
||
this._doAdd(child);
|
||
}
|
||
return this;
|
||
};
|
||
Group.prototype._doAdd = function (child) {
|
||
if (child.parent) {
|
||
child.parent.remove(child);
|
||
}
|
||
child.parent = this;
|
||
var zr = this.__zr;
|
||
if (zr && zr !== child.__zr) {
|
||
child.addSelfToZr(zr);
|
||
}
|
||
zr && zr.refresh();
|
||
};
|
||
Group.prototype.remove = function (child) {
|
||
var zr = this.__zr;
|
||
var children = this._children;
|
||
var idx = indexOf(children, child);
|
||
if (idx < 0) {
|
||
return this;
|
||
}
|
||
children.splice(idx, 1);
|
||
child.parent = null;
|
||
if (zr) {
|
||
child.removeSelfFromZr(zr);
|
||
}
|
||
zr && zr.refresh();
|
||
return this;
|
||
};
|
||
Group.prototype.removeAll = function () {
|
||
var children = this._children;
|
||
var zr = this.__zr;
|
||
for (var i = 0; i < children.length; i++) {
|
||
var child = children[i];
|
||
if (zr) {
|
||
child.removeSelfFromZr(zr);
|
||
}
|
||
child.parent = null;
|
||
}
|
||
children.length = 0;
|
||
return this;
|
||
};
|
||
Group.prototype.eachChild = function (cb, context) {
|
||
var children = this._children;
|
||
for (var i = 0; i < children.length; i++) {
|
||
var child = children[i];
|
||
cb.call(context, child, i);
|
||
}
|
||
return this;
|
||
};
|
||
Group.prototype.traverse = function (cb, context) {
|
||
for (var i = 0; i < this._children.length; i++) {
|
||
var child = this._children[i];
|
||
var stopped = cb.call(context, child);
|
||
if (child.isGroup && !stopped) {
|
||
child.traverse(cb, context);
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
Group.prototype.addSelfToZr = function (zr) {
|
||
_super.prototype.addSelfToZr.call(this, zr);
|
||
for (var i = 0; i < this._children.length; i++) {
|
||
var child = this._children[i];
|
||
child.addSelfToZr(zr);
|
||
}
|
||
};
|
||
Group.prototype.removeSelfFromZr = function (zr) {
|
||
_super.prototype.removeSelfFromZr.call(this, zr);
|
||
for (var i = 0; i < this._children.length; i++) {
|
||
var child = this._children[i];
|
||
child.removeSelfFromZr(zr);
|
||
}
|
||
};
|
||
Group.prototype.getBoundingRect = function (includeChildren) {
|
||
var tmpRect = new BoundingRect(0, 0, 0, 0);
|
||
var children = includeChildren || this._children;
|
||
var tmpMat = [];
|
||
var rect = null;
|
||
for (var i = 0; i < children.length; i++) {
|
||
var child = children[i];
|
||
if (child.ignore || child.invisible) {
|
||
continue;
|
||
}
|
||
var childRect = child.getBoundingRect();
|
||
var transform = child.getLocalTransform(tmpMat);
|
||
if (transform) {
|
||
BoundingRect.applyTransform(tmpRect, childRect, transform);
|
||
rect = rect || tmpRect.clone();
|
||
rect.union(tmpRect);
|
||
}
|
||
else {
|
||
rect = rect || childRect.clone();
|
||
rect.union(childRect);
|
||
}
|
||
}
|
||
return rect || tmpRect;
|
||
};
|
||
return Group;
|
||
}(Element));
|
||
Group.prototype.type = 'group';
|
||
|
||
/*!
|
||
* ZRender, a high performance 2d drawing library.
|
||
*
|
||
* Copyright (c) 2013, Baidu Inc.
|
||
* All rights reserved.
|
||
*
|
||
* LICENSE
|
||
* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
|
||
*/
|
||
var painterCtors = {};
|
||
var instances = {};
|
||
function delInstance(id) {
|
||
delete instances[id];
|
||
}
|
||
function isDarkMode(backgroundColor) {
|
||
if (!backgroundColor) {
|
||
return false;
|
||
}
|
||
if (typeof backgroundColor === 'string') {
|
||
return lum(backgroundColor, 1) < DARK_MODE_THRESHOLD;
|
||
}
|
||
else if (backgroundColor.colorStops) {
|
||
var colorStops = backgroundColor.colorStops;
|
||
var totalLum = 0;
|
||
var len = colorStops.length;
|
||
for (var i = 0; i < len; i++) {
|
||
totalLum += lum(colorStops[i].color, 1);
|
||
}
|
||
totalLum /= len;
|
||
return totalLum < DARK_MODE_THRESHOLD;
|
||
}
|
||
return false;
|
||
}
|
||
var ZRender = (function () {
|
||
function ZRender(id, dom, opts) {
|
||
var _this = this;
|
||
this._sleepAfterStill = 10;
|
||
this._stillFrameAccum = 0;
|
||
this._needsRefresh = true;
|
||
this._needsRefreshHover = true;
|
||
this._darkMode = false;
|
||
opts = opts || {};
|
||
this.dom = dom;
|
||
this.id = id;
|
||
var storage = new Storage();
|
||
var rendererType = opts.renderer || 'canvas';
|
||
if (!painterCtors[rendererType]) {
|
||
rendererType = keys(painterCtors)[0];
|
||
}
|
||
if ("development" !== 'production') {
|
||
if (!painterCtors[rendererType]) {
|
||
throw new Error("Renderer '" + rendererType + "' is not imported. Please import it first.");
|
||
}
|
||
}
|
||
opts.useDirtyRect = opts.useDirtyRect == null
|
||
? false
|
||
: opts.useDirtyRect;
|
||
var painter = new painterCtors[rendererType](dom, storage, opts, id);
|
||
var ssrMode = opts.ssr || painter.ssrOnly;
|
||
this.storage = storage;
|
||
this.painter = painter;
|
||
var handerProxy = (!env.node && !env.worker && !ssrMode)
|
||
? new HandlerDomProxy(painter.getViewportRoot(), painter.root)
|
||
: null;
|
||
this.handler = new Handler(storage, painter, handerProxy, painter.root);
|
||
this.animation = new Animation({
|
||
stage: {
|
||
update: ssrMode ? null : function () { return _this._flush(true); }
|
||
}
|
||
});
|
||
if (!ssrMode) {
|
||
this.animation.start();
|
||
}
|
||
}
|
||
ZRender.prototype.add = function (el) {
|
||
if (!el) {
|
||
return;
|
||
}
|
||
this.storage.addRoot(el);
|
||
el.addSelfToZr(this);
|
||
this.refresh();
|
||
};
|
||
ZRender.prototype.remove = function (el) {
|
||
if (!el) {
|
||
return;
|
||
}
|
||
this.storage.delRoot(el);
|
||
el.removeSelfFromZr(this);
|
||
this.refresh();
|
||
};
|
||
ZRender.prototype.configLayer = function (zLevel, config) {
|
||
if (this.painter.configLayer) {
|
||
this.painter.configLayer(zLevel, config);
|
||
}
|
||
this.refresh();
|
||
};
|
||
ZRender.prototype.setBackgroundColor = function (backgroundColor) {
|
||
if (this.painter.setBackgroundColor) {
|
||
this.painter.setBackgroundColor(backgroundColor);
|
||
}
|
||
this.refresh();
|
||
this._backgroundColor = backgroundColor;
|
||
this._darkMode = isDarkMode(backgroundColor);
|
||
};
|
||
ZRender.prototype.getBackgroundColor = function () {
|
||
return this._backgroundColor;
|
||
};
|
||
ZRender.prototype.setDarkMode = function (darkMode) {
|
||
this._darkMode = darkMode;
|
||
};
|
||
ZRender.prototype.isDarkMode = function () {
|
||
return this._darkMode;
|
||
};
|
||
ZRender.prototype.refreshImmediately = function (fromInside) {
|
||
if (!fromInside) {
|
||
this.animation.update(true);
|
||
}
|
||
this._needsRefresh = false;
|
||
this.painter.refresh();
|
||
this._needsRefresh = false;
|
||
};
|
||
ZRender.prototype.refresh = function () {
|
||
this._needsRefresh = true;
|
||
this.animation.start();
|
||
};
|
||
ZRender.prototype.flush = function () {
|
||
this._flush(false);
|
||
};
|
||
ZRender.prototype._flush = function (fromInside) {
|
||
var triggerRendered;
|
||
var start = getTime();
|
||
if (this._needsRefresh) {
|
||
triggerRendered = true;
|
||
this.refreshImmediately(fromInside);
|
||
}
|
||
if (this._needsRefreshHover) {
|
||
triggerRendered = true;
|
||
this.refreshHoverImmediately();
|
||
}
|
||
var end = getTime();
|
||
if (triggerRendered) {
|
||
this._stillFrameAccum = 0;
|
||
this.trigger('rendered', {
|
||
elapsedTime: end - start
|
||
});
|
||
}
|
||
else if (this._sleepAfterStill > 0) {
|
||
this._stillFrameAccum++;
|
||
if (this._stillFrameAccum > this._sleepAfterStill) {
|
||
this.animation.stop();
|
||
}
|
||
}
|
||
};
|
||
ZRender.prototype.setSleepAfterStill = function (stillFramesCount) {
|
||
this._sleepAfterStill = stillFramesCount;
|
||
};
|
||
ZRender.prototype.wakeUp = function () {
|
||
this.animation.start();
|
||
this._stillFrameAccum = 0;
|
||
};
|
||
ZRender.prototype.refreshHover = function () {
|
||
this._needsRefreshHover = true;
|
||
};
|
||
ZRender.prototype.refreshHoverImmediately = function () {
|
||
this._needsRefreshHover = false;
|
||
if (this.painter.refreshHover && this.painter.getType() === 'canvas') {
|
||
this.painter.refreshHover();
|
||
}
|
||
};
|
||
ZRender.prototype.resize = function (opts) {
|
||
opts = opts || {};
|
||
this.painter.resize(opts.width, opts.height);
|
||
this.handler.resize();
|
||
};
|
||
ZRender.prototype.clearAnimation = function () {
|
||
this.animation.clear();
|
||
};
|
||
ZRender.prototype.getWidth = function () {
|
||
return this.painter.getWidth();
|
||
};
|
||
ZRender.prototype.getHeight = function () {
|
||
return this.painter.getHeight();
|
||
};
|
||
ZRender.prototype.setCursorStyle = function (cursorStyle) {
|
||
this.handler.setCursorStyle(cursorStyle);
|
||
};
|
||
ZRender.prototype.findHover = function (x, y) {
|
||
return this.handler.findHover(x, y);
|
||
};
|
||
ZRender.prototype.on = function (eventName, eventHandler, context) {
|
||
this.handler.on(eventName, eventHandler, context);
|
||
return this;
|
||
};
|
||
ZRender.prototype.off = function (eventName, eventHandler) {
|
||
this.handler.off(eventName, eventHandler);
|
||
};
|
||
ZRender.prototype.trigger = function (eventName, event) {
|
||
this.handler.trigger(eventName, event);
|
||
};
|
||
ZRender.prototype.clear = function () {
|
||
var roots = this.storage.getRoots();
|
||
for (var i = 0; i < roots.length; i++) {
|
||
if (roots[i] instanceof Group) {
|
||
roots[i].removeSelfFromZr(this);
|
||
}
|
||
}
|
||
this.storage.delAllRoots();
|
||
this.painter.clear();
|
||
};
|
||
ZRender.prototype.dispose = function () {
|
||
this.animation.stop();
|
||
this.clear();
|
||
this.storage.dispose();
|
||
this.painter.dispose();
|
||
this.handler.dispose();
|
||
this.animation =
|
||
this.storage =
|
||
this.painter =
|
||
this.handler = null;
|
||
delInstance(this.id);
|
||
};
|
||
return ZRender;
|
||
}());
|
||
function init(dom, opts) {
|
||
var zr = new ZRender(guid(), dom, opts);
|
||
instances[zr.id] = zr;
|
||
return zr;
|
||
}
|
||
function dispose(zr) {
|
||
zr.dispose();
|
||
}
|
||
function disposeAll() {
|
||
for (var key in instances) {
|
||
if (instances.hasOwnProperty(key)) {
|
||
instances[key].dispose();
|
||
}
|
||
}
|
||
instances = {};
|
||
}
|
||
function getInstance(id) {
|
||
return instances[id];
|
||
}
|
||
function registerPainter(name, Ctor) {
|
||
painterCtors[name] = Ctor;
|
||
}
|
||
var version = '5.3.0';
|
||
|
||
var zrender = /*#__PURE__*/Object.freeze({
|
||
__proto__: null,
|
||
init: init,
|
||
dispose: dispose,
|
||
disposeAll: disposeAll,
|
||
getInstance: getInstance,
|
||
registerPainter: registerPainter,
|
||
version: version
|
||
});
|
||
|
||
var RADIAN_EPSILON = 1e-4; // Although chrome already enlarge this number to 100 for `toFixed`, but
|
||
// we sill follow the spec for compatibility.
|
||
|
||
var ROUND_SUPPORTED_PRECISION_MAX = 20;
|
||
|
||
function _trim(str) {
|
||
return str.replace(/^\s+|\s+$/g, '');
|
||
}
|
||
/**
|
||
* Linear mapping a value from domain to range
|
||
* @param val
|
||
* @param domain Domain extent domain[0] can be bigger than domain[1]
|
||
* @param range Range extent range[0] can be bigger than range[1]
|
||
* @param clamp Default to be false
|
||
*/
|
||
|
||
|
||
function linearMap(val, domain, range, clamp) {
|
||
var d0 = domain[0];
|
||
var d1 = domain[1];
|
||
var r0 = range[0];
|
||
var r1 = range[1];
|
||
var subDomain = d1 - d0;
|
||
var subRange = r1 - r0;
|
||
|
||
if (subDomain === 0) {
|
||
return subRange === 0 ? r0 : (r0 + r1) / 2;
|
||
} // Avoid accuracy problem in edge, such as
|
||
// 146.39 - 62.83 === 83.55999999999999.
|
||
// See echarts/test/ut/spec/util/number.js#linearMap#accuracyError
|
||
// It is a little verbose for efficiency considering this method
|
||
// is a hotspot.
|
||
|
||
|
||
if (clamp) {
|
||
if (subDomain > 0) {
|
||
if (val <= d0) {
|
||
return r0;
|
||
} else if (val >= d1) {
|
||
return r1;
|
||
}
|
||
} else {
|
||
if (val >= d0) {
|
||
return r0;
|
||
} else if (val <= d1) {
|
||
return r1;
|
||
}
|
||
}
|
||
} else {
|
||
if (val === d0) {
|
||
return r0;
|
||
}
|
||
|
||
if (val === d1) {
|
||
return r1;
|
||
}
|
||
}
|
||
|
||
return (val - d0) / subDomain * subRange + r0;
|
||
}
|
||
/**
|
||
* Convert a percent string to absolute number.
|
||
* Returns NaN if percent is not a valid string or number
|
||
*/
|
||
|
||
function parsePercent$1(percent, all) {
|
||
switch (percent) {
|
||
case 'center':
|
||
case 'middle':
|
||
percent = '50%';
|
||
break;
|
||
|
||
case 'left':
|
||
case 'top':
|
||
percent = '0%';
|
||
break;
|
||
|
||
case 'right':
|
||
case 'bottom':
|
||
percent = '100%';
|
||
break;
|
||
}
|
||
|
||
if (isString(percent)) {
|
||
if (_trim(percent).match(/%$/)) {
|
||
return parseFloat(percent) / 100 * all;
|
||
}
|
||
|
||
return parseFloat(percent);
|
||
}
|
||
|
||
return percent == null ? NaN : +percent;
|
||
}
|
||
function round(x, precision, returnStr) {
|
||
if (precision == null) {
|
||
precision = 10;
|
||
} // Avoid range error
|
||
|
||
|
||
precision = Math.min(Math.max(0, precision), ROUND_SUPPORTED_PRECISION_MAX); // PENDING: 1.005.toFixed(2) is '1.00' rather than '1.01'
|
||
|
||
x = (+x).toFixed(precision);
|
||
return returnStr ? x : +x;
|
||
}
|
||
/**
|
||
* Inplacd asc sort arr.
|
||
* The input arr will be modified.
|
||
*/
|
||
|
||
function asc(arr) {
|
||
arr.sort(function (a, b) {
|
||
return a - b;
|
||
});
|
||
return arr;
|
||
}
|
||
/**
|
||
* Get precision.
|
||
*/
|
||
|
||
function getPrecision(val) {
|
||
val = +val;
|
||
|
||
if (isNaN(val)) {
|
||
return 0;
|
||
} // It is much faster than methods converting number to string as follows
|
||
// let tmp = val.toString();
|
||
// return tmp.length - 1 - tmp.indexOf('.');
|
||
// especially when precision is low
|
||
// Notice:
|
||
// (1) If the loop count is over about 20, it is slower than `getPrecisionSafe`.
|
||
// (see https://jsbench.me/2vkpcekkvw/1)
|
||
// (2) If the val is less than for example 1e-15, the result may be incorrect.
|
||
// (see test/ut/spec/util/number.test.ts `getPrecision_equal_random`)
|
||
|
||
|
||
if (val > 1e-14) {
|
||
var e = 1;
|
||
|
||
for (var i = 0; i < 15; i++, e *= 10) {
|
||
if (Math.round(val * e) / e === val) {
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
|
||
return getPrecisionSafe(val);
|
||
}
|
||
/**
|
||
* Get precision with slow but safe method
|
||
*/
|
||
|
||
function getPrecisionSafe(val) {
|
||
// toLowerCase for: '3.4E-12'
|
||
var str = val.toString().toLowerCase(); // Consider scientific notation: '3.4e-12' '3.4e+12'
|
||
|
||
var eIndex = str.indexOf('e');
|
||
var exp = eIndex > 0 ? +str.slice(eIndex + 1) : 0;
|
||
var significandPartLen = eIndex > 0 ? eIndex : str.length;
|
||
var dotIndex = str.indexOf('.');
|
||
var decimalPartLen = dotIndex < 0 ? 0 : significandPartLen - 1 - dotIndex;
|
||
return Math.max(0, decimalPartLen - exp);
|
||
}
|
||
/**
|
||
* Minimal dicernible data precisioin according to a single pixel.
|
||
*/
|
||
|
||
function getPixelPrecision(dataExtent, pixelExtent) {
|
||
var log = Math.log;
|
||
var LN10 = Math.LN10;
|
||
var dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10);
|
||
var sizeQuantity = Math.round(log(Math.abs(pixelExtent[1] - pixelExtent[0])) / LN10); // toFixed() digits argument must be between 0 and 20.
|
||
|
||
var precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20);
|
||
return !isFinite(precision) ? 20 : precision;
|
||
}
|
||
/**
|
||
* Get a data of given precision, assuring the sum of percentages
|
||
* in valueList is 1.
|
||
* The largest remainer method is used.
|
||
* https://en.wikipedia.org/wiki/Largest_remainder_method
|
||
*
|
||
* @param valueList a list of all data
|
||
* @param idx index of the data to be processed in valueList
|
||
* @param precision integer number showing digits of precision
|
||
* @return percent ranging from 0 to 100
|
||
*/
|
||
|
||
function getPercentWithPrecision(valueList, idx, precision) {
|
||
if (!valueList[idx]) {
|
||
return 0;
|
||
}
|
||
|
||
var sum = reduce(valueList, function (acc, val) {
|
||
return acc + (isNaN(val) ? 0 : val);
|
||
}, 0);
|
||
|
||
if (sum === 0) {
|
||
return 0;
|
||
}
|
||
|
||
var digits = Math.pow(10, precision);
|
||
var votesPerQuota = map(valueList, function (val) {
|
||
return (isNaN(val) ? 0 : val) / sum * digits * 100;
|
||
});
|
||
var targetSeats = digits * 100;
|
||
var seats = map(votesPerQuota, function (votes) {
|
||
// Assign automatic seats.
|
||
return Math.floor(votes);
|
||
});
|
||
var currentSum = reduce(seats, function (acc, val) {
|
||
return acc + val;
|
||
}, 0);
|
||
var remainder = map(votesPerQuota, function (votes, idx) {
|
||
return votes - seats[idx];
|
||
}); // Has remainding votes.
|
||
|
||
while (currentSum < targetSeats) {
|
||
// Find next largest remainder.
|
||
var max = Number.NEGATIVE_INFINITY;
|
||
var maxId = null;
|
||
|
||
for (var i = 0, len = remainder.length; i < len; ++i) {
|
||
if (remainder[i] > max) {
|
||
max = remainder[i];
|
||
maxId = i;
|
||
}
|
||
} // Add a vote to max remainder.
|
||
|
||
|
||
++seats[maxId];
|
||
remainder[maxId] = 0;
|
||
++currentSum;
|
||
}
|
||
|
||
return seats[idx] / digits;
|
||
}
|
||
/**
|
||
* Solve the floating point adding problem like 0.1 + 0.2 === 0.30000000000000004
|
||
* See <http://0.30000000000000004.com/>
|
||
*/
|
||
|
||
function addSafe(val0, val1) {
|
||
var maxPrecision = Math.max(getPrecision(val0), getPrecision(val1)); // const multiplier = Math.pow(10, maxPrecision);
|
||
// return (Math.round(val0 * multiplier) + Math.round(val1 * multiplier)) / multiplier;
|
||
|
||
var sum = val0 + val1; // // PENDING: support more?
|
||
|
||
return maxPrecision > ROUND_SUPPORTED_PRECISION_MAX ? sum : round(sum, maxPrecision);
|
||
} // Number.MAX_SAFE_INTEGER, ie do not support.
|
||
|
||
var MAX_SAFE_INTEGER = 9007199254740991;
|
||
/**
|
||
* To 0 - 2 * PI, considering negative radian.
|
||
*/
|
||
|
||
function remRadian(radian) {
|
||
var pi2 = Math.PI * 2;
|
||
return (radian % pi2 + pi2) % pi2;
|
||
}
|
||
/**
|
||
* @param {type} radian
|
||
* @return {boolean}
|
||
*/
|
||
|
||
function isRadianAroundZero(val) {
|
||
return val > -RADIAN_EPSILON && val < RADIAN_EPSILON;
|
||
} // eslint-disable-next-line
|
||
|
||
var TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/; // jshint ignore:line
|
||
|
||
/**
|
||
* @param value valid type: number | string | Date, otherwise return `new Date(NaN)`
|
||
* These values can be accepted:
|
||
* + An instance of Date, represent a time in its own time zone.
|
||
* + Or string in a subset of ISO 8601, only including:
|
||
* + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06',
|
||
* + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123',
|
||
* + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00',
|
||
* all of which will be treated as local time if time zone is not specified
|
||
* (see <https://momentjs.com/>).
|
||
* + Or other string format, including (all of which will be treated as loacal time):
|
||
* '2012', '2012-3-1', '2012/3/1', '2012/03/01',
|
||
* '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123'
|
||
* + a timestamp, which represent a time in UTC.
|
||
* @return date Never be null/undefined. If invalid, return `new Date(NaN)`.
|
||
*/
|
||
|
||
function parseDate(value) {
|
||
if (value instanceof Date) {
|
||
return value;
|
||
} else if (isString(value)) {
|
||
// Different browsers parse date in different way, so we parse it manually.
|
||
// Some other issues:
|
||
// new Date('1970-01-01') is UTC,
|
||
// new Date('1970/01/01') and new Date('1970-1-01') is local.
|
||
// See issue #3623
|
||
var match = TIME_REG.exec(value);
|
||
|
||
if (!match) {
|
||
// return Invalid Date.
|
||
return new Date(NaN);
|
||
} // Use local time when no timezone offset specifed.
|
||
|
||
|
||
if (!match[8]) {
|
||
// match[n] can only be string or undefined.
|
||
// But take care of '12' + 1 => '121'.
|
||
return new Date(+match[1], +(match[2] || 1) - 1, +match[3] || 1, +match[4] || 0, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0);
|
||
} // Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time,
|
||
// https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment).
|
||
// For example, system timezone is set as "Time Zone: America/Toronto",
|
||
// then these code will get different result:
|
||
// `new Date(1478411999999).getTimezoneOffset(); // get 240`
|
||
// `new Date(1478412000000).getTimezoneOffset(); // get 300`
|
||
// So we should not use `new Date`, but use `Date.UTC`.
|
||
else {
|
||
var hour = +match[4] || 0;
|
||
|
||
if (match[8].toUpperCase() !== 'Z') {
|
||
hour -= +match[8].slice(0, 3);
|
||
}
|
||
|
||
return new Date(Date.UTC(+match[1], +(match[2] || 1) - 1, +match[3] || 1, hour, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0));
|
||
}
|
||
} else if (value == null) {
|
||
return new Date(NaN);
|
||
}
|
||
|
||
return new Date(Math.round(value));
|
||
}
|
||
/**
|
||
* Quantity of a number. e.g. 0.1, 1, 10, 100
|
||
*
|
||
* @param val
|
||
* @return
|
||
*/
|
||
|
||
function quantity(val) {
|
||
return Math.pow(10, quantityExponent(val));
|
||
}
|
||
/**
|
||
* Exponent of the quantity of a number
|
||
* e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3
|
||
*
|
||
* @param val non-negative value
|
||
* @return
|
||
*/
|
||
|
||
function quantityExponent(val) {
|
||
if (val === 0) {
|
||
return 0;
|
||
}
|
||
|
||
var exp = Math.floor(Math.log(val) / Math.LN10);
|
||
/**
|
||
* exp is expected to be the rounded-down result of the base-10 log of val.
|
||
* But due to the precision loss with Math.log(val), we need to restore it
|
||
* using 10^exp to make sure we can get val back from exp. #11249
|
||
*/
|
||
|
||
if (val / Math.pow(10, exp) >= 10) {
|
||
exp++;
|
||
}
|
||
|
||
return exp;
|
||
}
|
||
/**
|
||
* find a “nice” number approximately equal to x. Round the number if round = true,
|
||
* take ceiling if round = false. The primary observation is that the “nicest”
|
||
* numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.
|
||
*
|
||
* See "Nice Numbers for Graph Labels" of Graphic Gems.
|
||
*
|
||
* @param val Non-negative value.
|
||
* @param round
|
||
* @return Niced number
|
||
*/
|
||
|
||
function nice(val, round) {
|
||
var exponent = quantityExponent(val);
|
||
var exp10 = Math.pow(10, exponent);
|
||
var f = val / exp10; // 1 <= f < 10
|
||
|
||
var nf;
|
||
|
||
if (round) {
|
||
if (f < 1.5) {
|
||
nf = 1;
|
||
} else if (f < 2.5) {
|
||
nf = 2;
|
||
} else if (f < 4) {
|
||
nf = 3;
|
||
} else if (f < 7) {
|
||
nf = 5;
|
||
} else {
|
||
nf = 10;
|
||
}
|
||
} else {
|
||
if (f < 1) {
|
||
nf = 1;
|
||
} else if (f < 2) {
|
||
nf = 2;
|
||
} else if (f < 3) {
|
||
nf = 3;
|
||
} else if (f < 5) {
|
||
nf = 5;
|
||
} else {
|
||
nf = 10;
|
||
}
|
||
}
|
||
|
||
val = nf * exp10; // Fix 3 * 0.1 === 0.30000000000000004 issue (see IEEE 754).
|
||
// 20 is the uppper bound of toFixed.
|
||
|
||
return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val;
|
||
}
|
||
/**
|
||
* This code was copied from "d3.js"
|
||
* <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>.
|
||
* See the license statement at the head of this file.
|
||
* @param ascArr
|
||
*/
|
||
|
||
function quantile(ascArr, p) {
|
||
var H = (ascArr.length - 1) * p + 1;
|
||
var h = Math.floor(H);
|
||
var v = +ascArr[h - 1];
|
||
var e = H - h;
|
||
return e ? v + e * (ascArr[h] - v) : v;
|
||
}
|
||
/**
|
||
* Order intervals asc, and split them when overlap.
|
||
* expect(numberUtil.reformIntervals([
|
||
* {interval: [18, 62], close: [1, 1]},
|
||
* {interval: [-Infinity, -70], close: [0, 0]},
|
||
* {interval: [-70, -26], close: [1, 1]},
|
||
* {interval: [-26, 18], close: [1, 1]},
|
||
* {interval: [62, 150], close: [1, 1]},
|
||
* {interval: [106, 150], close: [1, 1]},
|
||
* {interval: [150, Infinity], close: [0, 0]}
|
||
* ])).toEqual([
|
||
* {interval: [-Infinity, -70], close: [0, 0]},
|
||
* {interval: [-70, -26], close: [1, 1]},
|
||
* {interval: [-26, 18], close: [0, 1]},
|
||
* {interval: [18, 62], close: [0, 1]},
|
||
* {interval: [62, 150], close: [0, 1]},
|
||
* {interval: [150, Infinity], close: [0, 0]}
|
||
* ]);
|
||
* @param list, where `close` mean open or close
|
||
* of the interval, and Infinity can be used.
|
||
* @return The origin list, which has been reformed.
|
||
*/
|
||
|
||
function reformIntervals(list) {
|
||
list.sort(function (a, b) {
|
||
return littleThan(a, b, 0) ? -1 : 1;
|
||
});
|
||
var curr = -Infinity;
|
||
var currClose = 1;
|
||
|
||
for (var i = 0; i < list.length;) {
|
||
var interval = list[i].interval;
|
||
var close_1 = list[i].close;
|
||
|
||
for (var lg = 0; lg < 2; lg++) {
|
||
if (interval[lg] <= curr) {
|
||
interval[lg] = curr;
|
||
close_1[lg] = !lg ? 1 - currClose : 1;
|
||
}
|
||
|
||
curr = interval[lg];
|
||
currClose = close_1[lg];
|
||
}
|
||
|
||
if (interval[0] === interval[1] && close_1[0] * close_1[1] !== 1) {
|
||
list.splice(i, 1);
|
||
} else {
|
||
i++;
|
||
}
|
||
}
|
||
|
||
return list;
|
||
|
||
function littleThan(a, b, lg) {
|
||
return a.interval[lg] < b.interval[lg] || a.interval[lg] === b.interval[lg] && (a.close[lg] - b.close[lg] === (!lg ? 1 : -1) || !lg && littleThan(a, b, 1));
|
||
}
|
||
}
|
||
/**
|
||
* [Numberic is defined as]:
|
||
* `parseFloat(val) == val`
|
||
* For example:
|
||
* numeric:
|
||
* typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity,
|
||
* and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec)
|
||
* not-numeric:
|
||
* null, undefined, [], {}, true, false, 'NaN', NaN, '123ab',
|
||
* empty string, string with only white-spaces or line-terminal (see es spec),
|
||
* 0x12, '0x12', '-0x12', 012, '012', '-012',
|
||
* non-string, ...
|
||
*
|
||
* @test See full test cases in `test/ut/spec/util/number.js`.
|
||
* @return Must be a typeof number. If not numeric, return NaN.
|
||
*/
|
||
|
||
function numericToNumber(val) {
|
||
var valFloat = parseFloat(val);
|
||
return valFloat == val // eslint-disable-line eqeqeq
|
||
&& (valFloat !== 0 || !isString(val) || val.indexOf('x') <= 0) // For case ' 0x0 '.
|
||
? valFloat : NaN;
|
||
}
|
||
/**
|
||
* Definition of "numeric": see `numericToNumber`.
|
||
*/
|
||
|
||
function isNumeric(val) {
|
||
return !isNaN(numericToNumber(val));
|
||
}
|
||
/**
|
||
* Use random base to prevent users hard code depending on
|
||
* this auto generated marker id.
|
||
* @return An positive integer.
|
||
*/
|
||
|
||
function getRandomIdBase() {
|
||
return Math.round(Math.random() * 9);
|
||
}
|
||
/**
|
||
* Get the greatest common dividor
|
||
*
|
||
* @param {number} a one number
|
||
* @param {number} b the other number
|
||
*/
|
||
|
||
function getGreatestCommonDividor(a, b) {
|
||
if (b === 0) {
|
||
return a;
|
||
}
|
||
|
||
return getGreatestCommonDividor(b, a % b);
|
||
}
|
||
/**
|
||
* Get the least common multiple
|
||
*
|
||
* @param {number} a one number
|
||
* @param {number} b the other number
|
||
*/
|
||
|
||
function getLeastCommonMultiple(a, b) {
|
||
if (a == null) {
|
||
return b;
|
||
}
|
||
|
||
if (b == null) {
|
||
return a;
|
||
}
|
||
|
||
return a * b / getGreatestCommonDividor(a, b);
|
||
}
|
||
|
||
var ECHARTS_PREFIX = '[ECharts] ';
|
||
var storedLogs = {};
|
||
var hasConsole = typeof console !== 'undefined' // eslint-disable-next-line
|
||
&& console.warn && console.log;
|
||
|
||
function outputLog(type, str, onlyOnce) {
|
||
if (hasConsole) {
|
||
if (onlyOnce) {
|
||
if (storedLogs[str]) {
|
||
return;
|
||
}
|
||
|
||
storedLogs[str] = true;
|
||
} // eslint-disable-next-line
|
||
|
||
|
||
console[type](ECHARTS_PREFIX + str);
|
||
}
|
||
}
|
||
|
||
function log(str, onlyOnce) {
|
||
outputLog('log', str, onlyOnce);
|
||
}
|
||
function warn(str, onlyOnce) {
|
||
outputLog('warn', str, onlyOnce);
|
||
}
|
||
function error(str, onlyOnce) {
|
||
outputLog('error', str, onlyOnce);
|
||
}
|
||
function deprecateLog(str) {
|
||
if ("development" !== 'production') {
|
||
// Not display duplicate message.
|
||
outputLog('warn', 'DEPRECATED: ' + str, true);
|
||
}
|
||
}
|
||
function deprecateReplaceLog(oldOpt, newOpt, scope) {
|
||
if ("development" !== 'production') {
|
||
deprecateLog((scope ? "[" + scope + "]" : '') + (oldOpt + " is deprecated, use " + newOpt + " instead."));
|
||
}
|
||
}
|
||
/**
|
||
* If in __DEV__ environment, get console printable message for users hint.
|
||
* Parameters are separated by ' '.
|
||
* @usuage
|
||
* makePrintable('This is an error on', someVar, someObj);
|
||
*
|
||
* @param hintInfo anything about the current execution context to hint users.
|
||
* @throws Error
|
||
*/
|
||
|
||
function makePrintable() {
|
||
var hintInfo = [];
|
||
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
hintInfo[_i] = arguments[_i];
|
||
}
|
||
|
||
var msg = '';
|
||
|
||
if ("development" !== 'production') {
|
||
// Fuzzy stringify for print.
|
||
// This code only exist in dev environment.
|
||
var makePrintableStringIfPossible_1 = function (val) {
|
||
return val === void 0 ? 'undefined' : val === Infinity ? 'Infinity' : val === -Infinity ? '-Infinity' : eqNaN(val) ? 'NaN' : val instanceof Date ? 'Date(' + val.toISOString() + ')' : isFunction(val) ? 'function () { ... }' : isRegExp(val) ? val + '' : null;
|
||
};
|
||
|
||
msg = map(hintInfo, function (arg) {
|
||
if (isString(arg)) {
|
||
// Print without quotation mark for some statement.
|
||
return arg;
|
||
} else {
|
||
var printableStr = makePrintableStringIfPossible_1(arg);
|
||
|
||
if (printableStr != null) {
|
||
return printableStr;
|
||
} else if (typeof JSON !== 'undefined' && JSON.stringify) {
|
||
try {
|
||
return JSON.stringify(arg, function (n, val) {
|
||
var printableStr = makePrintableStringIfPossible_1(val);
|
||
return printableStr == null ? val : printableStr;
|
||
}); // In most cases the info object is small, so do not line break.
|
||
} catch (err) {
|
||
return '?';
|
||
}
|
||
} else {
|
||
return '?';
|
||
}
|
||
}
|
||
}).join(' ');
|
||
}
|
||
|
||
return msg;
|
||
}
|
||
/**
|
||
* @throws Error
|
||
*/
|
||
|
||
function throwError(msg) {
|
||
throw new Error(msg);
|
||
}
|
||
|
||
function interpolateNumber$1(p0, p1, percent) {
|
||
return (p1 - p0) * percent + p0;
|
||
}
|
||
/**
|
||
* Make the name displayable. But we should
|
||
* make sure it is not duplicated with user
|
||
* specified name, so use '\0';
|
||
*/
|
||
|
||
|
||
var DUMMY_COMPONENT_NAME_PREFIX = 'series\0';
|
||
var INTERNAL_COMPONENT_ID_PREFIX = '\0_ec_\0';
|
||
/**
|
||
* If value is not array, then translate it to array.
|
||
* @param {*} value
|
||
* @return {Array} [value] or value
|
||
*/
|
||
|
||
function normalizeToArray(value) {
|
||
return value instanceof Array ? value : value == null ? [] : [value];
|
||
}
|
||
/**
|
||
* Sync default option between normal and emphasis like `position` and `show`
|
||
* In case some one will write code like
|
||
* label: {
|
||
* show: false,
|
||
* position: 'outside',
|
||
* fontSize: 18
|
||
* },
|
||
* emphasis: {
|
||
* label: { show: true }
|
||
* }
|
||
*/
|
||
|
||
function defaultEmphasis(opt, key, subOpts) {
|
||
// Caution: performance sensitive.
|
||
if (opt) {
|
||
opt[key] = opt[key] || {};
|
||
opt.emphasis = opt.emphasis || {};
|
||
opt.emphasis[key] = opt.emphasis[key] || {}; // Default emphasis option from normal
|
||
|
||
for (var i = 0, len = subOpts.length; i < len; i++) {
|
||
var subOptName = subOpts[i];
|
||
|
||
if (!opt.emphasis[key].hasOwnProperty(subOptName) && opt[key].hasOwnProperty(subOptName)) {
|
||
opt.emphasis[key][subOptName] = opt[key][subOptName];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
var TEXT_STYLE_OPTIONS = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'rich', 'tag', 'color', 'textBorderColor', 'textBorderWidth', 'width', 'height', 'lineHeight', 'align', 'verticalAlign', 'baseline', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY', 'textShadowColor', 'textShadowBlur', 'textShadowOffsetX', 'textShadowOffsetY', 'backgroundColor', 'borderColor', 'borderWidth', 'borderRadius', 'padding']; // modelUtil.LABEL_OPTIONS = modelUtil.TEXT_STYLE_OPTIONS.concat([
|
||
// 'position', 'offset', 'rotate', 'origin', 'show', 'distance', 'formatter',
|
||
// 'fontStyle', 'fontWeight', 'fontSize', 'fontFamily',
|
||
// // FIXME: deprecated, check and remove it.
|
||
// 'textStyle'
|
||
// ]);
|
||
|
||
/**
|
||
* The method do not ensure performance.
|
||
* data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]
|
||
* This helper method retieves value from data.
|
||
*/
|
||
|
||
function getDataItemValue(dataItem) {
|
||
return isObject(dataItem) && !isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem;
|
||
}
|
||
/**
|
||
* data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]
|
||
* This helper method determine if dataItem has extra option besides value
|
||
*/
|
||
|
||
function isDataItemOption(dataItem) {
|
||
return isObject(dataItem) && !(dataItem instanceof Array); // // markLine data can be array
|
||
// && !(dataItem[0] && isObject(dataItem[0]) && !(dataItem[0] instanceof Array));
|
||
}
|
||
/**
|
||
* Mapping to existings for merge.
|
||
*
|
||
* Mode "normalMege":
|
||
* The mapping result (merge result) will keep the order of the existing
|
||
* component, rather than the order of new option. Because we should ensure
|
||
* some specified index reference (like xAxisIndex) keep work.
|
||
* And in most cases, "merge option" is used to update partial option but not
|
||
* be expected to change the order.
|
||
*
|
||
* Mode "replaceMege":
|
||
* (1) Only the id mapped components will be merged.
|
||
* (2) Other existing components (except internal compoonets) will be removed.
|
||
* (3) Other new options will be used to create new component.
|
||
* (4) The index of the existing compoents will not be modified.
|
||
* That means their might be "hole" after the removal.
|
||
* The new components are created first at those available index.
|
||
*
|
||
* Mode "replaceAll":
|
||
* This mode try to support that reproduce an echarts instance from another
|
||
* echarts instance (via `getOption`) in some simple cases.
|
||
* In this senario, the `result` index are exactly the consistent with the `newCmptOptions`,
|
||
* which ensures the compoennt index referring (like `xAxisIndex: ?`) corrent. That is,
|
||
* the "hole" in `newCmptOptions` will also be kept.
|
||
* On the contrary, other modes try best to eliminate holes.
|
||
* PENDING: This is an experimental mode yet.
|
||
*
|
||
* @return See the comment of <MappingResult>.
|
||
*/
|
||
|
||
function mappingToExists(existings, newCmptOptions, mode) {
|
||
var isNormalMergeMode = mode === 'normalMerge';
|
||
var isReplaceMergeMode = mode === 'replaceMerge';
|
||
var isReplaceAllMode = mode === 'replaceAll';
|
||
existings = existings || [];
|
||
newCmptOptions = (newCmptOptions || []).slice();
|
||
var existingIdIdxMap = createHashMap(); // Validate id and name on user input option.
|
||
|
||
each(newCmptOptions, function (cmptOption, index) {
|
||
if (!isObject(cmptOption)) {
|
||
newCmptOptions[index] = null;
|
||
return;
|
||
}
|
||
|
||
if ("development" !== 'production') {
|
||
// There is some legacy case that name is set as `false`.
|
||
// But should work normally rather than throw error.
|
||
if (cmptOption.id != null && !isValidIdOrName(cmptOption.id)) {
|
||
warnInvalidateIdOrName(cmptOption.id);
|
||
}
|
||
|
||
if (cmptOption.name != null && !isValidIdOrName(cmptOption.name)) {
|
||
warnInvalidateIdOrName(cmptOption.name);
|
||
}
|
||
}
|
||
});
|
||
var result = prepareResult(existings, existingIdIdxMap, mode);
|
||
|
||
if (isNormalMergeMode || isReplaceMergeMode) {
|
||
mappingById(result, existings, existingIdIdxMap, newCmptOptions);
|
||
}
|
||
|
||
if (isNormalMergeMode) {
|
||
mappingByName(result, newCmptOptions);
|
||
}
|
||
|
||
if (isNormalMergeMode || isReplaceMergeMode) {
|
||
mappingByIndex(result, newCmptOptions, isReplaceMergeMode);
|
||
} else if (isReplaceAllMode) {
|
||
mappingInReplaceAllMode(result, newCmptOptions);
|
||
}
|
||
|
||
makeIdAndName(result); // The array `result` MUST NOT contain elided items, otherwise the
|
||
// forEach will ommit those items and result in incorrect result.
|
||
|
||
return result;
|
||
}
|
||
|
||
function prepareResult(existings, existingIdIdxMap, mode) {
|
||
var result = [];
|
||
|
||
if (mode === 'replaceAll') {
|
||
return result;
|
||
} // Do not use native `map` to in case that the array `existings`
|
||
// contains elided items, which will be ommited.
|
||
|
||
|
||
for (var index = 0; index < existings.length; index++) {
|
||
var existing = existings[index]; // Because of replaceMerge, `existing` may be null/undefined.
|
||
|
||
if (existing && existing.id != null) {
|
||
existingIdIdxMap.set(existing.id, index);
|
||
} // For non-internal-componnets:
|
||
// Mode "normalMerge": all existings kept.
|
||
// Mode "replaceMerge": all existing removed unless mapped by id.
|
||
// For internal-components:
|
||
// go with "replaceMerge" approach in both mode.
|
||
|
||
|
||
result.push({
|
||
existing: mode === 'replaceMerge' || isComponentIdInternal(existing) ? null : existing,
|
||
newOption: null,
|
||
keyInfo: null,
|
||
brandNew: null
|
||
});
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
function mappingById(result, existings, existingIdIdxMap, newCmptOptions) {
|
||
// Mapping by id if specified.
|
||
each(newCmptOptions, function (cmptOption, index) {
|
||
if (!cmptOption || cmptOption.id == null) {
|
||
return;
|
||
}
|
||
|
||
var optionId = makeComparableKey(cmptOption.id);
|
||
var existingIdx = existingIdIdxMap.get(optionId);
|
||
|
||
if (existingIdx != null) {
|
||
var resultItem = result[existingIdx];
|
||
assert(!resultItem.newOption, 'Duplicated option on id "' + optionId + '".');
|
||
resultItem.newOption = cmptOption; // In both mode, if id matched, new option will be merged to
|
||
// the existings rather than creating new component model.
|
||
|
||
resultItem.existing = existings[existingIdx];
|
||
newCmptOptions[index] = null;
|
||
}
|
||
});
|
||
}
|
||
|
||
function mappingByName(result, newCmptOptions) {
|
||
// Mapping by name if specified.
|
||
each(newCmptOptions, function (cmptOption, index) {
|
||
if (!cmptOption || cmptOption.name == null) {
|
||
return;
|
||
}
|
||
|
||
for (var i = 0; i < result.length; i++) {
|
||
var existing = result[i].existing;
|
||
|
||
if (!result[i].newOption // Consider name: two map to one.
|
||
// Can not match when both ids existing but different.
|
||
&& existing && (existing.id == null || cmptOption.id == null) && !isComponentIdInternal(cmptOption) && !isComponentIdInternal(existing) && keyExistAndEqual('name', existing, cmptOption)) {
|
||
result[i].newOption = cmptOption;
|
||
newCmptOptions[index] = null;
|
||
return;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
function mappingByIndex(result, newCmptOptions, brandNew) {
|
||
each(newCmptOptions, function (cmptOption) {
|
||
if (!cmptOption) {
|
||
return;
|
||
} // Find the first place that not mapped by id and not internal component (consider the "hole").
|
||
|
||
|
||
var resultItem;
|
||
var nextIdx = 0;
|
||
|
||
while ( // Be `!resultItem` only when `nextIdx >= result.length`.
|
||
(resultItem = result[nextIdx]) && ( // (1) Existing models that already have id should be able to mapped to. Because
|
||
// after mapping performed, model will always be assigned with an id if user not given.
|
||
// After that all models have id.
|
||
// (2) If new option has id, it can only set to a hole or append to the last. It should
|
||
// not be merged to the existings with different id. Because id should not be overwritten.
|
||
// (3) Name can be overwritten, because axis use name as 'show label text'.
|
||
resultItem.newOption || isComponentIdInternal(resultItem.existing) || // In mode "replaceMerge", here no not-mapped-non-internal-existing.
|
||
resultItem.existing && cmptOption.id != null && !keyExistAndEqual('id', cmptOption, resultItem.existing))) {
|
||
nextIdx++;
|
||
}
|
||
|
||
if (resultItem) {
|
||
resultItem.newOption = cmptOption;
|
||
resultItem.brandNew = brandNew;
|
||
} else {
|
||
result.push({
|
||
newOption: cmptOption,
|
||
brandNew: brandNew,
|
||
existing: null,
|
||
keyInfo: null
|
||
});
|
||
}
|
||
|
||
nextIdx++;
|
||
});
|
||
}
|
||
|
||
function mappingInReplaceAllMode(result, newCmptOptions) {
|
||
each(newCmptOptions, function (cmptOption) {
|
||
// The feature "reproduce" requires "hole" will also reproduced
|
||
// in case that compoennt index referring are broken.
|
||
result.push({
|
||
newOption: cmptOption,
|
||
brandNew: true,
|
||
existing: null,
|
||
keyInfo: null
|
||
});
|
||
});
|
||
}
|
||
/**
|
||
* Make id and name for mapping result (result of mappingToExists)
|
||
* into `keyInfo` field.
|
||
*/
|
||
|
||
|
||
function makeIdAndName(mapResult) {
|
||
// We use this id to hash component models and view instances
|
||
// in echarts. id can be specified by user, or auto generated.
|
||
// The id generation rule ensures new view instance are able
|
||
// to mapped to old instance when setOption are called in
|
||
// no-merge mode. So we generate model id by name and plus
|
||
// type in view id.
|
||
// name can be duplicated among components, which is convenient
|
||
// to specify multi components (like series) by one name.
|
||
// Ensure that each id is distinct.
|
||
var idMap = createHashMap();
|
||
each(mapResult, function (item) {
|
||
var existing = item.existing;
|
||
existing && idMap.set(existing.id, item);
|
||
});
|
||
each(mapResult, function (item) {
|
||
var opt = item.newOption; // Force ensure id not duplicated.
|
||
|
||
assert(!opt || opt.id == null || !idMap.get(opt.id) || idMap.get(opt.id) === item, 'id duplicates: ' + (opt && opt.id));
|
||
opt && opt.id != null && idMap.set(opt.id, item);
|
||
!item.keyInfo && (item.keyInfo = {});
|
||
}); // Make name and id.
|
||
|
||
each(mapResult, function (item, index) {
|
||
var existing = item.existing;
|
||
var opt = item.newOption;
|
||
var keyInfo = item.keyInfo;
|
||
|
||
if (!isObject(opt)) {
|
||
return;
|
||
} // name can be overwitten. Consider case: axis.name = '20km'.
|
||
// But id generated by name will not be changed, which affect
|
||
// only in that case: setOption with 'not merge mode' and view
|
||
// instance will be recreated, which can be accepted.
|
||
|
||
|
||
keyInfo.name = opt.name != null ? makeComparableKey(opt.name) : existing ? existing.name // Avoid diffferent series has the same name,
|
||
// because name may be used like in color pallet.
|
||
: DUMMY_COMPONENT_NAME_PREFIX + index;
|
||
|
||
if (existing) {
|
||
keyInfo.id = makeComparableKey(existing.id);
|
||
} else if (opt.id != null) {
|
||
keyInfo.id = makeComparableKey(opt.id);
|
||
} else {
|
||
// Consider this situatoin:
|
||
// optionA: [{name: 'a'}, {name: 'a'}, {..}]
|
||
// optionB [{..}, {name: 'a'}, {name: 'a'}]
|
||
// Series with the same name between optionA and optionB
|
||
// should be mapped.
|
||
var idNum = 0;
|
||
|
||
do {
|
||
keyInfo.id = '\0' + keyInfo.name + '\0' + idNum++;
|
||
} while (idMap.get(keyInfo.id));
|
||
}
|
||
|
||
idMap.set(keyInfo.id, item);
|
||
});
|
||
}
|
||
|
||
function keyExistAndEqual(attr, obj1, obj2) {
|
||
var key1 = convertOptionIdName(obj1[attr], null);
|
||
var key2 = convertOptionIdName(obj2[attr], null); // See `MappingExistingItem`. `id` and `name` trade string equals to number.
|
||
|
||
return key1 != null && key2 != null && key1 === key2;
|
||
}
|
||
/**
|
||
* @return return null if not exist.
|
||
*/
|
||
|
||
|
||
function makeComparableKey(val) {
|
||
if ("development" !== 'production') {
|
||
if (val == null) {
|
||
throw new Error();
|
||
}
|
||
}
|
||
|
||
return convertOptionIdName(val, '');
|
||
}
|
||
|
||
function convertOptionIdName(idOrName, defaultValue) {
|
||
if (idOrName == null) {
|
||
return defaultValue;
|
||
}
|
||
|
||
return isString(idOrName) ? idOrName : isNumber(idOrName) || isStringSafe(idOrName) ? idOrName + '' : defaultValue;
|
||
}
|
||
|
||
function warnInvalidateIdOrName(idOrName) {
|
||
if ("development" !== 'production') {
|
||
warn('`' + idOrName + '` is invalid id or name. Must be a string or number.');
|
||
}
|
||
}
|
||
|
||
function isValidIdOrName(idOrName) {
|
||
return isStringSafe(idOrName) || isNumeric(idOrName);
|
||
}
|
||
|
||
function isNameSpecified(componentModel) {
|
||
var name = componentModel.name; // Is specified when `indexOf` get -1 or > 0.
|
||
|
||
return !!(name && name.indexOf(DUMMY_COMPONENT_NAME_PREFIX));
|
||
}
|
||
/**
|
||
* @public
|
||
* @param {Object} cmptOption
|
||
* @return {boolean}
|
||
*/
|
||
|
||
function isComponentIdInternal(cmptOption) {
|
||
return cmptOption && cmptOption.id != null && makeComparableKey(cmptOption.id).indexOf(INTERNAL_COMPONENT_ID_PREFIX) === 0;
|
||
}
|
||
function makeInternalComponentId(idSuffix) {
|
||
return INTERNAL_COMPONENT_ID_PREFIX + idSuffix;
|
||
}
|
||
function setComponentTypeToKeyInfo(mappingResult, mainType, componentModelCtor) {
|
||
// Set mainType and complete subType.
|
||
each(mappingResult, function (item) {
|
||
var newOption = item.newOption;
|
||
|
||
if (isObject(newOption)) {
|
||
item.keyInfo.mainType = mainType;
|
||
item.keyInfo.subType = determineSubType(mainType, newOption, item.existing, componentModelCtor);
|
||
}
|
||
});
|
||
}
|
||
|
||
function determineSubType(mainType, newCmptOption, existComponent, componentModelCtor) {
|
||
var subType = newCmptOption.type ? newCmptOption.type : existComponent ? existComponent.subType // Use determineSubType only when there is no existComponent.
|
||
: componentModelCtor.determineSubType(mainType, newCmptOption); // tooltip, markline, markpoint may always has no subType
|
||
|
||
return subType;
|
||
}
|
||
/**
|
||
* A helper for removing duplicate items between batchA and batchB,
|
||
* and in themselves, and categorize by series.
|
||
*
|
||
* @param batchA Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]
|
||
* @param batchB Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]
|
||
* @return result: [resultBatchA, resultBatchB]
|
||
*/
|
||
|
||
|
||
function compressBatches(batchA, batchB) {
|
||
var mapA = {};
|
||
var mapB = {};
|
||
makeMap(batchA || [], mapA);
|
||
makeMap(batchB || [], mapB, mapA);
|
||
return [mapToArray(mapA), mapToArray(mapB)];
|
||
|
||
function makeMap(sourceBatch, map, otherMap) {
|
||
for (var i = 0, len = sourceBatch.length; i < len; i++) {
|
||
var seriesId = convertOptionIdName(sourceBatch[i].seriesId, null);
|
||
|
||
if (seriesId == null) {
|
||
return;
|
||
}
|
||
|
||
var dataIndices = normalizeToArray(sourceBatch[i].dataIndex);
|
||
var otherDataIndices = otherMap && otherMap[seriesId];
|
||
|
||
for (var j = 0, lenj = dataIndices.length; j < lenj; j++) {
|
||
var dataIndex = dataIndices[j];
|
||
|
||
if (otherDataIndices && otherDataIndices[dataIndex]) {
|
||
otherDataIndices[dataIndex] = null;
|
||
} else {
|
||
(map[seriesId] || (map[seriesId] = {}))[dataIndex] = 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
function mapToArray(map, isData) {
|
||
var result = [];
|
||
|
||
for (var i in map) {
|
||
if (map.hasOwnProperty(i) && map[i] != null) {
|
||
if (isData) {
|
||
result.push(+i);
|
||
} else {
|
||
var dataIndices = mapToArray(map[i], true);
|
||
dataIndices.length && result.push({
|
||
seriesId: i,
|
||
dataIndex: dataIndices
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
}
|
||
/**
|
||
* @param payload Contains dataIndex (means rawIndex) / dataIndexInside / name
|
||
* each of which can be Array or primary type.
|
||
* @return dataIndex If not found, return undefined/null.
|
||
*/
|
||
|
||
function queryDataIndex(data, payload) {
|
||
if (payload.dataIndexInside != null) {
|
||
return payload.dataIndexInside;
|
||
} else if (payload.dataIndex != null) {
|
||
return isArray(payload.dataIndex) ? map(payload.dataIndex, function (value) {
|
||
return data.indexOfRawIndex(value);
|
||
}) : data.indexOfRawIndex(payload.dataIndex);
|
||
} else if (payload.name != null) {
|
||
return isArray(payload.name) ? map(payload.name, function (value) {
|
||
return data.indexOfName(value);
|
||
}) : data.indexOfName(payload.name);
|
||
}
|
||
}
|
||
/**
|
||
* Enable property storage to any host object.
|
||
* Notice: Serialization is not supported.
|
||
*
|
||
* For example:
|
||
* let inner = zrUitl.makeInner();
|
||
*
|
||
* function some1(hostObj) {
|
||
* inner(hostObj).someProperty = 1212;
|
||
* ...
|
||
* }
|
||
* function some2() {
|
||
* let fields = inner(this);
|
||
* fields.someProperty1 = 1212;
|
||
* fields.someProperty2 = 'xx';
|
||
* ...
|
||
* }
|
||
*
|
||
* @return {Function}
|
||
*/
|
||
|
||
function makeInner() {
|
||
var key = '__ec_inner_' + innerUniqueIndex++;
|
||
return function (hostObj) {
|
||
return hostObj[key] || (hostObj[key] = {});
|
||
};
|
||
}
|
||
var innerUniqueIndex = getRandomIdBase();
|
||
/**
|
||
* The same behavior as `component.getReferringComponents`.
|
||
*/
|
||
|
||
function parseFinder(ecModel, finderInput, opt) {
|
||
var _a = preParseFinder(finderInput, opt),
|
||
mainTypeSpecified = _a.mainTypeSpecified,
|
||
queryOptionMap = _a.queryOptionMap,
|
||
others = _a.others;
|
||
|
||
var result = others;
|
||
var defaultMainType = opt ? opt.defaultMainType : null;
|
||
|
||
if (!mainTypeSpecified && defaultMainType) {
|
||
queryOptionMap.set(defaultMainType, {});
|
||
}
|
||
|
||
queryOptionMap.each(function (queryOption, mainType) {
|
||
var queryResult = queryReferringComponents(ecModel, mainType, queryOption, {
|
||
useDefault: defaultMainType === mainType,
|
||
enableAll: opt && opt.enableAll != null ? opt.enableAll : true,
|
||
enableNone: opt && opt.enableNone != null ? opt.enableNone : true
|
||
});
|
||
result[mainType + 'Models'] = queryResult.models;
|
||
result[mainType + 'Model'] = queryResult.models[0];
|
||
});
|
||
return result;
|
||
}
|
||
function preParseFinder(finderInput, opt) {
|
||
var finder;
|
||
|
||
if (isString(finderInput)) {
|
||
var obj = {};
|
||
obj[finderInput + 'Index'] = 0;
|
||
finder = obj;
|
||
} else {
|
||
finder = finderInput;
|
||
}
|
||
|
||
var queryOptionMap = createHashMap();
|
||
var others = {};
|
||
var mainTypeSpecified = false;
|
||
each(finder, function (value, key) {
|
||
// Exclude 'dataIndex' and other illgal keys.
|
||
if (key === 'dataIndex' || key === 'dataIndexInside') {
|
||
others[key] = value;
|
||
return;
|
||
}
|
||
|
||
var parsedKey = key.match(/^(\w+)(Index|Id|Name)$/) || [];
|
||
var mainType = parsedKey[1];
|
||
var queryType = (parsedKey[2] || '').toLowerCase();
|
||
|
||
if (!mainType || !queryType || opt && opt.includeMainTypes && indexOf(opt.includeMainTypes, mainType) < 0) {
|
||
return;
|
||
}
|
||
|
||
mainTypeSpecified = mainTypeSpecified || !!mainType;
|
||
var queryOption = queryOptionMap.get(mainType) || queryOptionMap.set(mainType, {});
|
||
queryOption[queryType] = value;
|
||
});
|
||
return {
|
||
mainTypeSpecified: mainTypeSpecified,
|
||
queryOptionMap: queryOptionMap,
|
||
others: others
|
||
};
|
||
}
|
||
var SINGLE_REFERRING = {
|
||
useDefault: true,
|
||
enableAll: false,
|
||
enableNone: false
|
||
};
|
||
var MULTIPLE_REFERRING = {
|
||
useDefault: false,
|
||
enableAll: true,
|
||
enableNone: true
|
||
};
|
||
function queryReferringComponents(ecModel, mainType, userOption, opt) {
|
||
opt = opt || SINGLE_REFERRING;
|
||
var indexOption = userOption.index;
|
||
var idOption = userOption.id;
|
||
var nameOption = userOption.name;
|
||
var result = {
|
||
models: null,
|
||
specified: indexOption != null || idOption != null || nameOption != null
|
||
};
|
||
|
||
if (!result.specified) {
|
||
// Use the first as default if `useDefault`.
|
||
var firstCmpt = void 0;
|
||
result.models = opt.useDefault && (firstCmpt = ecModel.getComponent(mainType)) ? [firstCmpt] : [];
|
||
return result;
|
||
}
|
||
|
||
if (indexOption === 'none' || indexOption === false) {
|
||
assert(opt.enableNone, '`"none"` or `false` is not a valid value on index option.');
|
||
result.models = [];
|
||
return result;
|
||
} // `queryComponents` will return all components if
|
||
// both all of index/id/name are null/undefined.
|
||
|
||
|
||
if (indexOption === 'all') {
|
||
assert(opt.enableAll, '`"all"` is not a valid value on index option.');
|
||
indexOption = idOption = nameOption = null;
|
||
}
|
||
|
||
result.models = ecModel.queryComponents({
|
||
mainType: mainType,
|
||
index: indexOption,
|
||
id: idOption,
|
||
name: nameOption
|
||
});
|
||
return result;
|
||
}
|
||
function setAttribute(dom, key, value) {
|
||
dom.setAttribute ? dom.setAttribute(key, value) : dom[key] = value;
|
||
}
|
||
function getAttribute(dom, key) {
|
||
return dom.getAttribute ? dom.getAttribute(key) : dom[key];
|
||
}
|
||
function getTooltipRenderMode(renderModeOption) {
|
||
if (renderModeOption === 'auto') {
|
||
// Using html when `document` exists, use richText otherwise
|
||
return env.domSupported ? 'html' : 'richText';
|
||
} else {
|
||
return renderModeOption || 'html';
|
||
}
|
||
}
|
||
/**
|
||
* Group a list by key.
|
||
*/
|
||
|
||
function groupData(array, getKey // return key
|
||
) {
|
||
var buckets = createHashMap();
|
||
var keys = [];
|
||
each(array, function (item) {
|
||
var key = getKey(item);
|
||
(buckets.get(key) || (keys.push(key), buckets.set(key, []))).push(item);
|
||
});
|
||
return {
|
||
keys: keys,
|
||
buckets: buckets
|
||
};
|
||
}
|
||
/**
|
||
* Interpolate raw values of a series with percent
|
||
*
|
||
* @param data data
|
||
* @param labelModel label model of the text element
|
||
* @param sourceValue start value. May be null/undefined when init.
|
||
* @param targetValue end value
|
||
* @param percent 0~1 percentage; 0 uses start value while 1 uses end value
|
||
* @return interpolated values
|
||
* If `sourceValue` and `targetValue` are `number`, return `number`.
|
||
* If `sourceValue` and `targetValue` are `string`, return `string`.
|
||
* If `sourceValue` and `targetValue` are `(string | number)[]`, return `(string | number)[]`.
|
||
* Other cases do not supported.
|
||
*/
|
||
|
||
function interpolateRawValues(data, precision, sourceValue, targetValue, percent) {
|
||
var isAutoPrecision = precision == null || precision === 'auto';
|
||
|
||
if (targetValue == null) {
|
||
return targetValue;
|
||
}
|
||
|
||
if (isNumber(targetValue)) {
|
||
var value = interpolateNumber$1(sourceValue || 0, targetValue, percent);
|
||
return round(value, isAutoPrecision ? Math.max(getPrecision(sourceValue || 0), getPrecision(targetValue)) : precision);
|
||
} else if (isString(targetValue)) {
|
||
return percent < 1 ? sourceValue : targetValue;
|
||
} else {
|
||
var interpolated = [];
|
||
var leftArr = sourceValue;
|
||
var rightArr = targetValue;
|
||
var length_1 = Math.max(leftArr ? leftArr.length : 0, rightArr.length);
|
||
|
||
for (var i = 0; i < length_1; ++i) {
|
||
var info = data.getDimensionInfo(i); // Don't interpolate ordinal dims
|
||
|
||
if (info && info.type === 'ordinal') {
|
||
// In init, there is no `sourceValue`, but should better not to get undefined result.
|
||
interpolated[i] = (percent < 1 && leftArr ? leftArr : rightArr)[i];
|
||
} else {
|
||
var leftVal = leftArr && leftArr[i] ? leftArr[i] : 0;
|
||
var rightVal = rightArr[i];
|
||
var value = interpolateNumber$1(leftVal, rightVal, percent);
|
||
interpolated[i] = round(value, isAutoPrecision ? Math.max(getPrecision(leftVal), getPrecision(rightVal)) : precision);
|
||
}
|
||
}
|
||
|
||
return interpolated;
|
||
}
|
||
}
|
||
|
||
var TYPE_DELIMITER = '.';
|
||
var IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';
|
||
var IS_EXTENDED_CLASS = '___EC__EXTENDED_CLASS___';
|
||
/**
|
||
* Notice, parseClassType('') should returns {main: '', sub: ''}
|
||
* @public
|
||
*/
|
||
|
||
function parseClassType(componentType) {
|
||
var ret = {
|
||
main: '',
|
||
sub: ''
|
||
};
|
||
|
||
if (componentType) {
|
||
var typeArr = componentType.split(TYPE_DELIMITER);
|
||
ret.main = typeArr[0] || '';
|
||
ret.sub = typeArr[1] || '';
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
/**
|
||
* @public
|
||
*/
|
||
|
||
function checkClassType(componentType) {
|
||
assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType "' + componentType + '" illegal');
|
||
}
|
||
|
||
function isExtendedClass(clz) {
|
||
return !!(clz && clz[IS_EXTENDED_CLASS]);
|
||
}
|
||
/**
|
||
* Implements `ExtendableConstructor` for `rootClz`.
|
||
*
|
||
* @usage
|
||
* ```ts
|
||
* class Xxx {}
|
||
* type XxxConstructor = typeof Xxx & ExtendableConstructor
|
||
* enableClassExtend(Xxx as XxxConstructor);
|
||
* ```
|
||
*/
|
||
|
||
function enableClassExtend(rootClz, mandatoryMethods) {
|
||
rootClz.$constructor = rootClz; // FIXME: not necessary?
|
||
|
||
rootClz.extend = function (proto) {
|
||
if ("development" !== 'production') {
|
||
each(mandatoryMethods, function (method) {
|
||
if (!proto[method]) {
|
||
console.warn('Method `' + method + '` should be implemented' + (proto.type ? ' in ' + proto.type : '') + '.');
|
||
}
|
||
});
|
||
}
|
||
|
||
var superClass = this;
|
||
var ExtendedClass;
|
||
|
||
if (isESClass(superClass)) {
|
||
ExtendedClass =
|
||
/** @class */
|
||
function (_super) {
|
||
__extends(class_1, _super);
|
||
|
||
function class_1() {
|
||
return _super.apply(this, arguments) || this;
|
||
}
|
||
|
||
return class_1;
|
||
}(superClass);
|
||
} else {
|
||
// For backward compat, we both support ts class inheritance and this
|
||
// "extend" approach.
|
||
// The constructor should keep the same behavior as ts class inheritance:
|
||
// If this constructor/$constructor is not declared, auto invoke the super
|
||
// constructor.
|
||
// If this constructor/$constructor is declared, it is responsible for
|
||
// calling the super constructor.
|
||
ExtendedClass = function () {
|
||
(proto.$constructor || superClass).apply(this, arguments);
|
||
};
|
||
|
||
inherits(ExtendedClass, this);
|
||
}
|
||
|
||
extend(ExtendedClass.prototype, proto);
|
||
ExtendedClass[IS_EXTENDED_CLASS] = true;
|
||
ExtendedClass.extend = this.extend;
|
||
ExtendedClass.superCall = superCall;
|
||
ExtendedClass.superApply = superApply;
|
||
ExtendedClass.superClass = superClass;
|
||
return ExtendedClass;
|
||
};
|
||
}
|
||
|
||
function isESClass(fn) {
|
||
return isFunction(fn) && /^class\s/.test(Function.prototype.toString.call(fn));
|
||
}
|
||
/**
|
||
* A work around to both support ts extend and this extend mechanism.
|
||
* on sub-class.
|
||
* @usage
|
||
* ```ts
|
||
* class Component { ... }
|
||
* classUtil.enableClassExtend(Component);
|
||
* classUtil.enableClassManagement(Component, {registerWhenExtend: true});
|
||
*
|
||
* class Series extends Component { ... }
|
||
* // Without calling `markExtend`, `registerWhenExtend` will not work.
|
||
* Component.markExtend(Series);
|
||
* ```
|
||
*/
|
||
|
||
|
||
function mountExtend(SubClz, SupperClz) {
|
||
SubClz.extend = SupperClz.extend;
|
||
} // A random offset.
|
||
|
||
var classBase = Math.round(Math.random() * 10);
|
||
/**
|
||
* Implements `CheckableConstructor` for `target`.
|
||
* Can not use instanceof, consider different scope by
|
||
* cross domain or es module import in ec extensions.
|
||
* Mount a method "isInstance()" to Clz.
|
||
*
|
||
* @usage
|
||
* ```ts
|
||
* class Xxx {}
|
||
* type XxxConstructor = typeof Xxx & CheckableConstructor;
|
||
* enableClassCheck(Xxx as XxxConstructor)
|
||
* ```
|
||
*/
|
||
|
||
function enableClassCheck(target) {
|
||
var classAttr = ['__\0is_clz', classBase++].join('_');
|
||
target.prototype[classAttr] = true;
|
||
|
||
if ("development" !== 'production') {
|
||
assert(!target.isInstance, 'The method "is" can not be defined.');
|
||
}
|
||
|
||
target.isInstance = function (obj) {
|
||
return !!(obj && obj[classAttr]);
|
||
};
|
||
} // superCall should have class info, which can not be fetch from 'this'.
|
||
// Consider this case:
|
||
// class A has method f,
|
||
// class B inherits class A, overrides method f, f call superApply('f'),
|
||
// class C inherits class B, do not overrides method f,
|
||
// then when method of class C is called, dead loop occured.
|
||
|
||
function superCall(context, methodName) {
|
||
var args = [];
|
||
|
||
for (var _i = 2; _i < arguments.length; _i++) {
|
||
args[_i - 2] = arguments[_i];
|
||
}
|
||
|
||
return this.superClass.prototype[methodName].apply(context, args);
|
||
}
|
||
|
||
function superApply(context, methodName, args) {
|
||
return this.superClass.prototype[methodName].apply(context, args);
|
||
}
|
||
/**
|
||
* Implements `ClassManager` for `target`
|
||
*
|
||
* @usage
|
||
* ```ts
|
||
* class Xxx {}
|
||
* type XxxConstructor = typeof Xxx & ClassManager
|
||
* enableClassManagement(Xxx as XxxConstructor);
|
||
* ```
|
||
*/
|
||
|
||
|
||
function enableClassManagement(target) {
|
||
/**
|
||
* Component model classes
|
||
* key: componentType,
|
||
* value:
|
||
* componentClass, when componentType is 'xxx'
|
||
* or Object.<subKey, componentClass>, when componentType is 'xxx.yy'
|
||
*/
|
||
var storage = {};
|
||
|
||
target.registerClass = function (clz) {
|
||
// `type` should not be a "instance memeber".
|
||
// If using TS class, should better declared as `static type = 'series.pie'`.
|
||
// otherwise users have to mount `type` on prototype manually.
|
||
// For backward compat and enable instance visit type via `this.type`,
|
||
// we stil support fetch `type` from prototype.
|
||
var componentFullType = clz.type || clz.prototype.type;
|
||
|
||
if (componentFullType) {
|
||
checkClassType(componentFullType); // If only static type declared, we assign it to prototype mandatorily.
|
||
|
||
clz.prototype.type = componentFullType;
|
||
var componentTypeInfo = parseClassType(componentFullType);
|
||
|
||
if (!componentTypeInfo.sub) {
|
||
if ("development" !== 'production') {
|
||
if (storage[componentTypeInfo.main]) {
|
||
console.warn(componentTypeInfo.main + ' exists.');
|
||
}
|
||
}
|
||
|
||
storage[componentTypeInfo.main] = clz;
|
||
} else if (componentTypeInfo.sub !== IS_CONTAINER) {
|
||
var container = makeContainer(componentTypeInfo);
|
||
container[componentTypeInfo.sub] = clz;
|
||
}
|
||
}
|
||
|
||
return clz;
|
||
};
|
||
|
||
target.getClass = function (mainType, subType, throwWhenNotFound) {
|
||
var clz = storage[mainType];
|
||
|
||
if (clz && clz[IS_CONTAINER]) {
|
||
clz = subType ? clz[subType] : null;
|
||
}
|
||
|
||
if (throwWhenNotFound && !clz) {
|
||
throw new Error(!subType ? mainType + '.' + 'type should be specified.' : 'Component ' + mainType + '.' + (subType || '') + ' is used but not imported.');
|
||
}
|
||
|
||
return clz;
|
||
};
|
||
|
||
target.getClassesByMainType = function (componentType) {
|
||
var componentTypeInfo = parseClassType(componentType);
|
||
var result = [];
|
||
var obj = storage[componentTypeInfo.main];
|
||
|
||
if (obj && obj[IS_CONTAINER]) {
|
||
each(obj, function (o, type) {
|
||
type !== IS_CONTAINER && result.push(o);
|
||
});
|
||
} else {
|
||
result.push(obj);
|
||
}
|
||
|
||
return result;
|
||
};
|
||
|
||
target.hasClass = function (componentType) {
|
||
// Just consider componentType.main.
|
||
var componentTypeInfo = parseClassType(componentType);
|
||
return !!storage[componentTypeInfo.main];
|
||
};
|
||
/**
|
||
* @return Like ['aa', 'bb'], but can not be ['aa.xx']
|
||
*/
|
||
|
||
|
||
target.getAllClassMainTypes = function () {
|
||
var types = [];
|
||
each(storage, function (obj, type) {
|
||
types.push(type);
|
||
});
|
||
return types;
|
||
};
|
||
/**
|
||
* If a main type is container and has sub types
|
||
*/
|
||
|
||
|
||
target.hasSubTypes = function (componentType) {
|
||
var componentTypeInfo = parseClassType(componentType);
|
||
var obj = storage[componentTypeInfo.main];
|
||
return obj && obj[IS_CONTAINER];
|
||
};
|
||
|
||
function makeContainer(componentTypeInfo) {
|
||
var container = storage[componentTypeInfo.main];
|
||
|
||
if (!container || !container[IS_CONTAINER]) {
|
||
container = storage[componentTypeInfo.main] = {};
|
||
container[IS_CONTAINER] = true;
|
||
}
|
||
|
||
return container;
|
||
}
|
||
} // /**
|
||
// * @param {string|Array.<string>} properties
|
||
// */
|
||
// export function setReadOnly(obj, properties) {
|
||
// FIXME It seems broken in IE8 simulation of IE11
|
||
// if (!zrUtil.isArray(properties)) {
|
||
// properties = properties != null ? [properties] : [];
|
||
// }
|
||
// zrUtil.each(properties, function (prop) {
|
||
// let value = obj[prop];
|
||
// Object.defineProperty
|
||
// && Object.defineProperty(obj, prop, {
|
||
// value: value, writable: false
|
||
// });
|
||
// zrUtil.isArray(obj[prop])
|
||
// && Object.freeze
|
||
// && Object.freeze(obj[prop]);
|
||
// });
|
||
// }
|
||
|
||
function makeStyleMapper(properties, ignoreParent) {
|
||
// Normalize
|
||
for (var i = 0; i < properties.length; i++) {
|
||
if (!properties[i][1]) {
|
||
properties[i][1] = properties[i][0];
|
||
}
|
||
}
|
||
|
||
ignoreParent = ignoreParent || false;
|
||
return function (model, excludes, includes) {
|
||
var style = {};
|
||
|
||
for (var i = 0; i < properties.length; i++) {
|
||
var propName = properties[i][1];
|
||
|
||
if (excludes && indexOf(excludes, propName) >= 0 || includes && indexOf(includes, propName) < 0) {
|
||
continue;
|
||
}
|
||
|
||
var val = model.getShallow(propName, ignoreParent);
|
||
|
||
if (val != null) {
|
||
style[properties[i][0]] = val;
|
||
}
|
||
} // TODO Text or image?
|
||
|
||
|
||
return style;
|
||
};
|
||
}
|
||
|
||
var AREA_STYLE_KEY_MAP = [['fill', 'color'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['opacity'], ['shadowColor'] // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
|
||
// So do not transfer decal directly.
|
||
];
|
||
var getAreaStyle = makeStyleMapper(AREA_STYLE_KEY_MAP);
|
||
|
||
var AreaStyleMixin =
|
||
/** @class */
|
||
function () {
|
||
function AreaStyleMixin() {}
|
||
|
||
AreaStyleMixin.prototype.getAreaStyle = function (excludes, includes) {
|
||
return getAreaStyle(this, excludes, includes);
|
||
};
|
||
|
||
return AreaStyleMixin;
|
||
}();
|
||
|
||
var globalImageCache = new LRU(50);
|
||
function findExistImage(newImageOrSrc) {
|
||
if (typeof newImageOrSrc === 'string') {
|
||
var cachedImgObj = globalImageCache.get(newImageOrSrc);
|
||
return cachedImgObj && cachedImgObj.image;
|
||
}
|
||
else {
|
||
return newImageOrSrc;
|
||
}
|
||
}
|
||
function createOrUpdateImage(newImageOrSrc, image, hostEl, onload, cbPayload) {
|
||
if (!newImageOrSrc) {
|
||
return image;
|
||
}
|
||
else if (typeof newImageOrSrc === 'string') {
|
||
if ((image && image.__zrImageSrc === newImageOrSrc) || !hostEl) {
|
||
return image;
|
||
}
|
||
var cachedImgObj = globalImageCache.get(newImageOrSrc);
|
||
var pendingWrap = { hostEl: hostEl, cb: onload, cbPayload: cbPayload };
|
||
if (cachedImgObj) {
|
||
image = cachedImgObj.image;
|
||
!isImageReady(image) && cachedImgObj.pending.push(pendingWrap);
|
||
}
|
||
else {
|
||
var image_1 = platformApi.loadImage(newImageOrSrc, imageOnLoad, imageOnLoad);
|
||
image_1.__zrImageSrc = newImageOrSrc;
|
||
globalImageCache.put(newImageOrSrc, image_1.__cachedImgObj = {
|
||
image: image_1,
|
||
pending: [pendingWrap]
|
||
});
|
||
}
|
||
return image;
|
||
}
|
||
else {
|
||
return newImageOrSrc;
|
||
}
|
||
}
|
||
function imageOnLoad() {
|
||
var cachedImgObj = this.__cachedImgObj;
|
||
this.onload = this.onerror = this.__cachedImgObj = null;
|
||
for (var i = 0; i < cachedImgObj.pending.length; i++) {
|
||
var pendingWrap = cachedImgObj.pending[i];
|
||
var cb = pendingWrap.cb;
|
||
cb && cb(this, pendingWrap.cbPayload);
|
||
pendingWrap.hostEl.dirty();
|
||
}
|
||
cachedImgObj.pending.length = 0;
|
||
}
|
||
function isImageReady(image) {
|
||
return image && image.width && image.height;
|
||
}
|
||
|
||
var STYLE_REG = /\{([a-zA-Z0-9_]+)\|([^}]*)\}/g;
|
||
function truncateText(text, containerWidth, font, ellipsis, options) {
|
||
if (!containerWidth) {
|
||
return '';
|
||
}
|
||
var textLines = (text + '').split('\n');
|
||
options = prepareTruncateOptions(containerWidth, font, ellipsis, options);
|
||
for (var i = 0, len = textLines.length; i < len; i++) {
|
||
textLines[i] = truncateSingleLine(textLines[i], options);
|
||
}
|
||
return textLines.join('\n');
|
||
}
|
||
function prepareTruncateOptions(containerWidth, font, ellipsis, options) {
|
||
options = options || {};
|
||
var preparedOpts = extend({}, options);
|
||
preparedOpts.font = font;
|
||
ellipsis = retrieve2(ellipsis, '...');
|
||
preparedOpts.maxIterations = retrieve2(options.maxIterations, 2);
|
||
var minChar = preparedOpts.minChar = retrieve2(options.minChar, 0);
|
||
preparedOpts.cnCharWidth = getWidth('国', font);
|
||
var ascCharWidth = preparedOpts.ascCharWidth = getWidth('a', font);
|
||
preparedOpts.placeholder = retrieve2(options.placeholder, '');
|
||
var contentWidth = containerWidth = Math.max(0, containerWidth - 1);
|
||
for (var i = 0; i < minChar && contentWidth >= ascCharWidth; i++) {
|
||
contentWidth -= ascCharWidth;
|
||
}
|
||
var ellipsisWidth = getWidth(ellipsis, font);
|
||
if (ellipsisWidth > contentWidth) {
|
||
ellipsis = '';
|
||
ellipsisWidth = 0;
|
||
}
|
||
contentWidth = containerWidth - ellipsisWidth;
|
||
preparedOpts.ellipsis = ellipsis;
|
||
preparedOpts.ellipsisWidth = ellipsisWidth;
|
||
preparedOpts.contentWidth = contentWidth;
|
||
preparedOpts.containerWidth = containerWidth;
|
||
return preparedOpts;
|
||
}
|
||
function truncateSingleLine(textLine, options) {
|
||
var containerWidth = options.containerWidth;
|
||
var font = options.font;
|
||
var contentWidth = options.contentWidth;
|
||
if (!containerWidth) {
|
||
return '';
|
||
}
|
||
var lineWidth = getWidth(textLine, font);
|
||
if (lineWidth <= containerWidth) {
|
||
return textLine;
|
||
}
|
||
for (var j = 0;; j++) {
|
||
if (lineWidth <= contentWidth || j >= options.maxIterations) {
|
||
textLine += options.ellipsis;
|
||
break;
|
||
}
|
||
var subLength = j === 0
|
||
? estimateLength(textLine, contentWidth, options.ascCharWidth, options.cnCharWidth)
|
||
: lineWidth > 0
|
||
? Math.floor(textLine.length * contentWidth / lineWidth)
|
||
: 0;
|
||
textLine = textLine.substr(0, subLength);
|
||
lineWidth = getWidth(textLine, font);
|
||
}
|
||
if (textLine === '') {
|
||
textLine = options.placeholder;
|
||
}
|
||
return textLine;
|
||
}
|
||
function estimateLength(text, contentWidth, ascCharWidth, cnCharWidth) {
|
||
var width = 0;
|
||
var i = 0;
|
||
for (var len = text.length; i < len && width < contentWidth; i++) {
|
||
var charCode = text.charCodeAt(i);
|
||
width += (0 <= charCode && charCode <= 127) ? ascCharWidth : cnCharWidth;
|
||
}
|
||
return i;
|
||
}
|
||
function parsePlainText(text, style) {
|
||
text != null && (text += '');
|
||
var overflow = style.overflow;
|
||
var padding = style.padding;
|
||
var font = style.font;
|
||
var truncate = overflow === 'truncate';
|
||
var calculatedLineHeight = getLineHeight(font);
|
||
var lineHeight = retrieve2(style.lineHeight, calculatedLineHeight);
|
||
var bgColorDrawn = !!(style.backgroundColor);
|
||
var truncateLineOverflow = style.lineOverflow === 'truncate';
|
||
var width = style.width;
|
||
var lines;
|
||
if (width != null && (overflow === 'break' || overflow === 'breakAll')) {
|
||
lines = text ? wrapText(text, style.font, width, overflow === 'breakAll', 0).lines : [];
|
||
}
|
||
else {
|
||
lines = text ? text.split('\n') : [];
|
||
}
|
||
var contentHeight = lines.length * lineHeight;
|
||
var height = retrieve2(style.height, contentHeight);
|
||
if (contentHeight > height && truncateLineOverflow) {
|
||
var lineCount = Math.floor(height / lineHeight);
|
||
lines = lines.slice(0, lineCount);
|
||
}
|
||
if (text && truncate && width != null) {
|
||
var options = prepareTruncateOptions(width, font, style.ellipsis, {
|
||
minChar: style.truncateMinChar,
|
||
placeholder: style.placeholder
|
||
});
|
||
for (var i = 0; i < lines.length; i++) {
|
||
lines[i] = truncateSingleLine(lines[i], options);
|
||
}
|
||
}
|
||
var outerHeight = height;
|
||
var contentWidth = 0;
|
||
for (var i = 0; i < lines.length; i++) {
|
||
contentWidth = Math.max(getWidth(lines[i], font), contentWidth);
|
||
}
|
||
if (width == null) {
|
||
width = contentWidth;
|
||
}
|
||
var outerWidth = contentWidth;
|
||
if (padding) {
|
||
outerHeight += padding[0] + padding[2];
|
||
outerWidth += padding[1] + padding[3];
|
||
width += padding[1] + padding[3];
|
||
}
|
||
if (bgColorDrawn) {
|
||
outerWidth = width;
|
||
}
|
||
return {
|
||
lines: lines,
|
||
height: height,
|
||
outerWidth: outerWidth,
|
||
outerHeight: outerHeight,
|
||
lineHeight: lineHeight,
|
||
calculatedLineHeight: calculatedLineHeight,
|
||
contentWidth: contentWidth,
|
||
contentHeight: contentHeight,
|
||
width: width
|
||
};
|
||
}
|
||
var RichTextToken = (function () {
|
||
function RichTextToken() {
|
||
}
|
||
return RichTextToken;
|
||
}());
|
||
var RichTextLine = (function () {
|
||
function RichTextLine(tokens) {
|
||
this.tokens = [];
|
||
if (tokens) {
|
||
this.tokens = tokens;
|
||
}
|
||
}
|
||
return RichTextLine;
|
||
}());
|
||
var RichTextContentBlock = (function () {
|
||
function RichTextContentBlock() {
|
||
this.width = 0;
|
||
this.height = 0;
|
||
this.contentWidth = 0;
|
||
this.contentHeight = 0;
|
||
this.outerWidth = 0;
|
||
this.outerHeight = 0;
|
||
this.lines = [];
|
||
}
|
||
return RichTextContentBlock;
|
||
}());
|
||
function parseRichText(text, style) {
|
||
var contentBlock = new RichTextContentBlock();
|
||
text != null && (text += '');
|
||
if (!text) {
|
||
return contentBlock;
|
||
}
|
||
var topWidth = style.width;
|
||
var topHeight = style.height;
|
||
var overflow = style.overflow;
|
||
var wrapInfo = (overflow === 'break' || overflow === 'breakAll') && topWidth != null
|
||
? { width: topWidth, accumWidth: 0, breakAll: overflow === 'breakAll' }
|
||
: null;
|
||
var lastIndex = STYLE_REG.lastIndex = 0;
|
||
var result;
|
||
while ((result = STYLE_REG.exec(text)) != null) {
|
||
var matchedIndex = result.index;
|
||
if (matchedIndex > lastIndex) {
|
||
pushTokens(contentBlock, text.substring(lastIndex, matchedIndex), style, wrapInfo);
|
||
}
|
||
pushTokens(contentBlock, result[2], style, wrapInfo, result[1]);
|
||
lastIndex = STYLE_REG.lastIndex;
|
||
}
|
||
if (lastIndex < text.length) {
|
||
pushTokens(contentBlock, text.substring(lastIndex, text.length), style, wrapInfo);
|
||
}
|
||
var pendingList = [];
|
||
var calculatedHeight = 0;
|
||
var calculatedWidth = 0;
|
||
var stlPadding = style.padding;
|
||
var truncate = overflow === 'truncate';
|
||
var truncateLine = style.lineOverflow === 'truncate';
|
||
function finishLine(line, lineWidth, lineHeight) {
|
||
line.width = lineWidth;
|
||
line.lineHeight = lineHeight;
|
||
calculatedHeight += lineHeight;
|
||
calculatedWidth = Math.max(calculatedWidth, lineWidth);
|
||
}
|
||
outer: for (var i = 0; i < contentBlock.lines.length; i++) {
|
||
var line = contentBlock.lines[i];
|
||
var lineHeight = 0;
|
||
var lineWidth = 0;
|
||
for (var j = 0; j < line.tokens.length; j++) {
|
||
var token = line.tokens[j];
|
||
var tokenStyle = token.styleName && style.rich[token.styleName] || {};
|
||
var textPadding = token.textPadding = tokenStyle.padding;
|
||
var paddingH = textPadding ? textPadding[1] + textPadding[3] : 0;
|
||
var font = token.font = tokenStyle.font || style.font;
|
||
token.contentHeight = getLineHeight(font);
|
||
var tokenHeight = retrieve2(tokenStyle.height, token.contentHeight);
|
||
token.innerHeight = tokenHeight;
|
||
textPadding && (tokenHeight += textPadding[0] + textPadding[2]);
|
||
token.height = tokenHeight;
|
||
token.lineHeight = retrieve3(tokenStyle.lineHeight, style.lineHeight, tokenHeight);
|
||
token.align = tokenStyle && tokenStyle.align || style.align;
|
||
token.verticalAlign = tokenStyle && tokenStyle.verticalAlign || 'middle';
|
||
if (truncateLine && topHeight != null && calculatedHeight + token.lineHeight > topHeight) {
|
||
if (j > 0) {
|
||
line.tokens = line.tokens.slice(0, j);
|
||
finishLine(line, lineWidth, lineHeight);
|
||
contentBlock.lines = contentBlock.lines.slice(0, i + 1);
|
||
}
|
||
else {
|
||
contentBlock.lines = contentBlock.lines.slice(0, i);
|
||
}
|
||
break outer;
|
||
}
|
||
var styleTokenWidth = tokenStyle.width;
|
||
var tokenWidthNotSpecified = styleTokenWidth == null || styleTokenWidth === 'auto';
|
||
if (typeof styleTokenWidth === 'string' && styleTokenWidth.charAt(styleTokenWidth.length - 1) === '%') {
|
||
token.percentWidth = styleTokenWidth;
|
||
pendingList.push(token);
|
||
token.contentWidth = getWidth(token.text, font);
|
||
}
|
||
else {
|
||
if (tokenWidthNotSpecified) {
|
||
var textBackgroundColor = tokenStyle.backgroundColor;
|
||
var bgImg = textBackgroundColor && textBackgroundColor.image;
|
||
if (bgImg) {
|
||
bgImg = findExistImage(bgImg);
|
||
if (isImageReady(bgImg)) {
|
||
token.width = Math.max(token.width, bgImg.width * tokenHeight / bgImg.height);
|
||
}
|
||
}
|
||
}
|
||
var remainTruncWidth = truncate && topWidth != null
|
||
? topWidth - lineWidth : null;
|
||
if (remainTruncWidth != null && remainTruncWidth < token.width) {
|
||
if (!tokenWidthNotSpecified || remainTruncWidth < paddingH) {
|
||
token.text = '';
|
||
token.width = token.contentWidth = 0;
|
||
}
|
||
else {
|
||
token.text = truncateText(token.text, remainTruncWidth - paddingH, font, style.ellipsis, { minChar: style.truncateMinChar });
|
||
token.width = token.contentWidth = getWidth(token.text, font);
|
||
}
|
||
}
|
||
else {
|
||
token.contentWidth = getWidth(token.text, font);
|
||
}
|
||
}
|
||
token.width += paddingH;
|
||
lineWidth += token.width;
|
||
tokenStyle && (lineHeight = Math.max(lineHeight, token.lineHeight));
|
||
}
|
||
finishLine(line, lineWidth, lineHeight);
|
||
}
|
||
contentBlock.outerWidth = contentBlock.width = retrieve2(topWidth, calculatedWidth);
|
||
contentBlock.outerHeight = contentBlock.height = retrieve2(topHeight, calculatedHeight);
|
||
contentBlock.contentHeight = calculatedHeight;
|
||
contentBlock.contentWidth = calculatedWidth;
|
||
if (stlPadding) {
|
||
contentBlock.outerWidth += stlPadding[1] + stlPadding[3];
|
||
contentBlock.outerHeight += stlPadding[0] + stlPadding[2];
|
||
}
|
||
for (var i = 0; i < pendingList.length; i++) {
|
||
var token = pendingList[i];
|
||
var percentWidth = token.percentWidth;
|
||
token.width = parseInt(percentWidth, 10) / 100 * contentBlock.width;
|
||
}
|
||
return contentBlock;
|
||
}
|
||
function pushTokens(block, str, style, wrapInfo, styleName) {
|
||
var isEmptyStr = str === '';
|
||
var tokenStyle = styleName && style.rich[styleName] || {};
|
||
var lines = block.lines;
|
||
var font = tokenStyle.font || style.font;
|
||
var newLine = false;
|
||
var strLines;
|
||
var linesWidths;
|
||
if (wrapInfo) {
|
||
var tokenPadding = tokenStyle.padding;
|
||
var tokenPaddingH = tokenPadding ? tokenPadding[1] + tokenPadding[3] : 0;
|
||
if (tokenStyle.width != null && tokenStyle.width !== 'auto') {
|
||
var outerWidth_1 = parsePercent(tokenStyle.width, wrapInfo.width) + tokenPaddingH;
|
||
if (lines.length > 0) {
|
||
if (outerWidth_1 + wrapInfo.accumWidth > wrapInfo.width) {
|
||
strLines = str.split('\n');
|
||
newLine = true;
|
||
}
|
||
}
|
||
wrapInfo.accumWidth = outerWidth_1;
|
||
}
|
||
else {
|
||
var res = wrapText(str, font, wrapInfo.width, wrapInfo.breakAll, wrapInfo.accumWidth);
|
||
wrapInfo.accumWidth = res.accumWidth + tokenPaddingH;
|
||
linesWidths = res.linesWidths;
|
||
strLines = res.lines;
|
||
}
|
||
}
|
||
else {
|
||
strLines = str.split('\n');
|
||
}
|
||
for (var i = 0; i < strLines.length; i++) {
|
||
var text = strLines[i];
|
||
var token = new RichTextToken();
|
||
token.styleName = styleName;
|
||
token.text = text;
|
||
token.isLineHolder = !text && !isEmptyStr;
|
||
if (typeof tokenStyle.width === 'number') {
|
||
token.width = tokenStyle.width;
|
||
}
|
||
else {
|
||
token.width = linesWidths
|
||
? linesWidths[i]
|
||
: getWidth(text, font);
|
||
}
|
||
if (!i && !newLine) {
|
||
var tokens = (lines[lines.length - 1] || (lines[0] = new RichTextLine())).tokens;
|
||
var tokensLen = tokens.length;
|
||
(tokensLen === 1 && tokens[0].isLineHolder)
|
||
? (tokens[0] = token)
|
||
: ((text || !tokensLen || isEmptyStr) && tokens.push(token));
|
||
}
|
||
else {
|
||
lines.push(new RichTextLine([token]));
|
||
}
|
||
}
|
||
}
|
||
function isLatin(ch) {
|
||
var code = ch.charCodeAt(0);
|
||
return code >= 0x21 && code <= 0x17F;
|
||
}
|
||
var breakCharMap = reduce(',&?/;] '.split(''), function (obj, ch) {
|
||
obj[ch] = true;
|
||
return obj;
|
||
}, {});
|
||
function isWordBreakChar(ch) {
|
||
if (isLatin(ch)) {
|
||
if (breakCharMap[ch]) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
function wrapText(text, font, lineWidth, isBreakAll, lastAccumWidth) {
|
||
var lines = [];
|
||
var linesWidths = [];
|
||
var line = '';
|
||
var currentWord = '';
|
||
var currentWordWidth = 0;
|
||
var accumWidth = 0;
|
||
for (var i = 0; i < text.length; i++) {
|
||
var ch = text.charAt(i);
|
||
if (ch === '\n') {
|
||
if (currentWord) {
|
||
line += currentWord;
|
||
accumWidth += currentWordWidth;
|
||
}
|
||
lines.push(line);
|
||
linesWidths.push(accumWidth);
|
||
line = '';
|
||
currentWord = '';
|
||
currentWordWidth = 0;
|
||
accumWidth = 0;
|
||
continue;
|
||
}
|
||
var chWidth = getWidth(ch, font);
|
||
var inWord = isBreakAll ? false : !isWordBreakChar(ch);
|
||
if (!lines.length
|
||
? lastAccumWidth + accumWidth + chWidth > lineWidth
|
||
: accumWidth + chWidth > lineWidth) {
|
||
if (!accumWidth) {
|
||
if (inWord) {
|
||
lines.push(currentWord);
|
||
linesWidths.push(currentWordWidth);
|
||
currentWord = ch;
|
||
currentWordWidth = chWidth;
|
||
}
|
||
else {
|
||
lines.push(ch);
|
||
linesWidths.push(chWidth);
|
||
}
|
||
}
|
||
else if (line || currentWord) {
|
||
if (inWord) {
|
||
if (!line) {
|
||
line = currentWord;
|
||
currentWord = '';
|
||
currentWordWidth = 0;
|
||
accumWidth = currentWordWidth;
|
||
}
|
||
lines.push(line);
|
||
linesWidths.push(accumWidth - currentWordWidth);
|
||
currentWord += ch;
|
||
currentWordWidth += chWidth;
|
||
line = '';
|
||
accumWidth = currentWordWidth;
|
||
}
|
||
else {
|
||
if (currentWord) {
|
||
line += currentWord;
|
||
currentWord = '';
|
||
currentWordWidth = 0;
|
||
}
|
||
lines.push(line);
|
||
linesWidths.push(accumWidth);
|
||
line = ch;
|
||
accumWidth = chWidth;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
accumWidth += chWidth;
|
||
if (inWord) {
|
||
currentWord += ch;
|
||
currentWordWidth += chWidth;
|
||
}
|
||
else {
|
||
if (currentWord) {
|
||
line += currentWord;
|
||
currentWord = '';
|
||
currentWordWidth = 0;
|
||
}
|
||
line += ch;
|
||
}
|
||
}
|
||
if (!lines.length && !line) {
|
||
line = text;
|
||
currentWord = '';
|
||
currentWordWidth = 0;
|
||
}
|
||
if (currentWord) {
|
||
line += currentWord;
|
||
}
|
||
if (line) {
|
||
lines.push(line);
|
||
linesWidths.push(accumWidth);
|
||
}
|
||
if (lines.length === 1) {
|
||
accumWidth += lastAccumWidth;
|
||
}
|
||
return {
|
||
accumWidth: accumWidth,
|
||
lines: lines,
|
||
linesWidths: linesWidths
|
||
};
|
||
}
|
||
|
||
var STYLE_MAGIC_KEY = '__zr_style_' + Math.round((Math.random() * 10));
|
||
var DEFAULT_COMMON_STYLE = {
|
||
shadowBlur: 0,
|
||
shadowOffsetX: 0,
|
||
shadowOffsetY: 0,
|
||
shadowColor: '#000',
|
||
opacity: 1,
|
||
blend: 'source-over'
|
||
};
|
||
var DEFAULT_COMMON_ANIMATION_PROPS = {
|
||
style: {
|
||
shadowBlur: true,
|
||
shadowOffsetX: true,
|
||
shadowOffsetY: true,
|
||
shadowColor: true,
|
||
opacity: true
|
||
}
|
||
};
|
||
DEFAULT_COMMON_STYLE[STYLE_MAGIC_KEY] = true;
|
||
var PRIMARY_STATES_KEYS$1 = ['z', 'z2', 'invisible'];
|
||
var PRIMARY_STATES_KEYS_IN_HOVER_LAYER = ['invisible'];
|
||
var Displayable = (function (_super) {
|
||
__extends(Displayable, _super);
|
||
function Displayable(props) {
|
||
return _super.call(this, props) || this;
|
||
}
|
||
Displayable.prototype._init = function (props) {
|
||
var keysArr = keys(props);
|
||
for (var i = 0; i < keysArr.length; i++) {
|
||
var key = keysArr[i];
|
||
if (key === 'style') {
|
||
this.useStyle(props[key]);
|
||
}
|
||
else {
|
||
_super.prototype.attrKV.call(this, key, props[key]);
|
||
}
|
||
}
|
||
if (!this.style) {
|
||
this.useStyle({});
|
||
}
|
||
};
|
||
Displayable.prototype.beforeBrush = function () { };
|
||
Displayable.prototype.afterBrush = function () { };
|
||
Displayable.prototype.innerBeforeBrush = function () { };
|
||
Displayable.prototype.innerAfterBrush = function () { };
|
||
Displayable.prototype.shouldBePainted = function (viewWidth, viewHeight, considerClipPath, considerAncestors) {
|
||
var m = this.transform;
|
||
if (this.ignore
|
||
|| this.invisible
|
||
|| this.style.opacity === 0
|
||
|| (this.culling
|
||
&& isDisplayableCulled(this, viewWidth, viewHeight))
|
||
|| (m && !m[0] && !m[3])) {
|
||
return false;
|
||
}
|
||
if (considerClipPath && this.__clipPaths) {
|
||
for (var i = 0; i < this.__clipPaths.length; ++i) {
|
||
if (this.__clipPaths[i].isZeroArea()) {
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
if (considerAncestors && this.parent) {
|
||
var parent_1 = this.parent;
|
||
while (parent_1) {
|
||
if (parent_1.ignore) {
|
||
return false;
|
||
}
|
||
parent_1 = parent_1.parent;
|
||
}
|
||
}
|
||
return true;
|
||
};
|
||
Displayable.prototype.contain = function (x, y) {
|
||
return this.rectContain(x, y);
|
||
};
|
||
Displayable.prototype.traverse = function (cb, context) {
|
||
cb.call(context, this);
|
||
};
|
||
Displayable.prototype.rectContain = function (x, y) {
|
||
var coord = this.transformCoordToLocal(x, y);
|
||
var rect = this.getBoundingRect();
|
||
return rect.contain(coord[0], coord[1]);
|
||
};
|
||
Displayable.prototype.getPaintRect = function () {
|
||
var rect = this._paintRect;
|
||
if (!this._paintRect || this.__dirty) {
|
||
var transform = this.transform;
|
||
var elRect = this.getBoundingRect();
|
||
var style = this.style;
|
||
var shadowSize = style.shadowBlur || 0;
|
||
var shadowOffsetX = style.shadowOffsetX || 0;
|
||
var shadowOffsetY = style.shadowOffsetY || 0;
|
||
rect = this._paintRect || (this._paintRect = new BoundingRect(0, 0, 0, 0));
|
||
if (transform) {
|
||
BoundingRect.applyTransform(rect, elRect, transform);
|
||
}
|
||
else {
|
||
rect.copy(elRect);
|
||
}
|
||
if (shadowSize || shadowOffsetX || shadowOffsetY) {
|
||
rect.width += shadowSize * 2 + Math.abs(shadowOffsetX);
|
||
rect.height += shadowSize * 2 + Math.abs(shadowOffsetY);
|
||
rect.x = Math.min(rect.x, rect.x + shadowOffsetX - shadowSize);
|
||
rect.y = Math.min(rect.y, rect.y + shadowOffsetY - shadowSize);
|
||
}
|
||
var tolerance = this.dirtyRectTolerance;
|
||
if (!rect.isZero()) {
|
||
rect.x = Math.floor(rect.x - tolerance);
|
||
rect.y = Math.floor(rect.y - tolerance);
|
||
rect.width = Math.ceil(rect.width + 1 + tolerance * 2);
|
||
rect.height = Math.ceil(rect.height + 1 + tolerance * 2);
|
||
}
|
||
}
|
||
return rect;
|
||
};
|
||
Displayable.prototype.setPrevPaintRect = function (paintRect) {
|
||
if (paintRect) {
|
||
this._prevPaintRect = this._prevPaintRect || new BoundingRect(0, 0, 0, 0);
|
||
this._prevPaintRect.copy(paintRect);
|
||
}
|
||
else {
|
||
this._prevPaintRect = null;
|
||
}
|
||
};
|
||
Displayable.prototype.getPrevPaintRect = function () {
|
||
return this._prevPaintRect;
|
||
};
|
||
Displayable.prototype.animateStyle = function (loop) {
|
||
return this.animate('style', loop);
|
||
};
|
||
Displayable.prototype.updateDuringAnimation = function (targetKey) {
|
||
if (targetKey === 'style') {
|
||
this.dirtyStyle();
|
||
}
|
||
else {
|
||
this.markRedraw();
|
||
}
|
||
};
|
||
Displayable.prototype.attrKV = function (key, value) {
|
||
if (key !== 'style') {
|
||
_super.prototype.attrKV.call(this, key, value);
|
||
}
|
||
else {
|
||
if (!this.style) {
|
||
this.useStyle(value);
|
||
}
|
||
else {
|
||
this.setStyle(value);
|
||
}
|
||
}
|
||
};
|
||
Displayable.prototype.setStyle = function (keyOrObj, value) {
|
||
if (typeof keyOrObj === 'string') {
|
||
this.style[keyOrObj] = value;
|
||
}
|
||
else {
|
||
extend(this.style, keyOrObj);
|
||
}
|
||
this.dirtyStyle();
|
||
return this;
|
||
};
|
||
Displayable.prototype.dirtyStyle = function (notRedraw) {
|
||
if (!notRedraw) {
|
||
this.markRedraw();
|
||
}
|
||
this.__dirty |= STYLE_CHANGED_BIT;
|
||
if (this._rect) {
|
||
this._rect = null;
|
||
}
|
||
};
|
||
Displayable.prototype.dirty = function () {
|
||
this.dirtyStyle();
|
||
};
|
||
Displayable.prototype.styleChanged = function () {
|
||
return !!(this.__dirty & STYLE_CHANGED_BIT);
|
||
};
|
||
Displayable.prototype.styleUpdated = function () {
|
||
this.__dirty &= ~STYLE_CHANGED_BIT;
|
||
};
|
||
Displayable.prototype.createStyle = function (obj) {
|
||
return createObject(DEFAULT_COMMON_STYLE, obj);
|
||
};
|
||
Displayable.prototype.useStyle = function (obj) {
|
||
if (!obj[STYLE_MAGIC_KEY]) {
|
||
obj = this.createStyle(obj);
|
||
}
|
||
if (this.__inHover) {
|
||
this.__hoverStyle = obj;
|
||
}
|
||
else {
|
||
this.style = obj;
|
||
}
|
||
this.dirtyStyle();
|
||
};
|
||
Displayable.prototype.isStyleObject = function (obj) {
|
||
return obj[STYLE_MAGIC_KEY];
|
||
};
|
||
Displayable.prototype._innerSaveToNormal = function (toState) {
|
||
_super.prototype._innerSaveToNormal.call(this, toState);
|
||
var normalState = this._normalState;
|
||
if (toState.style && !normalState.style) {
|
||
normalState.style = this._mergeStyle(this.createStyle(), this.style);
|
||
}
|
||
this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS$1);
|
||
};
|
||
Displayable.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
|
||
_super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg);
|
||
var needsRestoreToNormal = !(state && keepCurrentStates);
|
||
var targetStyle;
|
||
if (state && state.style) {
|
||
if (transition) {
|
||
if (keepCurrentStates) {
|
||
targetStyle = state.style;
|
||
}
|
||
else {
|
||
targetStyle = this._mergeStyle(this.createStyle(), normalState.style);
|
||
this._mergeStyle(targetStyle, state.style);
|
||
}
|
||
}
|
||
else {
|
||
targetStyle = this._mergeStyle(this.createStyle(), keepCurrentStates ? this.style : normalState.style);
|
||
this._mergeStyle(targetStyle, state.style);
|
||
}
|
||
}
|
||
else if (needsRestoreToNormal) {
|
||
targetStyle = normalState.style;
|
||
}
|
||
if (targetStyle) {
|
||
if (transition) {
|
||
var sourceStyle = this.style;
|
||
this.style = this.createStyle(needsRestoreToNormal ? {} : sourceStyle);
|
||
if (needsRestoreToNormal) {
|
||
var changedKeys = keys(sourceStyle);
|
||
for (var i = 0; i < changedKeys.length; i++) {
|
||
var key = changedKeys[i];
|
||
if (key in targetStyle) {
|
||
targetStyle[key] = targetStyle[key];
|
||
this.style[key] = sourceStyle[key];
|
||
}
|
||
}
|
||
}
|
||
var targetKeys = keys(targetStyle);
|
||
for (var i = 0; i < targetKeys.length; i++) {
|
||
var key = targetKeys[i];
|
||
this.style[key] = this.style[key];
|
||
}
|
||
this._transitionState(stateName, {
|
||
style: targetStyle
|
||
}, animationCfg, this.getAnimationStyleProps());
|
||
}
|
||
else {
|
||
this.useStyle(targetStyle);
|
||
}
|
||
}
|
||
var statesKeys = this.__inHover ? PRIMARY_STATES_KEYS_IN_HOVER_LAYER : PRIMARY_STATES_KEYS$1;
|
||
for (var i = 0; i < statesKeys.length; i++) {
|
||
var key = statesKeys[i];
|
||
if (state && state[key] != null) {
|
||
this[key] = state[key];
|
||
}
|
||
else if (needsRestoreToNormal) {
|
||
if (normalState[key] != null) {
|
||
this[key] = normalState[key];
|
||
}
|
||
}
|
||
}
|
||
};
|
||
Displayable.prototype._mergeStates = function (states) {
|
||
var mergedState = _super.prototype._mergeStates.call(this, states);
|
||
var mergedStyle;
|
||
for (var i = 0; i < states.length; i++) {
|
||
var state = states[i];
|
||
if (state.style) {
|
||
mergedStyle = mergedStyle || {};
|
||
this._mergeStyle(mergedStyle, state.style);
|
||
}
|
||
}
|
||
if (mergedStyle) {
|
||
mergedState.style = mergedStyle;
|
||
}
|
||
return mergedState;
|
||
};
|
||
Displayable.prototype._mergeStyle = function (targetStyle, sourceStyle) {
|
||
extend(targetStyle, sourceStyle);
|
||
return targetStyle;
|
||
};
|
||
Displayable.prototype.getAnimationStyleProps = function () {
|
||
return DEFAULT_COMMON_ANIMATION_PROPS;
|
||
};
|
||
Displayable.initDefaultProps = (function () {
|
||
var dispProto = Displayable.prototype;
|
||
dispProto.type = 'displayable';
|
||
dispProto.invisible = false;
|
||
dispProto.z = 0;
|
||
dispProto.z2 = 0;
|
||
dispProto.zlevel = 0;
|
||
dispProto.culling = false;
|
||
dispProto.cursor = 'pointer';
|
||
dispProto.rectHover = false;
|
||
dispProto.incremental = false;
|
||
dispProto._rect = null;
|
||
dispProto.dirtyRectTolerance = 0;
|
||
dispProto.__dirty = REDRAW_BIT | STYLE_CHANGED_BIT;
|
||
})();
|
||
return Displayable;
|
||
}(Element));
|
||
var tmpRect = new BoundingRect(0, 0, 0, 0);
|
||
var viewRect = new BoundingRect(0, 0, 0, 0);
|
||
function isDisplayableCulled(el, width, height) {
|
||
tmpRect.copy(el.getBoundingRect());
|
||
if (el.transform) {
|
||
tmpRect.applyTransform(el.transform);
|
||
}
|
||
viewRect.width = width;
|
||
viewRect.height = height;
|
||
return !tmpRect.intersect(viewRect);
|
||
}
|
||
|
||
var mathMin$1 = Math.min;
|
||
var mathMax$1 = Math.max;
|
||
var mathSin = Math.sin;
|
||
var mathCos = Math.cos;
|
||
var PI2 = Math.PI * 2;
|
||
var start = create();
|
||
var end = create();
|
||
var extremity = create();
|
||
function fromPoints(points, min, max) {
|
||
if (points.length === 0) {
|
||
return;
|
||
}
|
||
var p = points[0];
|
||
var left = p[0];
|
||
var right = p[0];
|
||
var top = p[1];
|
||
var bottom = p[1];
|
||
for (var i = 1; i < points.length; i++) {
|
||
p = points[i];
|
||
left = mathMin$1(left, p[0]);
|
||
right = mathMax$1(right, p[0]);
|
||
top = mathMin$1(top, p[1]);
|
||
bottom = mathMax$1(bottom, p[1]);
|
||
}
|
||
min[0] = left;
|
||
min[1] = top;
|
||
max[0] = right;
|
||
max[1] = bottom;
|
||
}
|
||
function fromLine(x0, y0, x1, y1, min, max) {
|
||
min[0] = mathMin$1(x0, x1);
|
||
min[1] = mathMin$1(y0, y1);
|
||
max[0] = mathMax$1(x0, x1);
|
||
max[1] = mathMax$1(y0, y1);
|
||
}
|
||
var xDim = [];
|
||
var yDim = [];
|
||
function fromCubic(x0, y0, x1, y1, x2, y2, x3, y3, min, max) {
|
||
var cubicExtrema$1 = cubicExtrema;
|
||
var cubicAt$1 = cubicAt;
|
||
var n = cubicExtrema$1(x0, x1, x2, x3, xDim);
|
||
min[0] = Infinity;
|
||
min[1] = Infinity;
|
||
max[0] = -Infinity;
|
||
max[1] = -Infinity;
|
||
for (var i = 0; i < n; i++) {
|
||
var x = cubicAt$1(x0, x1, x2, x3, xDim[i]);
|
||
min[0] = mathMin$1(x, min[0]);
|
||
max[0] = mathMax$1(x, max[0]);
|
||
}
|
||
n = cubicExtrema$1(y0, y1, y2, y3, yDim);
|
||
for (var i = 0; i < n; i++) {
|
||
var y = cubicAt$1(y0, y1, y2, y3, yDim[i]);
|
||
min[1] = mathMin$1(y, min[1]);
|
||
max[1] = mathMax$1(y, max[1]);
|
||
}
|
||
min[0] = mathMin$1(x0, min[0]);
|
||
max[0] = mathMax$1(x0, max[0]);
|
||
min[0] = mathMin$1(x3, min[0]);
|
||
max[0] = mathMax$1(x3, max[0]);
|
||
min[1] = mathMin$1(y0, min[1]);
|
||
max[1] = mathMax$1(y0, max[1]);
|
||
min[1] = mathMin$1(y3, min[1]);
|
||
max[1] = mathMax$1(y3, max[1]);
|
||
}
|
||
function fromQuadratic(x0, y0, x1, y1, x2, y2, min, max) {
|
||
var quadraticExtremum$1 = quadraticExtremum;
|
||
var quadraticAt$1 = quadraticAt;
|
||
var tx = mathMax$1(mathMin$1(quadraticExtremum$1(x0, x1, x2), 1), 0);
|
||
var ty = mathMax$1(mathMin$1(quadraticExtremum$1(y0, y1, y2), 1), 0);
|
||
var x = quadraticAt$1(x0, x1, x2, tx);
|
||
var y = quadraticAt$1(y0, y1, y2, ty);
|
||
min[0] = mathMin$1(x0, x2, x);
|
||
min[1] = mathMin$1(y0, y2, y);
|
||
max[0] = mathMax$1(x0, x2, x);
|
||
max[1] = mathMax$1(y0, y2, y);
|
||
}
|
||
function fromArc(x, y, rx, ry, startAngle, endAngle, anticlockwise, min$1, max$1) {
|
||
var vec2Min = min;
|
||
var vec2Max = max;
|
||
var diff = Math.abs(startAngle - endAngle);
|
||
if (diff % PI2 < 1e-4 && diff > 1e-4) {
|
||
min$1[0] = x - rx;
|
||
min$1[1] = y - ry;
|
||
max$1[0] = x + rx;
|
||
max$1[1] = y + ry;
|
||
return;
|
||
}
|
||
start[0] = mathCos(startAngle) * rx + x;
|
||
start[1] = mathSin(startAngle) * ry + y;
|
||
end[0] = mathCos(endAngle) * rx + x;
|
||
end[1] = mathSin(endAngle) * ry + y;
|
||
vec2Min(min$1, start, end);
|
||
vec2Max(max$1, start, end);
|
||
startAngle = startAngle % (PI2);
|
||
if (startAngle < 0) {
|
||
startAngle = startAngle + PI2;
|
||
}
|
||
endAngle = endAngle % (PI2);
|
||
if (endAngle < 0) {
|
||
endAngle = endAngle + PI2;
|
||
}
|
||
if (startAngle > endAngle && !anticlockwise) {
|
||
endAngle += PI2;
|
||
}
|
||
else if (startAngle < endAngle && anticlockwise) {
|
||
startAngle += PI2;
|
||
}
|
||
if (anticlockwise) {
|
||
var tmp = endAngle;
|
||
endAngle = startAngle;
|
||
startAngle = tmp;
|
||
}
|
||
for (var angle = 0; angle < endAngle; angle += Math.PI / 2) {
|
||
if (angle > startAngle) {
|
||
extremity[0] = mathCos(angle) * rx + x;
|
||
extremity[1] = mathSin(angle) * ry + y;
|
||
vec2Min(min$1, extremity, min$1);
|
||
vec2Max(max$1, extremity, max$1);
|
||
}
|
||
}
|
||
}
|
||
|
||
var CMD = {
|
||
M: 1,
|
||
L: 2,
|
||
C: 3,
|
||
Q: 4,
|
||
A: 5,
|
||
Z: 6,
|
||
R: 7
|
||
};
|
||
var tmpOutX = [];
|
||
var tmpOutY = [];
|
||
var min$1 = [];
|
||
var max$1 = [];
|
||
var min2 = [];
|
||
var max2 = [];
|
||
var mathMin$2 = Math.min;
|
||
var mathMax$2 = Math.max;
|
||
var mathCos$1 = Math.cos;
|
||
var mathSin$1 = Math.sin;
|
||
var mathAbs = Math.abs;
|
||
var PI = Math.PI;
|
||
var PI2$1 = PI * 2;
|
||
var hasTypedArray = typeof Float32Array !== 'undefined';
|
||
var tmpAngles = [];
|
||
function modPI2(radian) {
|
||
var n = Math.round(radian / PI * 1e8) / 1e8;
|
||
return (n % 2) * PI;
|
||
}
|
||
function normalizeArcAngles(angles, anticlockwise) {
|
||
var newStartAngle = modPI2(angles[0]);
|
||
if (newStartAngle < 0) {
|
||
newStartAngle += PI2$1;
|
||
}
|
||
var delta = newStartAngle - angles[0];
|
||
var newEndAngle = angles[1];
|
||
newEndAngle += delta;
|
||
if (!anticlockwise && newEndAngle - newStartAngle >= PI2$1) {
|
||
newEndAngle = newStartAngle + PI2$1;
|
||
}
|
||
else if (anticlockwise && newStartAngle - newEndAngle >= PI2$1) {
|
||
newEndAngle = newStartAngle - PI2$1;
|
||
}
|
||
else if (!anticlockwise && newStartAngle > newEndAngle) {
|
||
newEndAngle = newStartAngle + (PI2$1 - modPI2(newStartAngle - newEndAngle));
|
||
}
|
||
else if (anticlockwise && newStartAngle < newEndAngle) {
|
||
newEndAngle = newStartAngle - (PI2$1 - modPI2(newEndAngle - newStartAngle));
|
||
}
|
||
angles[0] = newStartAngle;
|
||
angles[1] = newEndAngle;
|
||
}
|
||
var PathProxy = (function () {
|
||
function PathProxy(notSaveData) {
|
||
this.dpr = 1;
|
||
this._xi = 0;
|
||
this._yi = 0;
|
||
this._x0 = 0;
|
||
this._y0 = 0;
|
||
this._len = 0;
|
||
if (notSaveData) {
|
||
this._saveData = false;
|
||
}
|
||
if (this._saveData) {
|
||
this.data = [];
|
||
}
|
||
}
|
||
PathProxy.prototype.increaseVersion = function () {
|
||
this._version++;
|
||
};
|
||
PathProxy.prototype.getVersion = function () {
|
||
return this._version;
|
||
};
|
||
PathProxy.prototype.setScale = function (sx, sy, segmentIgnoreThreshold) {
|
||
segmentIgnoreThreshold = segmentIgnoreThreshold || 0;
|
||
if (segmentIgnoreThreshold > 0) {
|
||
this._ux = mathAbs(segmentIgnoreThreshold / devicePixelRatio / sx) || 0;
|
||
this._uy = mathAbs(segmentIgnoreThreshold / devicePixelRatio / sy) || 0;
|
||
}
|
||
};
|
||
PathProxy.prototype.setDPR = function (dpr) {
|
||
this.dpr = dpr;
|
||
};
|
||
PathProxy.prototype.setContext = function (ctx) {
|
||
this._ctx = ctx;
|
||
};
|
||
PathProxy.prototype.getContext = function () {
|
||
return this._ctx;
|
||
};
|
||
PathProxy.prototype.beginPath = function () {
|
||
this._ctx && this._ctx.beginPath();
|
||
this.reset();
|
||
return this;
|
||
};
|
||
PathProxy.prototype.reset = function () {
|
||
if (this._saveData) {
|
||
this._len = 0;
|
||
}
|
||
if (this._pathSegLen) {
|
||
this._pathSegLen = null;
|
||
this._pathLen = 0;
|
||
}
|
||
this._version++;
|
||
};
|
||
PathProxy.prototype.moveTo = function (x, y) {
|
||
this._drawPendingPt();
|
||
this.addData(CMD.M, x, y);
|
||
this._ctx && this._ctx.moveTo(x, y);
|
||
this._x0 = x;
|
||
this._y0 = y;
|
||
this._xi = x;
|
||
this._yi = y;
|
||
return this;
|
||
};
|
||
PathProxy.prototype.lineTo = function (x, y) {
|
||
var dx = mathAbs(x - this._xi);
|
||
var dy = mathAbs(y - this._yi);
|
||
var exceedUnit = dx > this._ux || dy > this._uy;
|
||
this.addData(CMD.L, x, y);
|
||
if (this._ctx && exceedUnit) {
|
||
this._ctx.lineTo(x, y);
|
||
}
|
||
if (exceedUnit) {
|
||
this._xi = x;
|
||
this._yi = y;
|
||
this._pendingPtDist = 0;
|
||
}
|
||
else {
|
||
var d2 = dx * dx + dy * dy;
|
||
if (d2 > this._pendingPtDist) {
|
||
this._pendingPtX = x;
|
||
this._pendingPtY = y;
|
||
this._pendingPtDist = d2;
|
||
}
|
||
}
|
||
return this;
|
||
};
|
||
PathProxy.prototype.bezierCurveTo = function (x1, y1, x2, y2, x3, y3) {
|
||
this._drawPendingPt();
|
||
this.addData(CMD.C, x1, y1, x2, y2, x3, y3);
|
||
if (this._ctx) {
|
||
this._ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);
|
||
}
|
||
this._xi = x3;
|
||
this._yi = y3;
|
||
return this;
|
||
};
|
||
PathProxy.prototype.quadraticCurveTo = function (x1, y1, x2, y2) {
|
||
this._drawPendingPt();
|
||
this.addData(CMD.Q, x1, y1, x2, y2);
|
||
if (this._ctx) {
|
||
this._ctx.quadraticCurveTo(x1, y1, x2, y2);
|
||
}
|
||
this._xi = x2;
|
||
this._yi = y2;
|
||
return this;
|
||
};
|
||
PathProxy.prototype.arc = function (cx, cy, r, startAngle, endAngle, anticlockwise) {
|
||
this._drawPendingPt();
|
||
tmpAngles[0] = startAngle;
|
||
tmpAngles[1] = endAngle;
|
||
normalizeArcAngles(tmpAngles, anticlockwise);
|
||
startAngle = tmpAngles[0];
|
||
endAngle = tmpAngles[1];
|
||
var delta = endAngle - startAngle;
|
||
this.addData(CMD.A, cx, cy, r, r, startAngle, delta, 0, anticlockwise ? 0 : 1);
|
||
this._ctx && this._ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);
|
||
this._xi = mathCos$1(endAngle) * r + cx;
|
||
this._yi = mathSin$1(endAngle) * r + cy;
|
||
return this;
|
||
};
|
||
PathProxy.prototype.arcTo = function (x1, y1, x2, y2, radius) {
|
||
this._drawPendingPt();
|
||
if (this._ctx) {
|
||
this._ctx.arcTo(x1, y1, x2, y2, radius);
|
||
}
|
||
return this;
|
||
};
|
||
PathProxy.prototype.rect = function (x, y, w, h) {
|
||
this._drawPendingPt();
|
||
this._ctx && this._ctx.rect(x, y, w, h);
|
||
this.addData(CMD.R, x, y, w, h);
|
||
return this;
|
||
};
|
||
PathProxy.prototype.closePath = function () {
|
||
this._drawPendingPt();
|
||
this.addData(CMD.Z);
|
||
var ctx = this._ctx;
|
||
var x0 = this._x0;
|
||
var y0 = this._y0;
|
||
if (ctx) {
|
||
ctx.closePath();
|
||
}
|
||
this._xi = x0;
|
||
this._yi = y0;
|
||
return this;
|
||
};
|
||
PathProxy.prototype.fill = function (ctx) {
|
||
ctx && ctx.fill();
|
||
this.toStatic();
|
||
};
|
||
PathProxy.prototype.stroke = function (ctx) {
|
||
ctx && ctx.stroke();
|
||
this.toStatic();
|
||
};
|
||
PathProxy.prototype.len = function () {
|
||
return this._len;
|
||
};
|
||
PathProxy.prototype.setData = function (data) {
|
||
var len = data.length;
|
||
if (!(this.data && this.data.length === len) && hasTypedArray) {
|
||
this.data = new Float32Array(len);
|
||
}
|
||
for (var i = 0; i < len; i++) {
|
||
this.data[i] = data[i];
|
||
}
|
||
this._len = len;
|
||
};
|
||
PathProxy.prototype.appendPath = function (path) {
|
||
if (!(path instanceof Array)) {
|
||
path = [path];
|
||
}
|
||
var len = path.length;
|
||
var appendSize = 0;
|
||
var offset = this._len;
|
||
for (var i = 0; i < len; i++) {
|
||
appendSize += path[i].len();
|
||
}
|
||
if (hasTypedArray && (this.data instanceof Float32Array)) {
|
||
this.data = new Float32Array(offset + appendSize);
|
||
}
|
||
for (var i = 0; i < len; i++) {
|
||
var appendPathData = path[i].data;
|
||
for (var k = 0; k < appendPathData.length; k++) {
|
||
this.data[offset++] = appendPathData[k];
|
||
}
|
||
}
|
||
this._len = offset;
|
||
};
|
||
PathProxy.prototype.addData = function (cmd, a, b, c, d, e, f, g, h) {
|
||
if (!this._saveData) {
|
||
return;
|
||
}
|
||
var data = this.data;
|
||
if (this._len + arguments.length > data.length) {
|
||
this._expandData();
|
||
data = this.data;
|
||
}
|
||
for (var i = 0; i < arguments.length; i++) {
|
||
data[this._len++] = arguments[i];
|
||
}
|
||
};
|
||
PathProxy.prototype._drawPendingPt = function () {
|
||
if (this._pendingPtDist > 0) {
|
||
this._ctx && this._ctx.lineTo(this._pendingPtX, this._pendingPtY);
|
||
this._pendingPtDist = 0;
|
||
}
|
||
};
|
||
PathProxy.prototype._expandData = function () {
|
||
if (!(this.data instanceof Array)) {
|
||
var newData = [];
|
||
for (var i = 0; i < this._len; i++) {
|
||
newData[i] = this.data[i];
|
||
}
|
||
this.data = newData;
|
||
}
|
||
};
|
||
PathProxy.prototype.toStatic = function () {
|
||
if (!this._saveData) {
|
||
return;
|
||
}
|
||
this._drawPendingPt();
|
||
var data = this.data;
|
||
if (data instanceof Array) {
|
||
data.length = this._len;
|
||
if (hasTypedArray && this._len > 11) {
|
||
this.data = new Float32Array(data);
|
||
}
|
||
}
|
||
};
|
||
PathProxy.prototype.getBoundingRect = function () {
|
||
min$1[0] = min$1[1] = min2[0] = min2[1] = Number.MAX_VALUE;
|
||
max$1[0] = max$1[1] = max2[0] = max2[1] = -Number.MAX_VALUE;
|
||
var data = this.data;
|
||
var xi = 0;
|
||
var yi = 0;
|
||
var x0 = 0;
|
||
var y0 = 0;
|
||
var i;
|
||
for (i = 0; i < this._len;) {
|
||
var cmd = data[i++];
|
||
var isFirst = i === 1;
|
||
if (isFirst) {
|
||
xi = data[i];
|
||
yi = data[i + 1];
|
||
x0 = xi;
|
||
y0 = yi;
|
||
}
|
||
switch (cmd) {
|
||
case CMD.M:
|
||
xi = x0 = data[i++];
|
||
yi = y0 = data[i++];
|
||
min2[0] = x0;
|
||
min2[1] = y0;
|
||
max2[0] = x0;
|
||
max2[1] = y0;
|
||
break;
|
||
case CMD.L:
|
||
fromLine(xi, yi, data[i], data[i + 1], min2, max2);
|
||
xi = data[i++];
|
||
yi = data[i++];
|
||
break;
|
||
case CMD.C:
|
||
fromCubic(xi, yi, data[i++], data[i++], data[i++], data[i++], data[i], data[i + 1], min2, max2);
|
||
xi = data[i++];
|
||
yi = data[i++];
|
||
break;
|
||
case CMD.Q:
|
||
fromQuadratic(xi, yi, data[i++], data[i++], data[i], data[i + 1], min2, max2);
|
||
xi = data[i++];
|
||
yi = data[i++];
|
||
break;
|
||
case CMD.A:
|
||
var cx = data[i++];
|
||
var cy = data[i++];
|
||
var rx = data[i++];
|
||
var ry = data[i++];
|
||
var startAngle = data[i++];
|
||
var endAngle = data[i++] + startAngle;
|
||
i += 1;
|
||
var anticlockwise = !data[i++];
|
||
if (isFirst) {
|
||
x0 = mathCos$1(startAngle) * rx + cx;
|
||
y0 = mathSin$1(startAngle) * ry + cy;
|
||
}
|
||
fromArc(cx, cy, rx, ry, startAngle, endAngle, anticlockwise, min2, max2);
|
||
xi = mathCos$1(endAngle) * rx + cx;
|
||
yi = mathSin$1(endAngle) * ry + cy;
|
||
break;
|
||
case CMD.R:
|
||
x0 = xi = data[i++];
|
||
y0 = yi = data[i++];
|
||
var width = data[i++];
|
||
var height = data[i++];
|
||
fromLine(x0, y0, x0 + width, y0 + height, min2, max2);
|
||
break;
|
||
case CMD.Z:
|
||
xi = x0;
|
||
yi = y0;
|
||
break;
|
||
}
|
||
min(min$1, min$1, min2);
|
||
max(max$1, max$1, max2);
|
||
}
|
||
if (i === 0) {
|
||
min$1[0] = min$1[1] = max$1[0] = max$1[1] = 0;
|
||
}
|
||
return new BoundingRect(min$1[0], min$1[1], max$1[0] - min$1[0], max$1[1] - min$1[1]);
|
||
};
|
||
PathProxy.prototype._calculateLength = function () {
|
||
var data = this.data;
|
||
var len = this._len;
|
||
var ux = this._ux;
|
||
var uy = this._uy;
|
||
var xi = 0;
|
||
var yi = 0;
|
||
var x0 = 0;
|
||
var y0 = 0;
|
||
if (!this._pathSegLen) {
|
||
this._pathSegLen = [];
|
||
}
|
||
var pathSegLen = this._pathSegLen;
|
||
var pathTotalLen = 0;
|
||
var segCount = 0;
|
||
for (var i = 0; i < len;) {
|
||
var cmd = data[i++];
|
||
var isFirst = i === 1;
|
||
if (isFirst) {
|
||
xi = data[i];
|
||
yi = data[i + 1];
|
||
x0 = xi;
|
||
y0 = yi;
|
||
}
|
||
var l = -1;
|
||
switch (cmd) {
|
||
case CMD.M:
|
||
xi = x0 = data[i++];
|
||
yi = y0 = data[i++];
|
||
break;
|
||
case CMD.L: {
|
||
var x2 = data[i++];
|
||
var y2 = data[i++];
|
||
var dx = x2 - xi;
|
||
var dy = y2 - yi;
|
||
if (mathAbs(dx) > ux || mathAbs(dy) > uy || i === len - 1) {
|
||
l = Math.sqrt(dx * dx + dy * dy);
|
||
xi = x2;
|
||
yi = y2;
|
||
}
|
||
break;
|
||
}
|
||
case CMD.C: {
|
||
var x1 = data[i++];
|
||
var y1 = data[i++];
|
||
var x2 = data[i++];
|
||
var y2 = data[i++];
|
||
var x3 = data[i++];
|
||
var y3 = data[i++];
|
||
l = cubicLength(xi, yi, x1, y1, x2, y2, x3, y3, 10);
|
||
xi = x3;
|
||
yi = y3;
|
||
break;
|
||
}
|
||
case CMD.Q: {
|
||
var x1 = data[i++];
|
||
var y1 = data[i++];
|
||
var x2 = data[i++];
|
||
var y2 = data[i++];
|
||
l = quadraticLength(xi, yi, x1, y1, x2, y2, 10);
|
||
xi = x2;
|
||
yi = y2;
|
||
break;
|
||
}
|
||
case CMD.A:
|
||
var cx = data[i++];
|
||
var cy = data[i++];
|
||
var rx = data[i++];
|
||
var ry = data[i++];
|
||
var startAngle = data[i++];
|
||
var delta = data[i++];
|
||
var endAngle = delta + startAngle;
|
||
i += 1;
|
||
var anticlockwise = !data[i++];
|
||
if (isFirst) {
|
||
x0 = mathCos$1(startAngle) * rx + cx;
|
||
y0 = mathSin$1(startAngle) * ry + cy;
|
||
}
|
||
l = mathMax$2(rx, ry) * mathMin$2(PI2$1, Math.abs(delta));
|
||
xi = mathCos$1(endAngle) * rx + cx;
|
||
yi = mathSin$1(endAngle) * ry + cy;
|
||
break;
|
||
case CMD.R: {
|
||
x0 = xi = data[i++];
|
||
y0 = yi = data[i++];
|
||
var width = data[i++];
|
||
var height = data[i++];
|
||
l = width * 2 + height * 2;
|
||
break;
|
||
}
|
||
case CMD.Z: {
|
||
var dx = x0 - xi;
|
||
var dy = y0 - yi;
|
||
l = Math.sqrt(dx * dx + dy * dy);
|
||
xi = x0;
|
||
yi = y0;
|
||
break;
|
||
}
|
||
}
|
||
if (l >= 0) {
|
||
pathSegLen[segCount++] = l;
|
||
pathTotalLen += l;
|
||
}
|
||
}
|
||
this._pathLen = pathTotalLen;
|
||
return pathTotalLen;
|
||
};
|
||
PathProxy.prototype.rebuildPath = function (ctx, percent) {
|
||
var d = this.data;
|
||
var ux = this._ux;
|
||
var uy = this._uy;
|
||
var len = this._len;
|
||
var x0;
|
||
var y0;
|
||
var xi;
|
||
var yi;
|
||
var x;
|
||
var y;
|
||
var drawPart = percent < 1;
|
||
var pathSegLen;
|
||
var pathTotalLen;
|
||
var accumLength = 0;
|
||
var segCount = 0;
|
||
var displayedLength;
|
||
var pendingPtDist = 0;
|
||
var pendingPtX;
|
||
var pendingPtY;
|
||
if (drawPart) {
|
||
if (!this._pathSegLen) {
|
||
this._calculateLength();
|
||
}
|
||
pathSegLen = this._pathSegLen;
|
||
pathTotalLen = this._pathLen;
|
||
displayedLength = percent * pathTotalLen;
|
||
if (!displayedLength) {
|
||
return;
|
||
}
|
||
}
|
||
lo: for (var i = 0; i < len;) {
|
||
var cmd = d[i++];
|
||
var isFirst = i === 1;
|
||
if (isFirst) {
|
||
xi = d[i];
|
||
yi = d[i + 1];
|
||
x0 = xi;
|
||
y0 = yi;
|
||
}
|
||
if (cmd !== CMD.L && pendingPtDist > 0) {
|
||
ctx.lineTo(pendingPtX, pendingPtY);
|
||
pendingPtDist = 0;
|
||
}
|
||
switch (cmd) {
|
||
case CMD.M:
|
||
x0 = xi = d[i++];
|
||
y0 = yi = d[i++];
|
||
ctx.moveTo(xi, yi);
|
||
break;
|
||
case CMD.L: {
|
||
x = d[i++];
|
||
y = d[i++];
|
||
var dx = mathAbs(x - xi);
|
||
var dy = mathAbs(y - yi);
|
||
if (dx > ux || dy > uy) {
|
||
if (drawPart) {
|
||
var l = pathSegLen[segCount++];
|
||
if (accumLength + l > displayedLength) {
|
||
var t = (displayedLength - accumLength) / l;
|
||
ctx.lineTo(xi * (1 - t) + x * t, yi * (1 - t) + y * t);
|
||
break lo;
|
||
}
|
||
accumLength += l;
|
||
}
|
||
ctx.lineTo(x, y);
|
||
xi = x;
|
||
yi = y;
|
||
pendingPtDist = 0;
|
||
}
|
||
else {
|
||
var d2 = dx * dx + dy * dy;
|
||
if (d2 > pendingPtDist) {
|
||
pendingPtX = x;
|
||
pendingPtY = y;
|
||
pendingPtDist = d2;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case CMD.C: {
|
||
var x1 = d[i++];
|
||
var y1 = d[i++];
|
||
var x2 = d[i++];
|
||
var y2 = d[i++];
|
||
var x3 = d[i++];
|
||
var y3 = d[i++];
|
||
if (drawPart) {
|
||
var l = pathSegLen[segCount++];
|
||
if (accumLength + l > displayedLength) {
|
||
var t = (displayedLength - accumLength) / l;
|
||
cubicSubdivide(xi, x1, x2, x3, t, tmpOutX);
|
||
cubicSubdivide(yi, y1, y2, y3, t, tmpOutY);
|
||
ctx.bezierCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2], tmpOutX[3], tmpOutY[3]);
|
||
break lo;
|
||
}
|
||
accumLength += l;
|
||
}
|
||
ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);
|
||
xi = x3;
|
||
yi = y3;
|
||
break;
|
||
}
|
||
case CMD.Q: {
|
||
var x1 = d[i++];
|
||
var y1 = d[i++];
|
||
var x2 = d[i++];
|
||
var y2 = d[i++];
|
||
if (drawPart) {
|
||
var l = pathSegLen[segCount++];
|
||
if (accumLength + l > displayedLength) {
|
||
var t = (displayedLength - accumLength) / l;
|
||
quadraticSubdivide(xi, x1, x2, t, tmpOutX);
|
||
quadraticSubdivide(yi, y1, y2, t, tmpOutY);
|
||
ctx.quadraticCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2]);
|
||
break lo;
|
||
}
|
||
accumLength += l;
|
||
}
|
||
ctx.quadraticCurveTo(x1, y1, x2, y2);
|
||
xi = x2;
|
||
yi = y2;
|
||
break;
|
||
}
|
||
case CMD.A:
|
||
var cx = d[i++];
|
||
var cy = d[i++];
|
||
var rx = d[i++];
|
||
var ry = d[i++];
|
||
var startAngle = d[i++];
|
||
var delta = d[i++];
|
||
var psi = d[i++];
|
||
var anticlockwise = !d[i++];
|
||
var r = (rx > ry) ? rx : ry;
|
||
var isEllipse = mathAbs(rx - ry) > 1e-3;
|
||
var endAngle = startAngle + delta;
|
||
var breakBuild = false;
|
||
if (drawPart) {
|
||
var l = pathSegLen[segCount++];
|
||
if (accumLength + l > displayedLength) {
|
||
endAngle = startAngle + delta * (displayedLength - accumLength) / l;
|
||
breakBuild = true;
|
||
}
|
||
accumLength += l;
|
||
}
|
||
if (isEllipse && ctx.ellipse) {
|
||
ctx.ellipse(cx, cy, rx, ry, psi, startAngle, endAngle, anticlockwise);
|
||
}
|
||
else {
|
||
ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);
|
||
}
|
||
if (breakBuild) {
|
||
break lo;
|
||
}
|
||
if (isFirst) {
|
||
x0 = mathCos$1(startAngle) * rx + cx;
|
||
y0 = mathSin$1(startAngle) * ry + cy;
|
||
}
|
||
xi = mathCos$1(endAngle) * rx + cx;
|
||
yi = mathSin$1(endAngle) * ry + cy;
|
||
break;
|
||
case CMD.R:
|
||
x0 = xi = d[i];
|
||
y0 = yi = d[i + 1];
|
||
x = d[i++];
|
||
y = d[i++];
|
||
var width = d[i++];
|
||
var height = d[i++];
|
||
if (drawPart) {
|
||
var l = pathSegLen[segCount++];
|
||
if (accumLength + l > displayedLength) {
|
||
var d_1 = displayedLength - accumLength;
|
||
ctx.moveTo(x, y);
|
||
ctx.lineTo(x + mathMin$2(d_1, width), y);
|
||
d_1 -= width;
|
||
if (d_1 > 0) {
|
||
ctx.lineTo(x + width, y + mathMin$2(d_1, height));
|
||
}
|
||
d_1 -= height;
|
||
if (d_1 > 0) {
|
||
ctx.lineTo(x + mathMax$2(width - d_1, 0), y + height);
|
||
}
|
||
d_1 -= width;
|
||
if (d_1 > 0) {
|
||
ctx.lineTo(x, y + mathMax$2(height - d_1, 0));
|
||
}
|
||
break lo;
|
||
}
|
||
accumLength += l;
|
||
}
|
||
ctx.rect(x, y, width, height);
|
||
break;
|
||
case CMD.Z:
|
||
if (drawPart) {
|
||
var l = pathSegLen[segCount++];
|
||
if (accumLength + l > displayedLength) {
|
||
var t = (displayedLength - accumLength) / l;
|
||
ctx.lineTo(xi * (1 - t) + x0 * t, yi * (1 - t) + y0 * t);
|
||
break lo;
|
||
}
|
||
accumLength += l;
|
||
}
|
||
ctx.closePath();
|
||
xi = x0;
|
||
yi = y0;
|
||
}
|
||
}
|
||
};
|
||
PathProxy.prototype.clone = function () {
|
||
var newProxy = new PathProxy();
|
||
var data = this.data;
|
||
newProxy.data = data.slice ? data.slice()
|
||
: Array.prototype.slice.call(data);
|
||
newProxy._len = this._len;
|
||
return newProxy;
|
||
};
|
||
PathProxy.CMD = CMD;
|
||
PathProxy.initDefaultProps = (function () {
|
||
var proto = PathProxy.prototype;
|
||
proto._saveData = true;
|
||
proto._ux = 0;
|
||
proto._uy = 0;
|
||
proto._pendingPtDist = 0;
|
||
proto._version = 0;
|
||
})();
|
||
return PathProxy;
|
||
}());
|
||
|
||
function containStroke(x0, y0, x1, y1, lineWidth, x, y) {
|
||
if (lineWidth === 0) {
|
||
return false;
|
||
}
|
||
var _l = lineWidth;
|
||
var _a = 0;
|
||
var _b = x0;
|
||
if ((y > y0 + _l && y > y1 + _l)
|
||
|| (y < y0 - _l && y < y1 - _l)
|
||
|| (x > x0 + _l && x > x1 + _l)
|
||
|| (x < x0 - _l && x < x1 - _l)) {
|
||
return false;
|
||
}
|
||
if (x0 !== x1) {
|
||
_a = (y0 - y1) / (x0 - x1);
|
||
_b = (x0 * y1 - x1 * y0) / (x0 - x1);
|
||
}
|
||
else {
|
||
return Math.abs(x - x0) <= _l / 2;
|
||
}
|
||
var tmp = _a * x - y + _b;
|
||
var _s = tmp * tmp / (_a * _a + 1);
|
||
return _s <= _l / 2 * _l / 2;
|
||
}
|
||
|
||
function containStroke$1(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) {
|
||
if (lineWidth === 0) {
|
||
return false;
|
||
}
|
||
var _l = lineWidth;
|
||
if ((y > y0 + _l && y > y1 + _l && y > y2 + _l && y > y3 + _l)
|
||
|| (y < y0 - _l && y < y1 - _l && y < y2 - _l && y < y3 - _l)
|
||
|| (x > x0 + _l && x > x1 + _l && x > x2 + _l && x > x3 + _l)
|
||
|| (x < x0 - _l && x < x1 - _l && x < x2 - _l && x < x3 - _l)) {
|
||
return false;
|
||
}
|
||
var d = cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null);
|
||
return d <= _l / 2;
|
||
}
|
||
|
||
function containStroke$2(x0, y0, x1, y1, x2, y2, lineWidth, x, y) {
|
||
if (lineWidth === 0) {
|
||
return false;
|
||
}
|
||
var _l = lineWidth;
|
||
if ((y > y0 + _l && y > y1 + _l && y > y2 + _l)
|
||
|| (y < y0 - _l && y < y1 - _l && y < y2 - _l)
|
||
|| (x > x0 + _l && x > x1 + _l && x > x2 + _l)
|
||
|| (x < x0 - _l && x < x1 - _l && x < x2 - _l)) {
|
||
return false;
|
||
}
|
||
var d = quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null);
|
||
return d <= _l / 2;
|
||
}
|
||
|
||
var PI2$2 = Math.PI * 2;
|
||
function normalizeRadian(angle) {
|
||
angle %= PI2$2;
|
||
if (angle < 0) {
|
||
angle += PI2$2;
|
||
}
|
||
return angle;
|
||
}
|
||
|
||
var PI2$3 = Math.PI * 2;
|
||
function containStroke$3(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) {
|
||
if (lineWidth === 0) {
|
||
return false;
|
||
}
|
||
var _l = lineWidth;
|
||
x -= cx;
|
||
y -= cy;
|
||
var d = Math.sqrt(x * x + y * y);
|
||
if ((d - _l > r) || (d + _l < r)) {
|
||
return false;
|
||
}
|
||
if (Math.abs(startAngle - endAngle) % PI2$3 < 1e-4) {
|
||
return true;
|
||
}
|
||
if (anticlockwise) {
|
||
var tmp = startAngle;
|
||
startAngle = normalizeRadian(endAngle);
|
||
endAngle = normalizeRadian(tmp);
|
||
}
|
||
else {
|
||
startAngle = normalizeRadian(startAngle);
|
||
endAngle = normalizeRadian(endAngle);
|
||
}
|
||
if (startAngle > endAngle) {
|
||
endAngle += PI2$3;
|
||
}
|
||
var angle = Math.atan2(y, x);
|
||
if (angle < 0) {
|
||
angle += PI2$3;
|
||
}
|
||
return (angle >= startAngle && angle <= endAngle)
|
||
|| (angle + PI2$3 >= startAngle && angle + PI2$3 <= endAngle);
|
||
}
|
||
|
||
function windingLine(x0, y0, x1, y1, x, y) {
|
||
if ((y > y0 && y > y1) || (y < y0 && y < y1)) {
|
||
return 0;
|
||
}
|
||
if (y1 === y0) {
|
||
return 0;
|
||
}
|
||
var t = (y - y0) / (y1 - y0);
|
||
var dir = y1 < y0 ? 1 : -1;
|
||
if (t === 1 || t === 0) {
|
||
dir = y1 < y0 ? 0.5 : -0.5;
|
||
}
|
||
var x_ = t * (x1 - x0) + x0;
|
||
return x_ === x ? Infinity : x_ > x ? dir : 0;
|
||
}
|
||
|
||
var CMD$1 = PathProxy.CMD;
|
||
var PI2$4 = Math.PI * 2;
|
||
var EPSILON$3 = 1e-4;
|
||
function isAroundEqual(a, b) {
|
||
return Math.abs(a - b) < EPSILON$3;
|
||
}
|
||
var roots = [-1, -1, -1];
|
||
var extrema = [-1, -1];
|
||
function swapExtrema() {
|
||
var tmp = extrema[0];
|
||
extrema[0] = extrema[1];
|
||
extrema[1] = tmp;
|
||
}
|
||
function windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) {
|
||
if ((y > y0 && y > y1 && y > y2 && y > y3)
|
||
|| (y < y0 && y < y1 && y < y2 && y < y3)) {
|
||
return 0;
|
||
}
|
||
var nRoots = cubicRootAt(y0, y1, y2, y3, y, roots);
|
||
if (nRoots === 0) {
|
||
return 0;
|
||
}
|
||
else {
|
||
var w = 0;
|
||
var nExtrema = -1;
|
||
var y0_ = void 0;
|
||
var y1_ = void 0;
|
||
for (var i = 0; i < nRoots; i++) {
|
||
var t = roots[i];
|
||
var unit = (t === 0 || t === 1) ? 0.5 : 1;
|
||
var x_ = cubicAt(x0, x1, x2, x3, t);
|
||
if (x_ < x) {
|
||
continue;
|
||
}
|
||
if (nExtrema < 0) {
|
||
nExtrema = cubicExtrema(y0, y1, y2, y3, extrema);
|
||
if (extrema[1] < extrema[0] && nExtrema > 1) {
|
||
swapExtrema();
|
||
}
|
||
y0_ = cubicAt(y0, y1, y2, y3, extrema[0]);
|
||
if (nExtrema > 1) {
|
||
y1_ = cubicAt(y0, y1, y2, y3, extrema[1]);
|
||
}
|
||
}
|
||
if (nExtrema === 2) {
|
||
if (t < extrema[0]) {
|
||
w += y0_ < y0 ? unit : -unit;
|
||
}
|
||
else if (t < extrema[1]) {
|
||
w += y1_ < y0_ ? unit : -unit;
|
||
}
|
||
else {
|
||
w += y3 < y1_ ? unit : -unit;
|
||
}
|
||
}
|
||
else {
|
||
if (t < extrema[0]) {
|
||
w += y0_ < y0 ? unit : -unit;
|
||
}
|
||
else {
|
||
w += y3 < y0_ ? unit : -unit;
|
||
}
|
||
}
|
||
}
|
||
return w;
|
||
}
|
||
}
|
||
function windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) {
|
||
if ((y > y0 && y > y1 && y > y2)
|
||
|| (y < y0 && y < y1 && y < y2)) {
|
||
return 0;
|
||
}
|
||
var nRoots = quadraticRootAt(y0, y1, y2, y, roots);
|
||
if (nRoots === 0) {
|
||
return 0;
|
||
}
|
||
else {
|
||
var t = quadraticExtremum(y0, y1, y2);
|
||
if (t >= 0 && t <= 1) {
|
||
var w = 0;
|
||
var y_ = quadraticAt(y0, y1, y2, t);
|
||