|
|
@@ -0,0 +1,43412 @@
|
|
|
+/*
|
|
|
+* 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(t, e) {
|
|
|
+ "object" == typeof exports && "undefined" != typeof module ? e(exports) : "function" == typeof define && define.amd ? define(["exports"], e) : e(t.echarts = {})
|
|
|
+}(this, function(t) {
|
|
|
+ "use strict";
|
|
|
+ var e = 2311
|
|
|
+ , n = function() {
|
|
|
+ return e++
|
|
|
+ }
|
|
|
+ , v = "object" == typeof wx && "function" == typeof wx.getSystemInfoSync ? {
|
|
|
+ browser: {},
|
|
|
+ os: {},
|
|
|
+ node: !1,
|
|
|
+ wxa: !0,
|
|
|
+ canvasSupported: !0,
|
|
|
+ svgSupported: !1,
|
|
|
+ touchEventsSupported: !0,
|
|
|
+ domSupported: !1
|
|
|
+ } : "undefined" == typeof document && "undefined" != typeof self ? {
|
|
|
+ browser: {},
|
|
|
+ os: {},
|
|
|
+ node: !1,
|
|
|
+ worker: !0,
|
|
|
+ canvasSupported: !0,
|
|
|
+ domSupported: !1
|
|
|
+ } : "undefined" == typeof navigator ? {
|
|
|
+ browser: {},
|
|
|
+ os: {},
|
|
|
+ node: !0,
|
|
|
+ worker: !1,
|
|
|
+ canvasSupported: !0,
|
|
|
+ svgSupported: !0,
|
|
|
+ domSupported: !1
|
|
|
+ } : function(t) {
|
|
|
+ var e = {}
|
|
|
+ , i = t.match(/Firefox\/([\d.]+)/)
|
|
|
+ , n = t.match(/MSIE\s([\d.]+)/) || t.match(/Trident\/.+?rv:(([\d.]+))/)
|
|
|
+ , o = t.match(/Edge\/([\d.]+)/)
|
|
|
+ , a = /micromessenger/i.test(t);
|
|
|
+ i && (e.firefox = !0,
|
|
|
+ e.version = i[1]);
|
|
|
+ n && (e.ie = !0,
|
|
|
+ e.version = n[1]);
|
|
|
+ o && (e.edge = !0,
|
|
|
+ e.version = o[1]);
|
|
|
+ a && (e.weChat = !0);
|
|
|
+ return {
|
|
|
+ browser: e,
|
|
|
+ os: {},
|
|
|
+ node: !1,
|
|
|
+ canvasSupported: !!document.createElement("canvas").getContext,
|
|
|
+ svgSupported: "undefined" != typeof SVGRect,
|
|
|
+ touchEventsSupported: "ontouchstart"in window && !e.ie && !e.edge,
|
|
|
+ pointerEventsSupported: "onpointerdown"in window && (e.edge || e.ie && 11 <= e.version),
|
|
|
+ domSupported: "undefined" != typeof document
|
|
|
+ }
|
|
|
+ }(navigator.userAgent);
|
|
|
+ var s = {
|
|
|
+ "[object Function]": 1,
|
|
|
+ "[object RegExp]": 1,
|
|
|
+ "[object Date]": 1,
|
|
|
+ "[object Error]": 1,
|
|
|
+ "[object CanvasGradient]": 1,
|
|
|
+ "[object CanvasPattern]": 1,
|
|
|
+ "[object Image]": 1,
|
|
|
+ "[object Canvas]": 1
|
|
|
+ }
|
|
|
+ , l = {
|
|
|
+ "[object Int8Array]": 1,
|
|
|
+ "[object Uint8Array]": 1,
|
|
|
+ "[object Uint8ClampedArray]": 1,
|
|
|
+ "[object Int16Array]": 1,
|
|
|
+ "[object Uint16Array]": 1,
|
|
|
+ "[object Int32Array]": 1,
|
|
|
+ "[object Uint32Array]": 1,
|
|
|
+ "[object Float32Array]": 1,
|
|
|
+ "[object Float64Array]": 1
|
|
|
+ }
|
|
|
+ , u = Object.prototype.toString
|
|
|
+ , i = Array.prototype
|
|
|
+ , r = i.forEach
|
|
|
+ , h = i.filter
|
|
|
+ , o = i.slice
|
|
|
+ , c = i.map
|
|
|
+ , d = i.reduce
|
|
|
+ , a = {};
|
|
|
+ function f(t, e) {
|
|
|
+ "createCanvas" === t && (g = null),
|
|
|
+ a[t] = e
|
|
|
+ }
|
|
|
+ function k(t) {
|
|
|
+ if (null == t || "object" != typeof t)
|
|
|
+ return t;
|
|
|
+ var e = t
|
|
|
+ , i = u.call(t);
|
|
|
+ if ("[object Array]" === i) {
|
|
|
+ if (!$(t)) {
|
|
|
+ e = [];
|
|
|
+ for (var n = 0, o = t.length; n < o; n++)
|
|
|
+ e[n] = k(t[n])
|
|
|
+ }
|
|
|
+ } else if (l[i]) {
|
|
|
+ if (!$(t)) {
|
|
|
+ var a = t.constructor;
|
|
|
+ if (t.constructor.from)
|
|
|
+ e = a.from(t);
|
|
|
+ else {
|
|
|
+ e = new a(t.length);
|
|
|
+ for (n = 0,
|
|
|
+ o = t.length; n < o; n++)
|
|
|
+ e[n] = k(t[n])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (!s[i] && !$(t) && !G(t))
|
|
|
+ for (var r in e = {},
|
|
|
+ t)
|
|
|
+ t.hasOwnProperty(r) && (e[r] = k(t[r]));
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ function m(t, e, i) {
|
|
|
+ if (!z(e) || !z(t))
|
|
|
+ return i ? k(e) : t;
|
|
|
+ for (var n in e)
|
|
|
+ if (e.hasOwnProperty(n)) {
|
|
|
+ var o = t[n]
|
|
|
+ , a = e[n];
|
|
|
+ !z(a) || !z(o) || L(a) || L(o) || G(a) || G(o) || B(a) || B(o) || $(a) || $(o) ? !i && n in t || (t[n] = k(e[n])) : m(o, a, i)
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function p(t, e) {
|
|
|
+ for (var i = t[0], n = 1, o = t.length; n < o; n++)
|
|
|
+ i = m(i, t[n], e);
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ function P(t, e) {
|
|
|
+ for (var i in e)
|
|
|
+ e.hasOwnProperty(i) && (t[i] = e[i]);
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function D(t, e, i) {
|
|
|
+ for (var n in e)
|
|
|
+ e.hasOwnProperty(n) && (i ? null != e[n] : null == t[n]) && (t[n] = e[n]);
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function y() {
|
|
|
+ return a.createCanvas()
|
|
|
+ }
|
|
|
+ var g;
|
|
|
+ function x() {
|
|
|
+ return g = g || y().getContext("2d")
|
|
|
+ }
|
|
|
+ function _(t, e) {
|
|
|
+ if (t) {
|
|
|
+ if (t.indexOf)
|
|
|
+ return t.indexOf(e);
|
|
|
+ for (var i = 0, n = t.length; i < n; i++)
|
|
|
+ if (t[i] === e)
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ return -1
|
|
|
+ }
|
|
|
+ function w(t, e) {
|
|
|
+ var i = t.prototype;
|
|
|
+ function n() {}
|
|
|
+ for (var o in n.prototype = e.prototype,
|
|
|
+ t.prototype = new n,
|
|
|
+ i)
|
|
|
+ i.hasOwnProperty(o) && (t.prototype[o] = i[o]);
|
|
|
+ (t.prototype.constructor = t).superClass = e
|
|
|
+ }
|
|
|
+ function b(t, e, i) {
|
|
|
+ D(t = "prototype"in t ? t.prototype : t, e = "prototype"in e ? e.prototype : e, i)
|
|
|
+ }
|
|
|
+ function N(t) {
|
|
|
+ if (t)
|
|
|
+ return "string" != typeof t && "number" == typeof t.length
|
|
|
+ }
|
|
|
+ function E(t, e, i) {
|
|
|
+ if (t && e)
|
|
|
+ if (t.forEach && t.forEach === r)
|
|
|
+ t.forEach(e, i);
|
|
|
+ else if (t.length === +t.length)
|
|
|
+ for (var n = 0, o = t.length; n < o; n++)
|
|
|
+ e.call(i, t[n], n, t);
|
|
|
+ else
|
|
|
+ for (var a in t)
|
|
|
+ t.hasOwnProperty(a) && e.call(i, t[a], a, t)
|
|
|
+ }
|
|
|
+ function O(t, e, i) {
|
|
|
+ if (t && e) {
|
|
|
+ if (t.map && t.map === c)
|
|
|
+ return t.map(e, i);
|
|
|
+ for (var n = [], o = 0, a = t.length; o < a; o++)
|
|
|
+ n.push(e.call(i, t[o], o, t));
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function S(t, e, i, n) {
|
|
|
+ if (t && e) {
|
|
|
+ if (t.reduce && t.reduce === d)
|
|
|
+ return t.reduce(e, i, n);
|
|
|
+ for (var o = 0, a = t.length; o < a; o++)
|
|
|
+ i = e.call(n, i, t[o], o, t);
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function M(t, e, i) {
|
|
|
+ if (t && e) {
|
|
|
+ if (t.filter && t.filter === h)
|
|
|
+ return t.filter(e, i);
|
|
|
+ for (var n = [], o = 0, a = t.length; o < a; o++)
|
|
|
+ e.call(i, t[o], o, t) && n.push(t[o]);
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function I(t, e, i) {
|
|
|
+ if (t && e)
|
|
|
+ for (var n = 0, o = t.length; n < o; n++)
|
|
|
+ if (e.call(i, t[n], n, t))
|
|
|
+ return t[n]
|
|
|
+ }
|
|
|
+ function A(t, e) {
|
|
|
+ var i = o.call(arguments, 2);
|
|
|
+ return function() {
|
|
|
+ return t.apply(e, i.concat(o.call(arguments)))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function T(t) {
|
|
|
+ var e = o.call(arguments, 1);
|
|
|
+ return function() {
|
|
|
+ return t.apply(this, e.concat(o.call(arguments)))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function L(t) {
|
|
|
+ return "[object Array]" === u.call(t)
|
|
|
+ }
|
|
|
+ function C(t) {
|
|
|
+ return "function" == typeof t
|
|
|
+ }
|
|
|
+ function R(t) {
|
|
|
+ return "[object String]" === u.call(t)
|
|
|
+ }
|
|
|
+ function z(t) {
|
|
|
+ var e = typeof t;
|
|
|
+ return "function" == e || !!t && "object" == e
|
|
|
+ }
|
|
|
+ function B(t) {
|
|
|
+ return !!s[u.call(t)]
|
|
|
+ }
|
|
|
+ function V(t) {
|
|
|
+ return !!l[u.call(t)]
|
|
|
+ }
|
|
|
+ function G(t) {
|
|
|
+ return "object" == typeof t && "number" == typeof t.nodeType && "object" == typeof t.ownerDocument
|
|
|
+ }
|
|
|
+ function F(t) {
|
|
|
+ return t != t
|
|
|
+ }
|
|
|
+ function W(t) {
|
|
|
+ for (var e = 0, i = arguments.length; e < i; e++)
|
|
|
+ if (null != arguments[e])
|
|
|
+ return arguments[e]
|
|
|
+ }
|
|
|
+ function H(t, e) {
|
|
|
+ return null != t ? t : e
|
|
|
+ }
|
|
|
+ function Z(t, e, i) {
|
|
|
+ return null != t ? t : null != e ? e : i
|
|
|
+ }
|
|
|
+ function U() {
|
|
|
+ return Function.call.apply(o, arguments)
|
|
|
+ }
|
|
|
+ function X(t) {
|
|
|
+ if ("number" == typeof t)
|
|
|
+ return [t, t, t, t];
|
|
|
+ var e = t.length;
|
|
|
+ return 2 === e ? [t[0], t[1], t[0], t[1]] : 3 === e ? [t[0], t[1], t[2], t[1]] : t
|
|
|
+ }
|
|
|
+ function Y(t, e) {
|
|
|
+ if (!t)
|
|
|
+ throw new Error(e)
|
|
|
+ }
|
|
|
+ function j(t) {
|
|
|
+ return null == t ? null : "function" == typeof t.trim ? t.trim() : t.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "")
|
|
|
+ }
|
|
|
+ a.createCanvas = function() {
|
|
|
+ return document.createElement("canvas")
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var q = "__ec_primitive__";
|
|
|
+ function K(t) {
|
|
|
+ t[q] = !0
|
|
|
+ }
|
|
|
+ function $(t) {
|
|
|
+ return t[q]
|
|
|
+ }
|
|
|
+ function J(t) {
|
|
|
+ var i = L(t);
|
|
|
+ this.data = {};
|
|
|
+ var n = this;
|
|
|
+ function e(t, e) {
|
|
|
+ i ? n.set(t, e) : n.set(e, t)
|
|
|
+ }
|
|
|
+ t instanceof J ? t.each(e) : t && E(t, e)
|
|
|
+ }
|
|
|
+ function Q(t) {
|
|
|
+ return new J(t)
|
|
|
+ }
|
|
|
+ function tt(t, e) {
|
|
|
+ for (var i = new t.constructor(t.length + e.length), n = 0; n < t.length; n++)
|
|
|
+ i[n] = t[n];
|
|
|
+ var o = t.length;
|
|
|
+ for (n = 0; n < e.length; n++)
|
|
|
+ i[n + o] = e[n];
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ function et() {}
|
|
|
+ J.prototype = {
|
|
|
+ constructor: J,
|
|
|
+ get: function(t) {
|
|
|
+ return this.data.hasOwnProperty(t) ? this.data[t] : null
|
|
|
+ },
|
|
|
+ set: function(t, e) {
|
|
|
+ return this.data[t] = e
|
|
|
+ },
|
|
|
+ each: function(t, e) {
|
|
|
+ for (var i in void 0 !== e && (t = A(t, e)),
|
|
|
+ this.data)
|
|
|
+ this.data.hasOwnProperty(i) && t(this.data[i], i)
|
|
|
+ },
|
|
|
+ removeKey: function(t) {
|
|
|
+ delete this.data[t]
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var it = (Object.freeze || Object)({
|
|
|
+ $override: f,
|
|
|
+ clone: k,
|
|
|
+ merge: m,
|
|
|
+ mergeAll: p,
|
|
|
+ extend: P,
|
|
|
+ defaults: D,
|
|
|
+ createCanvas: y,
|
|
|
+ getContext: x,
|
|
|
+ indexOf: _,
|
|
|
+ inherits: w,
|
|
|
+ mixin: b,
|
|
|
+ isArrayLike: N,
|
|
|
+ each: E,
|
|
|
+ map: O,
|
|
|
+ reduce: S,
|
|
|
+ filter: M,
|
|
|
+ find: I,
|
|
|
+ bind: A,
|
|
|
+ curry: T,
|
|
|
+ isArray: L,
|
|
|
+ isFunction: C,
|
|
|
+ isString: R,
|
|
|
+ isObject: z,
|
|
|
+ isBuiltInObject: B,
|
|
|
+ isTypedArray: V,
|
|
|
+ isDom: G,
|
|
|
+ eqNaN: F,
|
|
|
+ retrieve: W,
|
|
|
+ retrieve2: H,
|
|
|
+ retrieve3: Z,
|
|
|
+ slice: U,
|
|
|
+ normalizeCssArray: X,
|
|
|
+ assert: Y,
|
|
|
+ trim: j,
|
|
|
+ setAsPrimitive: K,
|
|
|
+ isPrimitive: $,
|
|
|
+ createHashMap: Q,
|
|
|
+ concatArray: tt,
|
|
|
+ noop: et
|
|
|
+ })
|
|
|
+ , nt = "undefined" == typeof Float32Array ? Array : Float32Array;
|
|
|
+ function ot(t, e) {
|
|
|
+ var i = new nt(2);
|
|
|
+ return null == t && (t = 0),
|
|
|
+ null == e && (e = 0),
|
|
|
+ i[0] = t,
|
|
|
+ i[1] = e,
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function at(t, e) {
|
|
|
+ return t[0] = e[0],
|
|
|
+ t[1] = e[1],
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function rt(t) {
|
|
|
+ var e = new nt(2);
|
|
|
+ return e[0] = t[0],
|
|
|
+ e[1] = t[1],
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function st(t, e, i) {
|
|
|
+ return t[0] = e,
|
|
|
+ t[1] = i,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function lt(t, e, i) {
|
|
|
+ return t[0] = e[0] + i[0],
|
|
|
+ t[1] = e[1] + i[1],
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function ut(t, e, i, n) {
|
|
|
+ return t[0] = e[0] + i[0] * n,
|
|
|
+ t[1] = e[1] + i[1] * n,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function ht(t, e, i) {
|
|
|
+ return t[0] = e[0] - i[0],
|
|
|
+ t[1] = e[1] - i[1],
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function ct(t) {
|
|
|
+ return Math.sqrt(ft(t))
|
|
|
+ }
|
|
|
+ var dt = ct;
|
|
|
+ function ft(t) {
|
|
|
+ return t[0] * t[0] + t[1] * t[1]
|
|
|
+ }
|
|
|
+ var pt = ft;
|
|
|
+ function gt(t, e, i) {
|
|
|
+ return t[0] = e[0] * i,
|
|
|
+ t[1] = e[1] * i,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function mt(t, e) {
|
|
|
+ var i = ct(e);
|
|
|
+ return 0 === i ? (t[0] = 0,
|
|
|
+ t[1] = 0) : (t[0] = e[0] / i,
|
|
|
+ t[1] = e[1] / i),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function vt(t, e) {
|
|
|
+ return Math.sqrt((t[0] - e[0]) * (t[0] - e[0]) + (t[1] - e[1]) * (t[1] - e[1]))
|
|
|
+ }
|
|
|
+ var yt = vt;
|
|
|
+ function xt(t, e) {
|
|
|
+ return (t[0] - e[0]) * (t[0] - e[0]) + (t[1] - e[1]) * (t[1] - e[1])
|
|
|
+ }
|
|
|
+ var _t = xt;
|
|
|
+ function wt(t, e, i, n) {
|
|
|
+ return t[0] = e[0] + n * (i[0] - e[0]),
|
|
|
+ t[1] = e[1] + n * (i[1] - e[1]),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function bt(t, e, i) {
|
|
|
+ var n = e[0]
|
|
|
+ , o = e[1];
|
|
|
+ return t[0] = i[0] * n + i[2] * o + i[4],
|
|
|
+ t[1] = i[1] * n + i[3] * o + i[5],
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function St(t, e, i) {
|
|
|
+ return t[0] = Math.min(e[0], i[0]),
|
|
|
+ t[1] = Math.min(e[1], i[1]),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function Mt(t, e, i) {
|
|
|
+ return t[0] = Math.max(e[0], i[0]),
|
|
|
+ t[1] = Math.max(e[1], i[1]),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ var It = (Object.freeze || Object)({
|
|
|
+ create: ot,
|
|
|
+ copy: at,
|
|
|
+ clone: rt,
|
|
|
+ set: st,
|
|
|
+ add: lt,
|
|
|
+ scaleAndAdd: ut,
|
|
|
+ sub: ht,
|
|
|
+ len: ct,
|
|
|
+ length: dt,
|
|
|
+ lenSquare: ft,
|
|
|
+ lengthSquare: pt,
|
|
|
+ mul: function(t, e, i) {
|
|
|
+ return t[0] = e[0] * i[0],
|
|
|
+ t[1] = e[1] * i[1],
|
|
|
+ t
|
|
|
+ },
|
|
|
+ div: function(t, e, i) {
|
|
|
+ return t[0] = e[0] / i[0],
|
|
|
+ t[1] = e[1] / i[1],
|
|
|
+ t
|
|
|
+ },
|
|
|
+ dot: function(t, e) {
|
|
|
+ return t[0] * e[0] + t[1] * e[1]
|
|
|
+ },
|
|
|
+ scale: gt,
|
|
|
+ normalize: mt,
|
|
|
+ distance: vt,
|
|
|
+ dist: yt,
|
|
|
+ distanceSquare: xt,
|
|
|
+ distSquare: _t,
|
|
|
+ negate: function(t, e) {
|
|
|
+ return t[0] = -e[0],
|
|
|
+ t[1] = -e[1],
|
|
|
+ t
|
|
|
+ },
|
|
|
+ lerp: wt,
|
|
|
+ applyTransform: bt,
|
|
|
+ min: St,
|
|
|
+ max: Mt
|
|
|
+ });
|
|
|
+ function Tt() {
|
|
|
+ this.on("mousedown", this._dragStart, this),
|
|
|
+ this.on("mousemove", this._drag, this),
|
|
|
+ this.on("mouseup", this._dragEnd, this)
|
|
|
+ }
|
|
|
+ function At(t, e) {
|
|
|
+ return {
|
|
|
+ target: t,
|
|
|
+ topTarget: e && e.topTarget
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Tt.prototype = {
|
|
|
+ constructor: Tt,
|
|
|
+ _dragStart: function(t) {
|
|
|
+ for (var e = t.target; e && !e.draggable; )
|
|
|
+ e = e.parent;
|
|
|
+ e && ((this._draggingTarget = e).dragging = !0,
|
|
|
+ this._x = t.offsetX,
|
|
|
+ this._y = t.offsetY,
|
|
|
+ this.dispatchToElement(At(e, t), "dragstart", t.event))
|
|
|
+ },
|
|
|
+ _drag: function(t) {
|
|
|
+ var e = this._draggingTarget;
|
|
|
+ if (e) {
|
|
|
+ var i = t.offsetX
|
|
|
+ , n = t.offsetY
|
|
|
+ , o = i - this._x
|
|
|
+ , a = n - this._y;
|
|
|
+ this._x = i,
|
|
|
+ this._y = n,
|
|
|
+ e.drift(o, a, t),
|
|
|
+ this.dispatchToElement(At(e, t), "drag", t.event);
|
|
|
+ var r = this.findHover(i, n, e).target
|
|
|
+ , s = this._dropTarget;
|
|
|
+ e !== (this._dropTarget = r) && (s && r !== s && this.dispatchToElement(At(s, t), "dragleave", t.event),
|
|
|
+ r && r !== s && this.dispatchToElement(At(r, t), "dragenter", t.event))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _dragEnd: function(t) {
|
|
|
+ var e = this._draggingTarget;
|
|
|
+ e && (e.dragging = !1),
|
|
|
+ this.dispatchToElement(At(e, t), "dragend", t.event),
|
|
|
+ this._dropTarget && this.dispatchToElement(At(this._dropTarget, t), "drop", t.event),
|
|
|
+ this._draggingTarget = null,
|
|
|
+ this._dropTarget = null
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var Dt = Array.prototype.slice
|
|
|
+ , Ct = function(t) {
|
|
|
+ this._$handlers = {},
|
|
|
+ this._$eventProcessor = t
|
|
|
+ };
|
|
|
+ function Lt(t, e, i, n, o, a) {
|
|
|
+ var r = t._$handlers;
|
|
|
+ if ("function" == typeof i && (o = n,
|
|
|
+ n = i,
|
|
|
+ i = null),
|
|
|
+ !n || !e)
|
|
|
+ return t;
|
|
|
+ i = function(t, e) {
|
|
|
+ var i = t._$eventProcessor;
|
|
|
+ return null != e && i && i.normalizeQuery && (e = i.normalizeQuery(e)),
|
|
|
+ e
|
|
|
+ }(t, i),
|
|
|
+ r[e] || (r[e] = []);
|
|
|
+ for (var s = 0; s < r[e].length; s++)
|
|
|
+ if (r[e][s].h === n)
|
|
|
+ return t;
|
|
|
+ var l = {
|
|
|
+ h: n,
|
|
|
+ one: a,
|
|
|
+ query: i,
|
|
|
+ ctx: o || t,
|
|
|
+ callAtLast: n.zrEventfulCallAtLast
|
|
|
+ }
|
|
|
+ , u = r[e].length - 1
|
|
|
+ , h = r[e][u];
|
|
|
+ return h && h.callAtLast ? r[e].splice(u, 0, l) : r[e].push(l),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ Ct.prototype = {
|
|
|
+ constructor: Ct,
|
|
|
+ one: function(t, e, i, n) {
|
|
|
+ return Lt(this, t, e, i, n, !0)
|
|
|
+ },
|
|
|
+ on: function(t, e, i, n) {
|
|
|
+ return Lt(this, t, e, i, n, !1)
|
|
|
+ },
|
|
|
+ isSilent: function(t) {
|
|
|
+ var e = this._$handlers;
|
|
|
+ return !e[t] || !e[t].length
|
|
|
+ },
|
|
|
+ off: function(t, e) {
|
|
|
+ var i = this._$handlers;
|
|
|
+ if (!t)
|
|
|
+ return this._$handlers = {},
|
|
|
+ this;
|
|
|
+ if (e) {
|
|
|
+ if (i[t]) {
|
|
|
+ for (var n = [], o = 0, a = i[t].length; o < a; o++)
|
|
|
+ i[t][o].h !== e && n.push(i[t][o]);
|
|
|
+ i[t] = n
|
|
|
+ }
|
|
|
+ i[t] && 0 === i[t].length && delete i[t]
|
|
|
+ } else
|
|
|
+ delete i[t];
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ trigger: function(t) {
|
|
|
+ var e = this._$handlers[t]
|
|
|
+ , i = this._$eventProcessor;
|
|
|
+ if (e) {
|
|
|
+ var n = arguments
|
|
|
+ , o = n.length;
|
|
|
+ 3 < o && (n = Dt.call(n, 1));
|
|
|
+ for (var a = e.length, r = 0; r < a; ) {
|
|
|
+ var s = e[r];
|
|
|
+ if (i && i.filter && null != s.query && !i.filter(t, s.query))
|
|
|
+ r++;
|
|
|
+ else {
|
|
|
+ switch (o) {
|
|
|
+ case 1:
|
|
|
+ s.h.call(s.ctx);
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ s.h.call(s.ctx, n[1]);
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ s.h.call(s.ctx, n[1], n[2]);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ s.h.apply(s.ctx, n)
|
|
|
+ }
|
|
|
+ s.one ? (e.splice(r, 1),
|
|
|
+ a--) : r++
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return i && i.afterTrigger && i.afterTrigger(t),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ triggerWithContext: function(t) {
|
|
|
+ var e = this._$handlers[t]
|
|
|
+ , i = this._$eventProcessor;
|
|
|
+ if (e) {
|
|
|
+ var n = arguments
|
|
|
+ , o = n.length;
|
|
|
+ 4 < o && (n = Dt.call(n, 1, n.length - 1));
|
|
|
+ for (var a = n[n.length - 1], r = e.length, s = 0; s < r; ) {
|
|
|
+ var l = e[s];
|
|
|
+ if (i && i.filter && null != l.query && !i.filter(t, l.query))
|
|
|
+ s++;
|
|
|
+ else {
|
|
|
+ switch (o) {
|
|
|
+ case 1:
|
|
|
+ l.h.call(a);
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ l.h.call(a, n[1]);
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ l.h.call(a, n[1], n[2]);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ l.h.apply(a, n)
|
|
|
+ }
|
|
|
+ l.one ? (e.splice(s, 1),
|
|
|
+ r--) : s++
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return i && i.afterTrigger && i.afterTrigger(t),
|
|
|
+ this
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var kt = Math.log(2);
|
|
|
+ function Pt(t, e, i, n, o, a) {
|
|
|
+ var r = n + "-" + o
|
|
|
+ , s = t.length;
|
|
|
+ if (a.hasOwnProperty(r))
|
|
|
+ return a[r];
|
|
|
+ if (1 === e) {
|
|
|
+ var l = Math.round(Math.log((1 << s) - 1 & ~o) / kt);
|
|
|
+ return t[i][l]
|
|
|
+ }
|
|
|
+ for (var u = n | 1 << i, h = i + 1; n & 1 << h; )
|
|
|
+ h++;
|
|
|
+ for (var c = 0, d = 0, f = 0; d < s; d++) {
|
|
|
+ var p = 1 << d;
|
|
|
+ p & o || (c += (f % 2 ? -1 : 1) * t[i][d] * Pt(t, e - 1, h, u, o | p, a),
|
|
|
+ f++)
|
|
|
+ }
|
|
|
+ return a[r] = c
|
|
|
+ }
|
|
|
+ function Nt(t, e) {
|
|
|
+ var i = [[t[0], t[1], 1, 0, 0, 0, -e[0] * t[0], -e[0] * t[1]], [0, 0, 0, t[0], t[1], 1, -e[1] * t[0], -e[1] * t[1]], [t[2], t[3], 1, 0, 0, 0, -e[2] * t[2], -e[2] * t[3]], [0, 0, 0, t[2], t[3], 1, -e[3] * t[2], -e[3] * t[3]], [t[4], t[5], 1, 0, 0, 0, -e[4] * t[4], -e[4] * t[5]], [0, 0, 0, t[4], t[5], 1, -e[5] * t[4], -e[5] * t[5]], [t[6], t[7], 1, 0, 0, 0, -e[6] * t[6], -e[6] * t[7]], [0, 0, 0, t[6], t[7], 1, -e[7] * t[6], -e[7] * t[7]]]
|
|
|
+ , n = {}
|
|
|
+ , o = Pt(i, 8, 0, 0, 0, n);
|
|
|
+ if (0 !== o) {
|
|
|
+ for (var a = [], r = 0; r < 8; r++)
|
|
|
+ for (var s = 0; s < 8; s++)
|
|
|
+ null == a[s] && (a[s] = 0),
|
|
|
+ a[s] += ((r + s) % 2 ? -1 : 1) * Pt(i, 7, 0 === r ? 1 : 0, 1 << r, 1 << s, n) / o * e[r];
|
|
|
+ return function(t, e, i) {
|
|
|
+ var n = e * a[6] + i * a[7] + 1;
|
|
|
+ t[0] = (e * a[0] + i * a[1] + a[2]) / n,
|
|
|
+ t[1] = (e * a[3] + i * a[4] + a[5]) / n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Ot = "___zrEVENTSAVED"
|
|
|
+ , Et = [];
|
|
|
+ function Rt(t, e, i, n, o) {
|
|
|
+ if (e.getBoundingClientRect && v.domSupported && !zt(e)) {
|
|
|
+ var a = e[Ot] || (e[Ot] = {})
|
|
|
+ , r = function(t, e, i) {
|
|
|
+ for (var n = i ? "invTrans" : "trans", o = e[n], a = e.srcCoords, r = !0, s = [], l = [], u = 0; u < 4; u++) {
|
|
|
+ var h = t[u].getBoundingClientRect()
|
|
|
+ , c = 2 * u
|
|
|
+ , d = h.left
|
|
|
+ , f = h.top;
|
|
|
+ s.push(d, f),
|
|
|
+ r = r && a && d === a[c] && f === a[1 + c],
|
|
|
+ l.push(t[u].offsetLeft, t[u].offsetTop)
|
|
|
+ }
|
|
|
+ return r && o ? o : (e.srcCoords = s,
|
|
|
+ e[n] = i ? Nt(l, s) : Nt(s, l))
|
|
|
+ }(function(t, e) {
|
|
|
+ var i = e.markers;
|
|
|
+ if (i)
|
|
|
+ return i;
|
|
|
+ i = e.markers = [];
|
|
|
+ for (var n = ["left", "right"], o = ["top", "bottom"], a = 0; a < 4; a++) {
|
|
|
+ var r = document.createElement("div")
|
|
|
+ , s = r.style
|
|
|
+ , l = a % 2
|
|
|
+ , u = (a >> 1) % 2;
|
|
|
+ s.cssText = ["position: absolute", "visibility: hidden", "padding: 0", "margin: 0", "border-width: 0", "user-select: none", "width:0", "height:0", n[l] + ":0", o[u] + ":0", n[1 - l] + ":auto", o[1 - u] + ":auto", ""].join("!important;"),
|
|
|
+ t.appendChild(r),
|
|
|
+ i.push(r)
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }(e, a), a, o);
|
|
|
+ if (r)
|
|
|
+ return r(t, i, n),
|
|
|
+ !0
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ function zt(t) {
|
|
|
+ return "CANVAS" === t.nodeName.toUpperCase()
|
|
|
+ }
|
|
|
+ var Bt = "undefined" != typeof window && !!window.addEventListener
|
|
|
+ , Vt = /^(?:mouse|pointer|contextmenu|drag|drop)|click/
|
|
|
+ , Gt = [];
|
|
|
+ function Ft(t, e, i, n) {
|
|
|
+ return i = i || {},
|
|
|
+ n || !v.canvasSupported ? Wt(t, e, i) : v.browser.firefox && null != e.layerX && e.layerX !== e.offsetX ? (i.zrX = e.layerX,
|
|
|
+ i.zrY = e.layerY) : null != e.offsetX ? (i.zrX = e.offsetX,
|
|
|
+ i.zrY = e.offsetY) : Wt(t, e, i),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function Wt(t, e, i) {
|
|
|
+ if (v.domSupported && t.getBoundingClientRect) {
|
|
|
+ var n = e.clientX
|
|
|
+ , o = e.clientY;
|
|
|
+ if (zt(t)) {
|
|
|
+ var a = t.getBoundingClientRect();
|
|
|
+ return i.zrX = n - a.left,
|
|
|
+ void (i.zrY = o - a.top)
|
|
|
+ }
|
|
|
+ if (Rt(Gt, t, n, o))
|
|
|
+ return i.zrX = Gt[0],
|
|
|
+ void (i.zrY = Gt[1])
|
|
|
+ }
|
|
|
+ i.zrX = i.zrY = 0
|
|
|
+ }
|
|
|
+ function Ht(t) {
|
|
|
+ return t || window.event
|
|
|
+ }
|
|
|
+ function Zt(t, e, i) {
|
|
|
+ if (null != (e = Ht(e)).zrX)
|
|
|
+ return e;
|
|
|
+ var n = e.type;
|
|
|
+ if (n && 0 <= n.indexOf("touch")) {
|
|
|
+ var o = "touchend" !== n ? e.targetTouches[0] : e.changedTouches[0];
|
|
|
+ o && Ft(t, o, e, i)
|
|
|
+ } else
|
|
|
+ Ft(t, e, e, i),
|
|
|
+ e.zrDelta = e.wheelDelta ? e.wheelDelta / 120 : -(e.detail || 0) / 3;
|
|
|
+ var a = e.button;
|
|
|
+ return null == e.which && void 0 !== a && Vt.test(e.type) && (e.which = 1 & a ? 1 : 2 & a ? 3 : 4 & a ? 2 : 0),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function Ut(t, e, i, n) {
|
|
|
+ Bt ? t.addEventListener(e, i, n) : t.attachEvent("on" + e, i)
|
|
|
+ }
|
|
|
+ var Xt = Bt ? function(t) {
|
|
|
+ t.preventDefault(),
|
|
|
+ t.stopPropagation(),
|
|
|
+ t.cancelBubble = !0
|
|
|
+ }
|
|
|
+ : function(t) {
|
|
|
+ t.returnValue = !1,
|
|
|
+ t.cancelBubble = !0
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function Yt(t) {
|
|
|
+ return 2 === t.which || 3 === t.which
|
|
|
+ }
|
|
|
+ function jt() {
|
|
|
+ this._track = []
|
|
|
+ }
|
|
|
+ function qt(t) {
|
|
|
+ var e = t[1][0] - t[0][0]
|
|
|
+ , i = t[1][1] - t[0][1];
|
|
|
+ return Math.sqrt(e * e + i * i)
|
|
|
+ }
|
|
|
+ jt.prototype = {
|
|
|
+ constructor: jt,
|
|
|
+ recognize: function(t, e, i) {
|
|
|
+ return this._doTrack(t, e, i),
|
|
|
+ this._recognize(t)
|
|
|
+ },
|
|
|
+ clear: function() {
|
|
|
+ return this._track.length = 0,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ _doTrack: function(t, e, i) {
|
|
|
+ var n = t.touches;
|
|
|
+ if (n) {
|
|
|
+ for (var o = {
|
|
|
+ points: [],
|
|
|
+ touches: [],
|
|
|
+ target: e,
|
|
|
+ event: t
|
|
|
+ }, a = 0, r = n.length; a < r; a++) {
|
|
|
+ var s = n[a]
|
|
|
+ , l = Ft(i, s, {});
|
|
|
+ o.points.push([l.zrX, l.zrY]),
|
|
|
+ o.touches.push(s)
|
|
|
+ }
|
|
|
+ this._track.push(o)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _recognize: function(t) {
|
|
|
+ for (var e in Kt)
|
|
|
+ if (Kt.hasOwnProperty(e)) {
|
|
|
+ var i = Kt[e](this._track, t);
|
|
|
+ if (i)
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var Kt = {
|
|
|
+ pinch: function(t, e) {
|
|
|
+ var i = t.length;
|
|
|
+ if (i) {
|
|
|
+ var n = (t[i - 1] || {}).points
|
|
|
+ , o = (t[i - 2] || {}).points || n;
|
|
|
+ if (o && 1 < o.length && n && 1 < n.length) {
|
|
|
+ var a = qt(n) / qt(o);
|
|
|
+ isFinite(a) || (a = 1),
|
|
|
+ e.pinchScale = a;
|
|
|
+ var r = function(t) {
|
|
|
+ return [(t[0][0] + t[1][0]) / 2, (t[0][1] + t[1][1]) / 2]
|
|
|
+ }(n);
|
|
|
+ return e.pinchX = r[0],
|
|
|
+ e.pinchY = r[1],
|
|
|
+ {
|
|
|
+ type: "pinch",
|
|
|
+ target: t[0].target,
|
|
|
+ event: e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , $t = "silent";
|
|
|
+ function Jt() {
|
|
|
+ Xt(this.event)
|
|
|
+ }
|
|
|
+ function Qt() {}
|
|
|
+ Qt.prototype.dispose = function() {}
|
|
|
+ ;
|
|
|
+ function te(t, e, i, n) {
|
|
|
+ Ct.call(this),
|
|
|
+ this.storage = t,
|
|
|
+ this.painter = e,
|
|
|
+ this.painterRoot = n,
|
|
|
+ i = i || new Qt,
|
|
|
+ this.proxy = null,
|
|
|
+ this._hovered = {},
|
|
|
+ this._lastTouchMoment,
|
|
|
+ this._lastX,
|
|
|
+ this._lastY,
|
|
|
+ this._gestureMgr,
|
|
|
+ Tt.call(this),
|
|
|
+ this.setHandlerProxy(i)
|
|
|
+ }
|
|
|
+ var ee = ["click", "dblclick", "mousewheel", "mouseout", "mouseup", "mousedown", "mousemove", "contextmenu"];
|
|
|
+ function ie(t, e, i) {
|
|
|
+ if (t[t.rectHover ? "rectContain" : "contain"](e, i)) {
|
|
|
+ for (var n, o = t; o; ) {
|
|
|
+ if (o.clipPath && !o.clipPath.contain(e, i))
|
|
|
+ return !1;
|
|
|
+ o.silent && (n = !0),
|
|
|
+ o = o.parent
|
|
|
+ }
|
|
|
+ return !n || $t
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ function ne(t, e, i) {
|
|
|
+ var n = t.painter;
|
|
|
+ return e < 0 || e > n.getWidth() || i < 0 || i > n.getHeight()
|
|
|
+ }
|
|
|
+ te.prototype = {
|
|
|
+ constructor: te,
|
|
|
+ setHandlerProxy: function(e) {
|
|
|
+ this.proxy && this.proxy.dispose(),
|
|
|
+ e && (E(ee, function(t) {
|
|
|
+ e.on && e.on(t, this[t], this)
|
|
|
+ }, this),
|
|
|
+ e.handler = this),
|
|
|
+ this.proxy = e
|
|
|
+ },
|
|
|
+ mousemove: function(t) {
|
|
|
+ var e = t.zrX
|
|
|
+ , i = t.zrY
|
|
|
+ , n = ne(this, e, i)
|
|
|
+ , o = this._hovered
|
|
|
+ , a = o.target;
|
|
|
+ a && !a.__zr && (a = (o = this.findHover(o.x, o.y)).target);
|
|
|
+ var r = this._hovered = n ? {
|
|
|
+ x: e,
|
|
|
+ y: i
|
|
|
+ } : this.findHover(e, i)
|
|
|
+ , s = r.target
|
|
|
+ , l = this.proxy;
|
|
|
+ l.setCursor && l.setCursor(s ? s.cursor : "default"),
|
|
|
+ a && s !== a && this.dispatchToElement(o, "mouseout", t),
|
|
|
+ this.dispatchToElement(r, "mousemove", t),
|
|
|
+ s && s !== a && this.dispatchToElement(r, "mouseover", t)
|
|
|
+ },
|
|
|
+ mouseout: function(t) {
|
|
|
+ var e = t.zrEventControl
|
|
|
+ , i = t.zrIsToLocalDOM;
|
|
|
+ "only_globalout" !== e && this.dispatchToElement(this._hovered, "mouseout", t),
|
|
|
+ "no_globalout" !== e && (i || this.trigger("globalout", {
|
|
|
+ type: "globalout",
|
|
|
+ event: t
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ resize: function(t) {
|
|
|
+ this._hovered = {}
|
|
|
+ },
|
|
|
+ dispatch: function(t, e) {
|
|
|
+ var i = this[t];
|
|
|
+ i && i.call(this, e)
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this.proxy.dispose(),
|
|
|
+ this.storage = this.proxy = this.painter = null
|
|
|
+ },
|
|
|
+ setCursorStyle: function(t) {
|
|
|
+ var e = this.proxy;
|
|
|
+ e.setCursor && e.setCursor(t)
|
|
|
+ },
|
|
|
+ dispatchToElement: function(t, e, i) {
|
|
|
+ var n = (t = t || {}).target;
|
|
|
+ if (!n || !n.silent) {
|
|
|
+ for (var o = "on" + e, a = function(t, e, i) {
|
|
|
+ return {
|
|
|
+ type: t,
|
|
|
+ event: i,
|
|
|
+ target: e.target,
|
|
|
+ topTarget: e.topTarget,
|
|
|
+ cancelBubble: !1,
|
|
|
+ offsetX: i.zrX,
|
|
|
+ offsetY: i.zrY,
|
|
|
+ gestureEvent: i.gestureEvent,
|
|
|
+ pinchX: i.pinchX,
|
|
|
+ pinchY: i.pinchY,
|
|
|
+ pinchScale: i.pinchScale,
|
|
|
+ wheelDelta: i.zrDelta,
|
|
|
+ zrByTouch: i.zrByTouch,
|
|
|
+ which: i.which,
|
|
|
+ stop: Jt
|
|
|
+ }
|
|
|
+ }(e, t, i); n && (n[o] && (a.cancelBubble = n[o].call(n, a)),
|
|
|
+ n.trigger(e, a),
|
|
|
+ n = n.parent,
|
|
|
+ !a.cancelBubble); )
|
|
|
+ ;
|
|
|
+ a.cancelBubble || (this.trigger(e, a),
|
|
|
+ this.painter && this.painter.eachOtherLayer(function(t) {
|
|
|
+ "function" == typeof t[o] && t[o].call(t, a),
|
|
|
+ t.trigger && t.trigger(e, a)
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ findHover: function(t, e, i) {
|
|
|
+ for (var n = this.storage.getDisplayList(), o = {
|
|
|
+ x: t,
|
|
|
+ y: e
|
|
|
+ }, a = n.length - 1; 0 <= a; a--) {
|
|
|
+ var r;
|
|
|
+ if (n[a] !== i && !n[a].ignore && (r = ie(n[a], t, e)) && (o.topTarget || (o.topTarget = n[a]),
|
|
|
+ r !== $t)) {
|
|
|
+ o.target = n[a];
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ },
|
|
|
+ processGesture: function(t, e) {
|
|
|
+ this._gestureMgr || (this._gestureMgr = new jt);
|
|
|
+ var i = this._gestureMgr;
|
|
|
+ "start" === e && i.clear();
|
|
|
+ var n = i.recognize(t, this.findHover(t.zrX, t.zrY, null).target, this.proxy.dom);
|
|
|
+ if ("end" === e && i.clear(),
|
|
|
+ n) {
|
|
|
+ var o = n.type;
|
|
|
+ t.gestureEvent = o,
|
|
|
+ this.dispatchToElement({
|
|
|
+ target: n.target
|
|
|
+ }, o, n.event)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ E(["click", "mousedown", "mouseup", "mousewheel", "dblclick", "contextmenu"], function(r) {
|
|
|
+ te.prototype[r] = function(t) {
|
|
|
+ var e, i, n = t.zrX, o = t.zrY, a = ne(this, n, o);
|
|
|
+ if ("mouseup" === r && a || (i = (e = this.findHover(n, o)).target),
|
|
|
+ "mousedown" === r)
|
|
|
+ this._downEl = i,
|
|
|
+ this._downPoint = [t.zrX, t.zrY],
|
|
|
+ this._upEl = i;
|
|
|
+ else if ("mouseup" === r)
|
|
|
+ this._upEl = i;
|
|
|
+ else if ("click" === r) {
|
|
|
+ if (this._downEl !== this._upEl || !this._downPoint || 4 < yt(this._downPoint, [t.zrX, t.zrY]))
|
|
|
+ return;
|
|
|
+ this._downPoint = null
|
|
|
+ }
|
|
|
+ this.dispatchToElement(e, r, t)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ b(te, Ct),
|
|
|
+ b(te, Tt);
|
|
|
+ var oe = "undefined" == typeof Float32Array ? Array : Float32Array;
|
|
|
+ function ae() {
|
|
|
+ var t = new oe(6);
|
|
|
+ return re(t),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function re(t) {
|
|
|
+ return t[0] = 1,
|
|
|
+ t[1] = 0,
|
|
|
+ t[2] = 0,
|
|
|
+ t[3] = 1,
|
|
|
+ t[4] = 0,
|
|
|
+ t[5] = 0,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function se(t, e) {
|
|
|
+ return t[0] = e[0],
|
|
|
+ t[1] = e[1],
|
|
|
+ t[2] = e[2],
|
|
|
+ t[3] = e[3],
|
|
|
+ t[4] = e[4],
|
|
|
+ t[5] = e[5],
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function le(t, e, i) {
|
|
|
+ var n = e[0] * i[0] + e[2] * i[1]
|
|
|
+ , o = e[1] * i[0] + e[3] * i[1]
|
|
|
+ , a = e[0] * i[2] + e[2] * i[3]
|
|
|
+ , r = e[1] * i[2] + e[3] * i[3]
|
|
|
+ , s = e[0] * i[4] + e[2] * i[5] + e[4]
|
|
|
+ , l = e[1] * i[4] + e[3] * i[5] + e[5];
|
|
|
+ return t[0] = n,
|
|
|
+ t[1] = o,
|
|
|
+ t[2] = a,
|
|
|
+ t[3] = r,
|
|
|
+ t[4] = s,
|
|
|
+ t[5] = l,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function ue(t, e, i) {
|
|
|
+ return t[0] = e[0],
|
|
|
+ t[1] = e[1],
|
|
|
+ t[2] = e[2],
|
|
|
+ t[3] = e[3],
|
|
|
+ t[4] = e[4] + i[0],
|
|
|
+ t[5] = e[5] + i[1],
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function he(t, e, i) {
|
|
|
+ var n = e[0]
|
|
|
+ , o = e[2]
|
|
|
+ , a = e[4]
|
|
|
+ , r = e[1]
|
|
|
+ , s = e[3]
|
|
|
+ , l = e[5]
|
|
|
+ , u = Math.sin(i)
|
|
|
+ , h = Math.cos(i);
|
|
|
+ return t[0] = n * h + r * u,
|
|
|
+ t[1] = -n * u + r * h,
|
|
|
+ t[2] = o * h + s * u,
|
|
|
+ t[3] = -o * u + h * s,
|
|
|
+ t[4] = h * a + u * l,
|
|
|
+ t[5] = h * l - u * a,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function ce(t, e, i) {
|
|
|
+ var n = i[0]
|
|
|
+ , o = i[1];
|
|
|
+ return t[0] = e[0] * n,
|
|
|
+ t[1] = e[1] * o,
|
|
|
+ t[2] = e[2] * n,
|
|
|
+ t[3] = e[3] * o,
|
|
|
+ t[4] = e[4] * n,
|
|
|
+ t[5] = e[5] * o,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function de(t, e) {
|
|
|
+ var i = e[0]
|
|
|
+ , n = e[2]
|
|
|
+ , o = e[4]
|
|
|
+ , a = e[1]
|
|
|
+ , r = e[3]
|
|
|
+ , s = e[5]
|
|
|
+ , l = i * r - a * n;
|
|
|
+ return l ? (l = 1 / l,
|
|
|
+ t[0] = r * l,
|
|
|
+ t[1] = -a * l,
|
|
|
+ t[2] = -n * l,
|
|
|
+ t[3] = i * l,
|
|
|
+ t[4] = (n * s - r * o) * l,
|
|
|
+ t[5] = (a * o - i * s) * l,
|
|
|
+ t) : null
|
|
|
+ }
|
|
|
+ function fe(t) {
|
|
|
+ var e = ae();
|
|
|
+ return se(e, t),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ var pe = (Object.freeze || Object)({
|
|
|
+ create: ae,
|
|
|
+ identity: re,
|
|
|
+ copy: se,
|
|
|
+ mul: le,
|
|
|
+ translate: ue,
|
|
|
+ rotate: he,
|
|
|
+ scale: ce,
|
|
|
+ invert: de,
|
|
|
+ clone: fe
|
|
|
+ })
|
|
|
+ , ge = re;
|
|
|
+ function me(t) {
|
|
|
+ return 5e-5 < t || t < -5e-5
|
|
|
+ }
|
|
|
+ var ve = function(t) {
|
|
|
+ (t = t || {}).position || (this.position = [0, 0]),
|
|
|
+ null == t.rotation && (this.rotation = 0),
|
|
|
+ t.scale || (this.scale = [1, 1]),
|
|
|
+ this.origin = this.origin || null
|
|
|
+ }
|
|
|
+ , ye = ve.prototype;
|
|
|
+ ye.transform = null,
|
|
|
+ ye.needLocalTransform = function() {
|
|
|
+ return me(this.rotation) || me(this.position[0]) || me(this.position[1]) || me(this.scale[0] - 1) || me(this.scale[1] - 1)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var xe = [];
|
|
|
+ ye.updateTransform = function() {
|
|
|
+ var t = this.parent
|
|
|
+ , e = t && t.transform
|
|
|
+ , i = this.needLocalTransform()
|
|
|
+ , n = this.transform;
|
|
|
+ if (i || e) {
|
|
|
+ n = n || ae(),
|
|
|
+ i ? this.getLocalTransform(n) : ge(n),
|
|
|
+ e && (i ? le(n, t.transform, n) : se(n, t.transform)),
|
|
|
+ this.transform = n;
|
|
|
+ var o = this.globalScaleRatio;
|
|
|
+ if (null != o && 1 !== o) {
|
|
|
+ this.getGlobalScale(xe);
|
|
|
+ var a = xe[0] < 0 ? -1 : 1
|
|
|
+ , r = xe[1] < 0 ? -1 : 1
|
|
|
+ , s = ((xe[0] - a) * o + a) / xe[0] || 0
|
|
|
+ , l = ((xe[1] - r) * o + r) / xe[1] || 0;
|
|
|
+ n[0] *= s,
|
|
|
+ n[1] *= s,
|
|
|
+ n[2] *= l,
|
|
|
+ n[3] *= l
|
|
|
+ }
|
|
|
+ this.invTransform = this.invTransform || ae(),
|
|
|
+ de(this.invTransform, n)
|
|
|
+ } else
|
|
|
+ n && ge(n)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ye.getLocalTransform = function(t) {
|
|
|
+ return ve.getLocalTransform(this, t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ye.setTransform = function(t) {
|
|
|
+ var e = this.transform
|
|
|
+ , i = t.dpr || 1;
|
|
|
+ e ? t.setTransform(i * e[0], i * e[1], i * e[2], i * e[3], i * e[4], i * e[5]) : t.setTransform(i, 0, 0, i, 0, 0)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ye.restoreTransform = function(t) {
|
|
|
+ var e = t.dpr || 1;
|
|
|
+ t.setTransform(e, 0, 0, e, 0, 0)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var _e = []
|
|
|
+ , we = ae();
|
|
|
+ ye.setLocalTransform = function(t) {
|
|
|
+ if (t) {
|
|
|
+ var e = t[0] * t[0] + t[1] * t[1]
|
|
|
+ , i = t[2] * t[2] + t[3] * t[3]
|
|
|
+ , n = this.position
|
|
|
+ , o = this.scale;
|
|
|
+ me(e - 1) && (e = Math.sqrt(e)),
|
|
|
+ me(i - 1) && (i = Math.sqrt(i)),
|
|
|
+ t[0] < 0 && (e = -e),
|
|
|
+ t[3] < 0 && (i = -i),
|
|
|
+ n[0] = t[4],
|
|
|
+ n[1] = t[5],
|
|
|
+ o[0] = e,
|
|
|
+ o[1] = i,
|
|
|
+ this.rotation = Math.atan2(-t[1] / i, t[0] / e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ye.decomposeTransform = function() {
|
|
|
+ if (this.transform) {
|
|
|
+ var t = this.parent
|
|
|
+ , e = this.transform;
|
|
|
+ t && t.transform && (le(_e, t.invTransform, e),
|
|
|
+ e = _e);
|
|
|
+ var i = this.origin;
|
|
|
+ i && (i[0] || i[1]) && (we[4] = i[0],
|
|
|
+ we[5] = i[1],
|
|
|
+ le(_e, e, we),
|
|
|
+ _e[4] -= i[0],
|
|
|
+ _e[5] -= i[1],
|
|
|
+ e = _e),
|
|
|
+ this.setLocalTransform(e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ye.getGlobalScale = function(t) {
|
|
|
+ var e = this.transform;
|
|
|
+ return t = t || [],
|
|
|
+ e ? (t[0] = Math.sqrt(e[0] * e[0] + e[1] * e[1]),
|
|
|
+ t[1] = Math.sqrt(e[2] * e[2] + e[3] * e[3]),
|
|
|
+ e[0] < 0 && (t[0] = -t[0]),
|
|
|
+ e[3] < 0 && (t[1] = -t[1])) : (t[0] = 1,
|
|
|
+ t[1] = 1),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ye.transformCoordToLocal = function(t, e) {
|
|
|
+ var i = [t, e]
|
|
|
+ , n = this.invTransform;
|
|
|
+ return n && bt(i, i, n),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ye.transformCoordToGlobal = function(t, e) {
|
|
|
+ var i = [t, e]
|
|
|
+ , n = this.transform;
|
|
|
+ return n && bt(i, i, n),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ve.getLocalTransform = function(t, e) {
|
|
|
+ ge(e = e || []);
|
|
|
+ var i = t.origin
|
|
|
+ , n = t.scale || [1, 1]
|
|
|
+ , o = t.rotation || 0
|
|
|
+ , a = t.position || [0, 0];
|
|
|
+ return i && (e[4] -= i[0],
|
|
|
+ e[5] -= i[1]),
|
|
|
+ ce(e, e, n),
|
|
|
+ o && he(e, e, o),
|
|
|
+ i && (e[4] += i[0],
|
|
|
+ e[5] += i[1]),
|
|
|
+ e[4] += a[0],
|
|
|
+ e[5] += a[1],
|
|
|
+ e
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var be = {
|
|
|
+ linear: function(t) {
|
|
|
+ return t
|
|
|
+ },
|
|
|
+ quadraticIn: function(t) {
|
|
|
+ return t * t
|
|
|
+ },
|
|
|
+ quadraticOut: function(t) {
|
|
|
+ return t * (2 - t)
|
|
|
+ },
|
|
|
+ quadraticInOut: function(t) {
|
|
|
+ return (t *= 2) < 1 ? .5 * t * t : -.5 * (--t * (t - 2) - 1)
|
|
|
+ },
|
|
|
+ cubicIn: function(t) {
|
|
|
+ return t * t * t
|
|
|
+ },
|
|
|
+ cubicOut: function(t) {
|
|
|
+ return --t * t * t + 1
|
|
|
+ },
|
|
|
+ cubicInOut: function(t) {
|
|
|
+ return (t *= 2) < 1 ? .5 * t * t * t : .5 * ((t -= 2) * t * t + 2)
|
|
|
+ },
|
|
|
+ quarticIn: function(t) {
|
|
|
+ return t * t * t * t
|
|
|
+ },
|
|
|
+ quarticOut: function(t) {
|
|
|
+ return 1 - --t * t * t * t
|
|
|
+ },
|
|
|
+ quarticInOut: function(t) {
|
|
|
+ return (t *= 2) < 1 ? .5 * t * t * t * t : -.5 * ((t -= 2) * t * t * t - 2)
|
|
|
+ },
|
|
|
+ quinticIn: function(t) {
|
|
|
+ return t * t * t * t * t
|
|
|
+ },
|
|
|
+ quinticOut: function(t) {
|
|
|
+ return --t * t * t * t * t + 1
|
|
|
+ },
|
|
|
+ quinticInOut: function(t) {
|
|
|
+ return (t *= 2) < 1 ? .5 * t * t * t * t * t : .5 * ((t -= 2) * t * t * t * t + 2)
|
|
|
+ },
|
|
|
+ sinusoidalIn: function(t) {
|
|
|
+ return 1 - Math.cos(t * Math.PI / 2)
|
|
|
+ },
|
|
|
+ sinusoidalOut: function(t) {
|
|
|
+ return Math.sin(t * Math.PI / 2)
|
|
|
+ },
|
|
|
+ sinusoidalInOut: function(t) {
|
|
|
+ return .5 * (1 - Math.cos(Math.PI * t))
|
|
|
+ },
|
|
|
+ exponentialIn: function(t) {
|
|
|
+ return 0 === t ? 0 : Math.pow(1024, t - 1)
|
|
|
+ },
|
|
|
+ exponentialOut: function(t) {
|
|
|
+ return 1 === t ? 1 : 1 - Math.pow(2, -10 * t)
|
|
|
+ },
|
|
|
+ exponentialInOut: function(t) {
|
|
|
+ return 0 === t ? 0 : 1 === t ? 1 : (t *= 2) < 1 ? .5 * Math.pow(1024, t - 1) : .5 * (2 - Math.pow(2, -10 * (t - 1)))
|
|
|
+ },
|
|
|
+ circularIn: function(t) {
|
|
|
+ return 1 - Math.sqrt(1 - t * t)
|
|
|
+ },
|
|
|
+ circularOut: function(t) {
|
|
|
+ return Math.sqrt(1 - --t * t)
|
|
|
+ },
|
|
|
+ circularInOut: function(t) {
|
|
|
+ return (t *= 2) < 1 ? -.5 * (Math.sqrt(1 - t * t) - 1) : .5 * (Math.sqrt(1 - (t -= 2) * t) + 1)
|
|
|
+ },
|
|
|
+ elasticIn: function(t) {
|
|
|
+ var e, i = .1;
|
|
|
+ return 0 === t ? 0 : 1 === t ? 1 : (e = !i || i < 1 ? (i = 1,
|
|
|
+ .1) : .4 * Math.asin(1 / i) / (2 * Math.PI),
|
|
|
+ -i * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - e) * (2 * Math.PI) / .4))
|
|
|
+ },
|
|
|
+ elasticOut: function(t) {
|
|
|
+ var e, i = .1;
|
|
|
+ return 0 === t ? 0 : 1 === t ? 1 : (e = !i || i < 1 ? (i = 1,
|
|
|
+ .1) : .4 * Math.asin(1 / i) / (2 * Math.PI),
|
|
|
+ i * Math.pow(2, -10 * t) * Math.sin((t - e) * (2 * Math.PI) / .4) + 1)
|
|
|
+ },
|
|
|
+ elasticInOut: function(t) {
|
|
|
+ var e, i = .1;
|
|
|
+ return 0 === t ? 0 : 1 === t ? 1 : (e = !i || i < 1 ? (i = 1,
|
|
|
+ .1) : .4 * Math.asin(1 / i) / (2 * Math.PI),
|
|
|
+ (t *= 2) < 1 ? i * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - e) * (2 * Math.PI) / .4) * -.5 : i * Math.pow(2, -10 * (t -= 1)) * Math.sin((t - e) * (2 * Math.PI) / .4) * .5 + 1)
|
|
|
+ },
|
|
|
+ backIn: function(t) {
|
|
|
+ return t * t * (2.70158 * t - 1.70158)
|
|
|
+ },
|
|
|
+ backOut: function(t) {
|
|
|
+ return --t * t * (2.70158 * t + 1.70158) + 1
|
|
|
+ },
|
|
|
+ backInOut: function(t) {
|
|
|
+ var e = 2.5949095;
|
|
|
+ return (t *= 2) < 1 ? t * t * ((1 + e) * t - e) * .5 : .5 * ((t -= 2) * t * ((1 + e) * t + e) + 2)
|
|
|
+ },
|
|
|
+ bounceIn: function(t) {
|
|
|
+ return 1 - be.bounceOut(1 - t)
|
|
|
+ },
|
|
|
+ bounceOut: function(t) {
|
|
|
+ return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375
|
|
|
+ },
|
|
|
+ bounceInOut: function(t) {
|
|
|
+ return t < .5 ? .5 * be.bounceIn(2 * t) : .5 * be.bounceOut(2 * t - 1) + .5
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Se(t) {
|
|
|
+ this._target = t.target,
|
|
|
+ this._life = t.life || 1e3,
|
|
|
+ this._delay = t.delay || 0,
|
|
|
+ this._initialized = !1,
|
|
|
+ this.loop = null != t.loop && t.loop,
|
|
|
+ this.gap = t.gap || 0,
|
|
|
+ this.easing = t.easing || "Linear",
|
|
|
+ this.onframe = t.onframe,
|
|
|
+ this.ondestroy = t.ondestroy,
|
|
|
+ this.onrestart = t.onrestart,
|
|
|
+ this._pausedTime = 0,
|
|
|
+ this._paused = !1
|
|
|
+ }
|
|
|
+ Se.prototype = {
|
|
|
+ constructor: Se,
|
|
|
+ step: function(t, e) {
|
|
|
+ if (this._initialized || (this._startTime = t + this._delay,
|
|
|
+ this._initialized = !0),
|
|
|
+ this._paused)
|
|
|
+ this._pausedTime += e;
|
|
|
+ else {
|
|
|
+ var i = (t - this._startTime - this._pausedTime) / this._life;
|
|
|
+ if (!(i < 0)) {
|
|
|
+ i = Math.min(i, 1);
|
|
|
+ var n = this.easing
|
|
|
+ , o = "string" == typeof n ? be[n] : n
|
|
|
+ , a = "function" == typeof o ? o(i) : i;
|
|
|
+ return this.fire("frame", a),
|
|
|
+ 1 === i ? this.loop ? (this.restart(t),
|
|
|
+ "restart") : (this._needsRemove = !0,
|
|
|
+ "destroy") : null
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ restart: function(t) {
|
|
|
+ var e = (t - this._startTime - this._pausedTime) % this._life;
|
|
|
+ this._startTime = t - e + this.gap,
|
|
|
+ this._pausedTime = 0,
|
|
|
+ this._needsRemove = !1
|
|
|
+ },
|
|
|
+ fire: function(t, e) {
|
|
|
+ this[t = "on" + t] && this[t](this._target, e)
|
|
|
+ },
|
|
|
+ pause: function() {
|
|
|
+ this._paused = !0
|
|
|
+ },
|
|
|
+ resume: function() {
|
|
|
+ this._paused = !1
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Me() {
|
|
|
+ this.head = null,
|
|
|
+ this.tail = null,
|
|
|
+ this._len = 0
|
|
|
+ }
|
|
|
+ var Ie = Me.prototype;
|
|
|
+ Ie.insert = function(t) {
|
|
|
+ var e = new Ae(t);
|
|
|
+ return this.insertEntry(e),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ie.insertEntry = function(t) {
|
|
|
+ this.head ? ((this.tail.next = t).prev = this.tail,
|
|
|
+ t.next = null,
|
|
|
+ this.tail = t) : this.head = this.tail = t,
|
|
|
+ this._len++
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ie.remove = function(t) {
|
|
|
+ var e = t.prev
|
|
|
+ , i = t.next;
|
|
|
+ e ? e.next = i : this.head = i,
|
|
|
+ i ? i.prev = e : this.tail = e,
|
|
|
+ t.next = t.prev = null,
|
|
|
+ this._len--
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ie.len = function() {
|
|
|
+ return this._len
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ie.clear = function() {
|
|
|
+ this.head = this.tail = null,
|
|
|
+ this._len = 0
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function Te(t) {
|
|
|
+ this._list = new Me,
|
|
|
+ this._map = {},
|
|
|
+ this._maxSize = t || 10,
|
|
|
+ this._lastRemovedEntry = null
|
|
|
+ }
|
|
|
+ var Ae = function(t) {
|
|
|
+ this.value = t,
|
|
|
+ this.next,
|
|
|
+ this.prev
|
|
|
+ }
|
|
|
+ , De = Te.prototype;
|
|
|
+ De.put = function(t, e) {
|
|
|
+ var i = this._list
|
|
|
+ , n = this._map
|
|
|
+ , o = null;
|
|
|
+ if (null == n[t]) {
|
|
|
+ var a = i.len()
|
|
|
+ , r = this._lastRemovedEntry;
|
|
|
+ if (a >= this._maxSize && 0 < a) {
|
|
|
+ var s = i.head;
|
|
|
+ i.remove(s),
|
|
|
+ delete n[s.key],
|
|
|
+ o = s.value,
|
|
|
+ this._lastRemovedEntry = s
|
|
|
+ }
|
|
|
+ r ? r.value = e : r = new Ae(e),
|
|
|
+ r.key = t,
|
|
|
+ i.insertEntry(r),
|
|
|
+ n[t] = r
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ De.get = function(t) {
|
|
|
+ var e = this._map[t]
|
|
|
+ , i = this._list;
|
|
|
+ if (null != e)
|
|
|
+ return e !== i.tail && (i.remove(e),
|
|
|
+ i.insertEntry(e)),
|
|
|
+ e.value
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ De.clear = function() {
|
|
|
+ this._list.clear(),
|
|
|
+ this._map = {}
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Ce = {
|
|
|
+ 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 Le(t) {
|
|
|
+ return (t = Math.round(t)) < 0 ? 0 : 255 < t ? 255 : t
|
|
|
+ }
|
|
|
+ function ke(t) {
|
|
|
+ return t < 0 ? 0 : 1 < t ? 1 : t
|
|
|
+ }
|
|
|
+ function Pe(t) {
|
|
|
+ return t.length && "%" === t.charAt(t.length - 1) ? Le(parseFloat(t) / 100 * 255) : Le(parseInt(t, 10))
|
|
|
+ }
|
|
|
+ function Ne(t) {
|
|
|
+ return t.length && "%" === t.charAt(t.length - 1) ? ke(parseFloat(t) / 100) : ke(parseFloat(t))
|
|
|
+ }
|
|
|
+ function Oe(t, e, i) {
|
|
|
+ return i < 0 ? i += 1 : 1 < i && (i -= 1),
|
|
|
+ 6 * i < 1 ? t + (e - t) * i * 6 : 2 * i < 1 ? e : 3 * i < 2 ? t + (e - t) * (2 / 3 - i) * 6 : t
|
|
|
+ }
|
|
|
+ function Ee(t, e, i) {
|
|
|
+ return t + (e - t) * i
|
|
|
+ }
|
|
|
+ function Re(t, e, i, n, o) {
|
|
|
+ return t[0] = e,
|
|
|
+ t[1] = i,
|
|
|
+ t[2] = n,
|
|
|
+ t[3] = o,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function ze(t, e) {
|
|
|
+ return t[0] = e[0],
|
|
|
+ t[1] = e[1],
|
|
|
+ t[2] = e[2],
|
|
|
+ t[3] = e[3],
|
|
|
+ t
|
|
|
+ }
|
|
|
+ var Be = new Te(20)
|
|
|
+ , Ve = null;
|
|
|
+ function Ge(t, e) {
|
|
|
+ Ve && ze(Ve, e),
|
|
|
+ Ve = Be.put(t, Ve || e.slice())
|
|
|
+ }
|
|
|
+ function Fe(t, e) {
|
|
|
+ if (t) {
|
|
|
+ e = e || [];
|
|
|
+ var i = Be.get(t);
|
|
|
+ if (i)
|
|
|
+ return ze(e, i);
|
|
|
+ var n, o = (t += "").replace(/ /g, "").toLowerCase();
|
|
|
+ if (o in Ce)
|
|
|
+ return ze(e, Ce[o]),
|
|
|
+ Ge(t, e),
|
|
|
+ e;
|
|
|
+ if ("#" === o.charAt(0))
|
|
|
+ return 4 === o.length ? 0 <= (n = parseInt(o.substr(1), 16)) && n <= 4095 ? (Re(e, (3840 & n) >> 4 | (3840 & n) >> 8, 240 & n | (240 & n) >> 4, 15 & n | (15 & n) << 4, 1),
|
|
|
+ Ge(t, e),
|
|
|
+ e) : void Re(e, 0, 0, 0, 1) : 7 === o.length ? 0 <= (n = parseInt(o.substr(1), 16)) && n <= 16777215 ? (Re(e, (16711680 & n) >> 16, (65280 & n) >> 8, 255 & n, 1),
|
|
|
+ Ge(t, e),
|
|
|
+ e) : void Re(e, 0, 0, 0, 1) : void 0;
|
|
|
+ var a = o.indexOf("(")
|
|
|
+ , r = o.indexOf(")");
|
|
|
+ if (-1 !== a && r + 1 === o.length) {
|
|
|
+ var s = o.substr(0, a)
|
|
|
+ , l = o.substr(a + 1, r - (a + 1)).split(",")
|
|
|
+ , u = 1;
|
|
|
+ switch (s) {
|
|
|
+ case "rgba":
|
|
|
+ if (4 !== l.length)
|
|
|
+ return void Re(e, 0, 0, 0, 1);
|
|
|
+ u = Ne(l.pop());
|
|
|
+ case "rgb":
|
|
|
+ return 3 !== l.length ? void Re(e, 0, 0, 0, 1) : (Re(e, Pe(l[0]), Pe(l[1]), Pe(l[2]), u),
|
|
|
+ Ge(t, e),
|
|
|
+ e);
|
|
|
+ case "hsla":
|
|
|
+ return 4 !== l.length ? void Re(e, 0, 0, 0, 1) : (l[3] = Ne(l[3]),
|
|
|
+ We(l, e),
|
|
|
+ Ge(t, e),
|
|
|
+ e);
|
|
|
+ case "hsl":
|
|
|
+ return 3 !== l.length ? void Re(e, 0, 0, 0, 1) : (We(l, e),
|
|
|
+ Ge(t, e),
|
|
|
+ e);
|
|
|
+ default:
|
|
|
+ return
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Re(e, 0, 0, 0, 1)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function We(t, e) {
|
|
|
+ var i = (parseFloat(t[0]) % 360 + 360) % 360 / 360
|
|
|
+ , n = Ne(t[1])
|
|
|
+ , o = Ne(t[2])
|
|
|
+ , a = o <= .5 ? o * (n + 1) : o + n - o * n
|
|
|
+ , r = 2 * o - a;
|
|
|
+ return Re(e = e || [], Le(255 * Oe(r, a, i + 1 / 3)), Le(255 * Oe(r, a, i)), Le(255 * Oe(r, a, i - 1 / 3)), 1),
|
|
|
+ 4 === t.length && (e[3] = t[3]),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function He(t, e) {
|
|
|
+ var i = Fe(t);
|
|
|
+ if (i) {
|
|
|
+ for (var n = 0; n < 3; n++)
|
|
|
+ i[n] = e < 0 ? i[n] * (1 - e) | 0 : (255 - i[n]) * e + i[n] | 0,
|
|
|
+ 255 < i[n] ? i[n] = 255 : t[n] < 0 && (i[n] = 0);
|
|
|
+ return $e(i, 4 === i.length ? "rgba" : "rgb")
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ze(t) {
|
|
|
+ var e = Fe(t);
|
|
|
+ if (e)
|
|
|
+ return ((1 << 24) + (e[0] << 16) + (e[1] << 8) + +e[2]).toString(16).slice(1)
|
|
|
+ }
|
|
|
+ function Ue(t, e, i) {
|
|
|
+ if (e && e.length && 0 <= t && t <= 1) {
|
|
|
+ i = i || [];
|
|
|
+ var n = t * (e.length - 1)
|
|
|
+ , o = Math.floor(n)
|
|
|
+ , a = Math.ceil(n)
|
|
|
+ , r = e[o]
|
|
|
+ , s = e[a]
|
|
|
+ , l = n - o;
|
|
|
+ return i[0] = Le(Ee(r[0], s[0], l)),
|
|
|
+ i[1] = Le(Ee(r[1], s[1], l)),
|
|
|
+ i[2] = Le(Ee(r[2], s[2], l)),
|
|
|
+ i[3] = ke(Ee(r[3], s[3], l)),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Xe = Ue;
|
|
|
+ function Ye(t, e, i) {
|
|
|
+ if (e && e.length && 0 <= t && t <= 1) {
|
|
|
+ var n = t * (e.length - 1)
|
|
|
+ , o = Math.floor(n)
|
|
|
+ , a = Math.ceil(n)
|
|
|
+ , r = Fe(e[o])
|
|
|
+ , s = Fe(e[a])
|
|
|
+ , l = n - o
|
|
|
+ , u = $e([Le(Ee(r[0], s[0], l)), Le(Ee(r[1], s[1], l)), Le(Ee(r[2], s[2], l)), ke(Ee(r[3], s[3], l))], "rgba");
|
|
|
+ return i ? {
|
|
|
+ color: u,
|
|
|
+ leftIndex: o,
|
|
|
+ rightIndex: a,
|
|
|
+ value: n
|
|
|
+ } : u
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var je = Ye;
|
|
|
+ function qe(t, e, i, n) {
|
|
|
+ if (t = Fe(t))
|
|
|
+ return t = function(t) {
|
|
|
+ if (t) {
|
|
|
+ var e, i, n = t[0] / 255, o = t[1] / 255, a = t[2] / 255, r = Math.min(n, o, a), s = Math.max(n, o, a), l = s - r, u = (s + r) / 2;
|
|
|
+ if (0 == l)
|
|
|
+ i = e = 0;
|
|
|
+ else {
|
|
|
+ i = u < .5 ? l / (s + r) : l / (2 - s - r);
|
|
|
+ var h = ((s - n) / 6 + l / 2) / l
|
|
|
+ , c = ((s - o) / 6 + l / 2) / l
|
|
|
+ , d = ((s - a) / 6 + l / 2) / l;
|
|
|
+ n === s ? e = d - c : o === s ? e = 1 / 3 + h - d : a === s && (e = 2 / 3 + c - h),
|
|
|
+ e < 0 && (e += 1),
|
|
|
+ 1 < e && (e -= 1)
|
|
|
+ }
|
|
|
+ var f = [360 * e, i, u];
|
|
|
+ return null != t[3] && f.push(t[3]),
|
|
|
+ f
|
|
|
+ }
|
|
|
+ }(t),
|
|
|
+ null != e && (t[0] = function(t) {
|
|
|
+ return (t = Math.round(t)) < 0 ? 0 : 360 < t ? 360 : t
|
|
|
+ }(e)),
|
|
|
+ null != i && (t[1] = Ne(i)),
|
|
|
+ null != n && (t[2] = Ne(n)),
|
|
|
+ $e(We(t), "rgba")
|
|
|
+ }
|
|
|
+ function Ke(t, e) {
|
|
|
+ if ((t = Fe(t)) && null != e)
|
|
|
+ return t[3] = ke(e),
|
|
|
+ $e(t, "rgba")
|
|
|
+ }
|
|
|
+ function $e(t, e) {
|
|
|
+ if (t && t.length) {
|
|
|
+ var i = t[0] + "," + t[1] + "," + t[2];
|
|
|
+ return "rgba" !== e && "hsva" !== e && "hsla" !== e || (i += "," + t[3]),
|
|
|
+ e + "(" + i + ")"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Je = (Object.freeze || Object)({
|
|
|
+ parse: Fe,
|
|
|
+ lift: He,
|
|
|
+ toHex: Ze,
|
|
|
+ fastLerp: Ue,
|
|
|
+ fastMapToColor: Xe,
|
|
|
+ lerp: Ye,
|
|
|
+ mapToColor: je,
|
|
|
+ modifyHSL: qe,
|
|
|
+ modifyAlpha: Ke,
|
|
|
+ stringify: $e
|
|
|
+ })
|
|
|
+ , Qe = Array.prototype.slice;
|
|
|
+ function ti(t, e) {
|
|
|
+ return t[e]
|
|
|
+ }
|
|
|
+ function ei(t, e, i) {
|
|
|
+ t[e] = i
|
|
|
+ }
|
|
|
+ function ii(t, e, i) {
|
|
|
+ return (e - t) * i + t
|
|
|
+ }
|
|
|
+ function ni(t, e, i) {
|
|
|
+ return .5 < i ? e : t
|
|
|
+ }
|
|
|
+ function oi(t, e, i, n, o) {
|
|
|
+ var a = t.length;
|
|
|
+ if (1 === o)
|
|
|
+ for (var r = 0; r < a; r++)
|
|
|
+ n[r] = ii(t[r], e[r], i);
|
|
|
+ else {
|
|
|
+ var s = a && t[0].length;
|
|
|
+ for (r = 0; r < a; r++)
|
|
|
+ for (var l = 0; l < s; l++)
|
|
|
+ n[r][l] = ii(t[r][l], e[r][l], i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ai(t, e, i) {
|
|
|
+ var n = t.length
|
|
|
+ , o = e.length;
|
|
|
+ if (n !== o)
|
|
|
+ if (o < n)
|
|
|
+ t.length = o;
|
|
|
+ else
|
|
|
+ for (var a = n; a < o; a++)
|
|
|
+ t.push(1 === i ? e[a] : Qe.call(e[a]));
|
|
|
+ var r = t[0] && t[0].length;
|
|
|
+ for (a = 0; a < t.length; a++)
|
|
|
+ if (1 === i)
|
|
|
+ isNaN(t[a]) && (t[a] = e[a]);
|
|
|
+ else
|
|
|
+ for (var s = 0; s < r; s++)
|
|
|
+ isNaN(t[a][s]) && (t[a][s] = e[a][s])
|
|
|
+ }
|
|
|
+ function ri(t, e, i) {
|
|
|
+ if (t === e)
|
|
|
+ return !0;
|
|
|
+ var n = t.length;
|
|
|
+ if (n !== e.length)
|
|
|
+ return !1;
|
|
|
+ if (1 === i) {
|
|
|
+ for (var o = 0; o < n; o++)
|
|
|
+ if (t[o] !== e[o])
|
|
|
+ return !1
|
|
|
+ } else {
|
|
|
+ var a = t[0].length;
|
|
|
+ for (o = 0; o < n; o++)
|
|
|
+ for (var r = 0; r < a; r++)
|
|
|
+ if (t[o][r] !== e[o][r])
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ function si(t, e, i, n, o, a, r, s, l) {
|
|
|
+ var u = t.length;
|
|
|
+ if (1 === l)
|
|
|
+ for (var h = 0; h < u; h++)
|
|
|
+ s[h] = li(t[h], e[h], i[h], n[h], o, a, r);
|
|
|
+ else {
|
|
|
+ var c = t[0].length;
|
|
|
+ for (h = 0; h < u; h++)
|
|
|
+ for (var d = 0; d < c; d++)
|
|
|
+ s[h][d] = li(t[h][d], e[h][d], i[h][d], n[h][d], o, a, r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function li(t, e, i, n, o, a, r) {
|
|
|
+ var s = .5 * (i - t)
|
|
|
+ , l = .5 * (n - e);
|
|
|
+ return (2 * (e - i) + s + l) * r + (-3 * (e - i) - 2 * s - l) * a + s * o + e
|
|
|
+ }
|
|
|
+ function ui(t) {
|
|
|
+ if (N(t)) {
|
|
|
+ var e = t.length;
|
|
|
+ if (N(t[0])) {
|
|
|
+ for (var i = [], n = 0; n < e; n++)
|
|
|
+ i.push(Qe.call(t[n]));
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ return Qe.call(t)
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function hi(t) {
|
|
|
+ return t[0] = Math.floor(t[0]),
|
|
|
+ t[1] = Math.floor(t[1]),
|
|
|
+ t[2] = Math.floor(t[2]),
|
|
|
+ "rgba(" + t.join(",") + ")"
|
|
|
+ }
|
|
|
+ function ci(t, e, i, n, a, o) {
|
|
|
+ var r = t._getter
|
|
|
+ , s = t._setter
|
|
|
+ , l = "spline" === e
|
|
|
+ , u = n.length;
|
|
|
+ if (u) {
|
|
|
+ var h, c = N(n[0].value), d = !1, f = !1, p = c ? function(t) {
|
|
|
+ var e = t[t.length - 1].value;
|
|
|
+ return N(e && e[0]) ? 2 : 1
|
|
|
+ }(n) : 0;
|
|
|
+ n.sort(function(t, e) {
|
|
|
+ return t.time - e.time
|
|
|
+ }),
|
|
|
+ h = n[u - 1].time;
|
|
|
+ for (var g = [], m = [], v = n[0].value, y = !0, x = 0; x < u; x++) {
|
|
|
+ g.push(n[x].time / h);
|
|
|
+ var _ = n[x].value;
|
|
|
+ if (c && ri(_, v, p) || !c && _ === v || (y = !1),
|
|
|
+ "string" == typeof (v = _)) {
|
|
|
+ var w = Fe(_);
|
|
|
+ w ? (_ = w,
|
|
|
+ d = !0) : f = !0
|
|
|
+ }
|
|
|
+ m.push(_)
|
|
|
+ }
|
|
|
+ if (o || !y) {
|
|
|
+ var b = m[u - 1];
|
|
|
+ for (x = 0; x < u - 1; x++)
|
|
|
+ c ? ai(m[x], b, p) : !isNaN(m[x]) || isNaN(b) || f || d || (m[x] = b);
|
|
|
+ c && ai(r(t._target, a), b, p);
|
|
|
+ var S, M, I, T, A, D = 0, C = 0;
|
|
|
+ if (d)
|
|
|
+ var L = [0, 0, 0, 0];
|
|
|
+ var k = new Se({
|
|
|
+ target: t._target,
|
|
|
+ life: h,
|
|
|
+ loop: t._loop,
|
|
|
+ delay: t._delay,
|
|
|
+ onframe: function(t, e) {
|
|
|
+ var i;
|
|
|
+ if (e < 0)
|
|
|
+ i = 0;
|
|
|
+ else if (e < C) {
|
|
|
+ for (i = Math.min(D + 1, u - 1); 0 <= i && !(g[i] <= e); i--)
|
|
|
+ ;
|
|
|
+ i = Math.min(i, u - 2)
|
|
|
+ } else {
|
|
|
+ for (i = D; i < u && !(g[i] > e); i++)
|
|
|
+ ;
|
|
|
+ i = Math.min(i - 1, u - 2)
|
|
|
+ }
|
|
|
+ C = e;
|
|
|
+ var n = g[(D = i) + 1] - g[i];
|
|
|
+ if (0 != n)
|
|
|
+ if (S = (e - g[i]) / n,
|
|
|
+ l)
|
|
|
+ if (I = m[i],
|
|
|
+ M = m[0 === i ? i : i - 1],
|
|
|
+ T = m[u - 2 < i ? u - 1 : i + 1],
|
|
|
+ A = m[u - 3 < i ? u - 1 : i + 2],
|
|
|
+ c)
|
|
|
+ si(M, I, T, A, S, S * S, S * S * S, r(t, a), p);
|
|
|
+ else {
|
|
|
+ if (d)
|
|
|
+ o = si(M, I, T, A, S, S * S, S * S * S, L, 1),
|
|
|
+ o = hi(L);
|
|
|
+ else {
|
|
|
+ if (f)
|
|
|
+ return ni(I, T, S);
|
|
|
+ o = li(M, I, T, A, S, S * S, S * S * S)
|
|
|
+ }
|
|
|
+ s(t, a, o)
|
|
|
+ }
|
|
|
+ else if (c)
|
|
|
+ oi(m[i], m[i + 1], S, r(t, a), p);
|
|
|
+ else {
|
|
|
+ var o;
|
|
|
+ if (d)
|
|
|
+ oi(m[i], m[i + 1], S, L, 1),
|
|
|
+ o = hi(L);
|
|
|
+ else {
|
|
|
+ if (f)
|
|
|
+ return ni(m[i], m[i + 1], S);
|
|
|
+ o = ii(m[i], m[i + 1], S)
|
|
|
+ }
|
|
|
+ s(t, a, o)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ ondestroy: i
|
|
|
+ });
|
|
|
+ return e && "spline" !== e && (k.easing = e),
|
|
|
+ k
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function di(t, e, i, n) {
|
|
|
+ this._tracks = {},
|
|
|
+ this._target = t,
|
|
|
+ this._loop = e || !1,
|
|
|
+ this._getter = i || ti,
|
|
|
+ this._setter = n || ei,
|
|
|
+ this._clipCount = 0,
|
|
|
+ this._delay = 0,
|
|
|
+ this._doneList = [],
|
|
|
+ this._onframeList = [],
|
|
|
+ this._clipList = []
|
|
|
+ }
|
|
|
+ di.prototype = {
|
|
|
+ when: function(t, e) {
|
|
|
+ var i = this._tracks;
|
|
|
+ for (var n in e)
|
|
|
+ if (e.hasOwnProperty(n)) {
|
|
|
+ if (!i[n]) {
|
|
|
+ i[n] = [];
|
|
|
+ var o = this._getter(this._target, n);
|
|
|
+ if (null == o)
|
|
|
+ continue;
|
|
|
+ 0 !== t && i[n].push({
|
|
|
+ time: 0,
|
|
|
+ value: ui(o)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ i[n].push({
|
|
|
+ time: t,
|
|
|
+ value: e[n]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ during: function(t) {
|
|
|
+ return this._onframeList.push(t),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ pause: function() {
|
|
|
+ for (var t = 0; t < this._clipList.length; t++)
|
|
|
+ this._clipList[t].pause();
|
|
|
+ this._paused = !0
|
|
|
+ },
|
|
|
+ resume: function() {
|
|
|
+ for (var t = 0; t < this._clipList.length; t++)
|
|
|
+ this._clipList[t].resume();
|
|
|
+ this._paused = !1
|
|
|
+ },
|
|
|
+ isPaused: function() {
|
|
|
+ return !!this._paused
|
|
|
+ },
|
|
|
+ _doneCallback: function() {
|
|
|
+ this._tracks = {},
|
|
|
+ this._clipList.length = 0;
|
|
|
+ for (var t = this._doneList, e = t.length, i = 0; i < e; i++)
|
|
|
+ t[i].call(this)
|
|
|
+ },
|
|
|
+ start: function(t, e) {
|
|
|
+ function i() {
|
|
|
+ --a || o._doneCallback()
|
|
|
+ }
|
|
|
+ var n, o = this, a = 0;
|
|
|
+ for (var r in this._tracks)
|
|
|
+ if (this._tracks.hasOwnProperty(r)) {
|
|
|
+ var s = ci(this, t, i, this._tracks[r], r, e);
|
|
|
+ s && (this._clipList.push(s),
|
|
|
+ a++,
|
|
|
+ this.animation && this.animation.addClip(s),
|
|
|
+ n = s)
|
|
|
+ }
|
|
|
+ if (n) {
|
|
|
+ var l = n.onframe;
|
|
|
+ n.onframe = function(t, e) {
|
|
|
+ l(t, e);
|
|
|
+ for (var i = 0; i < o._onframeList.length; i++)
|
|
|
+ o._onframeList[i](t, e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return a || this._doneCallback(),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ stop: function(t) {
|
|
|
+ for (var e = this._clipList, i = this.animation, n = 0; n < e.length; n++) {
|
|
|
+ var o = e[n];
|
|
|
+ t && o.onframe(this._target, 1),
|
|
|
+ i && i.removeClip(o)
|
|
|
+ }
|
|
|
+ e.length = 0
|
|
|
+ },
|
|
|
+ delay: function(t) {
|
|
|
+ return this._delay = t,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ done: function(t) {
|
|
|
+ return t && this._doneList.push(t),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ getClips: function() {
|
|
|
+ return this._clipList
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var fi = 1;
|
|
|
+ "undefined" != typeof window && (fi = Math.max(window.devicePixelRatio || 1, 1));
|
|
|
+ var pi = fi
|
|
|
+ , gi = function() {};
|
|
|
+ function mi() {
|
|
|
+ this.animators = []
|
|
|
+ }
|
|
|
+ var vi = gi;
|
|
|
+ function yi(t, e, i, n, o, a, r, s) {
|
|
|
+ R(n) ? (a = o,
|
|
|
+ o = n,
|
|
|
+ n = 0) : C(o) ? (a = o,
|
|
|
+ o = "linear",
|
|
|
+ n = 0) : C(n) ? (a = n,
|
|
|
+ n = 0) : i = C(i) ? (a = i,
|
|
|
+ 500) : i || 500,
|
|
|
+ t.stopAnimation(),
|
|
|
+ function t(e, i, n, o, a, r, s) {
|
|
|
+ var l = {};
|
|
|
+ var u = 0;
|
|
|
+ for (var h in o)
|
|
|
+ o.hasOwnProperty(h) && (null != n[h] ? z(o[h]) && !N(o[h]) ? t(e, i ? i + "." + h : h, n[h], o[h], a, r, s) : (s ? (l[h] = n[h],
|
|
|
+ xi(e, i, h, o[h])) : l[h] = o[h],
|
|
|
+ u++) : null == o[h] || s || xi(e, i, h, o[h]));
|
|
|
+ 0 < u && e.animate(i, !1).when(null == a ? 500 : a, l).delay(r || 0)
|
|
|
+ }(t, "", t, e, i, n, s);
|
|
|
+ var l = t.animators.slice()
|
|
|
+ , u = l.length;
|
|
|
+ function h() {
|
|
|
+ --u || a && a()
|
|
|
+ }
|
|
|
+ u || a && a();
|
|
|
+ for (var c = 0; c < l.length; c++)
|
|
|
+ l[c].done(h).start(o, r)
|
|
|
+ }
|
|
|
+ function xi(t, e, i, n) {
|
|
|
+ if (e) {
|
|
|
+ var o = {};
|
|
|
+ o[e] = {},
|
|
|
+ o[e][i] = n,
|
|
|
+ t.attr(o)
|
|
|
+ } else
|
|
|
+ t.attr(i, n)
|
|
|
+ }
|
|
|
+ mi.prototype = {
|
|
|
+ constructor: mi,
|
|
|
+ animate: function(t, e) {
|
|
|
+ var i, n = !1, o = this, a = this.__zr;
|
|
|
+ if (t) {
|
|
|
+ var r = t.split(".")
|
|
|
+ , s = o;
|
|
|
+ n = "shape" === r[0];
|
|
|
+ for (var l = 0, u = r.length; l < u; l++)
|
|
|
+ s = s && s[r[l]];
|
|
|
+ s && (i = s)
|
|
|
+ } else
|
|
|
+ i = o;
|
|
|
+ if (i) {
|
|
|
+ var h = o.animators
|
|
|
+ , c = new di(i,e);
|
|
|
+ return c.during(function(t) {
|
|
|
+ o.dirty(n)
|
|
|
+ }).done(function() {
|
|
|
+ h.splice(_(h, c), 1)
|
|
|
+ }),
|
|
|
+ h.push(c),
|
|
|
+ a && a.animation.addAnimator(c),
|
|
|
+ c
|
|
|
+ }
|
|
|
+ vi('Property "' + t + '" is not existed in element ' + o.id)
|
|
|
+ },
|
|
|
+ stopAnimation: function(t) {
|
|
|
+ for (var e = this.animators, i = e.length, n = 0; n < i; n++)
|
|
|
+ e[n].stop(t);
|
|
|
+ return e.length = 0,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ animateTo: function(t, e, i, n, o, a) {
|
|
|
+ yi(this, t, e, i, n, o, a)
|
|
|
+ },
|
|
|
+ animateFrom: function(t, e, i, n, o, a) {
|
|
|
+ yi(this, t, e, i, n, o, a, !0)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var _i = function(t) {
|
|
|
+ ve.call(this, t),
|
|
|
+ Ct.call(this, t),
|
|
|
+ mi.call(this, t),
|
|
|
+ this.id = t.id || n()
|
|
|
+ };
|
|
|
+ _i.prototype = {
|
|
|
+ type: "element",
|
|
|
+ name: "",
|
|
|
+ __zr: null,
|
|
|
+ ignore: !1,
|
|
|
+ clipPath: null,
|
|
|
+ isGroup: !1,
|
|
|
+ drift: function(t, e) {
|
|
|
+ switch (this.draggable) {
|
|
|
+ case "horizontal":
|
|
|
+ e = 0;
|
|
|
+ break;
|
|
|
+ case "vertical":
|
|
|
+ t = 0
|
|
|
+ }
|
|
|
+ var i = this.transform;
|
|
|
+ (i = i || (this.transform = [1, 0, 0, 1, 0, 0]))[4] += t,
|
|
|
+ i[5] += e,
|
|
|
+ this.decomposeTransform(),
|
|
|
+ this.dirty(!1)
|
|
|
+ },
|
|
|
+ beforeUpdate: function() {},
|
|
|
+ afterUpdate: function() {},
|
|
|
+ update: function() {
|
|
|
+ this.updateTransform()
|
|
|
+ },
|
|
|
+ traverse: function(t, e) {},
|
|
|
+ attrKV: function(t, e) {
|
|
|
+ if ("position" === t || "scale" === t || "origin" === t) {
|
|
|
+ if (e) {
|
|
|
+ var i = this[t];
|
|
|
+ (i = i || (this[t] = []))[0] = e[0],
|
|
|
+ i[1] = e[1]
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ this[t] = e
|
|
|
+ },
|
|
|
+ hide: function() {
|
|
|
+ this.ignore = !0,
|
|
|
+ this.__zr && this.__zr.refresh()
|
|
|
+ },
|
|
|
+ show: function() {
|
|
|
+ this.ignore = !1,
|
|
|
+ this.__zr && this.__zr.refresh()
|
|
|
+ },
|
|
|
+ attr: function(t, e) {
|
|
|
+ if ("string" == typeof t)
|
|
|
+ this.attrKV(t, e);
|
|
|
+ else if (z(t))
|
|
|
+ for (var i in t)
|
|
|
+ t.hasOwnProperty(i) && this.attrKV(i, t[i]);
|
|
|
+ return this.dirty(!1),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ setClipPath: function(t) {
|
|
|
+ var e = this.__zr;
|
|
|
+ e && t.addSelfToZr(e),
|
|
|
+ this.clipPath && this.clipPath !== t && this.removeClipPath(),
|
|
|
+ (this.clipPath = t).__zr = e,
|
|
|
+ (t.__clipTarget = this).dirty(!1)
|
|
|
+ },
|
|
|
+ removeClipPath: function() {
|
|
|
+ var t = this.clipPath;
|
|
|
+ t && (t.__zr && t.removeSelfFromZr(t.__zr),
|
|
|
+ t.__zr = null,
|
|
|
+ t.__clipTarget = null,
|
|
|
+ this.clipPath = null,
|
|
|
+ this.dirty(!1))
|
|
|
+ },
|
|
|
+ addSelfToZr: function(t) {
|
|
|
+ this.__zr = t;
|
|
|
+ var e = this.animators;
|
|
|
+ if (e)
|
|
|
+ for (var i = 0; i < e.length; i++)
|
|
|
+ t.animation.addAnimator(e[i]);
|
|
|
+ this.clipPath && this.clipPath.addSelfToZr(t)
|
|
|
+ },
|
|
|
+ removeSelfFromZr: function(t) {
|
|
|
+ this.__zr = null;
|
|
|
+ var e = this.animators;
|
|
|
+ if (e)
|
|
|
+ for (var i = 0; i < e.length; i++)
|
|
|
+ t.animation.removeAnimator(e[i]);
|
|
|
+ this.clipPath && this.clipPath.removeSelfFromZr(t)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ b(_i, mi),
|
|
|
+ b(_i, ve),
|
|
|
+ b(_i, Ct);
|
|
|
+ var wi, bi, Si, Mi, Ii = bt, Ti = Math.min, Ai = Math.max;
|
|
|
+ function Di(t, e, i, n) {
|
|
|
+ i < 0 && (t += i,
|
|
|
+ i = -i),
|
|
|
+ n < 0 && (e += n,
|
|
|
+ n = -n),
|
|
|
+ this.x = t,
|
|
|
+ this.y = e,
|
|
|
+ this.width = i,
|
|
|
+ this.height = n
|
|
|
+ }
|
|
|
+ Di.prototype = {
|
|
|
+ constructor: Di,
|
|
|
+ union: function(t) {
|
|
|
+ var e = Ti(t.x, this.x)
|
|
|
+ , i = Ti(t.y, this.y);
|
|
|
+ this.width = Ai(t.x + t.width, this.x + this.width) - e,
|
|
|
+ this.height = Ai(t.y + t.height, this.y + this.height) - i,
|
|
|
+ this.x = e,
|
|
|
+ this.y = i
|
|
|
+ },
|
|
|
+ applyTransform: (wi = [],
|
|
|
+ bi = [],
|
|
|
+ Si = [],
|
|
|
+ Mi = [],
|
|
|
+ function(t) {
|
|
|
+ if (t) {
|
|
|
+ wi[0] = Si[0] = this.x,
|
|
|
+ wi[1] = Mi[1] = this.y,
|
|
|
+ bi[0] = Mi[0] = this.x + this.width,
|
|
|
+ bi[1] = Si[1] = this.y + this.height,
|
|
|
+ Ii(wi, wi, t),
|
|
|
+ Ii(bi, bi, t),
|
|
|
+ Ii(Si, Si, t),
|
|
|
+ Ii(Mi, Mi, t),
|
|
|
+ this.x = Ti(wi[0], bi[0], Si[0], Mi[0]),
|
|
|
+ this.y = Ti(wi[1], bi[1], Si[1], Mi[1]);
|
|
|
+ var e = Ai(wi[0], bi[0], Si[0], Mi[0])
|
|
|
+ , i = Ai(wi[1], bi[1], Si[1], Mi[1]);
|
|
|
+ this.width = e - this.x,
|
|
|
+ this.height = i - this.y
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ calculateTransform: function(t) {
|
|
|
+ var e = t.width / this.width
|
|
|
+ , i = t.height / this.height
|
|
|
+ , n = ae();
|
|
|
+ return ue(n, n, [-this.x, -this.y]),
|
|
|
+ ce(n, n, [e, i]),
|
|
|
+ ue(n, n, [t.x, t.y]),
|
|
|
+ n
|
|
|
+ },
|
|
|
+ intersect: function(t) {
|
|
|
+ if (!t)
|
|
|
+ return !1;
|
|
|
+ t instanceof Di || (t = Di.create(t));
|
|
|
+ var e = this
|
|
|
+ , i = e.x
|
|
|
+ , n = e.x + e.width
|
|
|
+ , o = e.y
|
|
|
+ , a = e.y + e.height
|
|
|
+ , r = t.x
|
|
|
+ , s = t.x + t.width
|
|
|
+ , l = t.y
|
|
|
+ , u = t.y + t.height;
|
|
|
+ return !(n < r || s < i || a < l || u < o)
|
|
|
+ },
|
|
|
+ contain: function(t, e) {
|
|
|
+ var i = this;
|
|
|
+ return t >= i.x && t <= i.x + i.width && e >= i.y && e <= i.y + i.height
|
|
|
+ },
|
|
|
+ clone: function() {
|
|
|
+ return new Di(this.x,this.y,this.width,this.height)
|
|
|
+ },
|
|
|
+ copy: function(t) {
|
|
|
+ this.x = t.x,
|
|
|
+ this.y = t.y,
|
|
|
+ this.width = t.width,
|
|
|
+ this.height = t.height
|
|
|
+ },
|
|
|
+ plain: function() {
|
|
|
+ return {
|
|
|
+ x: this.x,
|
|
|
+ y: this.y,
|
|
|
+ width: this.width,
|
|
|
+ height: this.height
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Di.create = function(t) {
|
|
|
+ return new Di(t.x,t.y,t.width,t.height)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Ci = function(t) {
|
|
|
+ for (var e in t = t || {},
|
|
|
+ _i.call(this, t),
|
|
|
+ t)
|
|
|
+ t.hasOwnProperty(e) && (this[e] = t[e]);
|
|
|
+ this._children = [],
|
|
|
+ this.__storage = null,
|
|
|
+ this.__dirty = !0
|
|
|
+ };
|
|
|
+ Ci.prototype = {
|
|
|
+ constructor: Ci,
|
|
|
+ isGroup: !0,
|
|
|
+ type: "group",
|
|
|
+ silent: !1,
|
|
|
+ children: function() {
|
|
|
+ return this._children.slice()
|
|
|
+ },
|
|
|
+ childAt: function(t) {
|
|
|
+ return this._children[t]
|
|
|
+ },
|
|
|
+ childOfName: function(t) {
|
|
|
+ for (var e = this._children, i = 0; i < e.length; i++)
|
|
|
+ if (e[i].name === t)
|
|
|
+ return e[i]
|
|
|
+ },
|
|
|
+ childCount: function() {
|
|
|
+ return this._children.length
|
|
|
+ },
|
|
|
+ add: function(t) {
|
|
|
+ return t && t !== this && t.parent !== this && (this._children.push(t),
|
|
|
+ this._doAdd(t)),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ addBefore: function(t, e) {
|
|
|
+ if (t && t !== this && t.parent !== this && e && e.parent === this) {
|
|
|
+ var i = this._children
|
|
|
+ , n = i.indexOf(e);
|
|
|
+ 0 <= n && (i.splice(n, 0, t),
|
|
|
+ this._doAdd(t))
|
|
|
+ }
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ _doAdd: function(t) {
|
|
|
+ t.parent && t.parent.remove(t);
|
|
|
+ var e = (t.parent = this).__storage
|
|
|
+ , i = this.__zr;
|
|
|
+ e && e !== t.__storage && (e.addToStorage(t),
|
|
|
+ t instanceof Ci && t.addChildrenToStorage(e)),
|
|
|
+ i && i.refresh()
|
|
|
+ },
|
|
|
+ remove: function(t) {
|
|
|
+ var e = this.__zr
|
|
|
+ , i = this.__storage
|
|
|
+ , n = this._children
|
|
|
+ , o = _(n, t);
|
|
|
+ return o < 0 || (n.splice(o, 1),
|
|
|
+ t.parent = null,
|
|
|
+ i && (i.delFromStorage(t),
|
|
|
+ t instanceof Ci && t.delChildrenFromStorage(i)),
|
|
|
+ e && e.refresh()),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ removeAll: function() {
|
|
|
+ var t, e, i = this._children, n = this.__storage;
|
|
|
+ for (e = 0; e < i.length; e++)
|
|
|
+ t = i[e],
|
|
|
+ n && (n.delFromStorage(t),
|
|
|
+ t instanceof Ci && t.delChildrenFromStorage(n)),
|
|
|
+ t.parent = null;
|
|
|
+ return i.length = 0,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ eachChild: function(t, e) {
|
|
|
+ for (var i = this._children, n = 0; n < i.length; n++) {
|
|
|
+ var o = i[n];
|
|
|
+ t.call(e, o, n)
|
|
|
+ }
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ traverse: function(t, e) {
|
|
|
+ for (var i = 0; i < this._children.length; i++) {
|
|
|
+ var n = this._children[i];
|
|
|
+ t.call(e, n),
|
|
|
+ "group" === n.type && n.traverse(t, e)
|
|
|
+ }
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ addChildrenToStorage: function(t) {
|
|
|
+ for (var e = 0; e < this._children.length; e++) {
|
|
|
+ var i = this._children[e];
|
|
|
+ t.addToStorage(i),
|
|
|
+ i instanceof Ci && i.addChildrenToStorage(t)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ delChildrenFromStorage: function(t) {
|
|
|
+ for (var e = 0; e < this._children.length; e++) {
|
|
|
+ var i = this._children[e];
|
|
|
+ t.delFromStorage(i),
|
|
|
+ i instanceof Ci && i.delChildrenFromStorage(t)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dirty: function() {
|
|
|
+ return this.__dirty = !0,
|
|
|
+ this.__zr && this.__zr.refresh(),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ getBoundingRect: function(t) {
|
|
|
+ for (var e = null, i = new Di(0,0,0,0), n = t || this._children, o = [], a = 0; a < n.length; a++) {
|
|
|
+ var r = n[a];
|
|
|
+ if (!r.ignore && !r.invisible) {
|
|
|
+ var s = r.getBoundingRect()
|
|
|
+ , l = r.getLocalTransform(o);
|
|
|
+ l ? (i.copy(s),
|
|
|
+ i.applyTransform(l),
|
|
|
+ (e = e || i.clone()).union(i)) : (e = e || s.clone()).union(s)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return e || i
|
|
|
+ }
|
|
|
+ },
|
|
|
+ w(Ci, _i);
|
|
|
+ var Li = 32
|
|
|
+ , ki = 7;
|
|
|
+ function Pi(t, e, i, n) {
|
|
|
+ var o = e + 1;
|
|
|
+ if (o === i)
|
|
|
+ return 1;
|
|
|
+ if (n(t[o++], t[e]) < 0) {
|
|
|
+ for (; o < i && n(t[o], t[o - 1]) < 0; )
|
|
|
+ o++;
|
|
|
+ !function(t, e, i) {
|
|
|
+ i--;
|
|
|
+ for (; e < i; ) {
|
|
|
+ var n = t[e];
|
|
|
+ t[e++] = t[i],
|
|
|
+ t[i--] = n
|
|
|
+ }
|
|
|
+ }(t, e, o)
|
|
|
+ } else
|
|
|
+ for (; o < i && 0 <= n(t[o], t[o - 1]); )
|
|
|
+ o++;
|
|
|
+ return o - e
|
|
|
+ }
|
|
|
+ function Ni(t, e, i, n, o) {
|
|
|
+ for (n === e && n++; n < i; n++) {
|
|
|
+ for (var a, r = t[n], s = e, l = n; s < l; )
|
|
|
+ o(r, t[a = s + l >>> 1]) < 0 ? l = a : s = 1 + a;
|
|
|
+ var u = n - s;
|
|
|
+ switch (u) {
|
|
|
+ case 3:
|
|
|
+ t[s + 3] = t[s + 2];
|
|
|
+ case 2:
|
|
|
+ t[s + 2] = t[s + 1];
|
|
|
+ case 1:
|
|
|
+ t[s + 1] = t[s];
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ for (; 0 < u; )
|
|
|
+ t[s + u] = t[s + u - 1],
|
|
|
+ u--
|
|
|
+ }
|
|
|
+ t[s] = r
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Oi(t, e, i, n, o, a) {
|
|
|
+ var r = 0
|
|
|
+ , s = 0
|
|
|
+ , l = 1;
|
|
|
+ if (0 < a(t, e[i + o])) {
|
|
|
+ for (s = n - o; l < s && 0 < a(t, e[i + o + l]); )
|
|
|
+ (l = 1 + ((r = l) << 1)) <= 0 && (l = s);
|
|
|
+ s < l && (l = s),
|
|
|
+ r += o,
|
|
|
+ l += o
|
|
|
+ } else {
|
|
|
+ for (s = o + 1; l < s && a(t, e[i + o - l]) <= 0; )
|
|
|
+ (l = 1 + ((r = l) << 1)) <= 0 && (l = s);
|
|
|
+ s < l && (l = s);
|
|
|
+ var u = r;
|
|
|
+ r = o - l,
|
|
|
+ l = o - u
|
|
|
+ }
|
|
|
+ for (r++; r < l; ) {
|
|
|
+ var h = r + (l - r >>> 1);
|
|
|
+ 0 < a(t, e[i + h]) ? r = h + 1 : l = h
|
|
|
+ }
|
|
|
+ return l
|
|
|
+ }
|
|
|
+ function Ei(t, e, i, n, o, a) {
|
|
|
+ var r = 0
|
|
|
+ , s = 0
|
|
|
+ , l = 1;
|
|
|
+ if (a(t, e[i + o]) < 0) {
|
|
|
+ for (s = o + 1; l < s && a(t, e[i + o - l]) < 0; )
|
|
|
+ (l = 1 + ((r = l) << 1)) <= 0 && (l = s);
|
|
|
+ s < l && (l = s);
|
|
|
+ var u = r;
|
|
|
+ r = o - l,
|
|
|
+ l = o - u
|
|
|
+ } else {
|
|
|
+ for (s = n - o; l < s && 0 <= a(t, e[i + o + l]); )
|
|
|
+ (l = 1 + ((r = l) << 1)) <= 0 && (l = s);
|
|
|
+ s < l && (l = s),
|
|
|
+ r += o,
|
|
|
+ l += o
|
|
|
+ }
|
|
|
+ for (r++; r < l; ) {
|
|
|
+ var h = r + (l - r >>> 1);
|
|
|
+ a(t, e[i + h]) < 0 ? l = h : r = h + 1
|
|
|
+ }
|
|
|
+ return l
|
|
|
+ }
|
|
|
+ function Ri(p, g) {
|
|
|
+ var r, s, m = ki, l = 0, v = [];
|
|
|
+ function e(t) {
|
|
|
+ var e = r[t]
|
|
|
+ , i = s[t]
|
|
|
+ , n = r[t + 1]
|
|
|
+ , o = s[t + 1];
|
|
|
+ s[t] = i + o,
|
|
|
+ t === l - 3 && (r[t + 1] = r[t + 2],
|
|
|
+ s[t + 1] = s[t + 2]),
|
|
|
+ l--;
|
|
|
+ var a = Ei(p[n], p, e, i, 0, g);
|
|
|
+ e += a,
|
|
|
+ 0 !== (i -= a) && 0 !== (o = Oi(p[e + i - 1], p, n, o, o - 1, g)) && (i <= o ? function(t, e, i, n) {
|
|
|
+ var o = 0;
|
|
|
+ for (o = 0; o < e; o++)
|
|
|
+ v[o] = p[t + o];
|
|
|
+ var a = 0
|
|
|
+ , r = i
|
|
|
+ , s = t;
|
|
|
+ if (p[s++] = p[r++],
|
|
|
+ 0 == --n) {
|
|
|
+ for (o = 0; o < e; o++)
|
|
|
+ p[s + o] = v[a + o];
|
|
|
+ return
|
|
|
+ }
|
|
|
+ if (1 === e) {
|
|
|
+ for (o = 0; o < n; o++)
|
|
|
+ p[s + o] = p[r + o];
|
|
|
+ return p[s + n] = v[a]
|
|
|
+ }
|
|
|
+ var l, u, h, c = m;
|
|
|
+ for (; ; ) {
|
|
|
+ u = l = 0,
|
|
|
+ h = !1;
|
|
|
+ do {
|
|
|
+ if (g(p[r], v[a]) < 0) {
|
|
|
+ if (p[s++] = p[r++],
|
|
|
+ u++,
|
|
|
+ (l = 0) == --n) {
|
|
|
+ h = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ } else if (p[s++] = v[a++],
|
|
|
+ l++,
|
|
|
+ u = 0,
|
|
|
+ 1 == --e) {
|
|
|
+ h = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ } while ((l | u) < c);
|
|
|
+ if (h)
|
|
|
+ break;
|
|
|
+ do {
|
|
|
+ if (0 !== (l = Ei(p[r], v, a, e, 0, g))) {
|
|
|
+ for (o = 0; o < l; o++)
|
|
|
+ p[s + o] = v[a + o];
|
|
|
+ if (s += l,
|
|
|
+ a += l,
|
|
|
+ (e -= l) <= 1) {
|
|
|
+ h = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (p[s++] = p[r++],
|
|
|
+ 0 == --n) {
|
|
|
+ h = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ if (0 !== (u = Oi(v[a], p, r, n, 0, g))) {
|
|
|
+ for (o = 0; o < u; o++)
|
|
|
+ p[s + o] = p[r + o];
|
|
|
+ if (s += u,
|
|
|
+ r += u,
|
|
|
+ 0 === (n -= u)) {
|
|
|
+ h = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (p[s++] = v[a++],
|
|
|
+ 1 == --e) {
|
|
|
+ h = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ c--
|
|
|
+ } while (ki <= l || ki <= u);
|
|
|
+ if (h)
|
|
|
+ break;
|
|
|
+ c < 0 && (c = 0),
|
|
|
+ c += 2
|
|
|
+ }
|
|
|
+ if ((m = c) < 1 && (m = 1),
|
|
|
+ 1 === e) {
|
|
|
+ for (o = 0; o < n; o++)
|
|
|
+ p[s + o] = p[r + o];
|
|
|
+ p[s + n] = v[a]
|
|
|
+ } else {
|
|
|
+ if (0 === e)
|
|
|
+ throw new Error;
|
|
|
+ for (o = 0; o < e; o++)
|
|
|
+ p[s + o] = v[a + o]
|
|
|
+ }
|
|
|
+ }(e, i, n, o) : function(t, e, i, n) {
|
|
|
+ var o = 0;
|
|
|
+ for (o = 0; o < n; o++)
|
|
|
+ v[o] = p[i + o];
|
|
|
+ var a = t + e - 1
|
|
|
+ , r = n - 1
|
|
|
+ , s = i + n - 1
|
|
|
+ , l = 0
|
|
|
+ , u = 0;
|
|
|
+ if (p[s--] = p[a--],
|
|
|
+ 0 == --e) {
|
|
|
+ for (l = s - (n - 1),
|
|
|
+ o = 0; o < n; o++)
|
|
|
+ p[l + o] = v[o];
|
|
|
+ return
|
|
|
+ }
|
|
|
+ if (1 === n) {
|
|
|
+ for (u = (s -= e) + 1,
|
|
|
+ l = (a -= e) + 1,
|
|
|
+ o = e - 1; 0 <= o; o--)
|
|
|
+ p[u + o] = p[l + o];
|
|
|
+ return p[s] = v[r]
|
|
|
+ }
|
|
|
+ var h = m;
|
|
|
+ for (; ; ) {
|
|
|
+ var c = 0
|
|
|
+ , d = 0
|
|
|
+ , f = !1;
|
|
|
+ do {
|
|
|
+ if (g(v[r], p[a]) < 0) {
|
|
|
+ if (p[s--] = p[a--],
|
|
|
+ c++,
|
|
|
+ (d = 0) == --e) {
|
|
|
+ f = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ } else if (p[s--] = v[r--],
|
|
|
+ d++,
|
|
|
+ c = 0,
|
|
|
+ 1 == --n) {
|
|
|
+ f = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ } while ((c | d) < h);
|
|
|
+ if (f)
|
|
|
+ break;
|
|
|
+ do {
|
|
|
+ if (0 !== (c = e - Ei(v[r], p, t, e, e - 1, g))) {
|
|
|
+ for (e -= c,
|
|
|
+ u = (s -= c) + 1,
|
|
|
+ l = (a -= c) + 1,
|
|
|
+ o = c - 1; 0 <= o; o--)
|
|
|
+ p[u + o] = p[l + o];
|
|
|
+ if (0 === e) {
|
|
|
+ f = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (p[s--] = v[r--],
|
|
|
+ 1 == --n) {
|
|
|
+ f = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ if (0 !== (d = n - Oi(p[a], v, 0, n, n - 1, g))) {
|
|
|
+ for (n -= d,
|
|
|
+ u = (s -= d) + 1,
|
|
|
+ l = (r -= d) + 1,
|
|
|
+ o = 0; o < d; o++)
|
|
|
+ p[u + o] = v[l + o];
|
|
|
+ if (n <= 1) {
|
|
|
+ f = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (p[s--] = p[a--],
|
|
|
+ 0 == --e) {
|
|
|
+ f = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ h--
|
|
|
+ } while (ki <= c || ki <= d);
|
|
|
+ if (f)
|
|
|
+ break;
|
|
|
+ h < 0 && (h = 0),
|
|
|
+ h += 2
|
|
|
+ }
|
|
|
+ (m = h) < 1 && (m = 1);
|
|
|
+ if (1 === n) {
|
|
|
+ for (u = (s -= e) + 1,
|
|
|
+ l = (a -= e) + 1,
|
|
|
+ o = e - 1; 0 <= o; o--)
|
|
|
+ p[u + o] = p[l + o];
|
|
|
+ p[s] = v[r]
|
|
|
+ } else {
|
|
|
+ if (0 === n)
|
|
|
+ throw new Error;
|
|
|
+ for (l = s - (n - 1),
|
|
|
+ o = 0; o < n; o++)
|
|
|
+ p[l + o] = v[o]
|
|
|
+ }
|
|
|
+ }(e, i, n, o))
|
|
|
+ }
|
|
|
+ r = [],
|
|
|
+ s = [],
|
|
|
+ this.mergeRuns = function() {
|
|
|
+ for (; 1 < l; ) {
|
|
|
+ var t = l - 2;
|
|
|
+ if (1 <= t && s[t - 1] <= s[t] + s[t + 1] || 2 <= t && s[t - 2] <= s[t] + s[t - 1])
|
|
|
+ s[t - 1] < s[t + 1] && t--;
|
|
|
+ else if (s[t] > s[t + 1])
|
|
|
+ break;
|
|
|
+ e(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.forceMergeRuns = function() {
|
|
|
+ for (; 1 < l; ) {
|
|
|
+ var t = l - 2;
|
|
|
+ 0 < t && s[t - 1] < s[t + 1] && t--,
|
|
|
+ e(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.pushRun = function(t, e) {
|
|
|
+ r[l] = t,
|
|
|
+ s[l] = e,
|
|
|
+ l += 1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function zi(t, e, i, n) {
|
|
|
+ i = i || 0;
|
|
|
+ var o = (n = n || t.length) - i;
|
|
|
+ if (!(o < 2)) {
|
|
|
+ var a = 0;
|
|
|
+ if (o < Li)
|
|
|
+ Ni(t, i, n, i + (a = Pi(t, i, n, e)), e);
|
|
|
+ else {
|
|
|
+ var r = new Ri(t,e)
|
|
|
+ , s = function(t) {
|
|
|
+ for (var e = 0; Li <= t; )
|
|
|
+ e |= 1 & t,
|
|
|
+ t >>= 1;
|
|
|
+ return t + e
|
|
|
+ }(o);
|
|
|
+ do {
|
|
|
+ if ((a = Pi(t, i, n, e)) < s) {
|
|
|
+ var l = o;
|
|
|
+ s < l && (l = s),
|
|
|
+ Ni(t, i, i + l, i + a, e),
|
|
|
+ a = l
|
|
|
+ }
|
|
|
+ r.pushRun(i, a),
|
|
|
+ r.mergeRuns(),
|
|
|
+ o -= a,
|
|
|
+ i += a
|
|
|
+ } while (0 !== o);
|
|
|
+ r.forceMergeRuns()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Bi(t, e) {
|
|
|
+ return t.zlevel === e.zlevel ? t.z === e.z ? t.z2 - e.z2 : t.z - e.z : t.zlevel - e.zlevel
|
|
|
+ }
|
|
|
+ function Vi() {
|
|
|
+ this._roots = [],
|
|
|
+ this._displayList = [],
|
|
|
+ this._displayListLen = 0
|
|
|
+ }
|
|
|
+ Vi.prototype = {
|
|
|
+ constructor: Vi,
|
|
|
+ traverse: function(t, e) {
|
|
|
+ for (var i = 0; i < this._roots.length; i++)
|
|
|
+ this._roots[i].traverse(t, e)
|
|
|
+ },
|
|
|
+ getDisplayList: function(t, e) {
|
|
|
+ return e = e || !1,
|
|
|
+ t && this.updateDisplayList(e),
|
|
|
+ this._displayList
|
|
|
+ },
|
|
|
+ updateDisplayList: function(t) {
|
|
|
+ this._displayListLen = 0;
|
|
|
+ for (var e = this._roots, i = this._displayList, n = 0, o = e.length; n < o; n++)
|
|
|
+ this._updateAndAddDisplayable(e[n], null, t);
|
|
|
+ i.length = this._displayListLen,
|
|
|
+ v.canvasSupported && zi(i, Bi)
|
|
|
+ },
|
|
|
+ _updateAndAddDisplayable: function(t, e, i) {
|
|
|
+ if (!t.ignore || i) {
|
|
|
+ t.beforeUpdate(),
|
|
|
+ t.__dirty && t.update(),
|
|
|
+ t.afterUpdate();
|
|
|
+ var n = t.clipPath;
|
|
|
+ if (n) {
|
|
|
+ e = e ? e.slice() : [];
|
|
|
+ for (var o = n, a = t; o; )
|
|
|
+ o.parent = a,
|
|
|
+ o.updateTransform(),
|
|
|
+ e.push(o),
|
|
|
+ o = (a = o).clipPath
|
|
|
+ }
|
|
|
+ if (t.isGroup) {
|
|
|
+ for (var r = t._children, s = 0; s < r.length; s++) {
|
|
|
+ var l = r[s];
|
|
|
+ t.__dirty && (l.__dirty = !0),
|
|
|
+ this._updateAndAddDisplayable(l, e, i)
|
|
|
+ }
|
|
|
+ t.__dirty = !1
|
|
|
+ } else
|
|
|
+ t.__clipPaths = e,
|
|
|
+ this._displayList[this._displayListLen++] = t
|
|
|
+ }
|
|
|
+ },
|
|
|
+ addRoot: function(t) {
|
|
|
+ t.__storage !== this && (t instanceof Ci && t.addChildrenToStorage(this),
|
|
|
+ this.addToStorage(t),
|
|
|
+ this._roots.push(t))
|
|
|
+ },
|
|
|
+ delRoot: function(t) {
|
|
|
+ if (null == t) {
|
|
|
+ for (var e = 0; e < this._roots.length; e++) {
|
|
|
+ var i = this._roots[e];
|
|
|
+ i instanceof Ci && i.delChildrenFromStorage(this)
|
|
|
+ }
|
|
|
+ return this._roots = [],
|
|
|
+ this._displayList = [],
|
|
|
+ void (this._displayListLen = 0)
|
|
|
+ }
|
|
|
+ if (t instanceof Array) {
|
|
|
+ e = 0;
|
|
|
+ for (var n = t.length; e < n; e++)
|
|
|
+ this.delRoot(t[e])
|
|
|
+ } else {
|
|
|
+ var o = _(this._roots, t);
|
|
|
+ 0 <= o && (this.delFromStorage(t),
|
|
|
+ this._roots.splice(o, 1),
|
|
|
+ t instanceof Ci && t.delChildrenFromStorage(this))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ addToStorage: function(t) {
|
|
|
+ return t && (t.__storage = this,
|
|
|
+ t.dirty(!1)),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ delFromStorage: function(t) {
|
|
|
+ return t && (t.__storage = null),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._renderList = this._roots = null
|
|
|
+ },
|
|
|
+ displayableSortFunc: Bi
|
|
|
+ };
|
|
|
+ var Gi = {
|
|
|
+ shadowBlur: 1,
|
|
|
+ shadowOffsetX: 1,
|
|
|
+ shadowOffsetY: 1,
|
|
|
+ textShadowBlur: 1,
|
|
|
+ textShadowOffsetX: 1,
|
|
|
+ textShadowOffsetY: 1,
|
|
|
+ textBoxShadowBlur: 1,
|
|
|
+ textBoxShadowOffsetX: 1,
|
|
|
+ textBoxShadowOffsetY: 1
|
|
|
+ }
|
|
|
+ , Fi = function(t, e, i) {
|
|
|
+ return Gi.hasOwnProperty(e) ? i * t.dpr : i
|
|
|
+ }
|
|
|
+ , Wi = {
|
|
|
+ NONE: 0,
|
|
|
+ STYLE_BIND: 1,
|
|
|
+ PLAIN_TEXT: 2
|
|
|
+ }
|
|
|
+ , Hi = 9
|
|
|
+ , Zi = [["shadowBlur", 0], ["shadowOffsetX", 0], ["shadowOffsetY", 0], ["shadowColor", "#000"], ["lineCap", "butt"], ["lineJoin", "miter"], ["miterLimit", 10]]
|
|
|
+ , Ui = function(t) {
|
|
|
+ this.extendFrom(t, !1)
|
|
|
+ };
|
|
|
+ function Xi(t, e, i) {
|
|
|
+ var n = null == e.x ? 0 : e.x
|
|
|
+ , o = null == e.x2 ? 1 : e.x2
|
|
|
+ , a = null == e.y ? 0 : e.y
|
|
|
+ , r = null == e.y2 ? 0 : e.y2;
|
|
|
+ return e.global || (n = n * i.width + i.x,
|
|
|
+ o = o * i.width + i.x,
|
|
|
+ a = a * i.height + i.y,
|
|
|
+ r = r * i.height + i.y),
|
|
|
+ n = isNaN(n) ? 0 : n,
|
|
|
+ o = isNaN(o) ? 1 : o,
|
|
|
+ a = isNaN(a) ? 0 : a,
|
|
|
+ r = isNaN(r) ? 0 : r,
|
|
|
+ t.createLinearGradient(n, a, o, r)
|
|
|
+ }
|
|
|
+ function Yi(t, e, i) {
|
|
|
+ var n = i.width
|
|
|
+ , o = i.height
|
|
|
+ , a = Math.min(n, o)
|
|
|
+ , r = null == e.x ? .5 : e.x
|
|
|
+ , s = null == e.y ? .5 : e.y
|
|
|
+ , l = null == e.r ? .5 : e.r;
|
|
|
+ return e.global || (r = r * n + i.x,
|
|
|
+ s = s * o + i.y,
|
|
|
+ l *= a),
|
|
|
+ t.createRadialGradient(r, s, 0, r, s, l)
|
|
|
+ }
|
|
|
+ Ui.prototype = {
|
|
|
+ constructor: Ui,
|
|
|
+ fill: "#000",
|
|
|
+ stroke: null,
|
|
|
+ opacity: 1,
|
|
|
+ fillOpacity: null,
|
|
|
+ strokeOpacity: null,
|
|
|
+ lineDash: null,
|
|
|
+ lineDashOffset: 0,
|
|
|
+ shadowBlur: 0,
|
|
|
+ shadowOffsetX: 0,
|
|
|
+ shadowOffsetY: 0,
|
|
|
+ lineWidth: 1,
|
|
|
+ strokeNoScale: !1,
|
|
|
+ text: null,
|
|
|
+ font: null,
|
|
|
+ textFont: null,
|
|
|
+ fontStyle: null,
|
|
|
+ fontWeight: null,
|
|
|
+ fontSize: null,
|
|
|
+ fontFamily: null,
|
|
|
+ textTag: null,
|
|
|
+ textFill: "#000",
|
|
|
+ textStroke: null,
|
|
|
+ textWidth: null,
|
|
|
+ textHeight: null,
|
|
|
+ textStrokeWidth: 0,
|
|
|
+ textLineHeight: null,
|
|
|
+ textPosition: "inside",
|
|
|
+ textRect: null,
|
|
|
+ textOffset: null,
|
|
|
+ textAlign: null,
|
|
|
+ textVerticalAlign: null,
|
|
|
+ textDistance: 5,
|
|
|
+ textShadowColor: "transparent",
|
|
|
+ textShadowBlur: 0,
|
|
|
+ textShadowOffsetX: 0,
|
|
|
+ textShadowOffsetY: 0,
|
|
|
+ textBoxShadowColor: "transparent",
|
|
|
+ textBoxShadowBlur: 0,
|
|
|
+ textBoxShadowOffsetX: 0,
|
|
|
+ textBoxShadowOffsetY: 0,
|
|
|
+ transformText: !1,
|
|
|
+ textRotation: 0,
|
|
|
+ textOrigin: null,
|
|
|
+ textBackgroundColor: null,
|
|
|
+ textBorderColor: null,
|
|
|
+ textBorderWidth: 0,
|
|
|
+ textBorderRadius: 0,
|
|
|
+ textPadding: null,
|
|
|
+ rich: null,
|
|
|
+ truncate: null,
|
|
|
+ blend: null,
|
|
|
+ bind: function(t, e, i) {
|
|
|
+ var n = this
|
|
|
+ , o = i && i.style
|
|
|
+ , a = !o || t.__attrCachedBy !== Wi.STYLE_BIND;
|
|
|
+ t.__attrCachedBy = Wi.STYLE_BIND;
|
|
|
+ for (var r = 0; r < Zi.length; r++) {
|
|
|
+ var s = Zi[r]
|
|
|
+ , l = s[0];
|
|
|
+ !a && n[l] === o[l] || (t[l] = Fi(t, l, n[l] || s[1]))
|
|
|
+ }
|
|
|
+ if (!a && n.fill === o.fill || (t.fillStyle = n.fill),
|
|
|
+ !a && n.stroke === o.stroke || (t.strokeStyle = n.stroke),
|
|
|
+ !a && n.opacity === o.opacity || (t.globalAlpha = null == n.opacity ? 1 : n.opacity),
|
|
|
+ !a && n.blend === o.blend || (t.globalCompositeOperation = n.blend || "source-over"),
|
|
|
+ this.hasStroke()) {
|
|
|
+ var u = n.lineWidth;
|
|
|
+ t.lineWidth = u / (this.strokeNoScale && e && e.getLineScale ? e.getLineScale() : 1)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ hasFill: function() {
|
|
|
+ var t = this.fill;
|
|
|
+ return null != t && "none" !== t
|
|
|
+ },
|
|
|
+ hasStroke: function() {
|
|
|
+ var t = this.stroke;
|
|
|
+ return null != t && "none" !== t && 0 < this.lineWidth
|
|
|
+ },
|
|
|
+ extendFrom: function(t, e) {
|
|
|
+ if (t)
|
|
|
+ for (var i in t)
|
|
|
+ !t.hasOwnProperty(i) || !0 !== e && (!1 === e ? this.hasOwnProperty(i) : null == t[i]) || (this[i] = t[i])
|
|
|
+ },
|
|
|
+ set: function(t, e) {
|
|
|
+ "string" == typeof t ? this[t] = e : this.extendFrom(t, !0)
|
|
|
+ },
|
|
|
+ clone: function() {
|
|
|
+ var t = new this.constructor;
|
|
|
+ return t.extendFrom(this, !0),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ getGradient: function(t, e, i) {
|
|
|
+ for (var n = ("radial" === e.type ? Yi : Xi)(t, e, i), o = e.colorStops, a = 0; a < o.length; a++)
|
|
|
+ n.addColorStop(o[a].offset, o[a].color);
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ };
|
|
|
+ for (var ji = Ui.prototype, qi = 0; qi < Zi.length; qi++) {
|
|
|
+ var Ki = Zi[qi];
|
|
|
+ Ki[0]in ji || (ji[Ki[0]] = Ki[1])
|
|
|
+ }
|
|
|
+ Ui.getGradient = ji.getGradient;
|
|
|
+ function $i(t, e) {
|
|
|
+ this.image = t,
|
|
|
+ this.repeat = e,
|
|
|
+ this.type = "pattern"
|
|
|
+ }
|
|
|
+ function Ji() {
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ function Qi(t, e, i) {
|
|
|
+ var n = y()
|
|
|
+ , o = e.getWidth()
|
|
|
+ , a = e.getHeight()
|
|
|
+ , r = n.style;
|
|
|
+ return r && (r.position = "absolute",
|
|
|
+ r.left = 0,
|
|
|
+ r.top = 0,
|
|
|
+ r.width = o + "px",
|
|
|
+ r.height = a + "px",
|
|
|
+ n.setAttribute("data-zr-dom-id", t)),
|
|
|
+ n.width = o * i,
|
|
|
+ n.height = a * i,
|
|
|
+ n
|
|
|
+ }
|
|
|
+ function tn(t, e, i) {
|
|
|
+ var n;
|
|
|
+ i = i || pi,
|
|
|
+ "string" == typeof t ? n = Qi(t, e, i) : z(t) && (t = (n = t).id),
|
|
|
+ this.id = t;
|
|
|
+ var o = (this.dom = n).style;
|
|
|
+ o && (n.onselectstart = Ji,
|
|
|
+ o["-webkit-user-select"] = "none",
|
|
|
+ o["user-select"] = "none",
|
|
|
+ o["-webkit-touch-callout"] = "none",
|
|
|
+ o["-webkit-tap-highlight-color"] = "rgba(0,0,0,0)",
|
|
|
+ o.padding = 0,
|
|
|
+ o.margin = 0,
|
|
|
+ o["border-width"] = 0),
|
|
|
+ this.domBack = null,
|
|
|
+ this.ctxBack = null,
|
|
|
+ this.painter = e,
|
|
|
+ this.config = null,
|
|
|
+ this.clearColor = 0,
|
|
|
+ this.motionBlur = !1,
|
|
|
+ this.lastFrameAlpha = .7,
|
|
|
+ this.dpr = i
|
|
|
+ }
|
|
|
+ tn.prototype = {
|
|
|
+ constructor: tn,
|
|
|
+ __dirty: !0,
|
|
|
+ __used: !($i.prototype.getCanvasPattern = function(t) {
|
|
|
+ return t.createPattern(this.image, this.repeat || "repeat")
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ __drawIndex: 0,
|
|
|
+ __startIndex: 0,
|
|
|
+ __endIndex: 0,
|
|
|
+ incremental: !1,
|
|
|
+ getElementCount: function() {
|
|
|
+ return this.__endIndex - this.__startIndex
|
|
|
+ },
|
|
|
+ initContext: function() {
|
|
|
+ this.ctx = this.dom.getContext("2d"),
|
|
|
+ this.ctx.dpr = this.dpr
|
|
|
+ },
|
|
|
+ createBackBuffer: function() {
|
|
|
+ var t = this.dpr;
|
|
|
+ this.domBack = Qi("back-" + this.id, this.painter, t),
|
|
|
+ this.ctxBack = this.domBack.getContext("2d"),
|
|
|
+ 1 !== t && this.ctxBack.scale(t, t)
|
|
|
+ },
|
|
|
+ resize: function(t, e) {
|
|
|
+ var i = this.dpr
|
|
|
+ , n = this.dom
|
|
|
+ , o = n.style
|
|
|
+ , a = this.domBack;
|
|
|
+ o && (o.width = t + "px",
|
|
|
+ o.height = e + "px"),
|
|
|
+ n.width = t * i,
|
|
|
+ n.height = e * i,
|
|
|
+ a && (a.width = t * i,
|
|
|
+ a.height = e * i,
|
|
|
+ 1 !== i && this.ctxBack.scale(i, i))
|
|
|
+ },
|
|
|
+ clear: function(t, e) {
|
|
|
+ var i, n = this.dom, o = this.ctx, a = n.width, r = n.height, s = (e = e || this.clearColor,
|
|
|
+ this.motionBlur && !t), l = this.lastFrameAlpha, u = this.dpr;
|
|
|
+ s && (this.domBack || this.createBackBuffer(),
|
|
|
+ this.ctxBack.globalCompositeOperation = "copy",
|
|
|
+ this.ctxBack.drawImage(n, 0, 0, a / u, r / u)),
|
|
|
+ o.clearRect(0, 0, a, r),
|
|
|
+ e && "transparent" !== e && (e.colorStops ? (i = e.__canvasGradient || Ui.getGradient(o, e, {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: a,
|
|
|
+ height: r
|
|
|
+ }),
|
|
|
+ e.__canvasGradient = i) : e.image && (i = $i.prototype.getCanvasPattern.call(e, o)),
|
|
|
+ o.save(),
|
|
|
+ o.fillStyle = i || e,
|
|
|
+ o.fillRect(0, 0, a, r),
|
|
|
+ o.restore());
|
|
|
+ if (s) {
|
|
|
+ var h = this.domBack;
|
|
|
+ o.save(),
|
|
|
+ o.globalAlpha = l,
|
|
|
+ o.drawImage(h, 0, 0, a, r),
|
|
|
+ o.restore()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var en = "undefined" != typeof window && (window.requestAnimationFrame && window.requestAnimationFrame.bind(window) || window.msRequestAnimationFrame && window.msRequestAnimationFrame.bind(window) || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame) || function(t) {
|
|
|
+ setTimeout(t, 16)
|
|
|
+ }
|
|
|
+ , nn = new Te(50);
|
|
|
+ function on(t) {
|
|
|
+ if ("string" != typeof t)
|
|
|
+ return t;
|
|
|
+ var e = nn.get(t);
|
|
|
+ return e && e.image
|
|
|
+ }
|
|
|
+ function an(t, e, i, n, o) {
|
|
|
+ if (t) {
|
|
|
+ if ("string" != typeof t)
|
|
|
+ return t;
|
|
|
+ if (e && e.__zrImageSrc === t || !i)
|
|
|
+ return e;
|
|
|
+ var a = nn.get(t)
|
|
|
+ , r = {
|
|
|
+ hostEl: i,
|
|
|
+ cb: n,
|
|
|
+ cbPayload: o
|
|
|
+ };
|
|
|
+ return a ? sn(e = a.image) || a.pending.push(r) : ((e = new Image).onload = e.onerror = rn,
|
|
|
+ nn.put(t, e.__cachedImgObj = {
|
|
|
+ image: e,
|
|
|
+ pending: [r]
|
|
|
+ }),
|
|
|
+ e.src = e.__zrImageSrc = t),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ function rn() {
|
|
|
+ var t = this.__cachedImgObj;
|
|
|
+ this.onload = this.onerror = this.__cachedImgObj = null;
|
|
|
+ for (var e = 0; e < t.pending.length; e++) {
|
|
|
+ var i = t.pending[e]
|
|
|
+ , n = i.cb;
|
|
|
+ n && n(this, i.cbPayload),
|
|
|
+ i.hostEl.dirty()
|
|
|
+ }
|
|
|
+ t.pending.length = 0
|
|
|
+ }
|
|
|
+ function sn(t) {
|
|
|
+ return t && t.width && t.height
|
|
|
+ }
|
|
|
+ var ln = {}
|
|
|
+ , un = 0
|
|
|
+ , hn = 5e3
|
|
|
+ , cn = /\{([a-zA-Z0-9_]+)\|([^}]*)\}/g
|
|
|
+ , dn = "12px sans-serif"
|
|
|
+ , fn = {};
|
|
|
+ function pn(t, e) {
|
|
|
+ var i = t + ":" + (e = e || dn);
|
|
|
+ if (ln[i])
|
|
|
+ return ln[i];
|
|
|
+ for (var n, o, a = (t + "").split("\n"), r = 0, s = 0, l = a.length; s < l; s++)
|
|
|
+ r = Math.max((n = a[s],
|
|
|
+ o = e,
|
|
|
+ fn.measureText(n, o)).width, r);
|
|
|
+ return hn < un && (un = 0,
|
|
|
+ ln = {}),
|
|
|
+ un++,
|
|
|
+ ln[i] = r
|
|
|
+ }
|
|
|
+ function gn(t, e, i, n, o, a, r, s) {
|
|
|
+ return r ? function(t, e, i, n, o, a, r, s) {
|
|
|
+ var l = In(t, {
|
|
|
+ rich: r,
|
|
|
+ truncate: s,
|
|
|
+ font: e,
|
|
|
+ textAlign: i,
|
|
|
+ textPadding: o,
|
|
|
+ textLineHeight: a
|
|
|
+ })
|
|
|
+ , u = l.outerWidth
|
|
|
+ , h = l.outerHeight
|
|
|
+ , c = mn(0, u, i)
|
|
|
+ , d = vn(0, h, n);
|
|
|
+ return new Di(c,d,u,h)
|
|
|
+ }(t, e, i, n, o, a, r, s) : function(t, e, i, n, o, a, r) {
|
|
|
+ var s = Mn(t, e, o, a, r)
|
|
|
+ , l = pn(t, e);
|
|
|
+ o && (l += o[1] + o[3]);
|
|
|
+ var u = s.outerHeight
|
|
|
+ , h = mn(0, l, i)
|
|
|
+ , c = vn(0, u, n)
|
|
|
+ , d = new Di(h,c,l,u);
|
|
|
+ return d.lineHeight = s.lineHeight,
|
|
|
+ d
|
|
|
+ }(t, e, i, n, o, a, s)
|
|
|
+ }
|
|
|
+ function mn(t, e, i) {
|
|
|
+ return "right" === i ? t -= e : "center" === i && (t -= e / 2),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function vn(t, e, i) {
|
|
|
+ return "middle" === i ? t -= e / 2 : "bottom" === i && (t -= e),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function yn(t, e, i) {
|
|
|
+ var n = e.textPosition
|
|
|
+ , o = e.textDistance
|
|
|
+ , a = i.x
|
|
|
+ , r = i.y;
|
|
|
+ o = o || 0;
|
|
|
+ var s = i.height
|
|
|
+ , l = i.width
|
|
|
+ , u = s / 2
|
|
|
+ , h = "left"
|
|
|
+ , c = "top";
|
|
|
+ switch (n) {
|
|
|
+ case "left":
|
|
|
+ a -= o,
|
|
|
+ r += u,
|
|
|
+ h = "right",
|
|
|
+ c = "middle";
|
|
|
+ break;
|
|
|
+ case "right":
|
|
|
+ a += o + l,
|
|
|
+ r += u,
|
|
|
+ c = "middle";
|
|
|
+ break;
|
|
|
+ case "top":
|
|
|
+ a += l / 2,
|
|
|
+ r -= o,
|
|
|
+ h = "center",
|
|
|
+ c = "bottom";
|
|
|
+ break;
|
|
|
+ case "bottom":
|
|
|
+ a += l / 2,
|
|
|
+ r += s + o,
|
|
|
+ h = "center";
|
|
|
+ break;
|
|
|
+ case "inside":
|
|
|
+ a += l / 2,
|
|
|
+ r += u,
|
|
|
+ h = "center",
|
|
|
+ c = "middle";
|
|
|
+ break;
|
|
|
+ case "insideLeft":
|
|
|
+ a += o,
|
|
|
+ r += u,
|
|
|
+ c = "middle";
|
|
|
+ break;
|
|
|
+ case "insideRight":
|
|
|
+ a += l - o,
|
|
|
+ r += u,
|
|
|
+ h = "right",
|
|
|
+ c = "middle";
|
|
|
+ break;
|
|
|
+ case "insideTop":
|
|
|
+ a += l / 2,
|
|
|
+ r += o,
|
|
|
+ h = "center";
|
|
|
+ break;
|
|
|
+ case "insideBottom":
|
|
|
+ a += l / 2,
|
|
|
+ r += s - o,
|
|
|
+ h = "center",
|
|
|
+ c = "bottom";
|
|
|
+ break;
|
|
|
+ case "insideTopLeft":
|
|
|
+ a += o,
|
|
|
+ r += o;
|
|
|
+ break;
|
|
|
+ case "insideTopRight":
|
|
|
+ a += l - o,
|
|
|
+ r += o,
|
|
|
+ h = "right";
|
|
|
+ break;
|
|
|
+ case "insideBottomLeft":
|
|
|
+ a += o,
|
|
|
+ r += s - o,
|
|
|
+ c = "bottom";
|
|
|
+ break;
|
|
|
+ case "insideBottomRight":
|
|
|
+ a += l - o,
|
|
|
+ r += s - o,
|
|
|
+ h = "right",
|
|
|
+ c = "bottom"
|
|
|
+ }
|
|
|
+ return (t = t || {}).x = a,
|
|
|
+ t.y = r,
|
|
|
+ t.textAlign = h,
|
|
|
+ t.textVerticalAlign = c,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function xn(t, e, i, n, o) {
|
|
|
+ if (!e)
|
|
|
+ return "";
|
|
|
+ var a = (t + "").split("\n");
|
|
|
+ o = _n(e, i, n, o);
|
|
|
+ for (var r = 0, s = a.length; r < s; r++)
|
|
|
+ a[r] = wn(a[r], o);
|
|
|
+ return a.join("\n")
|
|
|
+ }
|
|
|
+ function _n(t, e, i, n) {
|
|
|
+ (n = P({}, n)).font = e;
|
|
|
+ i = H(i, "...");
|
|
|
+ n.maxIterations = H(n.maxIterations, 2);
|
|
|
+ var o = n.minChar = H(n.minChar, 0);
|
|
|
+ n.cnCharWidth = pn("国", e);
|
|
|
+ var a = n.ascCharWidth = pn("a", e);
|
|
|
+ n.placeholder = H(n.placeholder, "");
|
|
|
+ for (var r = t = Math.max(0, t - 1), s = 0; s < o && a <= r; s++)
|
|
|
+ r -= a;
|
|
|
+ var l = pn(i, e);
|
|
|
+ return r < l && (i = "",
|
|
|
+ l = 0),
|
|
|
+ r = t - l,
|
|
|
+ n.ellipsis = i,
|
|
|
+ n.ellipsisWidth = l,
|
|
|
+ n.contentWidth = r,
|
|
|
+ n.containerWidth = t,
|
|
|
+ n
|
|
|
+ }
|
|
|
+ function wn(t, e) {
|
|
|
+ var i = e.containerWidth
|
|
|
+ , n = e.font
|
|
|
+ , o = e.contentWidth;
|
|
|
+ if (!i)
|
|
|
+ return "";
|
|
|
+ var a = pn(t, n);
|
|
|
+ if (a <= i)
|
|
|
+ return t;
|
|
|
+ for (var r = 0; ; r++) {
|
|
|
+ if (a <= o || r >= e.maxIterations) {
|
|
|
+ t += e.ellipsis;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ var s = 0 === r ? bn(t, o, e.ascCharWidth, e.cnCharWidth) : 0 < a ? Math.floor(t.length * o / a) : 0;
|
|
|
+ a = pn(t = t.substr(0, s), n)
|
|
|
+ }
|
|
|
+ return "" === t && (t = e.placeholder),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function bn(t, e, i, n) {
|
|
|
+ for (var o = 0, a = 0, r = t.length; a < r && o < e; a++) {
|
|
|
+ var s = t.charCodeAt(a);
|
|
|
+ o += 0 <= s && s <= 127 ? i : n
|
|
|
+ }
|
|
|
+ return a
|
|
|
+ }
|
|
|
+ function Sn(t) {
|
|
|
+ return pn("国", t)
|
|
|
+ }
|
|
|
+ function Mn(t, e, i, n, o) {
|
|
|
+ null != t && (t += "");
|
|
|
+ var a = H(n, Sn(e))
|
|
|
+ , r = t ? t.split("\n") : []
|
|
|
+ , s = r.length * a
|
|
|
+ , l = s
|
|
|
+ , u = !0;
|
|
|
+ if (i && (l += i[0] + i[2]),
|
|
|
+ t && o) {
|
|
|
+ u = !1;
|
|
|
+ var h = o.outerHeight
|
|
|
+ , c = o.outerWidth;
|
|
|
+ if (null != h && h < l)
|
|
|
+ t = "",
|
|
|
+ r = [];
|
|
|
+ else if (null != c)
|
|
|
+ for (var d = _n(c - (i ? i[1] + i[3] : 0), e, o.ellipsis, {
|
|
|
+ minChar: o.minChar,
|
|
|
+ placeholder: o.placeholder
|
|
|
+ }), f = 0, p = r.length; f < p; f++)
|
|
|
+ r[f] = wn(r[f], d)
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ lines: r,
|
|
|
+ height: s,
|
|
|
+ outerHeight: l,
|
|
|
+ lineHeight: a,
|
|
|
+ canCacheByTextString: u
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function In(t, e) {
|
|
|
+ var i = {
|
|
|
+ lines: [],
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ };
|
|
|
+ if (null != t && (t += ""),
|
|
|
+ !t)
|
|
|
+ return i;
|
|
|
+ for (var n, o = cn.lastIndex = 0; null != (n = cn.exec(t)); ) {
|
|
|
+ var a = n.index;
|
|
|
+ o < a && Tn(i, t.substring(o, a)),
|
|
|
+ Tn(i, n[2], n[1]),
|
|
|
+ o = cn.lastIndex
|
|
|
+ }
|
|
|
+ o < t.length && Tn(i, t.substring(o, t.length));
|
|
|
+ var r = i.lines
|
|
|
+ , s = 0
|
|
|
+ , l = 0
|
|
|
+ , u = []
|
|
|
+ , h = e.textPadding
|
|
|
+ , c = e.truncate
|
|
|
+ , d = c && c.outerWidth
|
|
|
+ , f = c && c.outerHeight;
|
|
|
+ h && (null != d && (d -= h[1] + h[3]),
|
|
|
+ null != f && (f -= h[0] + h[2]));
|
|
|
+ for (var p = 0; p < r.length; p++) {
|
|
|
+ for (var g = r[p], m = 0, v = 0, y = 0; y < g.tokens.length; y++) {
|
|
|
+ var x = (C = g.tokens[y]).styleName && e.rich[C.styleName] || {}
|
|
|
+ , _ = C.textPadding = x.textPadding
|
|
|
+ , w = C.font = x.font || e.font
|
|
|
+ , b = C.textHeight = H(x.textHeight, Sn(w));
|
|
|
+ if (_ && (b += _[0] + _[2]),
|
|
|
+ C.height = b,
|
|
|
+ C.lineHeight = Z(x.textLineHeight, e.textLineHeight, b),
|
|
|
+ C.textAlign = x && x.textAlign || e.textAlign,
|
|
|
+ C.textVerticalAlign = x && x.textVerticalAlign || "middle",
|
|
|
+ null != f && s + C.lineHeight > f)
|
|
|
+ return {
|
|
|
+ lines: [],
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ };
|
|
|
+ C.textWidth = pn(C.text, w);
|
|
|
+ var S = x.textWidth
|
|
|
+ , M = null == S || "auto" === S;
|
|
|
+ if ("string" == typeof S && "%" === S.charAt(S.length - 1))
|
|
|
+ C.percentWidth = S,
|
|
|
+ u.push(C),
|
|
|
+ S = 0;
|
|
|
+ else {
|
|
|
+ if (M) {
|
|
|
+ S = C.textWidth;
|
|
|
+ var I = x.textBackgroundColor
|
|
|
+ , T = I && I.image;
|
|
|
+ T && sn(T = on(T)) && (S = Math.max(S, T.width * b / T.height))
|
|
|
+ }
|
|
|
+ var A = _ ? _[1] + _[3] : 0;
|
|
|
+ S += A;
|
|
|
+ var D = null != d ? d - v : null;
|
|
|
+ null != D && D < S && (!M || D < A ? (C.text = "",
|
|
|
+ C.textWidth = S = 0) : (C.text = xn(C.text, D - A, w, c.ellipsis, {
|
|
|
+ minChar: c.minChar
|
|
|
+ }),
|
|
|
+ C.textWidth = pn(C.text, w),
|
|
|
+ S = C.textWidth + A))
|
|
|
+ }
|
|
|
+ v += C.width = S,
|
|
|
+ x && (m = Math.max(m, C.lineHeight))
|
|
|
+ }
|
|
|
+ g.width = v,
|
|
|
+ s += g.lineHeight = m,
|
|
|
+ l = Math.max(l, v)
|
|
|
+ }
|
|
|
+ i.outerWidth = i.width = H(e.textWidth, l),
|
|
|
+ i.outerHeight = i.height = H(e.textHeight, s),
|
|
|
+ h && (i.outerWidth += h[1] + h[3],
|
|
|
+ i.outerHeight += h[0] + h[2]);
|
|
|
+ for (p = 0; p < u.length; p++) {
|
|
|
+ var C, L = (C = u[p]).percentWidth;
|
|
|
+ C.width = parseInt(L, 10) / 100 * l
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ function Tn(t, e, i) {
|
|
|
+ for (var n = "" === e, o = e.split("\n"), a = t.lines, r = 0; r < o.length; r++) {
|
|
|
+ var s = o[r]
|
|
|
+ , l = {
|
|
|
+ styleName: i,
|
|
|
+ text: s,
|
|
|
+ isLineHolder: !s && !n
|
|
|
+ };
|
|
|
+ if (r)
|
|
|
+ a.push({
|
|
|
+ tokens: [l]
|
|
|
+ });
|
|
|
+ else {
|
|
|
+ var u = (a[a.length - 1] || (a[0] = {
|
|
|
+ tokens: []
|
|
|
+ })).tokens
|
|
|
+ , h = u.length;
|
|
|
+ 1 === h && u[0].isLineHolder ? u[0] = l : !s && h && !n || u.push(l)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function An(t) {
|
|
|
+ var e = (t.fontSize || t.fontFamily) && [t.fontStyle, t.fontWeight, (t.fontSize || 12) + "px", t.fontFamily || "sans-serif"].join(" ");
|
|
|
+ return e && j(e) || t.textFont || t.font
|
|
|
+ }
|
|
|
+ function Dn(t, e) {
|
|
|
+ var i, n, o, a, r, s = e.x, l = e.y, u = e.width, h = e.height, c = e.r;
|
|
|
+ u < 0 && (s += u,
|
|
|
+ u = -u),
|
|
|
+ h < 0 && (l += h,
|
|
|
+ h = -h),
|
|
|
+ "number" == typeof c ? i = n = o = a = c : c instanceof Array ? 1 === c.length ? i = n = o = a = c[0] : 2 === c.length ? (i = o = c[0],
|
|
|
+ n = a = c[1]) : 3 === c.length ? (i = c[0],
|
|
|
+ n = a = c[1],
|
|
|
+ o = c[2]) : (i = c[0],
|
|
|
+ n = c[1],
|
|
|
+ o = c[2],
|
|
|
+ a = c[3]) : i = n = o = a = 0,
|
|
|
+ u < i + n && (i *= u / (r = i + n),
|
|
|
+ n *= u / r),
|
|
|
+ u < o + a && (o *= u / (r = o + a),
|
|
|
+ a *= u / r),
|
|
|
+ h < n + o && (n *= h / (r = n + o),
|
|
|
+ o *= h / r),
|
|
|
+ h < i + a && (i *= h / (r = i + a),
|
|
|
+ a *= h / r),
|
|
|
+ t.moveTo(s + i, l),
|
|
|
+ t.lineTo(s + u - n, l),
|
|
|
+ 0 !== n && t.arc(s + u - n, l + n, n, -Math.PI / 2, 0),
|
|
|
+ t.lineTo(s + u, l + h - o),
|
|
|
+ 0 !== o && t.arc(s + u - o, l + h - o, o, 0, Math.PI / 2),
|
|
|
+ t.lineTo(s + a, l + h),
|
|
|
+ 0 !== a && t.arc(s + a, l + h - a, a, Math.PI / 2, Math.PI),
|
|
|
+ t.lineTo(s, l + i),
|
|
|
+ 0 !== i && t.arc(s + i, l + i, i, Math.PI, 1.5 * Math.PI)
|
|
|
+ }
|
|
|
+ fn.measureText = function(t, e) {
|
|
|
+ var i = x();
|
|
|
+ return i.font = e || dn,
|
|
|
+ i.measureText(t)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Cn = dn
|
|
|
+ , Ln = {
|
|
|
+ left: 1,
|
|
|
+ right: 1,
|
|
|
+ center: 1
|
|
|
+ }
|
|
|
+ , kn = {
|
|
|
+ top: 1,
|
|
|
+ bottom: 1,
|
|
|
+ middle: 1
|
|
|
+ }
|
|
|
+ , Pn = [["textShadowBlur", "shadowBlur", 0], ["textShadowOffsetX", "shadowOffsetX", 0], ["textShadowOffsetY", "shadowOffsetY", 0], ["textShadowColor", "shadowColor", "transparent"]]
|
|
|
+ , Nn = {}
|
|
|
+ , On = {};
|
|
|
+ function En(t) {
|
|
|
+ return Rn(t),
|
|
|
+ E(t.rich, Rn),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function Rn(t) {
|
|
|
+ if (t) {
|
|
|
+ t.font = An(t);
|
|
|
+ var e = t.textAlign;
|
|
|
+ "middle" === e && (e = "center"),
|
|
|
+ t.textAlign = null == e || Ln[e] ? e : "left";
|
|
|
+ var i = t.textVerticalAlign || t.textBaseline;
|
|
|
+ "center" === i && (i = "middle"),
|
|
|
+ t.textVerticalAlign = null == i || kn[i] ? i : "top",
|
|
|
+ t.textPadding && (t.textPadding = X(t.textPadding))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function zn(t, e, i, n, o, a) {
|
|
|
+ n.rich ? function(t, e, i, n, o, a) {
|
|
|
+ a !== Hi && (e.__attrCachedBy = Wi.NONE);
|
|
|
+ var r = t.__textCotentBlock;
|
|
|
+ r && !t.__dirtyText || (r = t.__textCotentBlock = In(i, n));
|
|
|
+ !function(t, e, i, n, o) {
|
|
|
+ var a = i.width
|
|
|
+ , r = i.outerWidth
|
|
|
+ , s = i.outerHeight
|
|
|
+ , l = n.textPadding
|
|
|
+ , u = Hn(On, t, n, o)
|
|
|
+ , h = u.baseX
|
|
|
+ , c = u.baseY
|
|
|
+ , d = u.textAlign
|
|
|
+ , f = u.textVerticalAlign;
|
|
|
+ Bn(e, n, o, h, c);
|
|
|
+ var p = mn(h, r, d)
|
|
|
+ , g = vn(c, s, f)
|
|
|
+ , m = p
|
|
|
+ , v = g;
|
|
|
+ l && (m += l[3],
|
|
|
+ v += l[0]);
|
|
|
+ var y = m + a;
|
|
|
+ Gn(n) && Fn(t, e, n, p, g, r, s);
|
|
|
+ for (var x = 0; x < i.lines.length; x++) {
|
|
|
+ for (var _, w = i.lines[x], b = w.tokens, S = b.length, M = w.lineHeight, I = w.width, T = 0, A = m, D = y, C = S - 1; T < S && (!(_ = b[T]).textAlign || "left" === _.textAlign); )
|
|
|
+ Vn(t, e, _, n, M, v, A, "left"),
|
|
|
+ I -= _.width,
|
|
|
+ A += _.width,
|
|
|
+ T++;
|
|
|
+ for (; 0 <= C && "right" === (_ = b[C]).textAlign; )
|
|
|
+ Vn(t, e, _, n, M, v, D, "right"),
|
|
|
+ I -= _.width,
|
|
|
+ D -= _.width,
|
|
|
+ C--;
|
|
|
+ for (A += (a - (A - m) - (y - D) - I) / 2; T <= C; )
|
|
|
+ _ = b[T],
|
|
|
+ Vn(t, e, _, n, M, v, A + _.width / 2, "center"),
|
|
|
+ A += _.width,
|
|
|
+ T++;
|
|
|
+ v += M
|
|
|
+ }
|
|
|
+ }(t, e, r, n, o)
|
|
|
+ }(t, e, i, n, o, a) : function(t, e, i, n, o, a) {
|
|
|
+ var r, s = Gn(n), l = !1, u = e.__attrCachedBy === Wi.PLAIN_TEXT;
|
|
|
+ a !== Hi ? (a && (r = a.style,
|
|
|
+ l = !s && u && r),
|
|
|
+ e.__attrCachedBy = s ? Wi.NONE : Wi.PLAIN_TEXT) : u && (e.__attrCachedBy = Wi.NONE);
|
|
|
+ var h = n.font || Cn;
|
|
|
+ l && h === (r.font || Cn) || (e.font = h);
|
|
|
+ var c = t.__computedFont;
|
|
|
+ t.__styleFont !== h && (t.__styleFont = h,
|
|
|
+ c = t.__computedFont = e.font);
|
|
|
+ var d = n.textPadding
|
|
|
+ , f = n.textLineHeight
|
|
|
+ , p = t.__textCotentBlock;
|
|
|
+ p && !t.__dirtyText || (p = t.__textCotentBlock = Mn(i, c, d, f, n.truncate));
|
|
|
+ var g = p.outerHeight
|
|
|
+ , m = p.lines
|
|
|
+ , v = p.lineHeight
|
|
|
+ , y = Hn(On, t, n, o)
|
|
|
+ , x = y.baseX
|
|
|
+ , _ = y.baseY
|
|
|
+ , w = y.textAlign || "left"
|
|
|
+ , b = y.textVerticalAlign;
|
|
|
+ Bn(e, n, o, x, _);
|
|
|
+ var S = vn(_, g, b)
|
|
|
+ , M = x
|
|
|
+ , I = S;
|
|
|
+ if (s || d) {
|
|
|
+ var T = pn(i, c);
|
|
|
+ d && (T += d[1] + d[3]);
|
|
|
+ var A = mn(x, T, w);
|
|
|
+ s && Fn(t, e, n, A, S, T, g),
|
|
|
+ d && (M = jn(x, w, d),
|
|
|
+ I += d[0])
|
|
|
+ }
|
|
|
+ e.textAlign = w,
|
|
|
+ e.textBaseline = "middle",
|
|
|
+ e.globalAlpha = n.opacity || 1;
|
|
|
+ for (var D = 0; D < Pn.length; D++) {
|
|
|
+ var C = Pn[D]
|
|
|
+ , L = C[0]
|
|
|
+ , k = C[1]
|
|
|
+ , P = n[L];
|
|
|
+ l && P === r[L] || (e[k] = Fi(e, k, P || C[2]))
|
|
|
+ }
|
|
|
+ I += v / 2;
|
|
|
+ var N = n.textStrokeWidth
|
|
|
+ , O = l ? r.textStrokeWidth : null
|
|
|
+ , E = !l || N !== O
|
|
|
+ , R = !l || E || n.textStroke !== r.textStroke
|
|
|
+ , z = Un(n.textStroke, N)
|
|
|
+ , B = Xn(n.textFill);
|
|
|
+ z && (E && (e.lineWidth = N),
|
|
|
+ R && (e.strokeStyle = z));
|
|
|
+ B && (l && n.textFill === r.textFill || (e.fillStyle = B));
|
|
|
+ if (1 === m.length)
|
|
|
+ z && e.strokeText(m[0], M, I),
|
|
|
+ B && e.fillText(m[0], M, I);
|
|
|
+ else
|
|
|
+ for (D = 0; D < m.length; D++)
|
|
|
+ z && e.strokeText(m[D], M, I),
|
|
|
+ B && e.fillText(m[D], M, I),
|
|
|
+ I += v
|
|
|
+ }(t, e, i, n, o, a)
|
|
|
+ }
|
|
|
+ function Bn(t, e, i, n, o) {
|
|
|
+ if (i && e.textRotation) {
|
|
|
+ var a = e.textOrigin;
|
|
|
+ "center" === a ? (n = i.width / 2 + i.x,
|
|
|
+ o = i.height / 2 + i.y) : a && (n = a[0] + i.x,
|
|
|
+ o = a[1] + i.y),
|
|
|
+ t.translate(n, o),
|
|
|
+ t.rotate(-e.textRotation),
|
|
|
+ t.translate(-n, -o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Vn(t, e, i, n, o, a, r, s) {
|
|
|
+ var l = n.rich[i.styleName] || {};
|
|
|
+ l.text = i.text;
|
|
|
+ var u = i.textVerticalAlign
|
|
|
+ , h = a + o / 2;
|
|
|
+ "top" === u ? h = a + i.height / 2 : "bottom" === u && (h = a + o - i.height / 2),
|
|
|
+ !i.isLineHolder && Gn(l) && Fn(t, e, l, "right" === s ? r - i.width : "center" === s ? r - i.width / 2 : r, h - i.height / 2, i.width, i.height);
|
|
|
+ var c = i.textPadding;
|
|
|
+ c && (r = jn(r, s, c),
|
|
|
+ h -= i.height / 2 - c[2] - i.textHeight / 2),
|
|
|
+ Zn(e, "shadowBlur", Z(l.textShadowBlur, n.textShadowBlur, 0)),
|
|
|
+ Zn(e, "shadowColor", l.textShadowColor || n.textShadowColor || "transparent"),
|
|
|
+ Zn(e, "shadowOffsetX", Z(l.textShadowOffsetX, n.textShadowOffsetX, 0)),
|
|
|
+ Zn(e, "shadowOffsetY", Z(l.textShadowOffsetY, n.textShadowOffsetY, 0)),
|
|
|
+ Zn(e, "textAlign", s),
|
|
|
+ Zn(e, "textBaseline", "middle"),
|
|
|
+ Zn(e, "font", i.font || Cn);
|
|
|
+ var d = Un(l.textStroke || n.textStroke, p)
|
|
|
+ , f = Xn(l.textFill || n.textFill)
|
|
|
+ , p = H(l.textStrokeWidth, n.textStrokeWidth);
|
|
|
+ d && (Zn(e, "lineWidth", p),
|
|
|
+ Zn(e, "strokeStyle", d),
|
|
|
+ e.strokeText(i.text, r, h)),
|
|
|
+ f && (Zn(e, "fillStyle", f),
|
|
|
+ e.fillText(i.text, r, h))
|
|
|
+ }
|
|
|
+ function Gn(t) {
|
|
|
+ return !!(t.textBackgroundColor || t.textBorderWidth && t.textBorderColor)
|
|
|
+ }
|
|
|
+ function Fn(t, e, i, n, o, a, r) {
|
|
|
+ var s = i.textBackgroundColor
|
|
|
+ , l = i.textBorderWidth
|
|
|
+ , u = i.textBorderColor
|
|
|
+ , h = R(s);
|
|
|
+ if (Zn(e, "shadowBlur", i.textBoxShadowBlur || 0),
|
|
|
+ Zn(e, "shadowColor", i.textBoxShadowColor || "transparent"),
|
|
|
+ Zn(e, "shadowOffsetX", i.textBoxShadowOffsetX || 0),
|
|
|
+ Zn(e, "shadowOffsetY", i.textBoxShadowOffsetY || 0),
|
|
|
+ h || l && u) {
|
|
|
+ e.beginPath();
|
|
|
+ var c = i.textBorderRadius;
|
|
|
+ c ? Dn(e, {
|
|
|
+ x: n,
|
|
|
+ y: o,
|
|
|
+ width: a,
|
|
|
+ height: r,
|
|
|
+ r: c
|
|
|
+ }) : e.rect(n, o, a, r),
|
|
|
+ e.closePath()
|
|
|
+ }
|
|
|
+ if (h)
|
|
|
+ if (Zn(e, "fillStyle", s),
|
|
|
+ null != i.fillOpacity) {
|
|
|
+ var d = e.globalAlpha;
|
|
|
+ e.globalAlpha = i.fillOpacity * i.opacity,
|
|
|
+ e.fill(),
|
|
|
+ e.globalAlpha = d
|
|
|
+ } else
|
|
|
+ e.fill();
|
|
|
+ else if (z(s)) {
|
|
|
+ var f = s.image;
|
|
|
+ (f = an(f, null, t, Wn, s)) && sn(f) && e.drawImage(f, n, o, a, r)
|
|
|
+ }
|
|
|
+ if (l && u)
|
|
|
+ if (Zn(e, "lineWidth", l),
|
|
|
+ Zn(e, "strokeStyle", u),
|
|
|
+ null != i.strokeOpacity) {
|
|
|
+ d = e.globalAlpha;
|
|
|
+ e.globalAlpha = i.strokeOpacity * i.opacity,
|
|
|
+ e.stroke(),
|
|
|
+ e.globalAlpha = d
|
|
|
+ } else
|
|
|
+ e.stroke()
|
|
|
+ }
|
|
|
+ function Wn(t, e) {
|
|
|
+ e.image = t
|
|
|
+ }
|
|
|
+ function Hn(t, e, i, n) {
|
|
|
+ var o = i.x || 0
|
|
|
+ , a = i.y || 0
|
|
|
+ , r = i.textAlign
|
|
|
+ , s = i.textVerticalAlign;
|
|
|
+ if (n) {
|
|
|
+ var l = i.textPosition;
|
|
|
+ if (l instanceof Array)
|
|
|
+ o = n.x + Yn(l[0], n.width),
|
|
|
+ a = n.y + Yn(l[1], n.height);
|
|
|
+ else {
|
|
|
+ var u = e && e.calculateTextPosition ? e.calculateTextPosition(Nn, i, n) : yn(Nn, i, n);
|
|
|
+ o = u.x,
|
|
|
+ a = u.y,
|
|
|
+ r = r || u.textAlign,
|
|
|
+ s = s || u.textVerticalAlign
|
|
|
+ }
|
|
|
+ var h = i.textOffset;
|
|
|
+ h && (o += h[0],
|
|
|
+ a += h[1])
|
|
|
+ }
|
|
|
+ return (t = t || {}).baseX = o,
|
|
|
+ t.baseY = a,
|
|
|
+ t.textAlign = r,
|
|
|
+ t.textVerticalAlign = s,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function Zn(t, e, i) {
|
|
|
+ return t[e] = Fi(t, e, i),
|
|
|
+ t[e]
|
|
|
+ }
|
|
|
+ function Un(t, e) {
|
|
|
+ return null == t || e <= 0 || "transparent" === t || "none" === t ? null : t.image || t.colorStops ? "#000" : t
|
|
|
+ }
|
|
|
+ function Xn(t) {
|
|
|
+ return null == t || "none" === t ? null : t.image || t.colorStops ? "#000" : t
|
|
|
+ }
|
|
|
+ function Yn(t, e) {
|
|
|
+ return "string" == typeof t ? 0 <= t.lastIndexOf("%") ? parseFloat(t) / 100 * e : parseFloat(t) : t
|
|
|
+ }
|
|
|
+ function jn(t, e, i) {
|
|
|
+ return "right" === e ? t - i[1] : "center" === e ? t + i[3] / 2 - i[1] / 2 : t + i[3]
|
|
|
+ }
|
|
|
+ function qn(t, e) {
|
|
|
+ return null != t && (t || e.textBackgroundColor || e.textBorderWidth && e.textBorderColor || e.textPadding)
|
|
|
+ }
|
|
|
+ function Kn() {}
|
|
|
+ var $n = new Di;
|
|
|
+ function Jn(t) {
|
|
|
+ for (var e in t = t || {},
|
|
|
+ _i.call(this, t),
|
|
|
+ t)
|
|
|
+ t.hasOwnProperty(e) && "style" !== e && (this[e] = t[e]);
|
|
|
+ this.style = new Ui(t.style,this),
|
|
|
+ this._rect = null,
|
|
|
+ this.__clipPaths = null
|
|
|
+ }
|
|
|
+ function Qn(t) {
|
|
|
+ Jn.call(this, t)
|
|
|
+ }
|
|
|
+ Jn.prototype = {
|
|
|
+ constructor: Jn,
|
|
|
+ type: "displayable",
|
|
|
+ __dirty: !0,
|
|
|
+ invisible: !(Kn.prototype = {
|
|
|
+ constructor: Kn,
|
|
|
+ drawRectText: function(t, e) {
|
|
|
+ var i = this.style;
|
|
|
+ e = i.textRect || e,
|
|
|
+ this.__dirty && En(i);
|
|
|
+ var n = i.text;
|
|
|
+ if (null != n && (n += ""),
|
|
|
+ qn(n, i)) {
|
|
|
+ t.save();
|
|
|
+ var o = this.transform;
|
|
|
+ i.transformText ? this.setTransform(t) : o && ($n.copy(e),
|
|
|
+ $n.applyTransform(o),
|
|
|
+ e = $n),
|
|
|
+ zn(this, t, n, i, e, Hi),
|
|
|
+ t.restore()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ z: 0,
|
|
|
+ z2: 0,
|
|
|
+ zlevel: 0,
|
|
|
+ draggable: !1,
|
|
|
+ dragging: !1,
|
|
|
+ silent: !1,
|
|
|
+ culling: !1,
|
|
|
+ cursor: "pointer",
|
|
|
+ rectHover: !1,
|
|
|
+ progressive: !1,
|
|
|
+ incremental: !1,
|
|
|
+ globalScaleRatio: 1,
|
|
|
+ beforeBrush: function(t) {},
|
|
|
+ afterBrush: function(t) {},
|
|
|
+ brush: function(t, e) {},
|
|
|
+ getBoundingRect: function() {},
|
|
|
+ contain: function(t, e) {
|
|
|
+ return this.rectContain(t, e)
|
|
|
+ },
|
|
|
+ traverse: function(t, e) {
|
|
|
+ t.call(e, this)
|
|
|
+ },
|
|
|
+ rectContain: function(t, e) {
|
|
|
+ var i = this.transformCoordToLocal(t, e);
|
|
|
+ return this.getBoundingRect().contain(i[0], i[1])
|
|
|
+ },
|
|
|
+ dirty: function() {
|
|
|
+ this.__dirty = this.__dirtyText = !0,
|
|
|
+ this._rect = null,
|
|
|
+ this.__zr && this.__zr.refresh()
|
|
|
+ },
|
|
|
+ animateStyle: function(t) {
|
|
|
+ return this.animate("style", t)
|
|
|
+ },
|
|
|
+ attrKV: function(t, e) {
|
|
|
+ "style" !== t ? _i.prototype.attrKV.call(this, t, e) : this.style.set(e)
|
|
|
+ },
|
|
|
+ setStyle: function(t, e) {
|
|
|
+ return this.style.set(t, e),
|
|
|
+ this.dirty(!1),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ useStyle: function(t) {
|
|
|
+ return this.style = new Ui(t,this),
|
|
|
+ this.dirty(!1),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ calculateTextPosition: null
|
|
|
+ },
|
|
|
+ w(Jn, _i),
|
|
|
+ b(Jn, Kn),
|
|
|
+ Qn.prototype = {
|
|
|
+ constructor: Qn,
|
|
|
+ type: "image",
|
|
|
+ brush: function(t, e) {
|
|
|
+ var i = this.style
|
|
|
+ , n = i.image;
|
|
|
+ i.bind(t, this, e);
|
|
|
+ var o = this._image = an(n, this._image, this, this.onload);
|
|
|
+ if (o && sn(o)) {
|
|
|
+ var a = i.x || 0
|
|
|
+ , r = i.y || 0
|
|
|
+ , s = i.width
|
|
|
+ , l = i.height
|
|
|
+ , u = o.width / o.height;
|
|
|
+ if (null == s && null != l ? s = l * u : null == l && null != s ? l = s / u : null == s && null == l && (s = o.width,
|
|
|
+ l = o.height),
|
|
|
+ this.setTransform(t),
|
|
|
+ i.sWidth && i.sHeight) {
|
|
|
+ var h = i.sx || 0
|
|
|
+ , c = i.sy || 0;
|
|
|
+ t.drawImage(o, h, c, i.sWidth, i.sHeight, a, r, s, l)
|
|
|
+ } else if (i.sx && i.sy) {
|
|
|
+ var d = s - (h = i.sx)
|
|
|
+ , f = l - (c = i.sy);
|
|
|
+ t.drawImage(o, h, c, d, f, a, r, s, l)
|
|
|
+ } else
|
|
|
+ t.drawImage(o, a, r, s, l);
|
|
|
+ null != i.text && (this.restoreTransform(t),
|
|
|
+ this.drawRectText(t, this.getBoundingRect()))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getBoundingRect: function() {
|
|
|
+ var t = this.style;
|
|
|
+ return this._rect || (this._rect = new Di(t.x || 0,t.y || 0,t.width || 0,t.height || 0)),
|
|
|
+ this._rect
|
|
|
+ }
|
|
|
+ },
|
|
|
+ w(Qn, Jn);
|
|
|
+ var to = 314159;
|
|
|
+ function eo(t) {
|
|
|
+ return parseInt(t, 10)
|
|
|
+ }
|
|
|
+ var io = new Di(0,0,0,0)
|
|
|
+ , no = new Di(0,0,0,0);
|
|
|
+ function oo(t, e, i) {
|
|
|
+ this.type = "canvas";
|
|
|
+ var n = !t.nodeName || "CANVAS" === t.nodeName.toUpperCase();
|
|
|
+ this._opts = i = P({}, i || {}),
|
|
|
+ this.dpr = i.devicePixelRatio || pi,
|
|
|
+ this._singleCanvas = n;
|
|
|
+ var o = (this.root = t).style;
|
|
|
+ o && (o["-webkit-tap-highlight-color"] = "transparent",
|
|
|
+ o["-webkit-user-select"] = o["user-select"] = o["-webkit-touch-callout"] = "none",
|
|
|
+ t.innerHTML = ""),
|
|
|
+ this.storage = e;
|
|
|
+ var a = this._zlevelList = []
|
|
|
+ , r = this._layers = {};
|
|
|
+ if (this._layerConfig = {},
|
|
|
+ this._needsManuallyCompositing = !1,
|
|
|
+ n) {
|
|
|
+ var s = t.width
|
|
|
+ , l = t.height;
|
|
|
+ null != i.width && (s = i.width),
|
|
|
+ null != i.height && (l = i.height),
|
|
|
+ this.dpr = i.devicePixelRatio || 1,
|
|
|
+ t.width = s * this.dpr,
|
|
|
+ t.height = l * this.dpr,
|
|
|
+ this._width = s,
|
|
|
+ this._height = l;
|
|
|
+ var u = new tn(t,this,this.dpr);
|
|
|
+ u.__builtin__ = !0,
|
|
|
+ u.initContext(),
|
|
|
+ (r[to] = u).zlevel = to,
|
|
|
+ a.push(to),
|
|
|
+ this._domRoot = t
|
|
|
+ } else {
|
|
|
+ this._width = this._getSize(0),
|
|
|
+ this._height = this._getSize(1);
|
|
|
+ var h = this._domRoot = function(t, e) {
|
|
|
+ var i = document.createElement("div");
|
|
|
+ return i.style.cssText = ["position:relative", "width:" + t + "px", "height:" + e + "px", "padding:0", "margin:0", "border-width:0"].join(";") + ";",
|
|
|
+ i
|
|
|
+ }(this._width, this._height);
|
|
|
+ t.appendChild(h)
|
|
|
+ }
|
|
|
+ this._hoverlayer = null,
|
|
|
+ this._hoverElements = []
|
|
|
+ }
|
|
|
+ oo.prototype = {
|
|
|
+ constructor: oo,
|
|
|
+ getType: function() {
|
|
|
+ return "canvas"
|
|
|
+ },
|
|
|
+ isSingleCanvas: function() {
|
|
|
+ return this._singleCanvas
|
|
|
+ },
|
|
|
+ getViewportRoot: function() {
|
|
|
+ return this._domRoot
|
|
|
+ },
|
|
|
+ getViewportRootOffset: function() {
|
|
|
+ var t = this.getViewportRoot();
|
|
|
+ if (t)
|
|
|
+ return {
|
|
|
+ offsetLeft: t.offsetLeft || 0,
|
|
|
+ offsetTop: t.offsetTop || 0
|
|
|
+ }
|
|
|
+ },
|
|
|
+ refresh: function(t) {
|
|
|
+ var e = this.storage.getDisplayList(!0)
|
|
|
+ , i = this._zlevelList;
|
|
|
+ this._redrawId = Math.random(),
|
|
|
+ this._paintList(e, t, this._redrawId);
|
|
|
+ for (var n = 0; n < i.length; n++) {
|
|
|
+ var o = i[n]
|
|
|
+ , a = this._layers[o];
|
|
|
+ if (!a.__builtin__ && a.refresh) {
|
|
|
+ var r = 0 === n ? this._backgroundColor : null;
|
|
|
+ a.refresh(r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return this.refreshHover(),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ addHover: function(t, e) {
|
|
|
+ if (!t.__hoverMir) {
|
|
|
+ var i = new t.constructor({
|
|
|
+ style: t.style,
|
|
|
+ shape: t.shape,
|
|
|
+ z: t.z,
|
|
|
+ z2: t.z2,
|
|
|
+ silent: t.silent
|
|
|
+ });
|
|
|
+ return (i.__from = t).__hoverMir = i,
|
|
|
+ e && i.setStyle(e),
|
|
|
+ this._hoverElements.push(i),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ },
|
|
|
+ removeHover: function(t) {
|
|
|
+ var e = t.__hoverMir
|
|
|
+ , i = this._hoverElements
|
|
|
+ , n = _(i, e);
|
|
|
+ 0 <= n && i.splice(n, 1),
|
|
|
+ t.__hoverMir = null
|
|
|
+ },
|
|
|
+ clearHover: function(t) {
|
|
|
+ for (var e = this._hoverElements, i = 0; i < e.length; i++) {
|
|
|
+ var n = e[i].__from;
|
|
|
+ n && (n.__hoverMir = null)
|
|
|
+ }
|
|
|
+ e.length = 0
|
|
|
+ },
|
|
|
+ refreshHover: function() {
|
|
|
+ var t = this._hoverElements
|
|
|
+ , e = t.length
|
|
|
+ , i = this._hoverlayer;
|
|
|
+ if (i && i.clear(),
|
|
|
+ e) {
|
|
|
+ zi(t, this.storage.displayableSortFunc);
|
|
|
+ var n = {};
|
|
|
+ (i = i || (this._hoverlayer = this.getLayer(1e5))).ctx.save();
|
|
|
+ for (var o = 0; o < e; ) {
|
|
|
+ var a = t[o]
|
|
|
+ , r = a.__from;
|
|
|
+ r && r.__zr ? (o++,
|
|
|
+ r.invisible || (a.transform = r.transform,
|
|
|
+ a.invTransform = r.invTransform,
|
|
|
+ a.__clipPaths = r.__clipPaths,
|
|
|
+ this._doPaintEl(a, i, !0, n))) : (t.splice(o, 1),
|
|
|
+ r.__hoverMir = null,
|
|
|
+ e--)
|
|
|
+ }
|
|
|
+ i.ctx.restore()
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getHoverLayer: function() {
|
|
|
+ return this.getLayer(1e5)
|
|
|
+ },
|
|
|
+ _paintList: function(t, e, i) {
|
|
|
+ if (this._redrawId === i) {
|
|
|
+ e = e || !1,
|
|
|
+ this._updateLayerStatus(t);
|
|
|
+ var n = this._doPaintList(t, e);
|
|
|
+ if (this._needsManuallyCompositing && this._compositeManually(),
|
|
|
+ !n) {
|
|
|
+ var o = this;
|
|
|
+ en(function() {
|
|
|
+ o._paintList(t, e, i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _compositeManually: function() {
|
|
|
+ var e = this.getLayer(to).ctx
|
|
|
+ , i = this._domRoot.width
|
|
|
+ , n = this._domRoot.height;
|
|
|
+ e.clearRect(0, 0, i, n),
|
|
|
+ this.eachBuiltinLayer(function(t) {
|
|
|
+ t.virtual && e.drawImage(t.dom, 0, 0, i, n)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _doPaintList: function(t, e) {
|
|
|
+ for (var i = [], n = 0; n < this._zlevelList.length; n++) {
|
|
|
+ var o = this._zlevelList[n];
|
|
|
+ (s = this._layers[o]).__builtin__ && s !== this._hoverlayer && (s.__dirty || e) && i.push(s)
|
|
|
+ }
|
|
|
+ for (var a = !0, r = 0; r < i.length; r++) {
|
|
|
+ var s, l = (s = i[r]).ctx, u = {};
|
|
|
+ l.save();
|
|
|
+ var h = e ? s.__startIndex : s.__drawIndex
|
|
|
+ , c = !e && s.incremental && Date.now
|
|
|
+ , d = c && Date.now()
|
|
|
+ , f = s.zlevel === this._zlevelList[0] ? this._backgroundColor : null;
|
|
|
+ if (s.__startIndex === s.__endIndex)
|
|
|
+ s.clear(!1, f);
|
|
|
+ else if (h === s.__startIndex) {
|
|
|
+ var p = t[h];
|
|
|
+ p.incremental && p.notClear && !e || s.clear(!1, f)
|
|
|
+ }
|
|
|
+ -1 === h && (console.error("For some unknown reason. drawIndex is -1"),
|
|
|
+ h = s.__startIndex);
|
|
|
+ for (var g = h; g < s.__endIndex; g++) {
|
|
|
+ var m = t[g];
|
|
|
+ if (this._doPaintEl(m, s, e, u),
|
|
|
+ m.__dirty = m.__dirtyText = !1,
|
|
|
+ c)
|
|
|
+ if (15 < Date.now() - d)
|
|
|
+ break
|
|
|
+ }
|
|
|
+ s.__drawIndex = g,
|
|
|
+ s.__drawIndex < s.__endIndex && (a = !1),
|
|
|
+ u.prevElClipPaths && l.restore(),
|
|
|
+ l.restore()
|
|
|
+ }
|
|
|
+ return v.wxa && E(this._layers, function(t) {
|
|
|
+ t && t.ctx && t.ctx.draw && t.ctx.draw()
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ },
|
|
|
+ _doPaintEl: function(t, e, i, n) {
|
|
|
+ var o = e.ctx
|
|
|
+ , a = t.transform;
|
|
|
+ if ((e.__dirty || i) && !t.invisible && 0 !== t.style.opacity && (!a || a[0] || a[3]) && (!t.culling || !function(t, e, i) {
|
|
|
+ return io.copy(t.getBoundingRect()),
|
|
|
+ t.transform && io.applyTransform(t.transform),
|
|
|
+ no.width = e,
|
|
|
+ no.height = i,
|
|
|
+ !io.intersect(no)
|
|
|
+ }(t, this._width, this._height))) {
|
|
|
+ var r = t.__clipPaths
|
|
|
+ , s = n.prevElClipPaths;
|
|
|
+ s && !function(t, e) {
|
|
|
+ if (t === e)
|
|
|
+ return !1;
|
|
|
+ if (!t || !e || t.length !== e.length)
|
|
|
+ return !0;
|
|
|
+ for (var i = 0; i < t.length; i++)
|
|
|
+ if (t[i] !== e[i])
|
|
|
+ return !0;
|
|
|
+ return !1
|
|
|
+ }(r, s) || (s && (o.restore(),
|
|
|
+ n.prevElClipPaths = null,
|
|
|
+ n.prevEl = null),
|
|
|
+ r && (o.save(),
|
|
|
+ function(t, e) {
|
|
|
+ for (var i = 0; i < t.length; i++) {
|
|
|
+ var n = t[i];
|
|
|
+ n.setTransform(e),
|
|
|
+ e.beginPath(),
|
|
|
+ n.buildPath(e, n.shape),
|
|
|
+ e.clip(),
|
|
|
+ n.restoreTransform(e)
|
|
|
+ }
|
|
|
+ }(r, o),
|
|
|
+ n.prevElClipPaths = r)),
|
|
|
+ t.beforeBrush && t.beforeBrush(o),
|
|
|
+ t.brush(o, n.prevEl || null),
|
|
|
+ (n.prevEl = t).afterBrush && t.afterBrush(o)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getLayer: function(t, e) {
|
|
|
+ this._singleCanvas && !this._needsManuallyCompositing && (t = to);
|
|
|
+ var i = this._layers[t];
|
|
|
+ return i || ((i = new tn("zr_" + t,this,this.dpr)).zlevel = t,
|
|
|
+ i.__builtin__ = !0,
|
|
|
+ this._layerConfig[t] ? m(i, this._layerConfig[t], !0) : this._layerConfig[t - .01] && m(i, this._layerConfig[t - .01], !0),
|
|
|
+ e && (i.virtual = e),
|
|
|
+ this.insertLayer(t, i),
|
|
|
+ i.initContext()),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ insertLayer: function(t, e) {
|
|
|
+ var i = this._layers
|
|
|
+ , n = this._zlevelList
|
|
|
+ , o = n.length
|
|
|
+ , a = null
|
|
|
+ , r = -1
|
|
|
+ , s = this._domRoot;
|
|
|
+ if (i[t])
|
|
|
+ vi("ZLevel " + t + " has been used already");
|
|
|
+ else if (function(t) {
|
|
|
+ return !!t && (!!t.__builtin__ || "function" == typeof t.resize && "function" == typeof t.refresh)
|
|
|
+ }(e)) {
|
|
|
+ if (0 < o && t > n[0]) {
|
|
|
+ for (r = 0; r < o - 1 && !(n[r] < t && n[r + 1] > t); r++)
|
|
|
+ ;
|
|
|
+ a = i[n[r]]
|
|
|
+ }
|
|
|
+ if (n.splice(r + 1, 0, t),
|
|
|
+ !(i[t] = e).virtual)
|
|
|
+ if (a) {
|
|
|
+ var l = a.dom;
|
|
|
+ l.nextSibling ? s.insertBefore(e.dom, l.nextSibling) : s.appendChild(e.dom)
|
|
|
+ } else
|
|
|
+ s.firstChild ? s.insertBefore(e.dom, s.firstChild) : s.appendChild(e.dom)
|
|
|
+ } else
|
|
|
+ vi("Layer of zlevel " + t + " is not valid")
|
|
|
+ },
|
|
|
+ eachLayer: function(t, e) {
|
|
|
+ var i, n, o = this._zlevelList;
|
|
|
+ for (n = 0; n < o.length; n++)
|
|
|
+ i = o[n],
|
|
|
+ t.call(e, this._layers[i], i)
|
|
|
+ },
|
|
|
+ eachBuiltinLayer: function(t, e) {
|
|
|
+ var i, n, o, a = this._zlevelList;
|
|
|
+ for (o = 0; o < a.length; o++)
|
|
|
+ n = a[o],
|
|
|
+ (i = this._layers[n]).__builtin__ && t.call(e, i, n)
|
|
|
+ },
|
|
|
+ eachOtherLayer: function(t, e) {
|
|
|
+ var i, n, o, a = this._zlevelList;
|
|
|
+ for (o = 0; o < a.length; o++)
|
|
|
+ n = a[o],
|
|
|
+ (i = this._layers[n]).__builtin__ || t.call(e, i, n)
|
|
|
+ },
|
|
|
+ getLayers: function() {
|
|
|
+ return this._layers
|
|
|
+ },
|
|
|
+ _updateLayerStatus: function(t) {
|
|
|
+ function e(t) {
|
|
|
+ o && (o.__endIndex !== t && (o.__dirty = !0),
|
|
|
+ o.__endIndex = t)
|
|
|
+ }
|
|
|
+ if (this.eachBuiltinLayer(function(t, e) {
|
|
|
+ t.__dirty = t.__used = !1
|
|
|
+ }),
|
|
|
+ this._singleCanvas)
|
|
|
+ for (var i = 1; i < t.length; i++) {
|
|
|
+ if ((r = t[i]).zlevel !== t[i - 1].zlevel || r.incremental) {
|
|
|
+ this._needsManuallyCompositing = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var n, o = null, a = 0;
|
|
|
+ for (i = 0; i < t.length; i++) {
|
|
|
+ var r, s, l = (r = t[i]).zlevel;
|
|
|
+ n !== l && (n = l,
|
|
|
+ a = 0),
|
|
|
+ r.incremental ? ((s = this.getLayer(l + .001, this._needsManuallyCompositing)).incremental = !0,
|
|
|
+ a = 1) : s = this.getLayer(l + (0 < a ? .01 : 0), this._needsManuallyCompositing),
|
|
|
+ s.__builtin__ || vi("ZLevel " + l + " has been used by unkown layer " + s.id),
|
|
|
+ s !== o && (s.__used = !0,
|
|
|
+ s.__startIndex !== i && (s.__dirty = !0),
|
|
|
+ s.__startIndex = i,
|
|
|
+ s.incremental ? s.__drawIndex = -1 : s.__drawIndex = i,
|
|
|
+ e(i),
|
|
|
+ o = s),
|
|
|
+ r.__dirty && (s.__dirty = !0,
|
|
|
+ s.incremental && s.__drawIndex < 0 && (s.__drawIndex = i))
|
|
|
+ }
|
|
|
+ e(i),
|
|
|
+ this.eachBuiltinLayer(function(t, e) {
|
|
|
+ !t.__used && 0 < t.getElementCount() && (t.__dirty = !0,
|
|
|
+ t.__startIndex = t.__endIndex = t.__drawIndex = 0),
|
|
|
+ t.__dirty && t.__drawIndex < 0 && (t.__drawIndex = t.__startIndex)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ clear: function() {
|
|
|
+ return this.eachBuiltinLayer(this._clearLayer),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ _clearLayer: function(t) {
|
|
|
+ t.clear()
|
|
|
+ },
|
|
|
+ setBackgroundColor: function(t) {
|
|
|
+ this._backgroundColor = t
|
|
|
+ },
|
|
|
+ configLayer: function(t, e) {
|
|
|
+ if (e) {
|
|
|
+ var i = this._layerConfig;
|
|
|
+ i[t] ? m(i[t], e, !0) : i[t] = e;
|
|
|
+ for (var n = 0; n < this._zlevelList.length; n++) {
|
|
|
+ var o = this._zlevelList[n];
|
|
|
+ if (o === t || o === t + .01)
|
|
|
+ m(this._layers[o], i[t], !0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ delLayer: function(t) {
|
|
|
+ var e = this._layers
|
|
|
+ , i = this._zlevelList
|
|
|
+ , n = e[t];
|
|
|
+ n && (n.dom.parentNode.removeChild(n.dom),
|
|
|
+ delete e[t],
|
|
|
+ i.splice(_(i, t), 1))
|
|
|
+ },
|
|
|
+ resize: function(e, i) {
|
|
|
+ if (this._domRoot.style) {
|
|
|
+ var t = this._domRoot;
|
|
|
+ t.style.display = "none";
|
|
|
+ var n = this._opts;
|
|
|
+ if (null != e && (n.width = e),
|
|
|
+ null != i && (n.height = i),
|
|
|
+ e = this._getSize(0),
|
|
|
+ i = this._getSize(1),
|
|
|
+ t.style.display = "",
|
|
|
+ this._width !== e || i !== this._height) {
|
|
|
+ for (var o in t.style.width = e + "px",
|
|
|
+ t.style.height = i + "px",
|
|
|
+ this._layers)
|
|
|
+ this._layers.hasOwnProperty(o) && this._layers[o].resize(e, i);
|
|
|
+ E(this._progressiveLayers, function(t) {
|
|
|
+ t.resize(e, i)
|
|
|
+ }),
|
|
|
+ this.refresh(!0)
|
|
|
+ }
|
|
|
+ this._width = e,
|
|
|
+ this._height = i
|
|
|
+ } else {
|
|
|
+ if (null == e || null == i)
|
|
|
+ return;
|
|
|
+ this._width = e,
|
|
|
+ this._height = i,
|
|
|
+ this.getLayer(to).resize(e, i)
|
|
|
+ }
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ clearLayer: function(t) {
|
|
|
+ var e = this._layers[t];
|
|
|
+ e && e.clear()
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this.root.innerHTML = "",
|
|
|
+ this.root = this.storage = this._domRoot = this._layers = null
|
|
|
+ },
|
|
|
+ getRenderedCanvas: function(t) {
|
|
|
+ if (t = t || {},
|
|
|
+ this._singleCanvas && !this._compositeManually)
|
|
|
+ return this._layers[to].dom;
|
|
|
+ var e = new tn("image",this,t.pixelRatio || this.dpr);
|
|
|
+ if (e.initContext(),
|
|
|
+ e.clear(!1, t.backgroundColor || this._backgroundColor),
|
|
|
+ t.pixelRatio <= this.dpr) {
|
|
|
+ this.refresh();
|
|
|
+ var i = e.dom.width
|
|
|
+ , n = e.dom.height
|
|
|
+ , o = e.ctx;
|
|
|
+ this.eachLayer(function(t) {
|
|
|
+ t.__builtin__ ? o.drawImage(t.dom, 0, 0, i, n) : t.renderToCanvas && (e.ctx.save(),
|
|
|
+ t.renderToCanvas(e.ctx),
|
|
|
+ e.ctx.restore())
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ for (var a = {}, r = this.storage.getDisplayList(!0), s = 0; s < r.length; s++) {
|
|
|
+ var l = r[s];
|
|
|
+ this._doPaintEl(l, e, !0, a)
|
|
|
+ }
|
|
|
+ return e.dom
|
|
|
+ },
|
|
|
+ getWidth: function() {
|
|
|
+ return this._width
|
|
|
+ },
|
|
|
+ getHeight: function() {
|
|
|
+ return this._height
|
|
|
+ },
|
|
|
+ _getSize: function(t) {
|
|
|
+ var e = this._opts
|
|
|
+ , i = ["width", "height"][t]
|
|
|
+ , n = ["clientWidth", "clientHeight"][t]
|
|
|
+ , o = ["paddingLeft", "paddingTop"][t]
|
|
|
+ , a = ["paddingRight", "paddingBottom"][t];
|
|
|
+ if (null != e[i] && "auto" !== e[i])
|
|
|
+ return parseFloat(e[i]);
|
|
|
+ var r = this.root
|
|
|
+ , s = document.defaultView.getComputedStyle(r);
|
|
|
+ return (r[n] || eo(s[i]) || eo(r.style[i])) - (eo(s[o]) || 0) - (eo(s[a]) || 0) | 0
|
|
|
+ },
|
|
|
+ pathToImage: function(t, e) {
|
|
|
+ e = e || this.dpr;
|
|
|
+ var i = document.createElement("canvas")
|
|
|
+ , n = i.getContext("2d")
|
|
|
+ , o = t.getBoundingRect()
|
|
|
+ , a = t.style
|
|
|
+ , r = a.shadowBlur * e
|
|
|
+ , s = a.shadowOffsetX * e
|
|
|
+ , l = a.shadowOffsetY * e
|
|
|
+ , u = a.hasStroke() ? a.lineWidth : 0
|
|
|
+ , h = Math.max(u / 2, r - s)
|
|
|
+ , c = Math.max(u / 2, s + r)
|
|
|
+ , d = Math.max(u / 2, r - l)
|
|
|
+ , f = Math.max(u / 2, l + r)
|
|
|
+ , p = o.width + h + c
|
|
|
+ , g = o.height + d + f;
|
|
|
+ i.width = p * e,
|
|
|
+ i.height = g * e,
|
|
|
+ n.scale(e, e),
|
|
|
+ n.clearRect(0, 0, p, g),
|
|
|
+ n.dpr = e;
|
|
|
+ var m = {
|
|
|
+ position: t.position,
|
|
|
+ rotation: t.rotation,
|
|
|
+ scale: t.scale
|
|
|
+ };
|
|
|
+ t.position = [h - o.x, d - o.y],
|
|
|
+ t.rotation = 0,
|
|
|
+ t.scale = [1, 1],
|
|
|
+ t.updateTransform(),
|
|
|
+ t && t.brush(n);
|
|
|
+ var v = new Qn({
|
|
|
+ style: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ image: i
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return null != m.position && (v.position = t.position = m.position),
|
|
|
+ null != m.rotation && (v.rotation = t.rotation = m.rotation),
|
|
|
+ null != m.scale && (v.scale = t.scale = m.scale),
|
|
|
+ v
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function ao(t) {
|
|
|
+ t = t || {},
|
|
|
+ this.stage = t.stage || {},
|
|
|
+ this.onframe = t.onframe || function() {}
|
|
|
+ ,
|
|
|
+ this._clips = [],
|
|
|
+ this._running = !1,
|
|
|
+ this._time,
|
|
|
+ this._pausedTime,
|
|
|
+ this._pauseStart,
|
|
|
+ this._paused = !1,
|
|
|
+ Ct.call(this)
|
|
|
+ }
|
|
|
+ ao.prototype = {
|
|
|
+ constructor: ao,
|
|
|
+ addClip: function(t) {
|
|
|
+ this._clips.push(t)
|
|
|
+ },
|
|
|
+ addAnimator: function(t) {
|
|
|
+ t.animation = this;
|
|
|
+ for (var e = t.getClips(), i = 0; i < e.length; i++)
|
|
|
+ this.addClip(e[i])
|
|
|
+ },
|
|
|
+ removeClip: function(t) {
|
|
|
+ var e = _(this._clips, t);
|
|
|
+ 0 <= e && this._clips.splice(e, 1)
|
|
|
+ },
|
|
|
+ removeAnimator: function(t) {
|
|
|
+ for (var e = t.getClips(), i = 0; i < e.length; i++)
|
|
|
+ this.removeClip(e[i]);
|
|
|
+ t.animation = null
|
|
|
+ },
|
|
|
+ _update: function() {
|
|
|
+ for (var t = (new Date).getTime() - this._pausedTime, e = t - this._time, i = this._clips, n = i.length, o = [], a = [], r = 0; r < n; r++) {
|
|
|
+ var s = i[r]
|
|
|
+ , l = s.step(t, e);
|
|
|
+ l && (o.push(l),
|
|
|
+ a.push(s))
|
|
|
+ }
|
|
|
+ for (r = 0; r < n; )
|
|
|
+ i[r]._needsRemove ? (i[r] = i[n - 1],
|
|
|
+ i.pop(),
|
|
|
+ n--) : r++;
|
|
|
+ n = o.length;
|
|
|
+ for (r = 0; r < n; r++)
|
|
|
+ a[r].fire(o[r]);
|
|
|
+ this._time = t,
|
|
|
+ this.onframe(e),
|
|
|
+ this.trigger("frame", e),
|
|
|
+ this.stage.update && this.stage.update()
|
|
|
+ },
|
|
|
+ _startLoop: function() {
|
|
|
+ var e = this;
|
|
|
+ this._running = !0,
|
|
|
+ en(function t() {
|
|
|
+ e._running && (en(t),
|
|
|
+ e._paused || e._update())
|
|
|
+ })
|
|
|
+ },
|
|
|
+ start: function() {
|
|
|
+ this._time = (new Date).getTime(),
|
|
|
+ this._pausedTime = 0,
|
|
|
+ this._startLoop()
|
|
|
+ },
|
|
|
+ stop: function() {
|
|
|
+ this._running = !1
|
|
|
+ },
|
|
|
+ pause: function() {
|
|
|
+ this._paused || (this._pauseStart = (new Date).getTime(),
|
|
|
+ this._paused = !0)
|
|
|
+ },
|
|
|
+ resume: function() {
|
|
|
+ this._paused && (this._pausedTime += (new Date).getTime() - this._pauseStart,
|
|
|
+ this._paused = !1)
|
|
|
+ },
|
|
|
+ clear: function() {
|
|
|
+ this._clips = []
|
|
|
+ },
|
|
|
+ isFinished: function() {
|
|
|
+ return !this._clips.length
|
|
|
+ },
|
|
|
+ animate: function(t, e) {
|
|
|
+ var i = new di(t,(e = e || {}).loop,e.getter,e.setter);
|
|
|
+ return this.addAnimator(i),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ },
|
|
|
+ b(ao, Ct);
|
|
|
+ var ro, so, lo = v.domSupported, uo = (so = {
|
|
|
+ pointerdown: 1,
|
|
|
+ pointerup: 1,
|
|
|
+ pointermove: 1,
|
|
|
+ pointerout: 1
|
|
|
+ },
|
|
|
+ {
|
|
|
+ mouse: ro = ["click", "dblclick", "mousewheel", "mouseout", "mouseup", "mousedown", "mousemove", "contextmenu"],
|
|
|
+ touch: ["touchstart", "touchend", "touchmove"],
|
|
|
+ pointer: O(ro, function(t) {
|
|
|
+ var e = t.replace("mouse", "pointer");
|
|
|
+ return so.hasOwnProperty(e) ? e : t
|
|
|
+ })
|
|
|
+ }), ho = {
|
|
|
+ mouse: ["mousemove", "mouseup"],
|
|
|
+ pointer: ["pointermove", "pointerup"]
|
|
|
+ };
|
|
|
+ function co(t) {
|
|
|
+ return "mousewheel" === t && v.browser.firefox ? "DOMMouseScroll" : t
|
|
|
+ }
|
|
|
+ function fo(t) {
|
|
|
+ var e = t.pointerType;
|
|
|
+ return "pen" === e || "touch" === e
|
|
|
+ }
|
|
|
+ function po(t) {
|
|
|
+ t && (t.zrByTouch = !0)
|
|
|
+ }
|
|
|
+ function go(t, e) {
|
|
|
+ for (var i = e, n = !1; i && 9 !== i.nodeType && !(n = i.domBelongToZr || i !== e && i === t.painterRoot); )
|
|
|
+ i = i.parentNode;
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function mo(t, e) {
|
|
|
+ this.type = e.type,
|
|
|
+ this.target = this.currentTarget = t.dom,
|
|
|
+ this.pointerType = e.pointerType,
|
|
|
+ this.clientX = e.clientX,
|
|
|
+ this.clientY = e.clientY
|
|
|
+ }
|
|
|
+ var vo = mo.prototype;
|
|
|
+ vo.stopPropagation = vo.stopImmediatePropagation = vo.preventDefault = et;
|
|
|
+ var yo = {
|
|
|
+ mousedown: function(t) {
|
|
|
+ t = Zt(this.dom, t),
|
|
|
+ this._mayPointerCapture = [t.zrX, t.zrY],
|
|
|
+ this.trigger("mousedown", t)
|
|
|
+ },
|
|
|
+ mousemove: function(t) {
|
|
|
+ t = Zt(this.dom, t);
|
|
|
+ var e = this._mayPointerCapture;
|
|
|
+ !e || t.zrX === e[0] && t.zrY === e[1] || Mo(this, !0),
|
|
|
+ this.trigger("mousemove", t)
|
|
|
+ },
|
|
|
+ mouseup: function(t) {
|
|
|
+ t = Zt(this.dom, t),
|
|
|
+ Mo(this, !1),
|
|
|
+ this.trigger("mouseup", t)
|
|
|
+ },
|
|
|
+ mouseout: function(t) {
|
|
|
+ t = Zt(this.dom, t),
|
|
|
+ this._pointerCapturing && (t.zrEventControl = "no_globalout");
|
|
|
+ var e = t.toElement || t.relatedTarget;
|
|
|
+ t.zrIsToLocalDOM = go(this, e),
|
|
|
+ this.trigger("mouseout", t)
|
|
|
+ },
|
|
|
+ touchstart: function(t) {
|
|
|
+ po(t = Zt(this.dom, t)),
|
|
|
+ this._lastTouchMoment = new Date,
|
|
|
+ this.handler.processGesture(t, "start"),
|
|
|
+ yo.mousemove.call(this, t),
|
|
|
+ yo.mousedown.call(this, t)
|
|
|
+ },
|
|
|
+ touchmove: function(t) {
|
|
|
+ po(t = Zt(this.dom, t)),
|
|
|
+ this.handler.processGesture(t, "change"),
|
|
|
+ yo.mousemove.call(this, t)
|
|
|
+ },
|
|
|
+ touchend: function(t) {
|
|
|
+ po(t = Zt(this.dom, t)),
|
|
|
+ this.handler.processGesture(t, "end"),
|
|
|
+ yo.mouseup.call(this, t),
|
|
|
+ +new Date - this._lastTouchMoment < 300 && yo.click.call(this, t)
|
|
|
+ },
|
|
|
+ pointerdown: function(t) {
|
|
|
+ yo.mousedown.call(this, t)
|
|
|
+ },
|
|
|
+ pointermove: function(t) {
|
|
|
+ fo(t) || yo.mousemove.call(this, t)
|
|
|
+ },
|
|
|
+ pointerup: function(t) {
|
|
|
+ yo.mouseup.call(this, t)
|
|
|
+ },
|
|
|
+ pointerout: function(t) {
|
|
|
+ fo(t) || yo.mouseout.call(this, t)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ E(["click", "mousewheel", "dblclick", "contextmenu"], function(e) {
|
|
|
+ yo[e] = function(t) {
|
|
|
+ t = Zt(this.dom, t),
|
|
|
+ this.trigger(e, t)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var xo = {
|
|
|
+ pointermove: function(t) {
|
|
|
+ fo(t) || xo.mousemove.call(this, t)
|
|
|
+ },
|
|
|
+ pointerup: function(t) {
|
|
|
+ xo.mouseup.call(this, t)
|
|
|
+ },
|
|
|
+ mousemove: function(t) {
|
|
|
+ this.trigger("mousemove", t)
|
|
|
+ },
|
|
|
+ mouseup: function(t) {
|
|
|
+ var e = this._pointerCapturing;
|
|
|
+ Mo(this, !1),
|
|
|
+ this.trigger("mouseup", t),
|
|
|
+ e && (t.zrEventControl = "only_globalout",
|
|
|
+ this.trigger("mouseout", t))
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function _o(i, n) {
|
|
|
+ var o = n.domHandlers;
|
|
|
+ v.pointerEventsSupported ? E(uo.pointer, function(e) {
|
|
|
+ bo(n, e, function(t) {
|
|
|
+ o[e].call(i, t)
|
|
|
+ })
|
|
|
+ }) : (v.touchEventsSupported && E(uo.touch, function(e) {
|
|
|
+ bo(n, e, function(t) {
|
|
|
+ o[e].call(i, t),
|
|
|
+ function(t) {
|
|
|
+ t.touching = !0,
|
|
|
+ null != t.touchTimer && (clearTimeout(t.touchTimer),
|
|
|
+ t.touchTimer = null),
|
|
|
+ t.touchTimer = setTimeout(function() {
|
|
|
+ t.touching = !1,
|
|
|
+ t.touchTimer = null
|
|
|
+ }, 700)
|
|
|
+ }(n)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ E(uo.mouse, function(e) {
|
|
|
+ bo(n, e, function(t) {
|
|
|
+ t = Ht(t),
|
|
|
+ n.touching || o[e].call(i, t)
|
|
|
+ })
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ function wo(i, n) {
|
|
|
+ function t(e) {
|
|
|
+ bo(n, e, function(t) {
|
|
|
+ t = Ht(t),
|
|
|
+ go(i, t.target) || (t = function(t, e) {
|
|
|
+ return Zt(t.dom, new mo(t,e), !0)
|
|
|
+ }(i, t),
|
|
|
+ n.domHandlers[e].call(i, t))
|
|
|
+ }, {
|
|
|
+ capture: !0
|
|
|
+ })
|
|
|
+ }
|
|
|
+ v.pointerEventsSupported ? E(ho.pointer, t) : v.touchEventsSupported || E(ho.mouse, t)
|
|
|
+ }
|
|
|
+ function bo(t, e, i, n) {
|
|
|
+ t.mounted[e] = i,
|
|
|
+ t.listenerOpts[e] = n,
|
|
|
+ Ut(t.domTarget, co(e), i, n)
|
|
|
+ }
|
|
|
+ function So(t) {
|
|
|
+ var e, i, n, o, a = t.mounted;
|
|
|
+ for (var r in a)
|
|
|
+ a.hasOwnProperty(r) && (e = t.domTarget,
|
|
|
+ i = co(r),
|
|
|
+ n = a[r],
|
|
|
+ o = t.listenerOpts[r],
|
|
|
+ Bt ? e.removeEventListener(i, n, o) : e.detachEvent("on" + i, n));
|
|
|
+ t.mounted = {}
|
|
|
+ }
|
|
|
+ function Mo(t, e) {
|
|
|
+ if (t._mayPointerCapture = null,
|
|
|
+ lo && t._pointerCapturing ^ e) {
|
|
|
+ t._pointerCapturing = e;
|
|
|
+ var i = t._globalHandlerScope;
|
|
|
+ e ? wo(t, i) : So(i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Io(t, e) {
|
|
|
+ this.domTarget = t,
|
|
|
+ this.domHandlers = e,
|
|
|
+ this.mounted = {},
|
|
|
+ this.listenerOpts = {},
|
|
|
+ this.touchTimer = null,
|
|
|
+ this.touching = !1
|
|
|
+ }
|
|
|
+ function To(t, e) {
|
|
|
+ Ct.call(this),
|
|
|
+ this.dom = t,
|
|
|
+ this.painterRoot = e,
|
|
|
+ this._localHandlerScope = new Io(t,yo),
|
|
|
+ lo && (this._globalHandlerScope = new Io(document,xo)),
|
|
|
+ this._pointerCapturing = !1,
|
|
|
+ this._mayPointerCapture = null,
|
|
|
+ _o(this, this._localHandlerScope)
|
|
|
+ }
|
|
|
+ var Ao = To.prototype;
|
|
|
+ Ao.dispose = function() {
|
|
|
+ So(this._localHandlerScope),
|
|
|
+ lo && So(this._globalHandlerScope)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ao.setCursor = function(t) {
|
|
|
+ this.dom.style && (this.dom.style.cursor = t || "default")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ b(To, Ct);
|
|
|
+ var Do = !v.canvasSupported
|
|
|
+ , Co = {
|
|
|
+ canvas: oo
|
|
|
+ }
|
|
|
+ , Lo = {};
|
|
|
+ function ko(t, e) {
|
|
|
+ var i = new No(n(),t,e);
|
|
|
+ return Lo[i.id] = i
|
|
|
+ }
|
|
|
+ function Po(t, e) {
|
|
|
+ Co[t] = e
|
|
|
+ }
|
|
|
+ var No = function(t, e, i) {
|
|
|
+ i = i || {},
|
|
|
+ this.dom = e,
|
|
|
+ this.id = t;
|
|
|
+ var n = this
|
|
|
+ , o = new Vi
|
|
|
+ , a = i.renderer;
|
|
|
+ if (Do) {
|
|
|
+ if (!Co.vml)
|
|
|
+ throw new Error("You need to require 'zrender/vml/vml' to support IE8");
|
|
|
+ a = "vml"
|
|
|
+ } else
|
|
|
+ a && Co[a] || (a = "canvas");
|
|
|
+ var r = new Co[a](e,o,i,t);
|
|
|
+ this.storage = o,
|
|
|
+ this.painter = r;
|
|
|
+ var s = v.node || v.worker ? null : new To(r.getViewportRoot(),r.root);
|
|
|
+ this.handler = new te(o,r,s,r.root),
|
|
|
+ this.animation = new ao({
|
|
|
+ stage: {
|
|
|
+ update: A(this.flush, this)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ this.animation.start(),
|
|
|
+ this._needsRefresh;
|
|
|
+ var l = o.delFromStorage
|
|
|
+ , u = o.addToStorage;
|
|
|
+ o.delFromStorage = function(t) {
|
|
|
+ l.call(o, t),
|
|
|
+ t && t.removeSelfFromZr(n)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ o.addToStorage = function(t) {
|
|
|
+ u.call(o, t),
|
|
|
+ t.addSelfToZr(n)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ No.prototype = {
|
|
|
+ constructor: No,
|
|
|
+ getId: function() {
|
|
|
+ return this.id
|
|
|
+ },
|
|
|
+ add: function(t) {
|
|
|
+ this.storage.addRoot(t),
|
|
|
+ this._needsRefresh = !0
|
|
|
+ },
|
|
|
+ remove: function(t) {
|
|
|
+ this.storage.delRoot(t),
|
|
|
+ this._needsRefresh = !0
|
|
|
+ },
|
|
|
+ configLayer: function(t, e) {
|
|
|
+ this.painter.configLayer && this.painter.configLayer(t, e),
|
|
|
+ this._needsRefresh = !0
|
|
|
+ },
|
|
|
+ setBackgroundColor: function(t) {
|
|
|
+ this.painter.setBackgroundColor && this.painter.setBackgroundColor(t),
|
|
|
+ this._needsRefresh = !0
|
|
|
+ },
|
|
|
+ refreshImmediately: function() {
|
|
|
+ this._needsRefresh = this._needsRefreshHover = !1,
|
|
|
+ this.painter.refresh(),
|
|
|
+ this._needsRefresh = this._needsRefreshHover = !1
|
|
|
+ },
|
|
|
+ refresh: function() {
|
|
|
+ this._needsRefresh = !0
|
|
|
+ },
|
|
|
+ flush: function() {
|
|
|
+ var t;
|
|
|
+ this._needsRefresh && (t = !0,
|
|
|
+ this.refreshImmediately()),
|
|
|
+ this._needsRefreshHover && (t = !0,
|
|
|
+ this.refreshHoverImmediately()),
|
|
|
+ t && this.trigger("rendered")
|
|
|
+ },
|
|
|
+ addHover: function(t, e) {
|
|
|
+ if (this.painter.addHover) {
|
|
|
+ var i = this.painter.addHover(t, e);
|
|
|
+ return this.refreshHover(),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ },
|
|
|
+ removeHover: function(t) {
|
|
|
+ this.painter.removeHover && (this.painter.removeHover(t),
|
|
|
+ this.refreshHover())
|
|
|
+ },
|
|
|
+ clearHover: function() {
|
|
|
+ this.painter.clearHover && (this.painter.clearHover(),
|
|
|
+ this.refreshHover())
|
|
|
+ },
|
|
|
+ refreshHover: function() {
|
|
|
+ this._needsRefreshHover = !0
|
|
|
+ },
|
|
|
+ refreshHoverImmediately: function() {
|
|
|
+ this._needsRefreshHover = !1,
|
|
|
+ this.painter.refreshHover && this.painter.refreshHover()
|
|
|
+ },
|
|
|
+ resize: function(t) {
|
|
|
+ t = t || {},
|
|
|
+ this.painter.resize(t.width, t.height),
|
|
|
+ this.handler.resize()
|
|
|
+ },
|
|
|
+ clearAnimation: function() {
|
|
|
+ this.animation.clear()
|
|
|
+ },
|
|
|
+ getWidth: function() {
|
|
|
+ return this.painter.getWidth()
|
|
|
+ },
|
|
|
+ getHeight: function() {
|
|
|
+ return this.painter.getHeight()
|
|
|
+ },
|
|
|
+ pathToImage: function(t, e) {
|
|
|
+ return this.painter.pathToImage(t, e)
|
|
|
+ },
|
|
|
+ setCursorStyle: function(t) {
|
|
|
+ this.handler.setCursorStyle(t)
|
|
|
+ },
|
|
|
+ findHover: function(t, e) {
|
|
|
+ return this.handler.findHover(t, e)
|
|
|
+ },
|
|
|
+ on: function(t, e, i) {
|
|
|
+ this.handler.on(t, e, i)
|
|
|
+ },
|
|
|
+ off: function(t, e) {
|
|
|
+ this.handler.off(t, e)
|
|
|
+ },
|
|
|
+ trigger: function(t, e) {
|
|
|
+ this.handler.trigger(t, e)
|
|
|
+ },
|
|
|
+ clear: function() {
|
|
|
+ this.storage.delRoot(),
|
|
|
+ this.painter.clear()
|
|
|
+ },
|
|
|
+ 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,
|
|
|
+ function(t) {
|
|
|
+ delete Lo[t]
|
|
|
+ }(this.id)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var Oo = (Object.freeze || Object)({
|
|
|
+ version: "4.3.1",
|
|
|
+ init: ko,
|
|
|
+ dispose: function(t) {
|
|
|
+ if (t)
|
|
|
+ t.dispose();
|
|
|
+ else {
|
|
|
+ for (var e in Lo)
|
|
|
+ Lo.hasOwnProperty(e) && Lo[e].dispose();
|
|
|
+ Lo = {}
|
|
|
+ }
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ getInstance: function(t) {
|
|
|
+ return Lo[t]
|
|
|
+ },
|
|
|
+ registerPainter: Po
|
|
|
+ })
|
|
|
+ , Eo = E
|
|
|
+ , Ro = z
|
|
|
+ , zo = L
|
|
|
+ , Bo = "series\0";
|
|
|
+ function Vo(t) {
|
|
|
+ return t instanceof Array ? t : null == t ? [] : [t]
|
|
|
+ }
|
|
|
+ function Go(t, e, i) {
|
|
|
+ if (t) {
|
|
|
+ t[e] = t[e] || {},
|
|
|
+ t.emphasis = t.emphasis || {},
|
|
|
+ t.emphasis[e] = t.emphasis[e] || {};
|
|
|
+ for (var n = 0, o = i.length; n < o; n++) {
|
|
|
+ var a = i[n];
|
|
|
+ !t.emphasis[e].hasOwnProperty(a) && t[e].hasOwnProperty(a) && (t.emphasis[e][a] = t[e][a])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Fo = ["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"];
|
|
|
+ function Wo(t) {
|
|
|
+ return !Ro(t) || zo(t) || t instanceof Date ? t : t.value
|
|
|
+ }
|
|
|
+ function Ho(t, o) {
|
|
|
+ o = (o || []).slice();
|
|
|
+ var a = O(t || [], function(t, e) {
|
|
|
+ return {
|
|
|
+ exist: t
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return Eo(o, function(t, e) {
|
|
|
+ if (Ro(t)) {
|
|
|
+ for (var i = 0; i < a.length; i++)
|
|
|
+ if (!a[i].option && null != t.id && a[i].exist.id === t.id + "")
|
|
|
+ return a[i].option = t,
|
|
|
+ void (o[e] = null);
|
|
|
+ for (i = 0; i < a.length; i++) {
|
|
|
+ var n = a[i].exist;
|
|
|
+ if (!(a[i].option || null != n.id && null != t.id || null == t.name || Xo(t) || Xo(n) || n.name !== t.name + ""))
|
|
|
+ return a[i].option = t,
|
|
|
+ void (o[e] = null)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ Eo(o, function(t, e) {
|
|
|
+ if (Ro(t)) {
|
|
|
+ for (var i = 0; i < a.length; i++) {
|
|
|
+ var n = a[i].exist;
|
|
|
+ if (!a[i].option && !Xo(n) && null == t.id) {
|
|
|
+ a[i].option = t;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ i >= a.length && a.push({
|
|
|
+ option: t
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ function Zo(t) {
|
|
|
+ var r = Q();
|
|
|
+ Eo(t, function(t, e) {
|
|
|
+ var i = t.exist;
|
|
|
+ i && r.set(i.id, t)
|
|
|
+ }),
|
|
|
+ Eo(t, function(t, e) {
|
|
|
+ var i = t.option;
|
|
|
+ Y(!i || null == i.id || !r.get(i.id) || r.get(i.id) === t, "id duplicates: " + (i && i.id)),
|
|
|
+ i && null != i.id && r.set(i.id, t),
|
|
|
+ t.keyInfo || (t.keyInfo = {})
|
|
|
+ }),
|
|
|
+ Eo(t, function(t, e) {
|
|
|
+ var i = t.exist
|
|
|
+ , n = t.option
|
|
|
+ , o = t.keyInfo;
|
|
|
+ if (Ro(n)) {
|
|
|
+ if (o.name = null != n.name ? n.name + "" : i ? i.name : Bo + e,
|
|
|
+ i)
|
|
|
+ o.id = i.id;
|
|
|
+ else if (null != n.id)
|
|
|
+ o.id = n.id + "";
|
|
|
+ else
|
|
|
+ for (var a = 0; o.id = "\0" + o.name + "\0" + a++,
|
|
|
+ r.get(o.id); )
|
|
|
+ ;
|
|
|
+ r.set(o.id, t)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Uo(t) {
|
|
|
+ var e = t.name;
|
|
|
+ return !(!e || !e.indexOf(Bo))
|
|
|
+ }
|
|
|
+ function Xo(t) {
|
|
|
+ return Ro(t) && t.id && 0 === (t.id + "").indexOf("\0_ec_\0")
|
|
|
+ }
|
|
|
+ function Yo(e, t) {
|
|
|
+ return null != t.dataIndexInside ? t.dataIndexInside : null != t.dataIndex ? L(t.dataIndex) ? O(t.dataIndex, function(t) {
|
|
|
+ return e.indexOfRawIndex(t)
|
|
|
+ }) : e.indexOfRawIndex(t.dataIndex) : null != t.name ? L(t.name) ? O(t.name, function(t) {
|
|
|
+ return e.indexOfName(t)
|
|
|
+ }) : e.indexOfName(t.name) : void 0
|
|
|
+ }
|
|
|
+ function jo() {
|
|
|
+ var e = "__\0ec_inner_" + qo++ + "_" + Math.random().toFixed(5);
|
|
|
+ return function(t) {
|
|
|
+ return t[e] || (t[e] = {})
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var qo = 0;
|
|
|
+ function Ko(s, l, u) {
|
|
|
+ if (R(l)) {
|
|
|
+ var t = {};
|
|
|
+ t[l + "Index"] = 0,
|
|
|
+ l = t
|
|
|
+ }
|
|
|
+ var e = u && u.defaultMainType;
|
|
|
+ !e || $o(l, e + "Index") || $o(l, e + "Id") || $o(l, e + "Name") || (l[e + "Index"] = 0);
|
|
|
+ var h = {};
|
|
|
+ return Eo(l, function(t, e) {
|
|
|
+ t = l[e];
|
|
|
+ if ("dataIndex" !== e && "dataIndexInside" !== e) {
|
|
|
+ var i = e.match(/^(\w+)(Index|Id|Name)$/) || []
|
|
|
+ , n = i[1]
|
|
|
+ , o = (i[2] || "").toLowerCase();
|
|
|
+ if (!(!n || !o || null == t || "index" === o && "none" === t || u && u.includeMainTypes && _(u.includeMainTypes, n) < 0)) {
|
|
|
+ var a = {
|
|
|
+ mainType: n
|
|
|
+ };
|
|
|
+ "index" === o && "all" === t || (a[o] = t);
|
|
|
+ var r = s.queryComponents(a);
|
|
|
+ h[n + "Models"] = r,
|
|
|
+ h[n + "Model"] = r[0]
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ h[e] = t
|
|
|
+ }),
|
|
|
+ h
|
|
|
+ }
|
|
|
+ function $o(t, e) {
|
|
|
+ return t && t.hasOwnProperty(e)
|
|
|
+ }
|
|
|
+ function Jo(t, e, i) {
|
|
|
+ t.setAttribute ? t.setAttribute(e, i) : t[e] = i
|
|
|
+ }
|
|
|
+ function Qo(t) {
|
|
|
+ return "auto" === t ? v.domSupported ? "html" : "richText" : t || "html"
|
|
|
+ }
|
|
|
+ function ta(t, i) {
|
|
|
+ var n = Q()
|
|
|
+ , o = [];
|
|
|
+ return E(t, function(t) {
|
|
|
+ var e = i(t);
|
|
|
+ (n.get(e) || (o.push(e),
|
|
|
+ n.set(e, []))).push(t)
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ keys: o,
|
|
|
+ buckets: n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var ea = "."
|
|
|
+ , ia = "___EC__COMPONENT__CONTAINER___";
|
|
|
+ function na(t) {
|
|
|
+ var e = {
|
|
|
+ main: "",
|
|
|
+ sub: ""
|
|
|
+ };
|
|
|
+ return t && (t = t.split(ea),
|
|
|
+ e.main = t[0] || "",
|
|
|
+ e.sub = t[1] || ""),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function oa(t) {
|
|
|
+ (t.$constructor = t).extend = function(t) {
|
|
|
+ function e() {
|
|
|
+ t.$constructor ? t.$constructor.apply(this, arguments) : i.apply(this, arguments)
|
|
|
+ }
|
|
|
+ var i = this;
|
|
|
+ return P(e.prototype, t),
|
|
|
+ e.extend = this.extend,
|
|
|
+ e.superCall = sa,
|
|
|
+ e.superApply = la,
|
|
|
+ w(e, this),
|
|
|
+ e.superClass = i,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var aa = 0;
|
|
|
+ function ra(t) {
|
|
|
+ var e = ["__\0is_clz", aa++, Math.random().toFixed(3)].join("_");
|
|
|
+ t.prototype[e] = !0,
|
|
|
+ t.isInstance = function(t) {
|
|
|
+ return !(!t || !t[e])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function sa(t, e) {
|
|
|
+ var i = U(arguments, 2);
|
|
|
+ return this.superClass.prototype[e].apply(t, i)
|
|
|
+ }
|
|
|
+ function la(t, e, i) {
|
|
|
+ return this.superClass.prototype[e].apply(t, i)
|
|
|
+ }
|
|
|
+ function ua(i, t) {
|
|
|
+ t = t || {};
|
|
|
+ var o = {};
|
|
|
+ if (i.registerClass = function(t, e) {
|
|
|
+ if (e)
|
|
|
+ if (function(t) {
|
|
|
+ Y(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(t), 'componentType "' + t + '" illegal')
|
|
|
+ }(e),
|
|
|
+ (e = na(e)).sub) {
|
|
|
+ if (e.sub !== ia) {
|
|
|
+ (function(t) {
|
|
|
+ var e = o[t.main];
|
|
|
+ e && e[ia] || ((e = o[t.main] = {})[ia] = !0);
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ )(e)[e.sub] = t
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ o[e.main] = t;
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ i.getClass = function(t, e, i) {
|
|
|
+ var n = o[t];
|
|
|
+ if (n && n[ia] && (n = e ? n[e] : null),
|
|
|
+ i && !n)
|
|
|
+ throw new Error(e ? "Component " + t + "." + (e || "") + " not exists. Load it first." : t + ".type should be specified.");
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ i.getClassesByMainType = function(t) {
|
|
|
+ t = na(t);
|
|
|
+ var i = []
|
|
|
+ , e = o[t.main];
|
|
|
+ return e && e[ia] ? E(e, function(t, e) {
|
|
|
+ e !== ia && i.push(t)
|
|
|
+ }) : i.push(e),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ i.hasClass = function(t) {
|
|
|
+ return t = na(t),
|
|
|
+ !!o[t.main]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ i.getAllClassMainTypes = function() {
|
|
|
+ var i = [];
|
|
|
+ return E(o, function(t, e) {
|
|
|
+ i.push(e)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ i.hasSubTypes = function(t) {
|
|
|
+ t = na(t);
|
|
|
+ var e = o[t.main];
|
|
|
+ return e && e[ia]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ i.parseClassType = na,
|
|
|
+ t.registerWhenExtend) {
|
|
|
+ var n = i.extend;
|
|
|
+ n && (i.extend = function(t) {
|
|
|
+ var e = n.call(this, t);
|
|
|
+ return i.registerClass(e, t.type)
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ function ha(s) {
|
|
|
+ for (var t = 0; t < s.length; t++)
|
|
|
+ s[t][1] || (s[t][1] = s[t][0]);
|
|
|
+ return function(t, e, i) {
|
|
|
+ for (var n = {}, o = 0; o < s.length; o++) {
|
|
|
+ var a = s[o][1];
|
|
|
+ if (!(e && 0 <= _(e, a) || i && _(i, a) < 0)) {
|
|
|
+ var r = t.getShallow(a);
|
|
|
+ null != r && (n[s[o][0]] = r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var ca = ha([["lineWidth", "width"], ["stroke", "color"], ["opacity"], ["shadowBlur"], ["shadowOffsetX"], ["shadowOffsetY"], ["shadowColor"]])
|
|
|
+ , da = {
|
|
|
+ getLineStyle: function(t) {
|
|
|
+ var e = ca(this, t);
|
|
|
+ return e.lineDash = this.getLineDash(e.lineWidth),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ getLineDash: function(t) {
|
|
|
+ null == t && (t = 1);
|
|
|
+ var e = this.get("type")
|
|
|
+ , i = Math.max(t, 2)
|
|
|
+ , n = 4 * t;
|
|
|
+ return "solid" !== e && null != e && ("dashed" === e ? [n, n] : [i, i])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , fa = ha([["fill", "color"], ["shadowBlur"], ["shadowOffsetX"], ["shadowOffsetY"], ["opacity"], ["shadowColor"]])
|
|
|
+ , pa = {
|
|
|
+ getAreaStyle: function(t, e) {
|
|
|
+ return fa(this, t, e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , ga = Math.pow
|
|
|
+ , ma = Math.sqrt
|
|
|
+ , va = 1e-8
|
|
|
+ , ya = 1e-4
|
|
|
+ , xa = ma(3)
|
|
|
+ , _a = 1 / 3
|
|
|
+ , wa = ot()
|
|
|
+ , ba = ot()
|
|
|
+ , Sa = ot();
|
|
|
+ function Ma(t) {
|
|
|
+ return -va < t && t < va
|
|
|
+ }
|
|
|
+ function Ia(t) {
|
|
|
+ return va < t || t < -va
|
|
|
+ }
|
|
|
+ function Ta(t, e, i, n, o) {
|
|
|
+ var a = 1 - o;
|
|
|
+ return a * a * (a * t + 3 * o * e) + o * o * (o * n + 3 * a * i)
|
|
|
+ }
|
|
|
+ function Aa(t, e, i, n, o) {
|
|
|
+ var a = 1 - o;
|
|
|
+ return 3 * (((e - t) * a + 2 * (i - e) * o) * a + (n - i) * o * o)
|
|
|
+ }
|
|
|
+ function Da(t, e, i, n, o) {
|
|
|
+ var a = 6 * i - 12 * e + 6 * t
|
|
|
+ , r = 9 * e + 3 * n - 3 * t - 9 * i
|
|
|
+ , s = 3 * e - 3 * t
|
|
|
+ , l = 0;
|
|
|
+ if (Ma(r)) {
|
|
|
+ if (Ia(a))
|
|
|
+ 0 <= (h = -s / a) && h <= 1 && (o[l++] = h)
|
|
|
+ } else {
|
|
|
+ var u = a * a - 4 * r * s;
|
|
|
+ if (Ma(u))
|
|
|
+ o[0] = -a / (2 * r);
|
|
|
+ else if (0 < u) {
|
|
|
+ var h, c = ma(u), d = (-a - c) / (2 * r);
|
|
|
+ 0 <= (h = (-a + c) / (2 * r)) && h <= 1 && (o[l++] = h),
|
|
|
+ 0 <= d && d <= 1 && (o[l++] = d)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return l
|
|
|
+ }
|
|
|
+ function Ca(t, e, i, n, o, a) {
|
|
|
+ var r = (e - t) * o + t
|
|
|
+ , s = (i - e) * o + e
|
|
|
+ , l = (n - i) * o + i
|
|
|
+ , u = (s - r) * o + r
|
|
|
+ , h = (l - s) * o + s
|
|
|
+ , c = (h - u) * o + u;
|
|
|
+ a[0] = t,
|
|
|
+ a[1] = r,
|
|
|
+ a[2] = u,
|
|
|
+ a[3] = c,
|
|
|
+ a[4] = c,
|
|
|
+ a[5] = h,
|
|
|
+ a[6] = l,
|
|
|
+ a[7] = n
|
|
|
+ }
|
|
|
+ function La(t, e, i, n) {
|
|
|
+ var o = 1 - n;
|
|
|
+ return o * (o * t + 2 * n * e) + n * n * i
|
|
|
+ }
|
|
|
+ function ka(t, e, i, n) {
|
|
|
+ return 2 * ((1 - n) * (e - t) + n * (i - e))
|
|
|
+ }
|
|
|
+ function Pa(t, e, i) {
|
|
|
+ var n = t + i - 2 * e;
|
|
|
+ return 0 == n ? .5 : (t - e) / n
|
|
|
+ }
|
|
|
+ function Na(t, e, i, n, o) {
|
|
|
+ var a = (e - t) * n + t
|
|
|
+ , r = (i - e) * n + e
|
|
|
+ , s = (r - a) * n + a;
|
|
|
+ o[0] = t,
|
|
|
+ o[1] = a,
|
|
|
+ o[2] = s,
|
|
|
+ o[3] = s,
|
|
|
+ o[4] = r,
|
|
|
+ o[5] = i
|
|
|
+ }
|
|
|
+ var Oa = Math.min
|
|
|
+ , Ea = Math.max
|
|
|
+ , Ra = Math.sin
|
|
|
+ , za = Math.cos
|
|
|
+ , Ba = 2 * Math.PI
|
|
|
+ , Va = ot()
|
|
|
+ , Ga = ot()
|
|
|
+ , Fa = ot();
|
|
|
+ function Wa(t, e, i) {
|
|
|
+ if (0 !== t.length) {
|
|
|
+ var n, o = t[0], a = o[0], r = o[0], s = o[1], l = o[1];
|
|
|
+ for (n = 1; n < t.length; n++)
|
|
|
+ o = t[n],
|
|
|
+ a = Oa(a, o[0]),
|
|
|
+ r = Ea(r, o[0]),
|
|
|
+ s = Oa(s, o[1]),
|
|
|
+ l = Ea(l, o[1]);
|
|
|
+ e[0] = a,
|
|
|
+ e[1] = s,
|
|
|
+ i[0] = r,
|
|
|
+ i[1] = l
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ha(t, e, i, n, o, a) {
|
|
|
+ o[0] = Oa(t, i),
|
|
|
+ o[1] = Oa(e, n),
|
|
|
+ a[0] = Ea(t, i),
|
|
|
+ a[1] = Ea(e, n)
|
|
|
+ }
|
|
|
+ var Za = []
|
|
|
+ , Ua = [];
|
|
|
+ function Xa(t, e, i, n, o, a, r, s, l, u) {
|
|
|
+ var h, c = Da, d = Ta, f = c(t, i, o, r, Za);
|
|
|
+ for (l[0] = 1 / 0,
|
|
|
+ l[1] = 1 / 0,
|
|
|
+ u[0] = -1 / 0,
|
|
|
+ u[1] = -1 / 0,
|
|
|
+ h = 0; h < f; h++) {
|
|
|
+ var p = d(t, i, o, r, Za[h]);
|
|
|
+ l[0] = Oa(p, l[0]),
|
|
|
+ u[0] = Ea(p, u[0])
|
|
|
+ }
|
|
|
+ for (f = c(e, n, a, s, Ua),
|
|
|
+ h = 0; h < f; h++) {
|
|
|
+ var g = d(e, n, a, s, Ua[h]);
|
|
|
+ l[1] = Oa(g, l[1]),
|
|
|
+ u[1] = Ea(g, u[1])
|
|
|
+ }
|
|
|
+ l[0] = Oa(t, l[0]),
|
|
|
+ u[0] = Ea(t, u[0]),
|
|
|
+ l[0] = Oa(r, l[0]),
|
|
|
+ u[0] = Ea(r, u[0]),
|
|
|
+ l[1] = Oa(e, l[1]),
|
|
|
+ u[1] = Ea(e, u[1]),
|
|
|
+ l[1] = Oa(s, l[1]),
|
|
|
+ u[1] = Ea(s, u[1])
|
|
|
+ }
|
|
|
+ function Ya(t, e, i, n, o, a, r, s, l) {
|
|
|
+ var u = St
|
|
|
+ , h = Mt
|
|
|
+ , c = Math.abs(o - a);
|
|
|
+ if (c % Ba < 1e-4 && 1e-4 < c)
|
|
|
+ return s[0] = t - i,
|
|
|
+ s[1] = e - n,
|
|
|
+ l[0] = t + i,
|
|
|
+ void (l[1] = e + n);
|
|
|
+ if (Va[0] = za(o) * i + t,
|
|
|
+ Va[1] = Ra(o) * n + e,
|
|
|
+ Ga[0] = za(a) * i + t,
|
|
|
+ Ga[1] = Ra(a) * n + e,
|
|
|
+ u(s, Va, Ga),
|
|
|
+ h(l, Va, Ga),
|
|
|
+ (o %= Ba) < 0 && (o += Ba),
|
|
|
+ (a %= Ba) < 0 && (a += Ba),
|
|
|
+ a < o && !r ? a += Ba : o < a && r && (o += Ba),
|
|
|
+ r) {
|
|
|
+ var d = a;
|
|
|
+ a = o,
|
|
|
+ o = d
|
|
|
+ }
|
|
|
+ for (var f = 0; f < a; f += Math.PI / 2)
|
|
|
+ o < f && (Fa[0] = za(f) * i + t,
|
|
|
+ Fa[1] = Ra(f) * n + e,
|
|
|
+ u(s, Fa, s),
|
|
|
+ h(l, Fa, l))
|
|
|
+ }
|
|
|
+ var ja = {
|
|
|
+ M: 1,
|
|
|
+ L: 2,
|
|
|
+ C: 3,
|
|
|
+ Q: 4,
|
|
|
+ A: 5,
|
|
|
+ Z: 6,
|
|
|
+ R: 7
|
|
|
+ }
|
|
|
+ , qa = []
|
|
|
+ , Ka = []
|
|
|
+ , $a = []
|
|
|
+ , Ja = []
|
|
|
+ , Qa = Math.min
|
|
|
+ , tr = Math.max
|
|
|
+ , er = Math.cos
|
|
|
+ , ir = Math.sin
|
|
|
+ , nr = Math.sqrt
|
|
|
+ , or = Math.abs
|
|
|
+ , ar = "undefined" != typeof Float32Array
|
|
|
+ , rr = function(t) {
|
|
|
+ this._saveData = !t,
|
|
|
+ this._saveData && (this.data = []),
|
|
|
+ this._ctx = null
|
|
|
+ };
|
|
|
+ function sr(t, e, i, n, o, a, r) {
|
|
|
+ if (0 === o)
|
|
|
+ return !1;
|
|
|
+ var s = o
|
|
|
+ , l = 0;
|
|
|
+ if (e + s < r && n + s < r || r < e - s && r < n - s || t + s < a && i + s < a || a < t - s && a < i - s)
|
|
|
+ return !1;
|
|
|
+ if (t === i)
|
|
|
+ return Math.abs(a - t) <= s / 2;
|
|
|
+ var u = (l = (e - n) / (t - i)) * a - r + (t * n - i * e) / (t - i);
|
|
|
+ return u * u / (l * l + 1) <= s / 2 * s / 2
|
|
|
+ }
|
|
|
+ function lr(t, e, i, n, o, a, r, s, l, u, h) {
|
|
|
+ if (0 === l)
|
|
|
+ return !1;
|
|
|
+ var c = l;
|
|
|
+ return !(e + c < h && n + c < h && a + c < h && s + c < h || h < e - c && h < n - c && h < a - c && h < s - c || t + c < u && i + c < u && o + c < u && r + c < u || u < t - c && u < i - c && u < o - c && u < r - c) && function(t, e, i, n, o, a, r, s, l, u, h) {
|
|
|
+ var c, d, f, p, g, m = .005, v = 1 / 0;
|
|
|
+ wa[0] = l,
|
|
|
+ wa[1] = u;
|
|
|
+ for (var y = 0; y < 1; y += .05)
|
|
|
+ ba[0] = Ta(t, i, o, r, y),
|
|
|
+ ba[1] = Ta(e, n, a, s, y),
|
|
|
+ (p = _t(wa, ba)) < v && (c = y,
|
|
|
+ v = p);
|
|
|
+ v = 1 / 0;
|
|
|
+ for (var x = 0; x < 32 && !(m < ya); x++)
|
|
|
+ d = c - m,
|
|
|
+ f = c + m,
|
|
|
+ ba[0] = Ta(t, i, o, r, d),
|
|
|
+ ba[1] = Ta(e, n, a, s, d),
|
|
|
+ p = _t(ba, wa),
|
|
|
+ 0 <= d && p < v ? (c = d,
|
|
|
+ v = p) : (Sa[0] = Ta(t, i, o, r, f),
|
|
|
+ Sa[1] = Ta(e, n, a, s, f),
|
|
|
+ g = _t(Sa, wa),
|
|
|
+ f <= 1 && g < v ? (c = f,
|
|
|
+ v = g) : m *= .5);
|
|
|
+ return h && (h[0] = Ta(t, i, o, r, c),
|
|
|
+ h[1] = Ta(e, n, a, s, c)),
|
|
|
+ ma(v)
|
|
|
+ }(t, e, i, n, o, a, r, s, u, h, null) <= c / 2
|
|
|
+ }
|
|
|
+ function ur(t, e, i, n, o, a, r, s, l) {
|
|
|
+ if (0 === r)
|
|
|
+ return !1;
|
|
|
+ var u = r;
|
|
|
+ return !(e + u < l && n + u < l && a + u < l || l < e - u && l < n - u && l < a - u || t + u < s && i + u < s && o + u < s || s < t - u && s < i - u && s < o - u) && function(t, e, i, n, o, a, r, s, l) {
|
|
|
+ var u, h = .005, c = 1 / 0;
|
|
|
+ wa[0] = r,
|
|
|
+ wa[1] = s;
|
|
|
+ for (var d = 0; d < 1; d += .05) {
|
|
|
+ ba[0] = La(t, i, o, d),
|
|
|
+ ba[1] = La(e, n, a, d),
|
|
|
+ (m = _t(wa, ba)) < c && (u = d,
|
|
|
+ c = m)
|
|
|
+ }
|
|
|
+ c = 1 / 0;
|
|
|
+ for (var f = 0; f < 32 && !(h < ya); f++) {
|
|
|
+ var p = u - h
|
|
|
+ , g = u + h;
|
|
|
+ ba[0] = La(t, i, o, p),
|
|
|
+ ba[1] = La(e, n, a, p);
|
|
|
+ var m = _t(ba, wa);
|
|
|
+ if (0 <= p && m < c)
|
|
|
+ u = p,
|
|
|
+ c = m;
|
|
|
+ else {
|
|
|
+ Sa[0] = La(t, i, o, g),
|
|
|
+ Sa[1] = La(e, n, a, g);
|
|
|
+ var v = _t(Sa, wa);
|
|
|
+ g <= 1 && v < c ? (u = g,
|
|
|
+ c = v) : h *= .5
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return l && (l[0] = La(t, i, o, u),
|
|
|
+ l[1] = La(e, n, a, u)),
|
|
|
+ ma(c)
|
|
|
+ }(t, e, i, n, o, a, s, l, null) <= u / 2
|
|
|
+ }
|
|
|
+ rr.prototype = {
|
|
|
+ constructor: rr,
|
|
|
+ _xi: 0,
|
|
|
+ _yi: 0,
|
|
|
+ _x0: 0,
|
|
|
+ _y0: 0,
|
|
|
+ _ux: 0,
|
|
|
+ _uy: 0,
|
|
|
+ _len: 0,
|
|
|
+ _lineDash: null,
|
|
|
+ _dashOffset: 0,
|
|
|
+ _dashIdx: 0,
|
|
|
+ _dashSum: 0,
|
|
|
+ setScale: function(t, e, i) {
|
|
|
+ i = i || 0,
|
|
|
+ this._ux = or(i / pi / t) || 0,
|
|
|
+ this._uy = or(i / pi / e) || 0
|
|
|
+ },
|
|
|
+ getContext: function() {
|
|
|
+ return this._ctx
|
|
|
+ },
|
|
|
+ beginPath: function(t) {
|
|
|
+ return (this._ctx = t) && t.beginPath(),
|
|
|
+ t && (this.dpr = t.dpr),
|
|
|
+ this._saveData && (this._len = 0),
|
|
|
+ this._lineDash && (this._lineDash = null,
|
|
|
+ this._dashOffset = 0),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ moveTo: function(t, e) {
|
|
|
+ return this.addData(ja.M, t, e),
|
|
|
+ this._ctx && this._ctx.moveTo(t, e),
|
|
|
+ this._x0 = t,
|
|
|
+ this._y0 = e,
|
|
|
+ this._xi = t,
|
|
|
+ this._yi = e,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ lineTo: function(t, e) {
|
|
|
+ var i = or(t - this._xi) > this._ux || or(e - this._yi) > this._uy || this._len < 5;
|
|
|
+ return this.addData(ja.L, t, e),
|
|
|
+ this._ctx && i && (this._needsDash() ? this._dashedLineTo(t, e) : this._ctx.lineTo(t, e)),
|
|
|
+ i && (this._xi = t,
|
|
|
+ this._yi = e),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ bezierCurveTo: function(t, e, i, n, o, a) {
|
|
|
+ return this.addData(ja.C, t, e, i, n, o, a),
|
|
|
+ this._ctx && (this._needsDash() ? this._dashedBezierTo(t, e, i, n, o, a) : this._ctx.bezierCurveTo(t, e, i, n, o, a)),
|
|
|
+ this._xi = o,
|
|
|
+ this._yi = a,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ quadraticCurveTo: function(t, e, i, n) {
|
|
|
+ return this.addData(ja.Q, t, e, i, n),
|
|
|
+ this._ctx && (this._needsDash() ? this._dashedQuadraticTo(t, e, i, n) : this._ctx.quadraticCurveTo(t, e, i, n)),
|
|
|
+ this._xi = i,
|
|
|
+ this._yi = n,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ arc: function(t, e, i, n, o, a) {
|
|
|
+ return this.addData(ja.A, t, e, i, i, n, o - n, 0, a ? 0 : 1),
|
|
|
+ this._ctx && this._ctx.arc(t, e, i, n, o, a),
|
|
|
+ this._xi = er(o) * i + t,
|
|
|
+ this._yi = ir(o) * i + e,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ arcTo: function(t, e, i, n, o) {
|
|
|
+ return this._ctx && this._ctx.arcTo(t, e, i, n, o),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ rect: function(t, e, i, n) {
|
|
|
+ return this._ctx && this._ctx.rect(t, e, i, n),
|
|
|
+ this.addData(ja.R, t, e, i, n),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ closePath: function() {
|
|
|
+ this.addData(ja.Z);
|
|
|
+ var t = this._ctx
|
|
|
+ , e = this._x0
|
|
|
+ , i = this._y0;
|
|
|
+ return t && (this._needsDash() && this._dashedLineTo(e, i),
|
|
|
+ t.closePath()),
|
|
|
+ this._xi = e,
|
|
|
+ this._yi = i,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ fill: function(t) {
|
|
|
+ t && t.fill(),
|
|
|
+ this.toStatic()
|
|
|
+ },
|
|
|
+ stroke: function(t) {
|
|
|
+ t && t.stroke(),
|
|
|
+ this.toStatic()
|
|
|
+ },
|
|
|
+ setLineDash: function(t) {
|
|
|
+ if (t instanceof Array) {
|
|
|
+ this._lineDash = t;
|
|
|
+ for (var e = this._dashIdx = 0, i = 0; i < t.length; i++)
|
|
|
+ e += t[i];
|
|
|
+ this._dashSum = e
|
|
|
+ }
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ setLineDashOffset: function(t) {
|
|
|
+ return this._dashOffset = t,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ len: function() {
|
|
|
+ return this._len
|
|
|
+ },
|
|
|
+ setData: function(t) {
|
|
|
+ var e = t.length;
|
|
|
+ this.data && this.data.length === e || !ar || (this.data = new Float32Array(e));
|
|
|
+ for (var i = 0; i < e; i++)
|
|
|
+ this.data[i] = t[i];
|
|
|
+ this._len = e
|
|
|
+ },
|
|
|
+ appendPath: function(t) {
|
|
|
+ t instanceof Array || (t = [t]);
|
|
|
+ for (var e = t.length, i = 0, n = this._len, o = 0; o < e; o++)
|
|
|
+ i += t[o].len();
|
|
|
+ ar && this.data instanceof Float32Array && (this.data = new Float32Array(n + i));
|
|
|
+ for (o = 0; o < e; o++)
|
|
|
+ for (var a = t[o].data, r = 0; r < a.length; r++)
|
|
|
+ this.data[n++] = a[r];
|
|
|
+ this._len = n
|
|
|
+ },
|
|
|
+ addData: function(t) {
|
|
|
+ if (this._saveData) {
|
|
|
+ var e = this.data;
|
|
|
+ this._len + arguments.length > e.length && (this._expandData(),
|
|
|
+ e = this.data);
|
|
|
+ for (var i = 0; i < arguments.length; i++)
|
|
|
+ e[this._len++] = arguments[i];
|
|
|
+ this._prevCmd = t
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _expandData: function() {
|
|
|
+ if (!(this.data instanceof Array)) {
|
|
|
+ for (var t = [], e = 0; e < this._len; e++)
|
|
|
+ t[e] = this.data[e];
|
|
|
+ this.data = t
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _needsDash: function() {
|
|
|
+ return this._lineDash
|
|
|
+ },
|
|
|
+ _dashedLineTo: function(t, e) {
|
|
|
+ var i, n, o = this._dashSum, a = this._dashOffset, r = this._lineDash, s = this._ctx, l = this._xi, u = this._yi, h = t - l, c = e - u, d = nr(h * h + c * c), f = l, p = u, g = r.length;
|
|
|
+ for (a < 0 && (a = o + a),
|
|
|
+ f -= (a %= o) * (h /= d),
|
|
|
+ p -= a * (c /= d); 0 < h && f <= t || h < 0 && t <= f || 0 === h && (0 < c && p <= e || c < 0 && e <= p); )
|
|
|
+ f += h * (i = r[n = this._dashIdx]),
|
|
|
+ p += c * i,
|
|
|
+ this._dashIdx = (n + 1) % g,
|
|
|
+ 0 < h && f < l || h < 0 && l < f || 0 < c && p < u || c < 0 && u < p || s[n % 2 ? "moveTo" : "lineTo"](0 <= h ? Qa(f, t) : tr(f, t), 0 <= c ? Qa(p, e) : tr(p, e));
|
|
|
+ h = f - t,
|
|
|
+ c = p - e,
|
|
|
+ this._dashOffset = -nr(h * h + c * c)
|
|
|
+ },
|
|
|
+ _dashedBezierTo: function(t, e, i, n, o, a) {
|
|
|
+ var r, s, l, u, h, c = this._dashSum, d = this._dashOffset, f = this._lineDash, p = this._ctx, g = this._xi, m = this._yi, v = Ta, y = 0, x = this._dashIdx, _ = f.length, w = 0;
|
|
|
+ for (d < 0 && (d = c + d),
|
|
|
+ d %= c,
|
|
|
+ r = 0; r < 1; r += .1)
|
|
|
+ s = v(g, t, i, o, r + .1) - v(g, t, i, o, r),
|
|
|
+ l = v(m, e, n, a, r + .1) - v(m, e, n, a, r),
|
|
|
+ y += nr(s * s + l * l);
|
|
|
+ for (; x < _ && !(d < (w += f[x])); x++)
|
|
|
+ ;
|
|
|
+ for (r = (w - d) / y; r <= 1; )
|
|
|
+ u = v(g, t, i, o, r),
|
|
|
+ h = v(m, e, n, a, r),
|
|
|
+ x % 2 ? p.moveTo(u, h) : p.lineTo(u, h),
|
|
|
+ r += f[x] / y,
|
|
|
+ x = (x + 1) % _;
|
|
|
+ x % 2 != 0 && p.lineTo(o, a),
|
|
|
+ s = o - u,
|
|
|
+ l = a - h,
|
|
|
+ this._dashOffset = -nr(s * s + l * l)
|
|
|
+ },
|
|
|
+ _dashedQuadraticTo: function(t, e, i, n) {
|
|
|
+ var o = i
|
|
|
+ , a = n;
|
|
|
+ i = (i + 2 * t) / 3,
|
|
|
+ n = (n + 2 * e) / 3,
|
|
|
+ t = (this._xi + 2 * t) / 3,
|
|
|
+ e = (this._yi + 2 * e) / 3,
|
|
|
+ this._dashedBezierTo(t, e, i, n, o, a)
|
|
|
+ },
|
|
|
+ toStatic: function() {
|
|
|
+ var t = this.data;
|
|
|
+ t instanceof Array && (t.length = this._len,
|
|
|
+ ar && (this.data = new Float32Array(t)))
|
|
|
+ },
|
|
|
+ getBoundingRect: function() {
|
|
|
+ qa[0] = qa[1] = $a[0] = $a[1] = Number.MAX_VALUE,
|
|
|
+ Ka[0] = Ka[1] = Ja[0] = Ja[1] = -Number.MAX_VALUE;
|
|
|
+ for (var t, e, i, n, o, a, r, s, l, u, h, c, d, f, p = this.data, g = 0, m = 0, v = 0, y = 0, x = 0; x < p.length; ) {
|
|
|
+ var _ = p[x++];
|
|
|
+ switch (1 === x && (v = g = p[x],
|
|
|
+ y = m = p[x + 1]),
|
|
|
+ _) {
|
|
|
+ case ja.M:
|
|
|
+ g = v = p[x++],
|
|
|
+ m = y = p[x++],
|
|
|
+ $a[0] = v,
|
|
|
+ $a[1] = y,
|
|
|
+ Ja[0] = v,
|
|
|
+ Ja[1] = y;
|
|
|
+ break;
|
|
|
+ case ja.L:
|
|
|
+ Ha(g, m, p[x], p[x + 1], $a, Ja),
|
|
|
+ g = p[x++],
|
|
|
+ m = p[x++];
|
|
|
+ break;
|
|
|
+ case ja.C:
|
|
|
+ Xa(g, m, p[x++], p[x++], p[x++], p[x++], p[x], p[x + 1], $a, Ja),
|
|
|
+ g = p[x++],
|
|
|
+ m = p[x++];
|
|
|
+ break;
|
|
|
+ case ja.Q:
|
|
|
+ t = g,
|
|
|
+ e = m,
|
|
|
+ i = p[x++],
|
|
|
+ n = p[x++],
|
|
|
+ o = p[x],
|
|
|
+ a = p[x + 1],
|
|
|
+ r = $a,
|
|
|
+ s = Ja,
|
|
|
+ u = l = void 0,
|
|
|
+ u = La,
|
|
|
+ h = Ea(Oa((l = Pa)(t, i, o), 1), 0),
|
|
|
+ c = Ea(Oa(l(e, n, a), 1), 0),
|
|
|
+ d = u(t, i, o, h),
|
|
|
+ f = u(e, n, a, c),
|
|
|
+ r[0] = Oa(t, o, d),
|
|
|
+ r[1] = Oa(e, a, f),
|
|
|
+ s[0] = Ea(t, o, d),
|
|
|
+ s[1] = Ea(e, a, f),
|
|
|
+ g = p[x++],
|
|
|
+ m = p[x++];
|
|
|
+ break;
|
|
|
+ case ja.A:
|
|
|
+ var w = p[x++]
|
|
|
+ , b = p[x++]
|
|
|
+ , S = p[x++]
|
|
|
+ , M = p[x++]
|
|
|
+ , I = p[x++]
|
|
|
+ , T = p[x++] + I;
|
|
|
+ x += 1;
|
|
|
+ var A = 1 - p[x++];
|
|
|
+ 1 === x && (v = er(I) * S + w,
|
|
|
+ y = ir(I) * M + b),
|
|
|
+ Ya(w, b, S, M, I, T, A, $a, Ja),
|
|
|
+ g = er(T) * S + w,
|
|
|
+ m = ir(T) * M + b;
|
|
|
+ break;
|
|
|
+ case ja.R:
|
|
|
+ Ha(v = g = p[x++], y = m = p[x++], v + p[x++], y + p[x++], $a, Ja);
|
|
|
+ break;
|
|
|
+ case ja.Z:
|
|
|
+ g = v,
|
|
|
+ m = y
|
|
|
+ }
|
|
|
+ St(qa, qa, $a),
|
|
|
+ Mt(Ka, Ka, Ja)
|
|
|
+ }
|
|
|
+ return 0 === x && (qa[0] = qa[1] = Ka[0] = Ka[1] = 0),
|
|
|
+ new Di(qa[0],qa[1],Ka[0] - qa[0],Ka[1] - qa[1])
|
|
|
+ },
|
|
|
+ rebuildPath: function(t) {
|
|
|
+ for (var e, i, n, o, a, r, s = this.data, l = this._ux, u = this._uy, h = this._len, c = 0; c < h; ) {
|
|
|
+ var d = s[c++];
|
|
|
+ switch (1 === c && (e = n = s[c],
|
|
|
+ i = o = s[c + 1]),
|
|
|
+ d) {
|
|
|
+ case ja.M:
|
|
|
+ e = n = s[c++],
|
|
|
+ i = o = s[c++],
|
|
|
+ t.moveTo(n, o);
|
|
|
+ break;
|
|
|
+ case ja.L:
|
|
|
+ a = s[c++],
|
|
|
+ r = s[c++],
|
|
|
+ (or(a - n) > l || or(r - o) > u || c === h - 1) && (t.lineTo(a, r),
|
|
|
+ n = a,
|
|
|
+ o = r);
|
|
|
+ break;
|
|
|
+ case ja.C:
|
|
|
+ t.bezierCurveTo(s[c++], s[c++], s[c++], s[c++], s[c++], s[c++]),
|
|
|
+ n = s[c - 2],
|
|
|
+ o = s[c - 1];
|
|
|
+ break;
|
|
|
+ case ja.Q:
|
|
|
+ t.quadraticCurveTo(s[c++], s[c++], s[c++], s[c++]),
|
|
|
+ n = s[c - 2],
|
|
|
+ o = s[c - 1];
|
|
|
+ break;
|
|
|
+ case ja.A:
|
|
|
+ var f = s[c++]
|
|
|
+ , p = s[c++]
|
|
|
+ , g = s[c++]
|
|
|
+ , m = s[c++]
|
|
|
+ , v = s[c++]
|
|
|
+ , y = s[c++]
|
|
|
+ , x = s[c++]
|
|
|
+ , _ = s[c++]
|
|
|
+ , w = m < g ? g : m
|
|
|
+ , b = m < g ? 1 : g / m
|
|
|
+ , S = m < g ? m / g : 1
|
|
|
+ , M = v + y;
|
|
|
+ .001 < Math.abs(g - m) ? (t.translate(f, p),
|
|
|
+ t.rotate(x),
|
|
|
+ t.scale(b, S),
|
|
|
+ t.arc(0, 0, w, v, M, 1 - _),
|
|
|
+ t.scale(1 / b, 1 / S),
|
|
|
+ t.rotate(-x),
|
|
|
+ t.translate(-f, -p)) : t.arc(f, p, w, v, M, 1 - _),
|
|
|
+ 1 === c && (e = er(v) * g + f,
|
|
|
+ i = ir(v) * m + p),
|
|
|
+ n = er(M) * g + f,
|
|
|
+ o = ir(M) * m + p;
|
|
|
+ break;
|
|
|
+ case ja.R:
|
|
|
+ e = n = s[c],
|
|
|
+ i = o = s[c + 1],
|
|
|
+ t.rect(s[c++], s[c++], s[c++], s[c++]);
|
|
|
+ break;
|
|
|
+ case ja.Z:
|
|
|
+ t.closePath(),
|
|
|
+ n = e,
|
|
|
+ o = i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ rr.CMD = ja;
|
|
|
+ var hr = 2 * Math.PI;
|
|
|
+ function cr(t) {
|
|
|
+ return (t %= hr) < 0 && (t += hr),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ var dr = 2 * Math.PI;
|
|
|
+ function fr(t, e, i, n, o, a, r, s, l) {
|
|
|
+ if (0 === r)
|
|
|
+ return !1;
|
|
|
+ var u = r;
|
|
|
+ s -= t,
|
|
|
+ l -= e;
|
|
|
+ var h = Math.sqrt(s * s + l * l);
|
|
|
+ if (i < h - u || h + u < i)
|
|
|
+ return !1;
|
|
|
+ if (Math.abs(n - o) % dr < 1e-4)
|
|
|
+ return !0;
|
|
|
+ if (a) {
|
|
|
+ var c = n;
|
|
|
+ n = cr(o),
|
|
|
+ o = cr(c)
|
|
|
+ } else
|
|
|
+ n = cr(n),
|
|
|
+ o = cr(o);
|
|
|
+ o < n && (o += dr);
|
|
|
+ var d = Math.atan2(l, s);
|
|
|
+ return d < 0 && (d += dr),
|
|
|
+ n <= d && d <= o || n <= d + dr && d + dr <= o
|
|
|
+ }
|
|
|
+ function pr(t, e, i, n, o, a) {
|
|
|
+ if (e < a && n < a || a < e && a < n)
|
|
|
+ return 0;
|
|
|
+ if (n === e)
|
|
|
+ return 0;
|
|
|
+ var r = n < e ? 1 : -1
|
|
|
+ , s = (a - e) / (n - e);
|
|
|
+ 1 != s && 0 != s || (r = n < e ? .5 : -.5);
|
|
|
+ var l = s * (i - t) + t;
|
|
|
+ return l === o ? 1 / 0 : o < l ? r : 0
|
|
|
+ }
|
|
|
+ var gr = rr.CMD
|
|
|
+ , mr = 2 * Math.PI
|
|
|
+ , vr = 1e-4;
|
|
|
+ var yr = [-1, -1, -1]
|
|
|
+ , xr = [-1, -1];
|
|
|
+ function _r(t, e, i, n, o, a, r, s, l, u) {
|
|
|
+ if (e < u && n < u && a < u && s < u || u < e && u < n && u < a && u < s)
|
|
|
+ return 0;
|
|
|
+ var h, c = function(t, e, i, n, o, a) {
|
|
|
+ var r = n + 3 * (e - i) - t
|
|
|
+ , s = 3 * (i - 2 * e + t)
|
|
|
+ , l = 3 * (e - t)
|
|
|
+ , u = t - o
|
|
|
+ , h = s * s - 3 * r * l
|
|
|
+ , c = s * l - 9 * r * u
|
|
|
+ , d = l * l - 3 * s * u
|
|
|
+ , f = 0;
|
|
|
+ if (Ma(h) && Ma(c)) {
|
|
|
+ if (Ma(s))
|
|
|
+ a[0] = 0;
|
|
|
+ else
|
|
|
+ 0 <= (M = -l / s) && M <= 1 && (a[f++] = M)
|
|
|
+ } else {
|
|
|
+ var p = c * c - 4 * h * d;
|
|
|
+ if (Ma(p)) {
|
|
|
+ var g = c / h
|
|
|
+ , m = -g / 2;
|
|
|
+ 0 <= (M = -s / r + g) && M <= 1 && (a[f++] = M),
|
|
|
+ 0 <= m && m <= 1 && (a[f++] = m)
|
|
|
+ } else if (0 < p) {
|
|
|
+ var v = ma(p)
|
|
|
+ , y = h * s + 1.5 * r * (-c + v)
|
|
|
+ , x = h * s + 1.5 * r * (-c - v);
|
|
|
+ 0 <= (M = (-s - ((y = y < 0 ? -ga(-y, _a) : ga(y, _a)) + (x = x < 0 ? -ga(-x, _a) : ga(x, _a)))) / (3 * r)) && M <= 1 && (a[f++] = M)
|
|
|
+ } else {
|
|
|
+ var _ = (2 * h * s - 3 * r * c) / (2 * ma(h * h * h))
|
|
|
+ , w = Math.acos(_) / 3
|
|
|
+ , b = ma(h)
|
|
|
+ , S = Math.cos(w)
|
|
|
+ , M = (-s - 2 * b * S) / (3 * r)
|
|
|
+ , I = (m = (-s + b * (S + xa * Math.sin(w))) / (3 * r),
|
|
|
+ (-s + b * (S - xa * Math.sin(w))) / (3 * r));
|
|
|
+ 0 <= M && M <= 1 && (a[f++] = M),
|
|
|
+ 0 <= m && m <= 1 && (a[f++] = m),
|
|
|
+ 0 <= I && I <= 1 && (a[f++] = I)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return f
|
|
|
+ }(e, n, a, s, u, yr);
|
|
|
+ if (0 === c)
|
|
|
+ return 0;
|
|
|
+ for (var d, f, p = 0, g = -1, m = 0; m < c; m++) {
|
|
|
+ var v = yr[m]
|
|
|
+ , y = 0 === v || 1 === v ? .5 : 1;
|
|
|
+ Ta(t, i, o, r, v) < l || (g < 0 && (g = Da(e, n, a, s, xr),
|
|
|
+ xr[1] < xr[0] && 1 < g && (void 0,
|
|
|
+ h = xr[0],
|
|
|
+ xr[0] = xr[1],
|
|
|
+ xr[1] = h),
|
|
|
+ d = Ta(e, n, a, s, xr[0]),
|
|
|
+ 1 < g && (f = Ta(e, n, a, s, xr[1]))),
|
|
|
+ 2 === g ? v < xr[0] ? p += d < e ? y : -y : v < xr[1] ? p += f < d ? y : -y : p += s < f ? y : -y : v < xr[0] ? p += d < e ? y : -y : p += s < d ? y : -y)
|
|
|
+ }
|
|
|
+ return p
|
|
|
+ }
|
|
|
+ function wr(t, e, i, n, o, a, r, s) {
|
|
|
+ if (e < s && n < s && a < s || s < e && s < n && s < a)
|
|
|
+ return 0;
|
|
|
+ var l = function(t, e, i, n, o) {
|
|
|
+ var a = t - 2 * e + i
|
|
|
+ , r = 2 * (e - t)
|
|
|
+ , s = t - n
|
|
|
+ , l = 0;
|
|
|
+ if (Ma(a)) {
|
|
|
+ if (Ia(r))
|
|
|
+ 0 <= (h = -s / r) && h <= 1 && (o[l++] = h)
|
|
|
+ } else {
|
|
|
+ var u = r * r - 4 * a * s;
|
|
|
+ if (Ma(u))
|
|
|
+ 0 <= (h = -r / (2 * a)) && h <= 1 && (o[l++] = h);
|
|
|
+ else if (0 < u) {
|
|
|
+ var h, c = ma(u), d = (-r - c) / (2 * a);
|
|
|
+ 0 <= (h = (-r + c) / (2 * a)) && h <= 1 && (o[l++] = h),
|
|
|
+ 0 <= d && d <= 1 && (o[l++] = d)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return l
|
|
|
+ }(e, n, a, s, yr);
|
|
|
+ if (0 === l)
|
|
|
+ return 0;
|
|
|
+ var u = Pa(e, n, a);
|
|
|
+ if (0 <= u && u <= 1) {
|
|
|
+ for (var h = 0, c = La(e, n, a, u), d = 0; d < l; d++) {
|
|
|
+ var f = 0 === yr[d] || 1 === yr[d] ? .5 : 1;
|
|
|
+ La(t, i, o, yr[d]) < r || (yr[d] < u ? h += c < e ? f : -f : h += a < c ? f : -f)
|
|
|
+ }
|
|
|
+ return h
|
|
|
+ }
|
|
|
+ f = 0 === yr[0] || 1 === yr[0] ? .5 : 1;
|
|
|
+ return La(t, i, o, yr[0]) < r ? 0 : a < e ? f : -f
|
|
|
+ }
|
|
|
+ function br(t, e, i, n, o, a, r, s) {
|
|
|
+ if (i < (s -= e) || s < -i)
|
|
|
+ return 0;
|
|
|
+ var l = Math.sqrt(i * i - s * s);
|
|
|
+ yr[0] = -l,
|
|
|
+ yr[1] = l;
|
|
|
+ var u = Math.abs(n - o);
|
|
|
+ if (u < 1e-4)
|
|
|
+ return 0;
|
|
|
+ if (u % mr < 1e-4) {
|
|
|
+ o = mr;
|
|
|
+ var h = a ? 1 : -1;
|
|
|
+ return r >= yr[n = 0] + t && r <= yr[1] + t ? h : 0
|
|
|
+ }
|
|
|
+ if (a) {
|
|
|
+ l = n;
|
|
|
+ n = cr(o),
|
|
|
+ o = cr(l)
|
|
|
+ } else
|
|
|
+ n = cr(n),
|
|
|
+ o = cr(o);
|
|
|
+ o < n && (o += mr);
|
|
|
+ for (var c = 0, d = 0; d < 2; d++) {
|
|
|
+ var f = yr[d];
|
|
|
+ if (r < f + t) {
|
|
|
+ var p = Math.atan2(s, f);
|
|
|
+ h = a ? 1 : -1;
|
|
|
+ p < 0 && (p = mr + p),
|
|
|
+ (n <= p && p <= o || n <= p + mr && p + mr <= o) && (p > Math.PI / 2 && p < 1.5 * Math.PI && (h = -h),
|
|
|
+ c += h)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return c
|
|
|
+ }
|
|
|
+ function Sr(t, e, i, n, o) {
|
|
|
+ for (var a = 0, r = 0, s = 0, l = 0, u = 0, h = 0; h < t.length; ) {
|
|
|
+ var c = t[h++];
|
|
|
+ switch (c === gr.M && 1 < h && (i || (a += pr(r, s, l, u, n, o))),
|
|
|
+ 1 === h && (l = r = t[h],
|
|
|
+ u = s = t[h + 1]),
|
|
|
+ c) {
|
|
|
+ case gr.M:
|
|
|
+ r = l = t[h++],
|
|
|
+ s = u = t[h++];
|
|
|
+ break;
|
|
|
+ case gr.L:
|
|
|
+ if (i) {
|
|
|
+ if (sr(r, s, t[h], t[h + 1], e, n, o))
|
|
|
+ return !0
|
|
|
+ } else
|
|
|
+ a += pr(r, s, t[h], t[h + 1], n, o) || 0;
|
|
|
+ r = t[h++],
|
|
|
+ s = t[h++];
|
|
|
+ break;
|
|
|
+ case gr.C:
|
|
|
+ if (i) {
|
|
|
+ if (lr(r, s, t[h++], t[h++], t[h++], t[h++], t[h], t[h + 1], e, n, o))
|
|
|
+ return !0
|
|
|
+ } else
|
|
|
+ a += _r(r, s, t[h++], t[h++], t[h++], t[h++], t[h], t[h + 1], n, o) || 0;
|
|
|
+ r = t[h++],
|
|
|
+ s = t[h++];
|
|
|
+ break;
|
|
|
+ case gr.Q:
|
|
|
+ if (i) {
|
|
|
+ if (ur(r, s, t[h++], t[h++], t[h], t[h + 1], e, n, o))
|
|
|
+ return !0
|
|
|
+ } else
|
|
|
+ a += wr(r, s, t[h++], t[h++], t[h], t[h + 1], n, o) || 0;
|
|
|
+ r = t[h++],
|
|
|
+ s = t[h++];
|
|
|
+ break;
|
|
|
+ case gr.A:
|
|
|
+ var d = t[h++]
|
|
|
+ , f = t[h++]
|
|
|
+ , p = t[h++]
|
|
|
+ , g = t[h++]
|
|
|
+ , m = t[h++]
|
|
|
+ , v = t[h++];
|
|
|
+ h += 1;
|
|
|
+ var y = 1 - t[h++]
|
|
|
+ , x = Math.cos(m) * p + d
|
|
|
+ , _ = Math.sin(m) * g + f;
|
|
|
+ 1 < h ? a += pr(r, s, x, _, n, o) : (l = x,
|
|
|
+ u = _);
|
|
|
+ var w = (n - d) * g / p + d;
|
|
|
+ if (i) {
|
|
|
+ if (fr(d, f, g, m, m + v, y, e, w, o))
|
|
|
+ return !0
|
|
|
+ } else
|
|
|
+ a += br(d, f, g, m, m + v, y, w, o);
|
|
|
+ r = Math.cos(m + v) * p + d,
|
|
|
+ s = Math.sin(m + v) * g + f;
|
|
|
+ break;
|
|
|
+ case gr.R:
|
|
|
+ l = r = t[h++],
|
|
|
+ u = s = t[h++];
|
|
|
+ x = l + t[h++],
|
|
|
+ _ = u + t[h++];
|
|
|
+ if (i) {
|
|
|
+ if (sr(l, u, x, u, e, n, o) || sr(x, u, x, _, e, n, o) || sr(x, _, l, _, e, n, o) || sr(l, _, l, u, e, n, o))
|
|
|
+ return !0
|
|
|
+ } else
|
|
|
+ a += pr(x, u, x, _, n, o),
|
|
|
+ a += pr(l, _, l, u, n, o);
|
|
|
+ break;
|
|
|
+ case gr.Z:
|
|
|
+ if (i) {
|
|
|
+ if (sr(r, s, l, u, e, n, o))
|
|
|
+ return !0
|
|
|
+ } else
|
|
|
+ a += pr(r, s, l, u, n, o);
|
|
|
+ r = l,
|
|
|
+ s = u
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return i || function(t, e) {
|
|
|
+ return Math.abs(t - e) < vr
|
|
|
+ }(s, u) || (a += pr(r, s, l, u, n, o) || 0),
|
|
|
+ 0 !== a
|
|
|
+ }
|
|
|
+ var Mr = $i.prototype.getCanvasPattern
|
|
|
+ , Ir = Math.abs
|
|
|
+ , Tr = new rr(!0);
|
|
|
+ function Ar(t) {
|
|
|
+ Jn.call(this, t),
|
|
|
+ this.path = null
|
|
|
+ }
|
|
|
+ Ar.prototype = {
|
|
|
+ constructor: Ar,
|
|
|
+ type: "path",
|
|
|
+ __dirtyPath: !0,
|
|
|
+ strokeContainThreshold: 5,
|
|
|
+ segmentIgnoreThreshold: 0,
|
|
|
+ subPixelOptimize: !1,
|
|
|
+ brush: function(t, e) {
|
|
|
+ var i, n = this.style, o = this.path || Tr, a = n.hasStroke(), r = n.hasFill(), s = n.fill, l = n.stroke, u = r && !!s.colorStops, h = a && !!l.colorStops, c = r && !!s.image, d = a && !!l.image;
|
|
|
+ n.bind(t, this, e),
|
|
|
+ this.setTransform(t),
|
|
|
+ this.__dirty && (u && (i = i || this.getBoundingRect(),
|
|
|
+ this._fillGradient = n.getGradient(t, s, i)),
|
|
|
+ h && (i = i || this.getBoundingRect(),
|
|
|
+ this._strokeGradient = n.getGradient(t, l, i)));
|
|
|
+ u ? t.fillStyle = this._fillGradient : c && (t.fillStyle = Mr.call(s, t)),
|
|
|
+ h ? t.strokeStyle = this._strokeGradient : d && (t.strokeStyle = Mr.call(l, t));
|
|
|
+ var f = n.lineDash
|
|
|
+ , p = n.lineDashOffset
|
|
|
+ , g = !!t.setLineDash
|
|
|
+ , m = this.getGlobalScale();
|
|
|
+ if (o.setScale(m[0], m[1], this.segmentIgnoreThreshold),
|
|
|
+ this.__dirtyPath || f && !g && a ? (o.beginPath(t),
|
|
|
+ f && !g && (o.setLineDash(f),
|
|
|
+ o.setLineDashOffset(p)),
|
|
|
+ this.buildPath(o, this.shape, !1),
|
|
|
+ this.path && (this.__dirtyPath = !1)) : (t.beginPath(),
|
|
|
+ this.path.rebuildPath(t)),
|
|
|
+ r)
|
|
|
+ if (null != n.fillOpacity) {
|
|
|
+ var v = t.globalAlpha;
|
|
|
+ t.globalAlpha = n.fillOpacity * n.opacity,
|
|
|
+ o.fill(t),
|
|
|
+ t.globalAlpha = v
|
|
|
+ } else
|
|
|
+ o.fill(t);
|
|
|
+ if (f && g && (t.setLineDash(f),
|
|
|
+ t.lineDashOffset = p),
|
|
|
+ a)
|
|
|
+ if (null != n.strokeOpacity) {
|
|
|
+ v = t.globalAlpha;
|
|
|
+ t.globalAlpha = n.strokeOpacity * n.opacity,
|
|
|
+ o.stroke(t),
|
|
|
+ t.globalAlpha = v
|
|
|
+ } else
|
|
|
+ o.stroke(t);
|
|
|
+ f && g && t.setLineDash([]),
|
|
|
+ null != n.text && (this.restoreTransform(t),
|
|
|
+ this.drawRectText(t, this.getBoundingRect()))
|
|
|
+ },
|
|
|
+ buildPath: function(t, e, i) {},
|
|
|
+ createPathProxy: function() {
|
|
|
+ this.path = new rr
|
|
|
+ },
|
|
|
+ getBoundingRect: function() {
|
|
|
+ var t = this._rect
|
|
|
+ , e = this.style
|
|
|
+ , i = !t;
|
|
|
+ if (i) {
|
|
|
+ var n = this.path;
|
|
|
+ n = n || (this.path = new rr),
|
|
|
+ this.__dirtyPath && (n.beginPath(),
|
|
|
+ this.buildPath(n, this.shape, !1)),
|
|
|
+ t = n.getBoundingRect()
|
|
|
+ }
|
|
|
+ if (this._rect = t,
|
|
|
+ e.hasStroke()) {
|
|
|
+ var o = this._rectWithStroke || (this._rectWithStroke = t.clone());
|
|
|
+ if (this.__dirty || i) {
|
|
|
+ o.copy(t);
|
|
|
+ var a = e.lineWidth
|
|
|
+ , r = e.strokeNoScale ? this.getLineScale() : 1;
|
|
|
+ e.hasFill() || (a = Math.max(a, this.strokeContainThreshold || 4)),
|
|
|
+ 1e-10 < r && (o.width += a / r,
|
|
|
+ o.height += a / r,
|
|
|
+ o.x -= a / r / 2,
|
|
|
+ o.y -= a / r / 2)
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ },
|
|
|
+ contain: function(t, e) {
|
|
|
+ var i = this.transformCoordToLocal(t, e)
|
|
|
+ , n = this.getBoundingRect()
|
|
|
+ , o = this.style;
|
|
|
+ if (t = i[0],
|
|
|
+ e = i[1],
|
|
|
+ n.contain(t, e)) {
|
|
|
+ var a = this.path.data;
|
|
|
+ if (o.hasStroke()) {
|
|
|
+ var r = o.lineWidth
|
|
|
+ , s = o.strokeNoScale ? this.getLineScale() : 1;
|
|
|
+ if (1e-10 < s && (o.hasFill() || (r = Math.max(r, this.strokeContainThreshold)),
|
|
|
+ function(t, e, i, n) {
|
|
|
+ return Sr(t, e, !0, i, n)
|
|
|
+ }(a, r / s, t, e)))
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ if (o.hasFill())
|
|
|
+ return function(t, e, i) {
|
|
|
+ return Sr(t, 0, !1, e, i)
|
|
|
+ }(a, t, e)
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ },
|
|
|
+ dirty: function(t) {
|
|
|
+ null == t && (t = !0),
|
|
|
+ t && (this.__dirtyPath = t,
|
|
|
+ this._rect = null),
|
|
|
+ this.__dirty = this.__dirtyText = !0,
|
|
|
+ this.__zr && this.__zr.refresh(),
|
|
|
+ this.__clipTarget && this.__clipTarget.dirty()
|
|
|
+ },
|
|
|
+ animateShape: function(t) {
|
|
|
+ return this.animate("shape", t)
|
|
|
+ },
|
|
|
+ attrKV: function(t, e) {
|
|
|
+ "shape" === t ? (this.setShape(e),
|
|
|
+ this.__dirtyPath = !0,
|
|
|
+ this._rect = null) : Jn.prototype.attrKV.call(this, t, e)
|
|
|
+ },
|
|
|
+ setShape: function(t, e) {
|
|
|
+ var i = this.shape;
|
|
|
+ if (i) {
|
|
|
+ if (z(t))
|
|
|
+ for (var n in t)
|
|
|
+ t.hasOwnProperty(n) && (i[n] = t[n]);
|
|
|
+ else
|
|
|
+ i[t] = e;
|
|
|
+ this.dirty(!0)
|
|
|
+ }
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ getLineScale: function() {
|
|
|
+ var t = this.transform;
|
|
|
+ return t && 1e-10 < Ir(t[0] - 1) && 1e-10 < Ir(t[3] - 1) ? Math.sqrt(Ir(t[0] * t[3] - t[2] * t[1])) : 1
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Ar.extend = function(o) {
|
|
|
+ function t(t) {
|
|
|
+ Ar.call(this, t),
|
|
|
+ o.style && this.style.extendFrom(o.style, !1);
|
|
|
+ var e = o.shape;
|
|
|
+ if (e) {
|
|
|
+ this.shape = this.shape || {};
|
|
|
+ var i = this.shape;
|
|
|
+ for (var n in e)
|
|
|
+ !i.hasOwnProperty(n) && e.hasOwnProperty(n) && (i[n] = e[n])
|
|
|
+ }
|
|
|
+ o.init && o.init.call(this, t)
|
|
|
+ }
|
|
|
+ for (var e in w(t, Ar),
|
|
|
+ o)
|
|
|
+ "style" !== e && "shape" !== e && (t.prototype[e] = o[e]);
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(Ar, Jn);
|
|
|
+ function Dr(t) {
|
|
|
+ return Math.sqrt(t[0] * t[0] + t[1] * t[1])
|
|
|
+ }
|
|
|
+ var Cr = rr.CMD
|
|
|
+ , Lr = [[], [], []]
|
|
|
+ , kr = Math.sqrt
|
|
|
+ , Pr = Math.atan2
|
|
|
+ , Nr = function(t, e) {
|
|
|
+ var i, n, o, a, r, s = t.data, l = Cr.M, u = Cr.C, h = Cr.L, c = Cr.R, d = Cr.A, f = Cr.Q;
|
|
|
+ for (a = o = 0; o < s.length; ) {
|
|
|
+ switch (i = s[o++],
|
|
|
+ a = o,
|
|
|
+ n = 0,
|
|
|
+ i) {
|
|
|
+ case l:
|
|
|
+ case h:
|
|
|
+ n = 1;
|
|
|
+ break;
|
|
|
+ case u:
|
|
|
+ n = 3;
|
|
|
+ break;
|
|
|
+ case f:
|
|
|
+ n = 2;
|
|
|
+ break;
|
|
|
+ case d:
|
|
|
+ var p = e[4]
|
|
|
+ , g = e[5]
|
|
|
+ , m = kr(e[0] * e[0] + e[1] * e[1])
|
|
|
+ , v = kr(e[2] * e[2] + e[3] * e[3])
|
|
|
+ , y = Pr(-e[1] / v, e[0] / m);
|
|
|
+ s[o] *= m,
|
|
|
+ s[o++] += p,
|
|
|
+ s[o] *= v,
|
|
|
+ s[o++] += g,
|
|
|
+ s[o++] *= m,
|
|
|
+ s[o++] *= v,
|
|
|
+ s[o++] += y,
|
|
|
+ s[o++] += y,
|
|
|
+ a = o += 2;
|
|
|
+ break;
|
|
|
+ case c:
|
|
|
+ x[0] = s[o++],
|
|
|
+ x[1] = s[o++],
|
|
|
+ bt(x, x, e),
|
|
|
+ s[a++] = x[0],
|
|
|
+ s[a++] = x[1],
|
|
|
+ x[0] += s[o++],
|
|
|
+ x[1] += s[o++],
|
|
|
+ bt(x, x, e),
|
|
|
+ s[a++] = x[0],
|
|
|
+ s[a++] = x[1]
|
|
|
+ }
|
|
|
+ for (r = 0; r < n; r++) {
|
|
|
+ var x;
|
|
|
+ (x = Lr[r])[0] = s[o++],
|
|
|
+ x[1] = s[o++],
|
|
|
+ bt(x, x, e),
|
|
|
+ s[a++] = x[0],
|
|
|
+ s[a++] = x[1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Or = Math.sqrt
|
|
|
+ , Er = Math.sin
|
|
|
+ , Rr = Math.cos
|
|
|
+ , zr = Math.PI
|
|
|
+ , Br = function(t, e) {
|
|
|
+ return (t[0] * e[0] + t[1] * e[1]) / (Dr(t) * Dr(e))
|
|
|
+ }
|
|
|
+ , Vr = function(t, e) {
|
|
|
+ return (t[0] * e[1] < t[1] * e[0] ? -1 : 1) * Math.acos(Br(t, e))
|
|
|
+ };
|
|
|
+ function Gr(t, e, i, n, o, a, r, s, l, u, h) {
|
|
|
+ var c = l * (zr / 180)
|
|
|
+ , d = Rr(c) * (t - i) / 2 + Er(c) * (e - n) / 2
|
|
|
+ , f = -1 * Er(c) * (t - i) / 2 + Rr(c) * (e - n) / 2
|
|
|
+ , p = d * d / (r * r) + f * f / (s * s);
|
|
|
+ 1 < p && (r *= Or(p),
|
|
|
+ s *= Or(p));
|
|
|
+ var g = (o === a ? -1 : 1) * Or((r * r * (s * s) - r * r * (f * f) - s * s * (d * d)) / (r * r * (f * f) + s * s * (d * d))) || 0
|
|
|
+ , m = g * r * f / s
|
|
|
+ , v = g * -s * d / r
|
|
|
+ , y = (t + i) / 2 + Rr(c) * m - Er(c) * v
|
|
|
+ , x = (e + n) / 2 + Er(c) * m + Rr(c) * v
|
|
|
+ , _ = Vr([1, 0], [(d - m) / r, (f - v) / s])
|
|
|
+ , w = [(d - m) / r, (f - v) / s]
|
|
|
+ , b = [(-1 * d - m) / r, (-1 * f - v) / s]
|
|
|
+ , S = Vr(w, b);
|
|
|
+ Br(w, b) <= -1 && (S = zr),
|
|
|
+ 1 <= Br(w, b) && (S = 0),
|
|
|
+ 0 === a && 0 < S && (S -= 2 * zr),
|
|
|
+ 1 === a && S < 0 && (S += 2 * zr),
|
|
|
+ h.addData(u, y, x, r, s, _, S, c, a)
|
|
|
+ }
|
|
|
+ var Fr = /([mlvhzcqtsa])([^mlvhzcqtsa]*)/gi
|
|
|
+ , Wr = /-?([0-9]*\.)?[0-9]+([eE]-?[0-9]+)?/g;
|
|
|
+ function Hr(t, e) {
|
|
|
+ var i = function(t) {
|
|
|
+ if (!t)
|
|
|
+ return new rr;
|
|
|
+ for (var e, i = 0, n = 0, o = i, a = n, r = new rr, s = rr.CMD, l = t.match(Fr), u = 0; u < l.length; u++) {
|
|
|
+ for (var h, c = l[u], d = c.charAt(0), f = c.match(Wr) || [], p = f.length, g = 0; g < p; g++)
|
|
|
+ f[g] = parseFloat(f[g]);
|
|
|
+ for (var m = 0; m < p; ) {
|
|
|
+ var v, y, x, _, w, b, S, M = i, I = n;
|
|
|
+ switch (d) {
|
|
|
+ case "l":
|
|
|
+ i += f[m++],
|
|
|
+ n += f[m++],
|
|
|
+ h = s.L,
|
|
|
+ r.addData(h, i, n);
|
|
|
+ break;
|
|
|
+ case "L":
|
|
|
+ i = f[m++],
|
|
|
+ n = f[m++],
|
|
|
+ h = s.L,
|
|
|
+ r.addData(h, i, n);
|
|
|
+ break;
|
|
|
+ case "m":
|
|
|
+ i += f[m++],
|
|
|
+ n += f[m++],
|
|
|
+ h = s.M,
|
|
|
+ r.addData(h, i, n),
|
|
|
+ o = i,
|
|
|
+ a = n,
|
|
|
+ d = "l";
|
|
|
+ break;
|
|
|
+ case "M":
|
|
|
+ i = f[m++],
|
|
|
+ n = f[m++],
|
|
|
+ h = s.M,
|
|
|
+ r.addData(h, i, n),
|
|
|
+ o = i,
|
|
|
+ a = n,
|
|
|
+ d = "L";
|
|
|
+ break;
|
|
|
+ case "h":
|
|
|
+ i += f[m++],
|
|
|
+ h = s.L,
|
|
|
+ r.addData(h, i, n);
|
|
|
+ break;
|
|
|
+ case "H":
|
|
|
+ i = f[m++],
|
|
|
+ h = s.L,
|
|
|
+ r.addData(h, i, n);
|
|
|
+ break;
|
|
|
+ case "v":
|
|
|
+ n += f[m++],
|
|
|
+ h = s.L,
|
|
|
+ r.addData(h, i, n);
|
|
|
+ break;
|
|
|
+ case "V":
|
|
|
+ n = f[m++],
|
|
|
+ h = s.L,
|
|
|
+ r.addData(h, i, n);
|
|
|
+ break;
|
|
|
+ case "C":
|
|
|
+ h = s.C,
|
|
|
+ r.addData(h, f[m++], f[m++], f[m++], f[m++], f[m++], f[m++]),
|
|
|
+ i = f[m - 2],
|
|
|
+ n = f[m - 1];
|
|
|
+ break;
|
|
|
+ case "c":
|
|
|
+ h = s.C,
|
|
|
+ r.addData(h, f[m++] + i, f[m++] + n, f[m++] + i, f[m++] + n, f[m++] + i, f[m++] + n),
|
|
|
+ i += f[m - 2],
|
|
|
+ n += f[m - 1];
|
|
|
+ break;
|
|
|
+ case "S":
|
|
|
+ v = i,
|
|
|
+ y = n;
|
|
|
+ var T = r.len()
|
|
|
+ , A = r.data;
|
|
|
+ e === s.C && (v += i - A[T - 4],
|
|
|
+ y += n - A[T - 3]),
|
|
|
+ h = s.C,
|
|
|
+ M = f[m++],
|
|
|
+ I = f[m++],
|
|
|
+ i = f[m++],
|
|
|
+ n = f[m++],
|
|
|
+ r.addData(h, v, y, M, I, i, n);
|
|
|
+ break;
|
|
|
+ case "s":
|
|
|
+ v = i,
|
|
|
+ y = n;
|
|
|
+ T = r.len(),
|
|
|
+ A = r.data;
|
|
|
+ e === s.C && (v += i - A[T - 4],
|
|
|
+ y += n - A[T - 3]),
|
|
|
+ h = s.C,
|
|
|
+ M = i + f[m++],
|
|
|
+ I = n + f[m++],
|
|
|
+ i += f[m++],
|
|
|
+ n += f[m++],
|
|
|
+ r.addData(h, v, y, M, I, i, n);
|
|
|
+ break;
|
|
|
+ case "Q":
|
|
|
+ M = f[m++],
|
|
|
+ I = f[m++],
|
|
|
+ i = f[m++],
|
|
|
+ n = f[m++],
|
|
|
+ h = s.Q,
|
|
|
+ r.addData(h, M, I, i, n);
|
|
|
+ break;
|
|
|
+ case "q":
|
|
|
+ M = f[m++] + i,
|
|
|
+ I = f[m++] + n,
|
|
|
+ i += f[m++],
|
|
|
+ n += f[m++],
|
|
|
+ h = s.Q,
|
|
|
+ r.addData(h, M, I, i, n);
|
|
|
+ break;
|
|
|
+ case "T":
|
|
|
+ v = i,
|
|
|
+ y = n;
|
|
|
+ T = r.len(),
|
|
|
+ A = r.data;
|
|
|
+ e === s.Q && (v += i - A[T - 4],
|
|
|
+ y += n - A[T - 3]),
|
|
|
+ i = f[m++],
|
|
|
+ n = f[m++],
|
|
|
+ h = s.Q,
|
|
|
+ r.addData(h, v, y, i, n);
|
|
|
+ break;
|
|
|
+ case "t":
|
|
|
+ v = i,
|
|
|
+ y = n;
|
|
|
+ T = r.len(),
|
|
|
+ A = r.data;
|
|
|
+ e === s.Q && (v += i - A[T - 4],
|
|
|
+ y += n - A[T - 3]),
|
|
|
+ i += f[m++],
|
|
|
+ n += f[m++],
|
|
|
+ h = s.Q,
|
|
|
+ r.addData(h, v, y, i, n);
|
|
|
+ break;
|
|
|
+ case "A":
|
|
|
+ x = f[m++],
|
|
|
+ _ = f[m++],
|
|
|
+ w = f[m++],
|
|
|
+ b = f[m++],
|
|
|
+ S = f[m++],
|
|
|
+ Gr(M = i, I = n, i = f[m++], n = f[m++], b, S, x, _, w, h = s.A, r);
|
|
|
+ break;
|
|
|
+ case "a":
|
|
|
+ x = f[m++],
|
|
|
+ _ = f[m++],
|
|
|
+ w = f[m++],
|
|
|
+ b = f[m++],
|
|
|
+ S = f[m++],
|
|
|
+ Gr(M = i, I = n, i += f[m++], n += f[m++], b, S, x, _, w, h = s.A, r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ "z" !== d && "Z" !== d || (h = s.Z,
|
|
|
+ r.addData(h),
|
|
|
+ i = o,
|
|
|
+ n = a),
|
|
|
+ e = h
|
|
|
+ }
|
|
|
+ return r.toStatic(),
|
|
|
+ r
|
|
|
+ }(t);
|
|
|
+ return (e = e || {}).buildPath = function(t) {
|
|
|
+ if (t.setData) {
|
|
|
+ t.setData(i.data),
|
|
|
+ (e = t.getContext()) && t.rebuildPath(e)
|
|
|
+ } else {
|
|
|
+ var e = t;
|
|
|
+ i.rebuildPath(e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ e.applyTransform = function(t) {
|
|
|
+ Nr(i, t),
|
|
|
+ this.dirty(!0)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function Zr(t, e) {
|
|
|
+ return new Ar(Hr(t, e))
|
|
|
+ }
|
|
|
+ var Ur = function(t) {
|
|
|
+ Jn.call(this, t)
|
|
|
+ };
|
|
|
+ Ur.prototype = {
|
|
|
+ constructor: Ur,
|
|
|
+ type: "text",
|
|
|
+ brush: function(t, e) {
|
|
|
+ var i = this.style;
|
|
|
+ this.__dirty && En(i),
|
|
|
+ i.fill = i.stroke = i.shadowBlur = i.shadowColor = i.shadowOffsetX = i.shadowOffsetY = null;
|
|
|
+ var n = i.text;
|
|
|
+ null != n && (n += ""),
|
|
|
+ qn(n, i) ? (this.setTransform(t),
|
|
|
+ zn(this, t, n, i, null, e),
|
|
|
+ this.restoreTransform(t)) : t.__attrCachedBy = Wi.NONE
|
|
|
+ },
|
|
|
+ getBoundingRect: function() {
|
|
|
+ var t = this.style;
|
|
|
+ if (this.__dirty && En(t),
|
|
|
+ !this._rect) {
|
|
|
+ var e = t.text;
|
|
|
+ null != e ? e += "" : e = "";
|
|
|
+ var i = gn(t.text + "", t.font, t.textAlign, t.textVerticalAlign, t.textPadding, t.textLineHeight, t.rich);
|
|
|
+ if (i.x += t.x || 0,
|
|
|
+ i.y += t.y || 0,
|
|
|
+ Un(t.textStroke, t.textStrokeWidth)) {
|
|
|
+ var n = t.textStrokeWidth;
|
|
|
+ i.x -= n / 2,
|
|
|
+ i.y -= n / 2,
|
|
|
+ i.width += n,
|
|
|
+ i.height += n
|
|
|
+ }
|
|
|
+ this._rect = i
|
|
|
+ }
|
|
|
+ return this._rect
|
|
|
+ }
|
|
|
+ },
|
|
|
+ w(Ur, Jn);
|
|
|
+ function Xr(l) {
|
|
|
+ return v.browser.ie && 11 <= v.browser.version ? function() {
|
|
|
+ var t, e = this.__clipPaths, i = this.style;
|
|
|
+ if (e)
|
|
|
+ for (var n = 0; n < e.length; n++) {
|
|
|
+ var o = e[n]
|
|
|
+ , a = o && o.shape
|
|
|
+ , r = o && o.type;
|
|
|
+ if (a && ("sector" === r && a.startAngle === a.endAngle || "rect" === r && (!a.width || !a.height))) {
|
|
|
+ for (var s = 0; s < jr.length; s++)
|
|
|
+ jr[s][2] = i[jr[s][0]],
|
|
|
+ i[jr[s][0]] = jr[s][1];
|
|
|
+ t = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (l.apply(this, arguments),
|
|
|
+ t)
|
|
|
+ for (s = 0; s < jr.length; s++)
|
|
|
+ i[jr[s][0]] = jr[s][2]
|
|
|
+ }
|
|
|
+ : l
|
|
|
+ }
|
|
|
+ var Yr = Ar.extend({
|
|
|
+ type: "circle",
|
|
|
+ shape: {
|
|
|
+ cx: 0,
|
|
|
+ cy: 0,
|
|
|
+ r: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e, i) {
|
|
|
+ i && t.moveTo(e.cx + e.r, e.cy),
|
|
|
+ t.arc(e.cx, e.cy, e.r, 0, 2 * Math.PI, !0)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , jr = [["shadowBlur", 0], ["shadowColor", "#000"], ["shadowOffsetX", 0], ["shadowOffsetY", 0]]
|
|
|
+ , qr = Ar.extend({
|
|
|
+ type: "sector",
|
|
|
+ shape: {
|
|
|
+ cx: 0,
|
|
|
+ cy: 0,
|
|
|
+ r0: 0,
|
|
|
+ r: 0,
|
|
|
+ startAngle: 0,
|
|
|
+ endAngle: 2 * Math.PI,
|
|
|
+ clockwise: !0
|
|
|
+ },
|
|
|
+ brush: Xr(Ar.prototype.brush),
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.cx
|
|
|
+ , n = e.cy
|
|
|
+ , o = Math.max(e.r0 || 0, 0)
|
|
|
+ , a = Math.max(e.r, 0)
|
|
|
+ , r = e.startAngle
|
|
|
+ , s = e.endAngle
|
|
|
+ , l = e.clockwise
|
|
|
+ , u = Math.cos(r)
|
|
|
+ , h = Math.sin(r);
|
|
|
+ t.moveTo(u * o + i, h * o + n),
|
|
|
+ t.lineTo(u * a + i, h * a + n),
|
|
|
+ t.arc(i, n, a, r, s, !l),
|
|
|
+ t.lineTo(Math.cos(s) * o + i, Math.sin(s) * o + n),
|
|
|
+ 0 !== o && t.arc(i, n, o, s, r, l),
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , Kr = Ar.extend({
|
|
|
+ type: "ring",
|
|
|
+ shape: {
|
|
|
+ cx: 0,
|
|
|
+ cy: 0,
|
|
|
+ r: 0,
|
|
|
+ r0: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.cx
|
|
|
+ , n = e.cy
|
|
|
+ , o = 2 * Math.PI;
|
|
|
+ t.moveTo(i + e.r, n),
|
|
|
+ t.arc(i, n, e.r, 0, o, !1),
|
|
|
+ t.moveTo(i + e.r0, n),
|
|
|
+ t.arc(i, n, e.r0, 0, o, !0)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function $r(t, e, i, n, o, a, r) {
|
|
|
+ var s = .5 * (i - t)
|
|
|
+ , l = .5 * (n - e);
|
|
|
+ return (2 * (e - i) + s + l) * r + (-3 * (e - i) - 2 * s - l) * a + s * o + e
|
|
|
+ }
|
|
|
+ function Jr(t, e, i) {
|
|
|
+ var n = e.points
|
|
|
+ , o = e.smooth;
|
|
|
+ if (n && 2 <= n.length) {
|
|
|
+ if (o && "spline" !== o) {
|
|
|
+ var a = function(t, e, i, n) {
|
|
|
+ var o, a, r, s, l = [], u = [], h = [], c = [];
|
|
|
+ if (n) {
|
|
|
+ r = [1 / 0, 1 / 0],
|
|
|
+ s = [-1 / 0, -1 / 0];
|
|
|
+ for (var d = 0, f = t.length; d < f; d++)
|
|
|
+ St(r, r, t[d]),
|
|
|
+ Mt(s, s, t[d]);
|
|
|
+ St(r, r, n[0]),
|
|
|
+ Mt(s, s, n[1])
|
|
|
+ }
|
|
|
+ for (d = 0,
|
|
|
+ f = t.length; d < f; d++) {
|
|
|
+ var p = t[d];
|
|
|
+ if (i)
|
|
|
+ o = t[d ? d - 1 : f - 1],
|
|
|
+ a = t[(d + 1) % f];
|
|
|
+ else {
|
|
|
+ if (0 === d || d === f - 1) {
|
|
|
+ l.push(rt(t[d]));
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ o = t[d - 1],
|
|
|
+ a = t[d + 1]
|
|
|
+ }
|
|
|
+ ht(u, a, o),
|
|
|
+ gt(u, u, e);
|
|
|
+ var g = vt(p, o)
|
|
|
+ , m = vt(p, a)
|
|
|
+ , v = g + m;
|
|
|
+ 0 !== v && (g /= v,
|
|
|
+ m /= v),
|
|
|
+ gt(h, u, -g),
|
|
|
+ gt(c, u, m);
|
|
|
+ var y = lt([], p, h)
|
|
|
+ , x = lt([], p, c);
|
|
|
+ n && (Mt(y, y, r),
|
|
|
+ St(y, y, s),
|
|
|
+ Mt(x, x, r),
|
|
|
+ St(x, x, s)),
|
|
|
+ l.push(y),
|
|
|
+ l.push(x)
|
|
|
+ }
|
|
|
+ return i && l.push(l.shift()),
|
|
|
+ l
|
|
|
+ }(n, o, i, e.smoothConstraint);
|
|
|
+ t.moveTo(n[0][0], n[0][1]);
|
|
|
+ for (var r = n.length, s = 0; s < (i ? r : r - 1); s++) {
|
|
|
+ var l = a[2 * s]
|
|
|
+ , u = a[2 * s + 1]
|
|
|
+ , h = n[(s + 1) % r];
|
|
|
+ t.bezierCurveTo(l[0], l[1], u[0], u[1], h[0], h[1])
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ "spline" === o && (n = function(t, e) {
|
|
|
+ for (var i = t.length, n = [], o = 0, a = 1; a < i; a++)
|
|
|
+ o += vt(t[a - 1], t[a]);
|
|
|
+ var r = o / 2;
|
|
|
+ r = r < i ? i : r;
|
|
|
+ for (a = 0; a < r; a++) {
|
|
|
+ var s, l, u, h = a / (r - 1) * (e ? i : i - 1), c = Math.floor(h), d = h - c, f = t[c % i];
|
|
|
+ u = e ? (s = t[(c - 1 + i) % i],
|
|
|
+ l = t[(c + 1) % i],
|
|
|
+ t[(c + 2) % i]) : (s = t[0 === c ? c : c - 1],
|
|
|
+ l = t[i - 2 < c ? i - 1 : c + 1],
|
|
|
+ t[i - 3 < c ? i - 1 : c + 2]);
|
|
|
+ var p = d * d
|
|
|
+ , g = d * p;
|
|
|
+ n.push([$r(s[0], f[0], l[0], u[0], d, p, g), $r(s[1], f[1], l[1], u[1], d, p, g)])
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }(n, i)),
|
|
|
+ t.moveTo(n[0][0], n[0][1]);
|
|
|
+ s = 1;
|
|
|
+ for (var c = n.length; s < c; s++)
|
|
|
+ t.lineTo(n[s][0], n[s][1])
|
|
|
+ }
|
|
|
+ i && t.closePath()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Qr = Ar.extend({
|
|
|
+ type: "polygon",
|
|
|
+ shape: {
|
|
|
+ points: null,
|
|
|
+ smooth: !1,
|
|
|
+ smoothConstraint: null
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ Jr(t, e, !0)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , ts = Ar.extend({
|
|
|
+ type: "polyline",
|
|
|
+ shape: {
|
|
|
+ points: null,
|
|
|
+ smooth: !1,
|
|
|
+ smoothConstraint: null
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ stroke: "#000",
|
|
|
+ fill: null
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ Jr(t, e, !1)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , es = Math.round;
|
|
|
+ function is(t, e, i) {
|
|
|
+ if (e) {
|
|
|
+ var n = e.x1
|
|
|
+ , o = e.x2
|
|
|
+ , a = e.y1
|
|
|
+ , r = e.y2;
|
|
|
+ t.x1 = n,
|
|
|
+ t.x2 = o,
|
|
|
+ t.y1 = a,
|
|
|
+ t.y2 = r;
|
|
|
+ var s = i && i.lineWidth;
|
|
|
+ s && (es(2 * n) === es(2 * o) && (t.x1 = t.x2 = os(n, s, !0)),
|
|
|
+ es(2 * a) === es(2 * r) && (t.y1 = t.y2 = os(a, s, !0)))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ns(t, e, i) {
|
|
|
+ if (e) {
|
|
|
+ var n = e.x
|
|
|
+ , o = e.y
|
|
|
+ , a = e.width
|
|
|
+ , r = e.height;
|
|
|
+ t.x = n,
|
|
|
+ t.y = o,
|
|
|
+ t.width = a,
|
|
|
+ t.height = r;
|
|
|
+ var s = i && i.lineWidth;
|
|
|
+ s && (t.x = os(n, s, !0),
|
|
|
+ t.y = os(o, s, !0),
|
|
|
+ t.width = Math.max(os(n + a, s, !1) - t.x, 0 === a ? 0 : 1),
|
|
|
+ t.height = Math.max(os(o + r, s, !1) - t.y, 0 === r ? 0 : 1))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function os(t, e, i) {
|
|
|
+ if (!e)
|
|
|
+ return t;
|
|
|
+ var n = es(2 * t);
|
|
|
+ return (n + es(e)) % 2 == 0 ? n / 2 : (n + (i ? 1 : -1)) / 2
|
|
|
+ }
|
|
|
+ var as = {}
|
|
|
+ , rs = Ar.extend({
|
|
|
+ type: "rect",
|
|
|
+ shape: {
|
|
|
+ r: 0,
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i, n, o, a;
|
|
|
+ this.subPixelOptimize ? (ns(as, e, this.style),
|
|
|
+ i = as.x,
|
|
|
+ n = as.y,
|
|
|
+ o = as.width,
|
|
|
+ a = as.height,
|
|
|
+ as.r = e.r,
|
|
|
+ e = as) : (i = e.x,
|
|
|
+ n = e.y,
|
|
|
+ o = e.width,
|
|
|
+ a = e.height),
|
|
|
+ e.r ? Dn(t, e) : t.rect(i, n, o, a),
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , ss = {}
|
|
|
+ , ls = Ar.extend({
|
|
|
+ type: "line",
|
|
|
+ shape: {
|
|
|
+ x1: 0,
|
|
|
+ y1: 0,
|
|
|
+ x2: 0,
|
|
|
+ y2: 0,
|
|
|
+ percent: 1
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ stroke: "#000",
|
|
|
+ fill: null
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i, n, o, a;
|
|
|
+ a = this.subPixelOptimize ? (is(ss, e, this.style),
|
|
|
+ i = ss.x1,
|
|
|
+ n = ss.y1,
|
|
|
+ o = ss.x2,
|
|
|
+ ss.y2) : (i = e.x1,
|
|
|
+ n = e.y1,
|
|
|
+ o = e.x2,
|
|
|
+ e.y2);
|
|
|
+ var r = e.percent;
|
|
|
+ 0 !== r && (t.moveTo(i, n),
|
|
|
+ r < 1 && (o = i * (1 - r) + o * r,
|
|
|
+ a = n * (1 - r) + a * r),
|
|
|
+ t.lineTo(o, a))
|
|
|
+ },
|
|
|
+ pointAt: function(t) {
|
|
|
+ var e = this.shape;
|
|
|
+ return [e.x1 * (1 - t) + e.x2 * t, e.y1 * (1 - t) + e.y2 * t]
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , us = [];
|
|
|
+ function hs(t, e, i) {
|
|
|
+ var n = t.cpx2
|
|
|
+ , o = t.cpy2;
|
|
|
+ return null === n || null === o ? [(i ? Aa : Ta)(t.x1, t.cpx1, t.cpx2, t.x2, e), (i ? Aa : Ta)(t.y1, t.cpy1, t.cpy2, t.y2, e)] : [(i ? ka : La)(t.x1, t.cpx1, t.x2, e), (i ? ka : La)(t.y1, t.cpy1, t.y2, e)]
|
|
|
+ }
|
|
|
+ function cs(t) {
|
|
|
+ this.colorStops = t || []
|
|
|
+ }
|
|
|
+ var ds = Ar.extend({
|
|
|
+ type: "bezier-curve",
|
|
|
+ shape: {
|
|
|
+ x1: 0,
|
|
|
+ y1: 0,
|
|
|
+ x2: 0,
|
|
|
+ y2: 0,
|
|
|
+ cpx1: 0,
|
|
|
+ cpy1: 0,
|
|
|
+ percent: 1
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ stroke: "#000",
|
|
|
+ fill: null
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.x1
|
|
|
+ , n = e.y1
|
|
|
+ , o = e.x2
|
|
|
+ , a = e.y2
|
|
|
+ , r = e.cpx1
|
|
|
+ , s = e.cpy1
|
|
|
+ , l = e.cpx2
|
|
|
+ , u = e.cpy2
|
|
|
+ , h = e.percent;
|
|
|
+ 0 !== h && (t.moveTo(i, n),
|
|
|
+ null == l || null == u ? (h < 1 && (Na(i, r, o, h, us),
|
|
|
+ r = us[1],
|
|
|
+ o = us[2],
|
|
|
+ Na(n, s, a, h, us),
|
|
|
+ s = us[1],
|
|
|
+ a = us[2]),
|
|
|
+ t.quadraticCurveTo(r, s, o, a)) : (h < 1 && (Ca(i, r, l, o, h, us),
|
|
|
+ r = us[1],
|
|
|
+ l = us[2],
|
|
|
+ o = us[3],
|
|
|
+ Ca(n, s, u, a, h, us),
|
|
|
+ s = us[1],
|
|
|
+ u = us[2],
|
|
|
+ a = us[3]),
|
|
|
+ t.bezierCurveTo(r, s, l, u, o, a)))
|
|
|
+ },
|
|
|
+ pointAt: function(t) {
|
|
|
+ return hs(this.shape, t, !1)
|
|
|
+ },
|
|
|
+ tangentAt: function(t) {
|
|
|
+ var e = hs(this.shape, t, !0);
|
|
|
+ return mt(e, e)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , fs = Ar.extend({
|
|
|
+ type: "arc",
|
|
|
+ shape: {
|
|
|
+ cx: 0,
|
|
|
+ cy: 0,
|
|
|
+ r: 0,
|
|
|
+ startAngle: 0,
|
|
|
+ endAngle: 2 * Math.PI,
|
|
|
+ clockwise: !0
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ stroke: "#000",
|
|
|
+ fill: null
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.cx
|
|
|
+ , n = e.cy
|
|
|
+ , o = Math.max(e.r, 0)
|
|
|
+ , a = e.startAngle
|
|
|
+ , r = e.endAngle
|
|
|
+ , s = e.clockwise
|
|
|
+ , l = Math.cos(a)
|
|
|
+ , u = Math.sin(a);
|
|
|
+ t.moveTo(l * o + i, u * o + n),
|
|
|
+ t.arc(i, n, o, a, r, !s)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , ps = Ar.extend({
|
|
|
+ type: "compound",
|
|
|
+ shape: {
|
|
|
+ paths: null
|
|
|
+ },
|
|
|
+ _updatePathDirty: function() {
|
|
|
+ for (var t = this.__dirtyPath, e = this.shape.paths, i = 0; i < e.length; i++)
|
|
|
+ t = t || e[i].__dirtyPath;
|
|
|
+ this.__dirtyPath = t,
|
|
|
+ this.__dirty = this.__dirty || t
|
|
|
+ },
|
|
|
+ beforeBrush: function() {
|
|
|
+ this._updatePathDirty();
|
|
|
+ for (var t = this.shape.paths || [], e = this.getGlobalScale(), i = 0; i < t.length; i++)
|
|
|
+ t[i].path || t[i].createPathProxy(),
|
|
|
+ t[i].path.setScale(e[0], e[1], t[i].segmentIgnoreThreshold)
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ for (var i = e.paths || [], n = 0; n < i.length; n++)
|
|
|
+ i[n].buildPath(t, i[n].shape, !0)
|
|
|
+ },
|
|
|
+ afterBrush: function() {
|
|
|
+ for (var t = this.shape.paths || [], e = 0; e < t.length; e++)
|
|
|
+ t[e].__dirtyPath = !1
|
|
|
+ },
|
|
|
+ getBoundingRect: function() {
|
|
|
+ return this._updatePathDirty(),
|
|
|
+ Ar.prototype.getBoundingRect.call(this)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ cs.prototype = {
|
|
|
+ constructor: cs,
|
|
|
+ addColorStop: function(t, e) {
|
|
|
+ this.colorStops.push({
|
|
|
+ offset: t,
|
|
|
+ color: e
|
|
|
+ })
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function gs(t, e, i, n, o, a) {
|
|
|
+ this.x = null == t ? 0 : t,
|
|
|
+ this.y = null == e ? 0 : e,
|
|
|
+ this.x2 = null == i ? 1 : i,
|
|
|
+ this.y2 = null == n ? 0 : n,
|
|
|
+ this.type = "linear",
|
|
|
+ this.global = a || !1,
|
|
|
+ cs.call(this, o)
|
|
|
+ }
|
|
|
+ gs.prototype = {
|
|
|
+ constructor: gs
|
|
|
+ },
|
|
|
+ w(gs, cs);
|
|
|
+ function ms(t, e, i, n, o) {
|
|
|
+ this.x = null == t ? .5 : t,
|
|
|
+ this.y = null == e ? .5 : e,
|
|
|
+ this.r = null == i ? .5 : i,
|
|
|
+ this.type = "radial",
|
|
|
+ this.global = o || !1,
|
|
|
+ cs.call(this, n)
|
|
|
+ }
|
|
|
+ function vs(t) {
|
|
|
+ Jn.call(this, t),
|
|
|
+ this._displayables = [],
|
|
|
+ this._temporaryDisplayables = [],
|
|
|
+ this._cursor = 0,
|
|
|
+ this.notClear = !0
|
|
|
+ }
|
|
|
+ ms.prototype = {
|
|
|
+ constructor: ms
|
|
|
+ },
|
|
|
+ w(ms, cs),
|
|
|
+ vs.prototype.incremental = !0,
|
|
|
+ vs.prototype.clearDisplaybles = function() {
|
|
|
+ this._displayables = [],
|
|
|
+ this._temporaryDisplayables = [],
|
|
|
+ this._cursor = 0,
|
|
|
+ this.dirty(),
|
|
|
+ this.notClear = !1
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ vs.prototype.addDisplayable = function(t, e) {
|
|
|
+ e ? this._temporaryDisplayables.push(t) : this._displayables.push(t),
|
|
|
+ this.dirty()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ vs.prototype.addDisplayables = function(t, e) {
|
|
|
+ e = e || !1;
|
|
|
+ for (var i = 0; i < t.length; i++)
|
|
|
+ this.addDisplayable(t[i], e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ vs.prototype.eachPendingDisplayable = function(t) {
|
|
|
+ for (var e = this._cursor; e < this._displayables.length; e++)
|
|
|
+ t && t(this._displayables[e]);
|
|
|
+ for (e = 0; e < this._temporaryDisplayables.length; e++)
|
|
|
+ t && t(this._temporaryDisplayables[e])
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ vs.prototype.update = function() {
|
|
|
+ this.updateTransform();
|
|
|
+ for (var t = this._cursor; t < this._displayables.length; t++) {
|
|
|
+ (e = this._displayables[t]).parent = this,
|
|
|
+ e.update(),
|
|
|
+ e.parent = null
|
|
|
+ }
|
|
|
+ for (t = 0; t < this._temporaryDisplayables.length; t++) {
|
|
|
+ var e;
|
|
|
+ (e = this._temporaryDisplayables[t]).parent = this,
|
|
|
+ e.update(),
|
|
|
+ e.parent = null
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ vs.prototype.brush = function(t, e) {
|
|
|
+ for (var i = this._cursor; i < this._displayables.length; i++) {
|
|
|
+ (n = this._displayables[i]).beforeBrush && n.beforeBrush(t),
|
|
|
+ n.brush(t, i === this._cursor ? null : this._displayables[i - 1]),
|
|
|
+ n.afterBrush && n.afterBrush(t)
|
|
|
+ }
|
|
|
+ this._cursor = i;
|
|
|
+ for (i = 0; i < this._temporaryDisplayables.length; i++) {
|
|
|
+ var n;
|
|
|
+ (n = this._temporaryDisplayables[i]).beforeBrush && n.beforeBrush(t),
|
|
|
+ n.brush(t, 0 === i ? null : this._temporaryDisplayables[i - 1]),
|
|
|
+ n.afterBrush && n.afterBrush(t)
|
|
|
+ }
|
|
|
+ this._temporaryDisplayables = [],
|
|
|
+ this.notClear = !0
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var ys = [];
|
|
|
+ vs.prototype.getBoundingRect = function() {
|
|
|
+ if (!this._rect) {
|
|
|
+ for (var t = new Di(1 / 0,1 / 0,-1 / 0,-1 / 0), e = 0; e < this._displayables.length; e++) {
|
|
|
+ var i = this._displayables[e]
|
|
|
+ , n = i.getBoundingRect().clone();
|
|
|
+ i.needLocalTransform() && n.applyTransform(i.getLocalTransform(ys)),
|
|
|
+ t.union(n)
|
|
|
+ }
|
|
|
+ this._rect = t
|
|
|
+ }
|
|
|
+ return this._rect
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ vs.prototype.contain = function(t, e) {
|
|
|
+ var i = this.transformCoordToLocal(t, e);
|
|
|
+ if (this.getBoundingRect().contain(i[0], i[1]))
|
|
|
+ for (var n = 0; n < this._displayables.length; n++) {
|
|
|
+ if (this._displayables[n].contain(t, e))
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(vs, Jn);
|
|
|
+ var xs = Math.max
|
|
|
+ , _s = Math.min
|
|
|
+ , ws = {}
|
|
|
+ , bs = 1
|
|
|
+ , Ss = {
|
|
|
+ color: "textFill",
|
|
|
+ textBorderColor: "textStroke",
|
|
|
+ textBorderWidth: "textStrokeWidth"
|
|
|
+ }
|
|
|
+ , Ms = "emphasis"
|
|
|
+ , Is = "normal"
|
|
|
+ , Ts = 1
|
|
|
+ , As = {}
|
|
|
+ , Ds = {};
|
|
|
+ function Cs(t) {
|
|
|
+ return Ar.extend(t)
|
|
|
+ }
|
|
|
+ function Ls(t, e) {
|
|
|
+ Ds[t] = e
|
|
|
+ }
|
|
|
+ function ks(t) {
|
|
|
+ if (Ds.hasOwnProperty(t))
|
|
|
+ return Ds[t]
|
|
|
+ }
|
|
|
+ function Ps(t, e, i, n) {
|
|
|
+ var o = Zr(t, e);
|
|
|
+ return i && ("center" === n && (i = Os(i, o.getBoundingRect())),
|
|
|
+ Rs(o, i)),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ function Ns(t, i, n) {
|
|
|
+ var o = new Qn({
|
|
|
+ style: {
|
|
|
+ image: t,
|
|
|
+ x: i.x,
|
|
|
+ y: i.y,
|
|
|
+ width: i.width,
|
|
|
+ height: i.height
|
|
|
+ },
|
|
|
+ onload: function(t) {
|
|
|
+ if ("center" === n) {
|
|
|
+ var e = {
|
|
|
+ width: t.width,
|
|
|
+ height: t.height
|
|
|
+ };
|
|
|
+ o.setStyle(Os(i, e))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ function Os(t, e) {
|
|
|
+ var i, n = e.width / e.height, o = t.height * n;
|
|
|
+ return i = o <= t.width ? t.height : (o = t.width) / n,
|
|
|
+ {
|
|
|
+ x: t.x + t.width / 2 - o / 2,
|
|
|
+ y: t.y + t.height / 2 - i / 2,
|
|
|
+ width: o,
|
|
|
+ height: i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Es = function(t, e) {
|
|
|
+ for (var i = [], n = t.length, o = 0; o < n; o++) {
|
|
|
+ var a = t[o];
|
|
|
+ a.path || a.createPathProxy(),
|
|
|
+ a.__dirtyPath && a.buildPath(a.path, a.shape, !0),
|
|
|
+ i.push(a.path)
|
|
|
+ }
|
|
|
+ var r = new Ar(e);
|
|
|
+ return r.createPathProxy(),
|
|
|
+ r.buildPath = function(t) {
|
|
|
+ t.appendPath(i);
|
|
|
+ var e = t.getContext();
|
|
|
+ e && t.rebuildPath(e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ r
|
|
|
+ };
|
|
|
+ function Rs(t, e) {
|
|
|
+ if (t.applyTransform) {
|
|
|
+ var i = t.getBoundingRect().calculateTransform(e);
|
|
|
+ t.applyTransform(i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var zs = os;
|
|
|
+ function Bs(t) {
|
|
|
+ return null != t && "none" !== t
|
|
|
+ }
|
|
|
+ var Vs = Q()
|
|
|
+ , Gs = 0;
|
|
|
+ function Fs(t) {
|
|
|
+ var e = t.__hoverStl;
|
|
|
+ if (e && !t.__highlighted) {
|
|
|
+ var i = t.__zr
|
|
|
+ , n = t.useHoverLayer && i && "canvas" === i.painter.type;
|
|
|
+ if (t.__highlighted = n ? "layer" : "plain",
|
|
|
+ !(t.isGroup || !i && t.useHoverLayer)) {
|
|
|
+ var o = t
|
|
|
+ , a = t.style;
|
|
|
+ n && (a = (o = i.addHover(t)).style),
|
|
|
+ ll(a),
|
|
|
+ n || function(t) {
|
|
|
+ if (t.__hoverStlDirty) {
|
|
|
+ t.__hoverStlDirty = !1;
|
|
|
+ var e = t.__hoverStl;
|
|
|
+ if (e) {
|
|
|
+ var i = t.__cachedNormalStl = {};
|
|
|
+ t.__cachedNormalZ2 = t.z2;
|
|
|
+ var n = t.style;
|
|
|
+ for (var o in e)
|
|
|
+ null != e[o] && (i[o] = n[o]);
|
|
|
+ i.fill = n.fill,
|
|
|
+ i.stroke = n.stroke
|
|
|
+ } else
|
|
|
+ t.__cachedNormalStl = t.__cachedNormalZ2 = null
|
|
|
+ }
|
|
|
+ }(o),
|
|
|
+ a.extendFrom(e),
|
|
|
+ Ws(a, e, "fill"),
|
|
|
+ Ws(a, e, "stroke"),
|
|
|
+ sl(a),
|
|
|
+ n || (t.dirty(!1),
|
|
|
+ t.z2 += bs)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ws(t, e, i) {
|
|
|
+ !Bs(e[i]) && Bs(t[i]) && (t[i] = function(t) {
|
|
|
+ if ("string" != typeof t)
|
|
|
+ return t;
|
|
|
+ var e = Vs.get(t);
|
|
|
+ return e || (e = He(t, -.1),
|
|
|
+ Gs < 1e4 && (Vs.set(t, e),
|
|
|
+ Gs++)),
|
|
|
+ e
|
|
|
+ }(t[i]))
|
|
|
+ }
|
|
|
+ function Hs(t) {
|
|
|
+ var e = t.__highlighted;
|
|
|
+ if (e && (t.__highlighted = !1,
|
|
|
+ !t.isGroup))
|
|
|
+ if ("layer" === e)
|
|
|
+ t.__zr && t.__zr.removeHover(t);
|
|
|
+ else {
|
|
|
+ var i = t.style
|
|
|
+ , n = t.__cachedNormalStl;
|
|
|
+ n && (ll(i),
|
|
|
+ t.setStyle(n),
|
|
|
+ sl(i));
|
|
|
+ var o = t.__cachedNormalZ2;
|
|
|
+ null != o && t.z2 - o === bs && (t.z2 = o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Zs(t, e, i) {
|
|
|
+ var n, o = Is, a = Is;
|
|
|
+ t.__highlighted && (o = Ms,
|
|
|
+ n = !0),
|
|
|
+ e(t, i),
|
|
|
+ t.__highlighted && (a = Ms,
|
|
|
+ n = !0),
|
|
|
+ t.isGroup && t.traverse(function(t) {
|
|
|
+ t.isGroup || e(t, i)
|
|
|
+ }),
|
|
|
+ n && t.__highDownOnUpdate && t.__highDownOnUpdate(o, a)
|
|
|
+ }
|
|
|
+ function Us(t, e) {
|
|
|
+ e = t.__hoverStl = !1 !== e && (t.hoverStyle || e || {}),
|
|
|
+ t.__hoverStlDirty = !0,
|
|
|
+ t.__highlighted && (t.__cachedNormalStl = null,
|
|
|
+ Hs(t),
|
|
|
+ Fs(t))
|
|
|
+ }
|
|
|
+ function Xs(t) {
|
|
|
+ Ks(this, t) || this.__highByOuter || Zs(this, Fs)
|
|
|
+ }
|
|
|
+ function Ys(t) {
|
|
|
+ Ks(this, t) || this.__highByOuter || Zs(this, Hs)
|
|
|
+ }
|
|
|
+ function js(t) {
|
|
|
+ this.__highByOuter |= 1 << (t || 0),
|
|
|
+ Zs(this, Fs)
|
|
|
+ }
|
|
|
+ function qs(t) {
|
|
|
+ (this.__highByOuter &= ~(1 << (t || 0))) || Zs(this, Hs)
|
|
|
+ }
|
|
|
+ function Ks(t, e) {
|
|
|
+ return t.__highDownSilentOnTouch && e.zrByTouch
|
|
|
+ }
|
|
|
+ function $s(t, e) {
|
|
|
+ Js(t, !0),
|
|
|
+ Zs(t, Us, e)
|
|
|
+ }
|
|
|
+ function Js(t, e) {
|
|
|
+ var i = !1 === e;
|
|
|
+ if (t.__highDownSilentOnTouch = t.highDownSilentOnTouch,
|
|
|
+ t.__highDownOnUpdate = t.highDownOnUpdate,
|
|
|
+ !i || t.__highDownDispatcher) {
|
|
|
+ var n = i ? "off" : "on";
|
|
|
+ t[n]("mouseover", Xs)[n]("mouseout", Ys),
|
|
|
+ t[n]("emphasis", js)[n]("normal", qs),
|
|
|
+ t.__highByOuter = t.__highByOuter || 0,
|
|
|
+ t.__highDownDispatcher = !i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Qs(t) {
|
|
|
+ return !(!t || !t.__highDownDispatcher)
|
|
|
+ }
|
|
|
+ function tl(t) {
|
|
|
+ var e = As[t];
|
|
|
+ return null == e && Ts <= 32 && (e = As[t] = Ts++),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function el(t, e, i, n, o, a, r) {
|
|
|
+ var s, l = (o = o || ws).labelFetcher, u = o.labelDataIndex, h = o.labelDimIndex, c = o.labelProp, d = i.getShallow("show"), f = n.getShallow("show");
|
|
|
+ (d || f) && (l && (s = l.getFormattedLabel(u, "normal", null, h, c)),
|
|
|
+ null == s && (s = C(o.defaultText) ? o.defaultText(u, o) : o.defaultText));
|
|
|
+ var p = d ? s : null
|
|
|
+ , g = f ? H(l ? l.getFormattedLabel(u, "emphasis", null, h, c) : null, s) : null;
|
|
|
+ null == p && null == g || (nl(t, i, a, o),
|
|
|
+ nl(e, n, r, o, !0)),
|
|
|
+ t.text = p,
|
|
|
+ e.text = g
|
|
|
+ }
|
|
|
+ function il(t, e, i) {
|
|
|
+ var n = t.style;
|
|
|
+ e && (ll(n),
|
|
|
+ t.setStyle(e),
|
|
|
+ sl(n)),
|
|
|
+ n = t.__hoverStl,
|
|
|
+ i && n && (ll(n),
|
|
|
+ P(n, i),
|
|
|
+ sl(n))
|
|
|
+ }
|
|
|
+ function nl(t, e, i, n, o) {
|
|
|
+ return ol(t, e, n, o),
|
|
|
+ i && P(t, i),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function ol(t, e, i, n) {
|
|
|
+ if ((i = i || ws).isRectText) {
|
|
|
+ var o;
|
|
|
+ i.getTextPosition ? o = i.getTextPosition(e, n) : "outside" === (o = e.getShallow("position") || (n ? null : "inside")) && (o = "top"),
|
|
|
+ t.textPosition = o,
|
|
|
+ t.textOffset = e.getShallow("offset");
|
|
|
+ var a = e.getShallow("rotate");
|
|
|
+ null != a && (a *= Math.PI / 180),
|
|
|
+ t.textRotation = a,
|
|
|
+ t.textDistance = H(e.getShallow("distance"), n ? null : 5)
|
|
|
+ }
|
|
|
+ var r, s = e.ecModel, l = s && s.option.textStyle, u = function(t) {
|
|
|
+ var e;
|
|
|
+ for (; t && t !== t.ecModel; ) {
|
|
|
+ var i = (t.option || ws).rich;
|
|
|
+ if (i)
|
|
|
+ for (var n in e = e || {},
|
|
|
+ i)
|
|
|
+ i.hasOwnProperty(n) && (e[n] = 1);
|
|
|
+ t = t.parentModel
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }(e);
|
|
|
+ if (u)
|
|
|
+ for (var h in r = {},
|
|
|
+ u)
|
|
|
+ if (u.hasOwnProperty(h)) {
|
|
|
+ var c = e.getModel(["rich", h]);
|
|
|
+ al(r[h] = {}, c, l, i, n)
|
|
|
+ }
|
|
|
+ return t.rich = r,
|
|
|
+ al(t, e, l, i, n, !0),
|
|
|
+ i.forceRich && !i.textStyle && (i.textStyle = {}),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function al(t, e, i, n, o, a) {
|
|
|
+ i = !o && i || ws,
|
|
|
+ t.textFill = rl(e.getShallow("color"), n) || i.color,
|
|
|
+ t.textStroke = rl(e.getShallow("textBorderColor"), n) || i.textBorderColor,
|
|
|
+ t.textStrokeWidth = H(e.getShallow("textBorderWidth"), i.textBorderWidth),
|
|
|
+ o || (a && (t.insideRollbackOpt = n,
|
|
|
+ sl(t)),
|
|
|
+ null == t.textFill && (t.textFill = n.autoColor)),
|
|
|
+ t.fontStyle = e.getShallow("fontStyle") || i.fontStyle,
|
|
|
+ t.fontWeight = e.getShallow("fontWeight") || i.fontWeight,
|
|
|
+ t.fontSize = e.getShallow("fontSize") || i.fontSize,
|
|
|
+ t.fontFamily = e.getShallow("fontFamily") || i.fontFamily,
|
|
|
+ t.textAlign = e.getShallow("align"),
|
|
|
+ t.textVerticalAlign = e.getShallow("verticalAlign") || e.getShallow("baseline"),
|
|
|
+ t.textLineHeight = e.getShallow("lineHeight"),
|
|
|
+ t.textWidth = e.getShallow("width"),
|
|
|
+ t.textHeight = e.getShallow("height"),
|
|
|
+ t.textTag = e.getShallow("tag"),
|
|
|
+ a && n.disableBox || (t.textBackgroundColor = rl(e.getShallow("backgroundColor"), n),
|
|
|
+ t.textPadding = e.getShallow("padding"),
|
|
|
+ t.textBorderColor = rl(e.getShallow("borderColor"), n),
|
|
|
+ t.textBorderWidth = e.getShallow("borderWidth"),
|
|
|
+ t.textBorderRadius = e.getShallow("borderRadius"),
|
|
|
+ t.textBoxShadowColor = e.getShallow("shadowColor"),
|
|
|
+ t.textBoxShadowBlur = e.getShallow("shadowBlur"),
|
|
|
+ t.textBoxShadowOffsetX = e.getShallow("shadowOffsetX"),
|
|
|
+ t.textBoxShadowOffsetY = e.getShallow("shadowOffsetY")),
|
|
|
+ t.textShadowColor = e.getShallow("textShadowColor") || i.textShadowColor,
|
|
|
+ t.textShadowBlur = e.getShallow("textShadowBlur") || i.textShadowBlur,
|
|
|
+ t.textShadowOffsetX = e.getShallow("textShadowOffsetX") || i.textShadowOffsetX,
|
|
|
+ t.textShadowOffsetY = e.getShallow("textShadowOffsetY") || i.textShadowOffsetY
|
|
|
+ }
|
|
|
+ function rl(t, e) {
|
|
|
+ return "auto" !== t ? t : e && e.autoColor ? e.autoColor : null
|
|
|
+ }
|
|
|
+ function sl(t) {
|
|
|
+ var e, i = t.textPosition, n = t.insideRollbackOpt;
|
|
|
+ if (n && null == t.textFill) {
|
|
|
+ var o = n.autoColor
|
|
|
+ , a = n.isRectText
|
|
|
+ , r = n.useInsideStyle
|
|
|
+ , s = !1 !== r && (!0 === r || a && i && "string" == typeof i && 0 <= i.indexOf("inside"))
|
|
|
+ , l = !s && null != o;
|
|
|
+ (s || l) && (e = {
|
|
|
+ textFill: t.textFill,
|
|
|
+ textStroke: t.textStroke,
|
|
|
+ textStrokeWidth: t.textStrokeWidth
|
|
|
+ }),
|
|
|
+ s && (t.textFill = "#fff",
|
|
|
+ null == t.textStroke && (t.textStroke = o,
|
|
|
+ null == t.textStrokeWidth && (t.textStrokeWidth = 2))),
|
|
|
+ l && (t.textFill = o)
|
|
|
+ }
|
|
|
+ t.insideRollback = e
|
|
|
+ }
|
|
|
+ function ll(t) {
|
|
|
+ var e = t.insideRollback;
|
|
|
+ e && (t.textFill = e.textFill,
|
|
|
+ t.textStroke = e.textStroke,
|
|
|
+ t.textStrokeWidth = e.textStrokeWidth,
|
|
|
+ t.insideRollback = null)
|
|
|
+ }
|
|
|
+ function ul(t, e) {
|
|
|
+ var i = e && e.getModel("textStyle");
|
|
|
+ return j([t.fontStyle || i && i.getShallow("fontStyle") || "", t.fontWeight || i && i.getShallow("fontWeight") || "", (t.fontSize || i && i.getShallow("fontSize") || 12) + "px", t.fontFamily || i && i.getShallow("fontFamily") || "sans-serif"].join(" "))
|
|
|
+ }
|
|
|
+ function hl(t, e, i, n, o, a) {
|
|
|
+ if ("function" == typeof o && (a = o,
|
|
|
+ o = null),
|
|
|
+ n && n.isAnimationEnabled()) {
|
|
|
+ var r = t ? "Update" : ""
|
|
|
+ , s = n.getShallow("animationDuration" + r)
|
|
|
+ , l = n.getShallow("animationEasing" + r)
|
|
|
+ , u = n.getShallow("animationDelay" + r);
|
|
|
+ "function" == typeof u && (u = u(o, n.getAnimationDelayParams ? n.getAnimationDelayParams(e, o) : null)),
|
|
|
+ "function" == typeof s && (s = s(o)),
|
|
|
+ 0 < s ? e.animateTo(i, s, u || 0, l, a, !!a) : (e.stopAnimation(),
|
|
|
+ e.attr(i),
|
|
|
+ a && a())
|
|
|
+ } else
|
|
|
+ e.stopAnimation(),
|
|
|
+ e.attr(i),
|
|
|
+ a && a()
|
|
|
+ }
|
|
|
+ function cl(t, e, i, n, o) {
|
|
|
+ hl(!0, t, e, i, n, o)
|
|
|
+ }
|
|
|
+ function dl(t, e, i, n, o) {
|
|
|
+ hl(!1, t, e, i, n, o)
|
|
|
+ }
|
|
|
+ function fl(t, e) {
|
|
|
+ for (var i = re([]); t && t !== e; )
|
|
|
+ le(i, t.getLocalTransform(), i),
|
|
|
+ t = t.parent;
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ function pl(t, e, i) {
|
|
|
+ return e && !N(e) && (e = ve.getLocalTransform(e)),
|
|
|
+ i && (e = de([], e)),
|
|
|
+ bt([], t, e)
|
|
|
+ }
|
|
|
+ function gl(t, e, i) {
|
|
|
+ var n = 0 === e[4] || 0 === e[5] || 0 === e[0] ? 1 : Math.abs(2 * e[4] / e[0])
|
|
|
+ , o = 0 === e[4] || 0 === e[5] || 0 === e[2] ? 1 : Math.abs(2 * e[4] / e[2])
|
|
|
+ , a = ["left" === t ? -n : "right" === t ? n : 0, "top" === t ? -o : "bottom" === t ? o : 0];
|
|
|
+ return a = pl(a, e, i),
|
|
|
+ Math.abs(a[0]) > Math.abs(a[1]) ? 0 < a[0] ? "right" : "left" : 0 < a[1] ? "bottom" : "top"
|
|
|
+ }
|
|
|
+ function ml(t, e, n, i) {
|
|
|
+ if (t && e) {
|
|
|
+ var o, a = (o = {},
|
|
|
+ t.traverse(function(t) {
|
|
|
+ !t.isGroup && t.anid && (o[t.anid] = t)
|
|
|
+ }),
|
|
|
+ o);
|
|
|
+ e.traverse(function(t) {
|
|
|
+ if (!t.isGroup && t.anid) {
|
|
|
+ var e = a[t.anid];
|
|
|
+ if (e) {
|
|
|
+ var i = r(t);
|
|
|
+ t.attr(r(e)),
|
|
|
+ cl(t, i, n, t.dataIndex)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function r(t) {
|
|
|
+ var e = {
|
|
|
+ position: rt(t.position),
|
|
|
+ rotation: t.rotation
|
|
|
+ };
|
|
|
+ return t.shape && (e.shape = P({}, t.shape)),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function vl(t, n) {
|
|
|
+ return O(t, function(t) {
|
|
|
+ var e = t[0];
|
|
|
+ e = xs(e, n.x),
|
|
|
+ e = _s(e, n.x + n.width);
|
|
|
+ var i = t[1];
|
|
|
+ return i = xs(i, n.y),
|
|
|
+ [e, i = _s(i, n.y + n.height)]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function yl(t, e, i) {
|
|
|
+ var n = (e = P({
|
|
|
+ rectHover: !0
|
|
|
+ }, e)).style = {
|
|
|
+ strokeNoScale: !0
|
|
|
+ };
|
|
|
+ if (i = i || {
|
|
|
+ x: -1,
|
|
|
+ y: -1,
|
|
|
+ width: 2,
|
|
|
+ height: 2
|
|
|
+ },
|
|
|
+ t)
|
|
|
+ return 0 === t.indexOf("image://") ? (n.image = t.slice(8),
|
|
|
+ D(n, i),
|
|
|
+ new Qn(e)) : Ps(t.replace("path://", ""), e, i, "center")
|
|
|
+ }
|
|
|
+ function xl(t, e, i, n, o) {
|
|
|
+ for (var a = 0, r = o[o.length - 1]; a < o.length; a++) {
|
|
|
+ var s = o[a];
|
|
|
+ if (_l(t, e, i, n, s[0], s[1], r[0], r[1]))
|
|
|
+ return !0;
|
|
|
+ r = s
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function _l(t, e, i, n, o, a, r, s) {
|
|
|
+ var l = i - t
|
|
|
+ , u = n - e
|
|
|
+ , h = r - o
|
|
|
+ , c = s - a
|
|
|
+ , d = wl(h, c, l, u);
|
|
|
+ if (function(t) {
|
|
|
+ return t <= 1e-6 && -1e-6 <= t
|
|
|
+ }(d))
|
|
|
+ return !1;
|
|
|
+ var f = t - o
|
|
|
+ , p = e - a
|
|
|
+ , g = wl(f, p, l, u) / d;
|
|
|
+ if (g < 0 || 1 < g)
|
|
|
+ return !1;
|
|
|
+ var m = wl(f, p, h, c) / d;
|
|
|
+ return !(m < 0 || 1 < m)
|
|
|
+ }
|
|
|
+ function wl(t, e, i, n) {
|
|
|
+ return t * n - i * e
|
|
|
+ }
|
|
|
+ Ls("circle", Yr),
|
|
|
+ Ls("sector", qr),
|
|
|
+ Ls("ring", Kr),
|
|
|
+ Ls("polygon", Qr),
|
|
|
+ Ls("polyline", ts),
|
|
|
+ Ls("rect", rs),
|
|
|
+ Ls("line", ls),
|
|
|
+ Ls("bezierCurve", ds),
|
|
|
+ Ls("arc", fs);
|
|
|
+ var bl = (Object.freeze || Object)({
|
|
|
+ Z2_EMPHASIS_LIFT: bs,
|
|
|
+ CACHED_LABEL_STYLE_PROPERTIES: Ss,
|
|
|
+ extendShape: Cs,
|
|
|
+ extendPath: function(t, e) {
|
|
|
+ return function(t, e) {
|
|
|
+ return Ar.extend(Hr(t, e))
|
|
|
+ }(t, e)
|
|
|
+ },
|
|
|
+ registerShape: Ls,
|
|
|
+ getShapeClass: ks,
|
|
|
+ makePath: Ps,
|
|
|
+ makeImage: Ns,
|
|
|
+ mergePath: Es,
|
|
|
+ resizePath: Rs,
|
|
|
+ subPixelOptimizeLine: function(t) {
|
|
|
+ return is(t.shape, t.shape, t.style),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ subPixelOptimizeRect: function(t) {
|
|
|
+ return ns(t.shape, t.shape, t.style),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ subPixelOptimize: zs,
|
|
|
+ setElementHoverStyle: Us,
|
|
|
+ setHoverStyle: $s,
|
|
|
+ setAsHighDownDispatcher: Js,
|
|
|
+ isHighDownDispatcher: Qs,
|
|
|
+ getHighlightDigit: tl,
|
|
|
+ setLabelStyle: el,
|
|
|
+ modifyLabelStyle: il,
|
|
|
+ setTextStyle: nl,
|
|
|
+ setText: function(t, e, i) {
|
|
|
+ var n, o = {
|
|
|
+ isRectText: !0
|
|
|
+ };
|
|
|
+ !1 === i ? n = !0 : o.autoColor = i,
|
|
|
+ ol(t, e, o, n)
|
|
|
+ },
|
|
|
+ getFont: ul,
|
|
|
+ updateProps: cl,
|
|
|
+ initProps: dl,
|
|
|
+ getTransform: fl,
|
|
|
+ applyTransform: pl,
|
|
|
+ transformDirection: gl,
|
|
|
+ groupTransition: ml,
|
|
|
+ clipPointsByRect: vl,
|
|
|
+ clipRectByRect: function(t, e) {
|
|
|
+ var i = xs(t.x, e.x)
|
|
|
+ , n = _s(t.x + t.width, e.x + e.width)
|
|
|
+ , o = xs(t.y, e.y)
|
|
|
+ , a = _s(t.y + t.height, e.y + e.height);
|
|
|
+ if (i <= n && o <= a)
|
|
|
+ return {
|
|
|
+ x: i,
|
|
|
+ y: o,
|
|
|
+ width: n - i,
|
|
|
+ height: a - o
|
|
|
+ }
|
|
|
+ },
|
|
|
+ createIcon: yl,
|
|
|
+ linePolygonIntersect: xl,
|
|
|
+ lineLineIntersect: _l,
|
|
|
+ Group: Ci,
|
|
|
+ Image: Qn,
|
|
|
+ Text: Ur,
|
|
|
+ Circle: Yr,
|
|
|
+ Sector: qr,
|
|
|
+ Ring: Kr,
|
|
|
+ Polygon: Qr,
|
|
|
+ Polyline: ts,
|
|
|
+ Rect: rs,
|
|
|
+ Line: ls,
|
|
|
+ BezierCurve: ds,
|
|
|
+ Arc: fs,
|
|
|
+ IncrementalDisplayable: vs,
|
|
|
+ CompoundPath: ps,
|
|
|
+ LinearGradient: gs,
|
|
|
+ RadialGradient: ms,
|
|
|
+ BoundingRect: Di
|
|
|
+ })
|
|
|
+ , Sl = ["textStyle", "color"]
|
|
|
+ , Ml = {
|
|
|
+ getTextColor: function(t) {
|
|
|
+ var e = this.ecModel;
|
|
|
+ return this.getShallow("color") || (!t && e ? e.get(Sl) : null)
|
|
|
+ },
|
|
|
+ getFont: function() {
|
|
|
+ return ul({
|
|
|
+ fontStyle: this.getShallow("fontStyle"),
|
|
|
+ fontWeight: this.getShallow("fontWeight"),
|
|
|
+ fontSize: this.getShallow("fontSize"),
|
|
|
+ fontFamily: this.getShallow("fontFamily")
|
|
|
+ }, this.ecModel)
|
|
|
+ },
|
|
|
+ getTextRect: function(t) {
|
|
|
+ return gn(t, this.getFont(), this.getShallow("align"), this.getShallow("verticalAlign") || this.getShallow("baseline"), this.getShallow("padding"), this.getShallow("lineHeight"), this.getShallow("rich"), this.getShallow("truncateText"))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Il = ha([["fill", "color"], ["stroke", "borderColor"], ["lineWidth", "borderWidth"], ["opacity"], ["shadowBlur"], ["shadowOffsetX"], ["shadowOffsetY"], ["shadowColor"], ["textPosition"], ["textAlign"]])
|
|
|
+ , Tl = {
|
|
|
+ getItemStyle: function(t, e) {
|
|
|
+ var i = Il(this, t, e)
|
|
|
+ , n = this.getBorderLineDash();
|
|
|
+ return n && (i.lineDash = n),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ getBorderLineDash: function() {
|
|
|
+ var t = this.get("borderType");
|
|
|
+ return "solid" === t || null == t ? null : "dashed" === t ? [5, 5] : [1, 1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Al = b
|
|
|
+ , Dl = jo();
|
|
|
+ function Cl(t, e, i) {
|
|
|
+ this.parentModel = e,
|
|
|
+ this.ecModel = i,
|
|
|
+ this.option = t
|
|
|
+ }
|
|
|
+ function Ll(t, e, i) {
|
|
|
+ for (var n = 0; n < e.length && (!e[n] || null != (t = t && "object" == typeof t ? t[e[n]] : null)); n++)
|
|
|
+ ;
|
|
|
+ return null == t && i && (t = i.get(e)),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function kl(t, e) {
|
|
|
+ var i = Dl(t).getParent;
|
|
|
+ return i ? i.call(t, e) : t.parentModel
|
|
|
+ }
|
|
|
+ Cl.prototype = {
|
|
|
+ constructor: Cl,
|
|
|
+ init: null,
|
|
|
+ mergeOption: function(t) {
|
|
|
+ m(this.option, t, !0)
|
|
|
+ },
|
|
|
+ get: function(t, e) {
|
|
|
+ return null == t ? this.option : Ll(this.option, this.parsePath(t), !e && kl(this, t))
|
|
|
+ },
|
|
|
+ getShallow: function(t, e) {
|
|
|
+ var i = this.option
|
|
|
+ , n = null == i ? i : i[t]
|
|
|
+ , o = !e && kl(this, t);
|
|
|
+ return null == n && o && (n = o.getShallow(t)),
|
|
|
+ n
|
|
|
+ },
|
|
|
+ getModel: function(t, e) {
|
|
|
+ var i;
|
|
|
+ return new Cl(null == t ? this.option : Ll(this.option, t = this.parsePath(t)),e = e || (i = kl(this, t)) && i.getModel(t),this.ecModel)
|
|
|
+ },
|
|
|
+ isEmpty: function() {
|
|
|
+ return null == this.option
|
|
|
+ },
|
|
|
+ restoreData: function() {},
|
|
|
+ clone: function() {
|
|
|
+ return new this.constructor(k(this.option))
|
|
|
+ },
|
|
|
+ setReadOnly: function(t) {},
|
|
|
+ parsePath: function(t) {
|
|
|
+ return "string" == typeof t && (t = t.split(".")),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ customizeGetParent: function(t) {
|
|
|
+ Dl(this).getParent = t
|
|
|
+ },
|
|
|
+ isAnimationEnabled: function() {
|
|
|
+ if (!v.node) {
|
|
|
+ if (null != this.option.animation)
|
|
|
+ return !!this.option.animation;
|
|
|
+ if (this.parentModel)
|
|
|
+ return this.parentModel.isAnimationEnabled()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ oa(Cl),
|
|
|
+ ra(Cl),
|
|
|
+ Al(Cl, da),
|
|
|
+ Al(Cl, pa),
|
|
|
+ Al(Cl, Ml),
|
|
|
+ Al(Cl, Tl);
|
|
|
+ var Pl = 0;
|
|
|
+ function Nl(t) {
|
|
|
+ return [t || "", Pl++, Math.random().toFixed(5)].join("_")
|
|
|
+ }
|
|
|
+ var Ol = 1e-4;
|
|
|
+ function El(t, e, i, n) {
|
|
|
+ var o = e[1] - e[0]
|
|
|
+ , a = i[1] - i[0];
|
|
|
+ if (0 == o)
|
|
|
+ return 0 == a ? i[0] : (i[0] + i[1]) / 2;
|
|
|
+ if (n)
|
|
|
+ if (0 < o) {
|
|
|
+ if (t <= e[0])
|
|
|
+ return i[0];
|
|
|
+ if (t >= e[1])
|
|
|
+ return i[1]
|
|
|
+ } else {
|
|
|
+ if (t >= e[0])
|
|
|
+ return i[0];
|
|
|
+ if (t <= e[1])
|
|
|
+ return i[1]
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ if (t === e[0])
|
|
|
+ return i[0];
|
|
|
+ if (t === e[1])
|
|
|
+ return i[1]
|
|
|
+ }
|
|
|
+ return (t - e[0]) / o * a + i[0]
|
|
|
+ }
|
|
|
+ function Rl(t, e) {
|
|
|
+ switch (t) {
|
|
|
+ case "center":
|
|
|
+ case "middle":
|
|
|
+ t = "50%";
|
|
|
+ break;
|
|
|
+ case "left":
|
|
|
+ case "top":
|
|
|
+ t = "0%";
|
|
|
+ break;
|
|
|
+ case "right":
|
|
|
+ case "bottom":
|
|
|
+ t = "100%"
|
|
|
+ }
|
|
|
+ return "string" == typeof t ? function(t) {
|
|
|
+ return t.replace(/^\s+|\s+$/g, "")
|
|
|
+ }(t).match(/%$/) ? parseFloat(t) / 100 * e : parseFloat(t) : null == t ? NaN : +t
|
|
|
+ }
|
|
|
+ function zl(t, e, i) {
|
|
|
+ return null == e && (e = 10),
|
|
|
+ e = Math.min(Math.max(0, e), 20),
|
|
|
+ t = (+t).toFixed(e),
|
|
|
+ i ? t : +t
|
|
|
+ }
|
|
|
+ function Bl(t) {
|
|
|
+ return t.sort(function(t, e) {
|
|
|
+ return t - e
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function Vl(t) {
|
|
|
+ if (t = +t,
|
|
|
+ isNaN(t))
|
|
|
+ return 0;
|
|
|
+ for (var e = 1, i = 0; Math.round(t * e) / e !== t; )
|
|
|
+ e *= 10,
|
|
|
+ i++;
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ function Gl(t) {
|
|
|
+ var e = t.toString()
|
|
|
+ , i = e.indexOf("e");
|
|
|
+ if (0 < i) {
|
|
|
+ var n = +e.slice(i + 1);
|
|
|
+ return n < 0 ? -n : 0
|
|
|
+ }
|
|
|
+ var o = e.indexOf(".");
|
|
|
+ return o < 0 ? 0 : e.length - 1 - o
|
|
|
+ }
|
|
|
+ function Fl(t, e) {
|
|
|
+ var i = Math.log
|
|
|
+ , n = Math.LN10
|
|
|
+ , o = Math.floor(i(t[1] - t[0]) / n)
|
|
|
+ , a = Math.round(i(Math.abs(e[1] - e[0])) / n)
|
|
|
+ , r = Math.min(Math.max(-o + a, 0), 20);
|
|
|
+ return isFinite(r) ? r : 20
|
|
|
+ }
|
|
|
+ function Wl(t, e, i) {
|
|
|
+ if (!t[e])
|
|
|
+ return 0;
|
|
|
+ var n = S(t, function(t, e) {
|
|
|
+ return t + (isNaN(e) ? 0 : e)
|
|
|
+ }, 0);
|
|
|
+ if (0 === n)
|
|
|
+ return 0;
|
|
|
+ for (var o = Math.pow(10, i), a = O(t, function(t) {
|
|
|
+ return (isNaN(t) ? 0 : t) / n * o * 100
|
|
|
+ }), r = 100 * o, s = O(a, function(t) {
|
|
|
+ return Math.floor(t)
|
|
|
+ }), l = S(s, function(t, e) {
|
|
|
+ return t + e
|
|
|
+ }, 0), u = O(a, function(t, e) {
|
|
|
+ return t - s[e]
|
|
|
+ }); l < r; ) {
|
|
|
+ for (var h = Number.NEGATIVE_INFINITY, c = null, d = 0, f = u.length; d < f; ++d)
|
|
|
+ u[d] > h && (h = u[d],
|
|
|
+ c = d);
|
|
|
+ ++s[c],
|
|
|
+ u[c] = 0,
|
|
|
+ ++l
|
|
|
+ }
|
|
|
+ return s[e] / o
|
|
|
+ }
|
|
|
+ var Hl = 9007199254740991;
|
|
|
+ function Zl(t) {
|
|
|
+ var e = 2 * Math.PI;
|
|
|
+ return (t % e + e) % e
|
|
|
+ }
|
|
|
+ function Ul(t) {
|
|
|
+ return -Ol < t && t < Ol
|
|
|
+ }
|
|
|
+ var Xl = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d\d)(?::(\d\d)(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/;
|
|
|
+ function Yl(t) {
|
|
|
+ if (t instanceof Date)
|
|
|
+ return t;
|
|
|
+ if ("string" != typeof t)
|
|
|
+ return null == t ? new Date(NaN) : new Date(Math.round(t));
|
|
|
+ var e = Xl.exec(t);
|
|
|
+ if (!e)
|
|
|
+ return new Date(NaN);
|
|
|
+ if (e[8]) {
|
|
|
+ var i = +e[4] || 0;
|
|
|
+ return "Z" !== e[8].toUpperCase() && (i -= e[8].slice(0, 3)),
|
|
|
+ new Date(Date.UTC(+e[1], +(e[2] || 1) - 1, +e[3] || 1, i, +(e[5] || 0), +e[6] || 0, +e[7] || 0))
|
|
|
+ }
|
|
|
+ return new Date(+e[1],+(e[2] || 1) - 1,+e[3] || 1,+e[4] || 0,+(e[5] || 0),+e[6] || 0,+e[7] || 0)
|
|
|
+ }
|
|
|
+ function jl(t) {
|
|
|
+ return Math.pow(10, ql(t))
|
|
|
+ }
|
|
|
+ function ql(t) {
|
|
|
+ if (0 === t)
|
|
|
+ return 0;
|
|
|
+ var e = Math.floor(Math.log(t) / Math.LN10);
|
|
|
+ return 10 <= t / Math.pow(10, e) && e++,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function Kl(t, e) {
|
|
|
+ var i = ql(t)
|
|
|
+ , n = Math.pow(10, i)
|
|
|
+ , o = t / n;
|
|
|
+ return t = (e ? o < 1.5 ? 1 : o < 2.5 ? 2 : o < 4 ? 3 : o < 7 ? 5 : 10 : o < 1 ? 1 : o < 2 ? 2 : o < 3 ? 3 : o < 5 ? 5 : 10) * n,
|
|
|
+ -20 <= i ? +t.toFixed(i < 0 ? -i : 0) : t
|
|
|
+ }
|
|
|
+ function $l(t) {
|
|
|
+ t.sort(function(t, e) {
|
|
|
+ return function t(e, i, n) {
|
|
|
+ return e.interval[n] < i.interval[n] || e.interval[n] === i.interval[n] && (e.close[n] - i.close[n] == (n ? -1 : 1) || !n && t(e, i, 1))
|
|
|
+ }(t, e, 0) ? -1 : 1
|
|
|
+ });
|
|
|
+ for (var e = -1 / 0, i = 1, n = 0; n < t.length; ) {
|
|
|
+ for (var o = t[n].interval, a = t[n].close, r = 0; r < 2; r++)
|
|
|
+ o[r] <= e && (o[r] = e,
|
|
|
+ a[r] = r ? 1 : 1 - i),
|
|
|
+ e = o[r],
|
|
|
+ i = a[r];
|
|
|
+ o[0] === o[1] && a[0] * a[1] != 1 ? t.splice(n, 1) : n++
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function Jl(t) {
|
|
|
+ return 0 <= t - parseFloat(t)
|
|
|
+ }
|
|
|
+ var Ql = (Object.freeze || Object)({
|
|
|
+ linearMap: El,
|
|
|
+ parsePercent: Rl,
|
|
|
+ round: zl,
|
|
|
+ asc: Bl,
|
|
|
+ getPrecision: Vl,
|
|
|
+ getPrecisionSafe: Gl,
|
|
|
+ getPixelPrecision: Fl,
|
|
|
+ getPercentWithPrecision: Wl,
|
|
|
+ MAX_SAFE_INTEGER: Hl,
|
|
|
+ remRadian: Zl,
|
|
|
+ isRadianAroundZero: Ul,
|
|
|
+ parseDate: Yl,
|
|
|
+ quantity: jl,
|
|
|
+ quantityExponent: ql,
|
|
|
+ nice: Kl,
|
|
|
+ quantile: function(t, e) {
|
|
|
+ var i = (t.length - 1) * e + 1
|
|
|
+ , n = Math.floor(i)
|
|
|
+ , o = +t[n - 1]
|
|
|
+ , a = i - n;
|
|
|
+ return a ? o + a * (t[n] - o) : o
|
|
|
+ },
|
|
|
+ reformIntervals: $l,
|
|
|
+ isNumeric: Jl
|
|
|
+ });
|
|
|
+ function tu(t) {
|
|
|
+ return isNaN(t) ? "-" : (t = (t + "").split("."))[0].replace(/(\d{1,3})(?=(?:\d{3})+(?!\d))/g, "$1,") + (1 < t.length ? "." + t[1] : "")
|
|
|
+ }
|
|
|
+ function eu(t, e) {
|
|
|
+ return t = (t || "").toLowerCase().replace(/-(.)/g, function(t, e) {
|
|
|
+ return e.toUpperCase()
|
|
|
+ }),
|
|
|
+ e && t && (t = t.charAt(0).toUpperCase() + t.slice(1)),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ var iu = X
|
|
|
+ , nu = /([&<>"'])/g
|
|
|
+ , ou = {
|
|
|
+ "&": "&",
|
|
|
+ "<": "<",
|
|
|
+ ">": ">",
|
|
|
+ '"': """,
|
|
|
+ "'": "'"
|
|
|
+ };
|
|
|
+ function au(t) {
|
|
|
+ return null == t ? "" : (t + "").replace(nu, function(t, e) {
|
|
|
+ return ou[e]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function ru(t, e) {
|
|
|
+ return "{" + t + (null == e ? "" : e) + "}"
|
|
|
+ }
|
|
|
+ var su = ["a", "b", "c", "d", "e", "f", "g"];
|
|
|
+ function lu(t, e, i) {
|
|
|
+ L(e) || (e = [e]);
|
|
|
+ var n = e.length;
|
|
|
+ if (!n)
|
|
|
+ return "";
|
|
|
+ for (var o = e[0].$vars || [], a = 0; a < o.length; a++) {
|
|
|
+ var r = su[a];
|
|
|
+ t = t.replace(ru(r), ru(r, 0))
|
|
|
+ }
|
|
|
+ for (var s = 0; s < n; s++)
|
|
|
+ for (var l = 0; l < o.length; l++) {
|
|
|
+ var u = e[s][o[l]];
|
|
|
+ t = t.replace(ru(su[l], s), i ? au(u) : u)
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function uu(i, t, n) {
|
|
|
+ return E(t, function(t, e) {
|
|
|
+ i = i.replace("{" + e + "}", n ? au(t) : t)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function hu(t, e) {
|
|
|
+ var i = (t = R(t) ? {
|
|
|
+ color: t,
|
|
|
+ extraCssText: e
|
|
|
+ } : t || {}).color
|
|
|
+ , n = t.type
|
|
|
+ , o = (e = t.extraCssText,
|
|
|
+ t.renderMode || "html")
|
|
|
+ , a = t.markerId || "X";
|
|
|
+ return i ? "html" === o ? "subItem" === n ? '<span style="display:inline-block;vertical-align:middle;margin-right:8px;margin-left:3px;border-radius:4px;width:4px;height:4px;background-color:' + au(i) + ";" + (e || "") + '"></span>' : '<span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:' + au(i) + ";" + (e || "") + '"></span>' : {
|
|
|
+ renderMode: o,
|
|
|
+ content: "{marker" + a + "|} ",
|
|
|
+ style: {
|
|
|
+ color: i
|
|
|
+ }
|
|
|
+ } : ""
|
|
|
+ }
|
|
|
+ function cu(t, e) {
|
|
|
+ return "0000".substr(0, e - (t += "").length) + t
|
|
|
+ }
|
|
|
+ function du(t, e, i) {
|
|
|
+ "week" !== t && "month" !== t && "quarter" !== t && "half-year" !== t && "year" !== t || (t = "MM-dd\nyyyy");
|
|
|
+ var n = Yl(e)
|
|
|
+ , o = i ? "UTC" : ""
|
|
|
+ , a = n["get" + o + "FullYear"]()
|
|
|
+ , r = n["get" + o + "Month"]() + 1
|
|
|
+ , s = n["get" + o + "Date"]()
|
|
|
+ , l = n["get" + o + "Hours"]()
|
|
|
+ , u = n["get" + o + "Minutes"]()
|
|
|
+ , h = n["get" + o + "Seconds"]()
|
|
|
+ , c = n["get" + o + "Milliseconds"]();
|
|
|
+ return t = t.replace("MM", cu(r, 2)).replace("M", r).replace("yyyy", a).replace("yy", a % 100).replace("dd", cu(s, 2)).replace("d", s).replace("hh", cu(l, 2)).replace("h", l).replace("mm", cu(u, 2)).replace("m", u).replace("ss", cu(h, 2)).replace("s", h).replace("SSS", cu(c, 3))
|
|
|
+ }
|
|
|
+ function fu(t) {
|
|
|
+ return t ? t.charAt(0).toUpperCase() + t.substr(1) : t
|
|
|
+ }
|
|
|
+ var pu = xn;
|
|
|
+ function gu(t, e) {
|
|
|
+ if ("_blank" === e || "blank" === e) {
|
|
|
+ var i = window.open();
|
|
|
+ i.opener = null,
|
|
|
+ i.location = t
|
|
|
+ } else
|
|
|
+ window.open(t, e)
|
|
|
+ }
|
|
|
+ var mu = (Object.freeze || Object)({
|
|
|
+ addCommas: tu,
|
|
|
+ toCamelCase: eu,
|
|
|
+ normalizeCssArray: iu,
|
|
|
+ encodeHTML: au,
|
|
|
+ formatTpl: lu,
|
|
|
+ formatTplSimple: uu,
|
|
|
+ getTooltipMarker: hu,
|
|
|
+ formatTime: du,
|
|
|
+ capitalFirst: fu,
|
|
|
+ truncateText: pu,
|
|
|
+ getTextBoundingRect: function(t) {
|
|
|
+ return gn(t.text, t.font, t.textAlign, t.textVerticalAlign, t.textPadding, t.textLineHeight, t.rich, t.truncate)
|
|
|
+ },
|
|
|
+ getTextRect: function(t, e, i, n, o, a, r, s) {
|
|
|
+ return gn(t, e, i, n, o, s, a, r)
|
|
|
+ },
|
|
|
+ windowOpen: gu
|
|
|
+ })
|
|
|
+ , vu = E
|
|
|
+ , yu = ["left", "right", "top", "bottom", "width", "height"]
|
|
|
+ , xu = [["width", "left", "right"], ["height", "top", "bottom"]];
|
|
|
+ function _u(h, c, d, f, p) {
|
|
|
+ var g = 0
|
|
|
+ , m = 0;
|
|
|
+ null == f && (f = 1 / 0),
|
|
|
+ null == p && (p = 1 / 0);
|
|
|
+ var v = 0;
|
|
|
+ c.eachChild(function(t, e) {
|
|
|
+ var i, n, o = t.position, a = t.getBoundingRect(), r = c.childAt(e + 1), s = r && r.getBoundingRect();
|
|
|
+ if ("horizontal" === h) {
|
|
|
+ var l = a.width + (s ? -s.x + a.x : 0);
|
|
|
+ v = f < (i = g + l) || t.newline ? (g = 0,
|
|
|
+ i = l,
|
|
|
+ m += v + d,
|
|
|
+ a.height) : Math.max(v, a.height)
|
|
|
+ } else {
|
|
|
+ var u = a.height + (s ? -s.y + a.y : 0);
|
|
|
+ v = p < (n = m + u) || t.newline ? (g += v + d,
|
|
|
+ m = 0,
|
|
|
+ n = u,
|
|
|
+ a.width) : Math.max(v, a.width)
|
|
|
+ }
|
|
|
+ t.newline || (o[0] = g,
|
|
|
+ o[1] = m,
|
|
|
+ "horizontal" === h ? g = i + d : m = n + d)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var wu = _u;
|
|
|
+ T(_u, "vertical"),
|
|
|
+ T(_u, "horizontal");
|
|
|
+ function bu(t, e, i) {
|
|
|
+ i = iu(i || 0);
|
|
|
+ var n = e.width
|
|
|
+ , o = e.height
|
|
|
+ , a = Rl(t.left, n)
|
|
|
+ , r = Rl(t.top, o)
|
|
|
+ , s = Rl(t.right, n)
|
|
|
+ , l = Rl(t.bottom, o)
|
|
|
+ , u = Rl(t.width, n)
|
|
|
+ , h = Rl(t.height, o)
|
|
|
+ , c = i[2] + i[0]
|
|
|
+ , d = i[1] + i[3]
|
|
|
+ , f = t.aspect;
|
|
|
+ switch (isNaN(u) && (u = n - s - d - a),
|
|
|
+ isNaN(h) && (h = o - l - c - r),
|
|
|
+ null != f && (isNaN(u) && isNaN(h) && (n / o < f ? u = .8 * n : h = .8 * o),
|
|
|
+ isNaN(u) && (u = f * h),
|
|
|
+ isNaN(h) && (h = u / f)),
|
|
|
+ isNaN(a) && (a = n - s - u - d),
|
|
|
+ isNaN(r) && (r = o - l - h - c),
|
|
|
+ t.left || t.right) {
|
|
|
+ case "center":
|
|
|
+ a = n / 2 - u / 2 - i[3];
|
|
|
+ break;
|
|
|
+ case "right":
|
|
|
+ a = n - u - d
|
|
|
+ }
|
|
|
+ switch (t.top || t.bottom) {
|
|
|
+ case "middle":
|
|
|
+ case "center":
|
|
|
+ r = o / 2 - h / 2 - i[0];
|
|
|
+ break;
|
|
|
+ case "bottom":
|
|
|
+ r = o - h - c
|
|
|
+ }
|
|
|
+ a = a || 0,
|
|
|
+ r = r || 0,
|
|
|
+ isNaN(u) && (u = n - d - a - (s || 0)),
|
|
|
+ isNaN(h) && (h = o - c - r - (l || 0));
|
|
|
+ var p = new Di(a + i[3],r + i[0],u,h);
|
|
|
+ return p.margin = i,
|
|
|
+ p
|
|
|
+ }
|
|
|
+ function Su(t, e, i, n, o) {
|
|
|
+ var a = !o || !o.hv || o.hv[0]
|
|
|
+ , r = !o || !o.hv || o.hv[1]
|
|
|
+ , s = o && o.boundingMode || "all";
|
|
|
+ if (a || r) {
|
|
|
+ var l;
|
|
|
+ if ("raw" === s)
|
|
|
+ l = "group" === t.type ? new Di(0,0,+e.width || 0,+e.height || 0) : t.getBoundingRect();
|
|
|
+ else if (l = t.getBoundingRect(),
|
|
|
+ t.needLocalTransform()) {
|
|
|
+ var u = t.getLocalTransform();
|
|
|
+ (l = l.clone()).applyTransform(u)
|
|
|
+ }
|
|
|
+ e = bu(D({
|
|
|
+ width: l.width,
|
|
|
+ height: l.height
|
|
|
+ }, e), i, n);
|
|
|
+ var h = t.position
|
|
|
+ , c = a ? e.x - l.x : 0
|
|
|
+ , d = r ? e.y - l.y : 0;
|
|
|
+ t.attr("position", "raw" === s ? [c, d] : [h[0] + c, h[1] + d])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Mu(l, u, t) {
|
|
|
+ z(t) || (t = {});
|
|
|
+ var h = t.ignoreSize;
|
|
|
+ L(h) || (h = [h, h]);
|
|
|
+ var e = n(xu[0], 0)
|
|
|
+ , i = n(xu[1], 1);
|
|
|
+ function n(t, e) {
|
|
|
+ var i = {}
|
|
|
+ , n = 0
|
|
|
+ , o = {}
|
|
|
+ , a = 0;
|
|
|
+ if (vu(t, function(t) {
|
|
|
+ o[t] = l[t]
|
|
|
+ }),
|
|
|
+ vu(t, function(t) {
|
|
|
+ c(u, t) && (i[t] = o[t] = u[t]),
|
|
|
+ d(i, t) && n++,
|
|
|
+ d(o, t) && a++
|
|
|
+ }),
|
|
|
+ h[e])
|
|
|
+ return d(u, t[1]) ? o[t[2]] = null : d(u, t[2]) && (o[t[1]] = null),
|
|
|
+ o;
|
|
|
+ if (2 !== a && n) {
|
|
|
+ if (2 <= n)
|
|
|
+ return i;
|
|
|
+ for (var r = 0; r < t.length; r++) {
|
|
|
+ var s = t[r];
|
|
|
+ if (!c(i, s) && c(l, s)) {
|
|
|
+ i[s] = l[s];
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ function c(t, e) {
|
|
|
+ return t.hasOwnProperty(e)
|
|
|
+ }
|
|
|
+ function d(t, e) {
|
|
|
+ return null != t[e] && "auto" !== t[e]
|
|
|
+ }
|
|
|
+ function o(t, e, i) {
|
|
|
+ vu(t, function(t) {
|
|
|
+ e[t] = i[t]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ o(xu[0], l, e),
|
|
|
+ o(xu[1], l, i)
|
|
|
+ }
|
|
|
+ function Iu(t) {
|
|
|
+ return Tu({}, t)
|
|
|
+ }
|
|
|
+ function Tu(e, i) {
|
|
|
+ return i && e && vu(yu, function(t) {
|
|
|
+ i.hasOwnProperty(t) && (e[t] = i[t])
|
|
|
+ }),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ var Au, Du, Cu, Lu = jo(), ku = Cl.extend({
|
|
|
+ type: "component",
|
|
|
+ id: "",
|
|
|
+ name: "",
|
|
|
+ mainType: "",
|
|
|
+ subType: "",
|
|
|
+ componentIndex: 0,
|
|
|
+ defaultOption: null,
|
|
|
+ ecModel: null,
|
|
|
+ dependentModels: [],
|
|
|
+ uid: null,
|
|
|
+ layoutMode: null,
|
|
|
+ $constructor: function(t, e, i, n) {
|
|
|
+ Cl.call(this, t, e, i, n),
|
|
|
+ this.uid = Nl("ec_cpt_model")
|
|
|
+ },
|
|
|
+ init: function(t, e, i, n) {
|
|
|
+ this.mergeDefaultAndTheme(t, i)
|
|
|
+ },
|
|
|
+ mergeDefaultAndTheme: function(t, e) {
|
|
|
+ var i = this.layoutMode
|
|
|
+ , n = i ? Iu(t) : {};
|
|
|
+ m(t, e.getTheme().get(this.mainType)),
|
|
|
+ m(t, this.getDefaultOption()),
|
|
|
+ i && Mu(t, n, i)
|
|
|
+ },
|
|
|
+ mergeOption: function(t, e) {
|
|
|
+ m(this.option, t, !0);
|
|
|
+ var i = this.layoutMode;
|
|
|
+ i && Mu(this.option, t, i)
|
|
|
+ },
|
|
|
+ optionUpdated: function(t, e) {},
|
|
|
+ getDefaultOption: function() {
|
|
|
+ var t = Lu(this);
|
|
|
+ if (!t.defaultOption) {
|
|
|
+ for (var e = [], i = this.constructor; i; ) {
|
|
|
+ var n = i.prototype.defaultOption;
|
|
|
+ n && e.push(n),
|
|
|
+ i = i.superClass
|
|
|
+ }
|
|
|
+ for (var o = {}, a = e.length - 1; 0 <= a; a--)
|
|
|
+ o = m(o, e[a], !0);
|
|
|
+ t.defaultOption = o
|
|
|
+ }
|
|
|
+ return t.defaultOption
|
|
|
+ },
|
|
|
+ getReferringComponents: function(t) {
|
|
|
+ return this.ecModel.queryComponents({
|
|
|
+ mainType: t,
|
|
|
+ index: this.get(t + "Index", !0),
|
|
|
+ id: this.get(t + "Id", !0)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function Pu(t, e) {
|
|
|
+ return t[e] || (t[e] = {
|
|
|
+ predecessor: [],
|
|
|
+ successor: []
|
|
|
+ }),
|
|
|
+ t[e]
|
|
|
+ }
|
|
|
+ ua(ku, {
|
|
|
+ registerWhenExtend: !0
|
|
|
+ }),
|
|
|
+ Du = {},
|
|
|
+ (Au = ku).registerSubTypeDefaulter = function(t, e) {
|
|
|
+ t = na(t),
|
|
|
+ Du[t.main] = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Au.determineSubType = function(t, e) {
|
|
|
+ var i = e.type;
|
|
|
+ if (!i) {
|
|
|
+ var n = na(t).main;
|
|
|
+ Au.hasSubTypes(t) && Du[n] && (i = Du[n](e))
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Cu = function(t) {
|
|
|
+ var e = [];
|
|
|
+ E(ku.getClassesByMainType(t), function(t) {
|
|
|
+ e = e.concat(t.prototype.dependencies || [])
|
|
|
+ }),
|
|
|
+ e = O(e, function(t) {
|
|
|
+ return na(t).main
|
|
|
+ }),
|
|
|
+ "dataset" !== t && _(e, "dataset") <= 0 && e.unshift("dataset");
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ku.topologicalTravel = function(t, e, i, n) {
|
|
|
+ if (t.length) {
|
|
|
+ var o = function(e) {
|
|
|
+ var o = {}
|
|
|
+ , a = [];
|
|
|
+ return E(e, function(i) {
|
|
|
+ var n = Pu(o, i)
|
|
|
+ , t = function(t, e) {
|
|
|
+ var i = [];
|
|
|
+ return E(t, function(t) {
|
|
|
+ 0 <= _(e, t) && i.push(t)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }(n.originalDeps = Cu(i), e);
|
|
|
+ n.entryCount = t.length,
|
|
|
+ 0 === n.entryCount && a.push(i),
|
|
|
+ E(t, function(t) {
|
|
|
+ _(n.predecessor, t) < 0 && n.predecessor.push(t);
|
|
|
+ var e = Pu(o, t);
|
|
|
+ _(e.successor, t) < 0 && e.successor.push(i)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ graph: o,
|
|
|
+ noEntryList: a
|
|
|
+ }
|
|
|
+ }(e)
|
|
|
+ , a = o.graph
|
|
|
+ , r = o.noEntryList
|
|
|
+ , s = {};
|
|
|
+ for (E(t, function(t) {
|
|
|
+ s[t] = !0
|
|
|
+ }); r.length; ) {
|
|
|
+ var l = r.pop()
|
|
|
+ , u = a[l]
|
|
|
+ , h = !!s[l];
|
|
|
+ h && (i.call(n, l, u.originalDeps.slice()),
|
|
|
+ delete s[l]),
|
|
|
+ E(u.successor, h ? d : c)
|
|
|
+ }
|
|
|
+ E(s, function() {
|
|
|
+ throw new Error("Circle dependency may exists")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function c(t) {
|
|
|
+ a[t].entryCount--,
|
|
|
+ 0 === a[t].entryCount && r.push(t)
|
|
|
+ }
|
|
|
+ function d(t) {
|
|
|
+ s[t] = !0,
|
|
|
+ c(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ b(ku, {
|
|
|
+ getBoxLayoutParams: function() {
|
|
|
+ return {
|
|
|
+ left: this.get("left"),
|
|
|
+ top: this.get("top"),
|
|
|
+ right: this.get("right"),
|
|
|
+ bottom: this.get("bottom"),
|
|
|
+ width: this.get("width"),
|
|
|
+ height: this.get("height")
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var Nu = "";
|
|
|
+ "undefined" != typeof navigator && (Nu = navigator.platform || "");
|
|
|
+ var Ou = {
|
|
|
+ color: ["#c23531", "#2f4554", "#61a0a8", "#d48265", "#91c7ae", "#749f83", "#ca8622", "#bda29a", "#6e7074", "#546570", "#c4ccd3"],
|
|
|
+ gradientColor: ["#f6efa6", "#d88273", "#bf444c"],
|
|
|
+ textStyle: {
|
|
|
+ fontFamily: Nu.match(/^Win/) ? "Microsoft YaHei" : "sans-serif",
|
|
|
+ fontSize: 12,
|
|
|
+ fontStyle: "normal",
|
|
|
+ fontWeight: "normal"
|
|
|
+ },
|
|
|
+ blendMode: null,
|
|
|
+ animation: "auto",
|
|
|
+ animationDuration: 1e3,
|
|
|
+ animationDurationUpdate: 300,
|
|
|
+ animationEasing: "exponentialOut",
|
|
|
+ animationEasingUpdate: "cubicOut",
|
|
|
+ animationThreshold: 2e3,
|
|
|
+ progressiveThreshold: 3e3,
|
|
|
+ progressive: 400,
|
|
|
+ hoverLayerThreshold: 3e3,
|
|
|
+ useUTC: !1
|
|
|
+ }
|
|
|
+ , Eu = jo();
|
|
|
+ var Ru = {
|
|
|
+ clearColorPalette: function() {
|
|
|
+ Eu(this).colorIdx = 0,
|
|
|
+ Eu(this).colorNameMap = {}
|
|
|
+ },
|
|
|
+ getColorFromPalette: function(t, e, i) {
|
|
|
+ var n = Eu(e = e || this)
|
|
|
+ , o = n.colorIdx || 0
|
|
|
+ , a = n.colorNameMap = n.colorNameMap || {};
|
|
|
+ if (a.hasOwnProperty(t))
|
|
|
+ return a[t];
|
|
|
+ var r = Vo(this.get("color", !0))
|
|
|
+ , s = this.get("colorLayer", !0)
|
|
|
+ , l = null != i && s ? function(t, e) {
|
|
|
+ for (var i = t.length, n = 0; n < i; n++)
|
|
|
+ if (t[n].length > e)
|
|
|
+ return t[n];
|
|
|
+ return t[i - 1]
|
|
|
+ }(s, i) : r;
|
|
|
+ if ((l = l || r) && l.length) {
|
|
|
+ var u = l[o];
|
|
|
+ return t && (a[t] = u),
|
|
|
+ n.colorIdx = (o + 1) % l.length,
|
|
|
+ u
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , zu = "original"
|
|
|
+ , Bu = "arrayRows"
|
|
|
+ , Vu = "objectRows"
|
|
|
+ , Gu = "keyedColumns"
|
|
|
+ , Fu = "unknown"
|
|
|
+ , Wu = "typedArray"
|
|
|
+ , Hu = "column"
|
|
|
+ , Zu = "row";
|
|
|
+ function Uu(t) {
|
|
|
+ this.fromDataset = t.fromDataset,
|
|
|
+ this.data = t.data || (t.sourceFormat === Gu ? {} : []),
|
|
|
+ this.sourceFormat = t.sourceFormat || Fu,
|
|
|
+ this.seriesLayoutBy = t.seriesLayoutBy || Hu,
|
|
|
+ this.dimensionsDefine = t.dimensionsDefine,
|
|
|
+ this.encodeDefine = t.encodeDefine && Q(t.encodeDefine),
|
|
|
+ this.startIndex = t.startIndex || 0,
|
|
|
+ this.dimensionsDetectCount = t.dimensionsDetectCount
|
|
|
+ }
|
|
|
+ Uu.seriesDataToSource = function(t) {
|
|
|
+ return new Uu({
|
|
|
+ data: t,
|
|
|
+ sourceFormat: V(t) ? Wu : zu,
|
|
|
+ fromDataset: !1
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ra(Uu);
|
|
|
+ var Xu = {
|
|
|
+ Must: 1,
|
|
|
+ Might: 2,
|
|
|
+ Not: 3
|
|
|
+ }
|
|
|
+ , Yu = jo();
|
|
|
+ function ju(t) {
|
|
|
+ var e = t.option
|
|
|
+ , i = e.data
|
|
|
+ , n = V(i) ? Wu : zu
|
|
|
+ , o = !1
|
|
|
+ , a = e.seriesLayoutBy
|
|
|
+ , r = e.sourceHeader
|
|
|
+ , s = e.dimensions
|
|
|
+ , l = Qu(t);
|
|
|
+ if (l) {
|
|
|
+ var u = l.option;
|
|
|
+ i = u.source,
|
|
|
+ n = Yu(l).sourceFormat,
|
|
|
+ o = !0,
|
|
|
+ a = a || u.seriesLayoutBy,
|
|
|
+ null == r && (r = u.sourceHeader),
|
|
|
+ s = s || u.dimensions
|
|
|
+ }
|
|
|
+ var h = function(t, e, i, n, o) {
|
|
|
+ if (!t)
|
|
|
+ return {
|
|
|
+ dimensionsDefine: qu(o)
|
|
|
+ };
|
|
|
+ var a, r;
|
|
|
+ if (e === Bu)
|
|
|
+ "auto" === n || null == n ? Ku(function(t) {
|
|
|
+ null != t && "-" !== t && (R(t) ? null == r && (r = 1) : r = 0)
|
|
|
+ }, i, t, 10) : r = n ? 1 : 0,
|
|
|
+ o || 1 !== r || (o = [],
|
|
|
+ Ku(function(t, e) {
|
|
|
+ o[e] = null != t ? t : ""
|
|
|
+ }, i, t)),
|
|
|
+ a = o ? o.length : i === Zu ? t.length : t[0] ? t[0].length : null;
|
|
|
+ else if (e === Vu)
|
|
|
+ o = o || function(t) {
|
|
|
+ var e, i = 0;
|
|
|
+ for (; i < t.length && !(e = t[i++]); )
|
|
|
+ ;
|
|
|
+ if (e) {
|
|
|
+ var n = [];
|
|
|
+ return E(e, function(t, e) {
|
|
|
+ n.push(e)
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ }(t);
|
|
|
+ else if (e === Gu)
|
|
|
+ o || (o = [],
|
|
|
+ E(t, function(t, e) {
|
|
|
+ o.push(e)
|
|
|
+ }));
|
|
|
+ else if (e === zu) {
|
|
|
+ var s = Wo(t[0]);
|
|
|
+ a = L(s) && s.length || 1
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ startIndex: r,
|
|
|
+ dimensionsDefine: qu(o),
|
|
|
+ dimensionsDetectCount: a
|
|
|
+ }
|
|
|
+ }(i, n, a, r, s);
|
|
|
+ Yu(t).source = new Uu({
|
|
|
+ data: i,
|
|
|
+ fromDataset: o,
|
|
|
+ seriesLayoutBy: a,
|
|
|
+ sourceFormat: n,
|
|
|
+ dimensionsDefine: h.dimensionsDefine,
|
|
|
+ startIndex: h.startIndex,
|
|
|
+ dimensionsDetectCount: h.dimensionsDetectCount,
|
|
|
+ encodeDefine: e.encode
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function qu(t) {
|
|
|
+ if (t) {
|
|
|
+ var n = Q();
|
|
|
+ return O(t, function(t, e) {
|
|
|
+ if (null == (t = P({}, z(t) ? t : {
|
|
|
+ name: t
|
|
|
+ })).name)
|
|
|
+ return t;
|
|
|
+ t.name += "",
|
|
|
+ null == t.displayName && (t.displayName = t.name);
|
|
|
+ var i = n.get(t.name);
|
|
|
+ return i ? t.name += "-" + i.count++ : n.set(t.name, {
|
|
|
+ count: 1
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ku(t, e, i, n) {
|
|
|
+ if (null == n && (n = 1 / 0),
|
|
|
+ e === Zu)
|
|
|
+ for (var o = 0; o < i.length && o < n; o++)
|
|
|
+ t(i[o] ? i[o][0] : null, o);
|
|
|
+ else {
|
|
|
+ var a = i[0] || [];
|
|
|
+ for (o = 0; o < a.length && o < n; o++)
|
|
|
+ t(a[o], o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function $u(i, t, e) {
|
|
|
+ var a = {}
|
|
|
+ , n = Qu(t);
|
|
|
+ if (!n || !i)
|
|
|
+ return a;
|
|
|
+ var r, o, s = [], l = [], u = t.ecModel, h = Yu(u).datasetMap, c = n.uid + "_" + e.seriesLayoutBy;
|
|
|
+ E(i = i.slice(), function(t, e) {
|
|
|
+ z(t) || (i[e] = {
|
|
|
+ name: t
|
|
|
+ }),
|
|
|
+ "ordinal" === t.type && null == r && (o = p(i[r = e])),
|
|
|
+ a[t.name] = []
|
|
|
+ });
|
|
|
+ var d = h.get(c) || h.set(c, {
|
|
|
+ categoryWayDim: o,
|
|
|
+ valueWayDim: 0
|
|
|
+ });
|
|
|
+ function f(t, e, i) {
|
|
|
+ for (var n = 0; n < i; n++)
|
|
|
+ t.push(e + n)
|
|
|
+ }
|
|
|
+ function p(t) {
|
|
|
+ var e = t.dimsDef;
|
|
|
+ return e ? e.length : 1
|
|
|
+ }
|
|
|
+ return E(i, function(t, e) {
|
|
|
+ var i = t.name
|
|
|
+ , n = p(t);
|
|
|
+ if (null == r) {
|
|
|
+ var o = d.valueWayDim;
|
|
|
+ f(a[i], o, n),
|
|
|
+ f(l, o, n),
|
|
|
+ d.valueWayDim += n
|
|
|
+ } else if (r === e)
|
|
|
+ f(a[i], 0, n),
|
|
|
+ f(s, 0, n);
|
|
|
+ else {
|
|
|
+ o = d.categoryWayDim;
|
|
|
+ f(a[i], o, n),
|
|
|
+ f(l, o, n),
|
|
|
+ d.categoryWayDim += n
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ s.length && (a.itemName = s),
|
|
|
+ l.length && (a.seriesName = l),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ function Ju(t, l, u) {
|
|
|
+ var e = {};
|
|
|
+ if (!Qu(t))
|
|
|
+ return e;
|
|
|
+ var h, c = l.sourceFormat, d = l.dimensionsDefine;
|
|
|
+ c !== Vu && c !== Gu || E(d, function(t, e) {
|
|
|
+ "name" === (z(t) ? t.name : t) && (h = e)
|
|
|
+ });
|
|
|
+ var i = function() {
|
|
|
+ for (var t = {}, e = {}, i = [], n = 0, o = Math.min(5, u); n < o; n++) {
|
|
|
+ var a = th(l.data, c, l.seriesLayoutBy, d, l.startIndex, n);
|
|
|
+ i.push(a);
|
|
|
+ var r = a === Xu.Not;
|
|
|
+ if (r && null == t.v && n !== h && (t.v = n),
|
|
|
+ null != t.n && t.n !== t.v && (r || i[t.n] !== Xu.Not) || (t.n = n),
|
|
|
+ s(t) && i[t.n] !== Xu.Not)
|
|
|
+ return t;
|
|
|
+ r || (a === Xu.Might && null == e.v && n !== h && (e.v = n),
|
|
|
+ null != e.n && e.n !== e.v || (e.n = n))
|
|
|
+ }
|
|
|
+ function s(t) {
|
|
|
+ return null != t.v && null != t.n
|
|
|
+ }
|
|
|
+ return s(t) ? t : s(e) ? e : null
|
|
|
+ }();
|
|
|
+ if (i) {
|
|
|
+ e.value = i.v;
|
|
|
+ var n = null != h ? h : i.n;
|
|
|
+ e.itemName = [n],
|
|
|
+ e.seriesName = [n]
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ function Qu(t) {
|
|
|
+ var e = t.option;
|
|
|
+ if (!e.data)
|
|
|
+ return t.ecModel.getComponent("dataset", e.datasetIndex || 0)
|
|
|
+ }
|
|
|
+ function th(t, e, i, n, o, a) {
|
|
|
+ var r, s, l;
|
|
|
+ if (V(t))
|
|
|
+ return Xu.Not;
|
|
|
+ if (n) {
|
|
|
+ var u = n[a];
|
|
|
+ z(u) ? (s = u.name,
|
|
|
+ l = u.type) : R(u) && (s = u)
|
|
|
+ }
|
|
|
+ if (null != l)
|
|
|
+ return "ordinal" === l ? Xu.Must : Xu.Not;
|
|
|
+ if (e === Bu)
|
|
|
+ if (i === Zu) {
|
|
|
+ for (var h = t[a], c = 0; c < (h || []).length && c < 5; c++)
|
|
|
+ if (null != (r = g(h[o + c])))
|
|
|
+ return r
|
|
|
+ } else
|
|
|
+ for (c = 0; c < t.length && c < 5; c++) {
|
|
|
+ var d = t[o + c];
|
|
|
+ if (d && null != (r = g(d[a])))
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ else if (e === Vu) {
|
|
|
+ if (!s)
|
|
|
+ return Xu.Not;
|
|
|
+ for (c = 0; c < t.length && c < 5; c++) {
|
|
|
+ if ((f = t[c]) && null != (r = g(f[s])))
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ } else if (e === Gu) {
|
|
|
+ if (!s)
|
|
|
+ return Xu.Not;
|
|
|
+ if (!(h = t[s]) || V(h))
|
|
|
+ return Xu.Not;
|
|
|
+ for (c = 0; c < h.length && c < 5; c++)
|
|
|
+ if (null != (r = g(h[c])))
|
|
|
+ return r
|
|
|
+ } else if (e === zu)
|
|
|
+ for (c = 0; c < t.length && c < 5; c++) {
|
|
|
+ var f, p = Wo(f = t[c]);
|
|
|
+ if (!L(p))
|
|
|
+ return Xu.Not;
|
|
|
+ if (null != (r = g(p[a])))
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ function g(t) {
|
|
|
+ var e = R(t);
|
|
|
+ return null != t && isFinite(t) && "" !== t ? e ? Xu.Might : Xu.Not : e && "-" !== t ? Xu.Must : void 0
|
|
|
+ }
|
|
|
+ return Xu.Not
|
|
|
+ }
|
|
|
+ var eh = "\0_ec_inner"
|
|
|
+ , ih = Cl.extend({
|
|
|
+ init: function(t, e, i, n) {
|
|
|
+ i = i || {},
|
|
|
+ this.option = null,
|
|
|
+ this._theme = new Cl(i),
|
|
|
+ this._optionManager = n
|
|
|
+ },
|
|
|
+ setOption: function(t, e) {
|
|
|
+ Y(!(eh in t), "please use chart.getOption()"),
|
|
|
+ this._optionManager.setOption(t, e),
|
|
|
+ this.resetOption(null)
|
|
|
+ },
|
|
|
+ resetOption: function(t) {
|
|
|
+ var e = !1
|
|
|
+ , i = this._optionManager;
|
|
|
+ if (!t || "recreate" === t) {
|
|
|
+ var n = i.mountOption("recreate" === t);
|
|
|
+ this.option && "recreate" !== t ? (this.restoreData(),
|
|
|
+ this.mergeOption(n)) : function(t) {
|
|
|
+ t = t,
|
|
|
+ this.option = {},
|
|
|
+ this.option[eh] = 1,
|
|
|
+ this._componentsMap = Q({
|
|
|
+ series: []
|
|
|
+ }),
|
|
|
+ this._seriesIndices,
|
|
|
+ this._seriesIndicesMap,
|
|
|
+ function(i, t) {
|
|
|
+ var n = i.color && !i.colorLayer;
|
|
|
+ E(t, function(t, e) {
|
|
|
+ "colorLayer" === e && n || ku.hasClass(e) || ("object" == typeof t ? i[e] = i[e] ? m(i[e], t, !1) : k(t) : null == i[e] && (i[e] = t))
|
|
|
+ })
|
|
|
+ }(t, this._theme.option),
|
|
|
+ m(t, Ou, !1),
|
|
|
+ this.mergeOption(t)
|
|
|
+ }
|
|
|
+ .call(this, n),
|
|
|
+ e = !0
|
|
|
+ }
|
|
|
+ if ("timeline" !== t && "media" !== t || this.restoreData(),
|
|
|
+ !t || "recreate" === t || "timeline" === t) {
|
|
|
+ var o = i.getTimelineOption(this);
|
|
|
+ o && (this.mergeOption(o),
|
|
|
+ e = !0)
|
|
|
+ }
|
|
|
+ if (!t || "recreate" === t || "media" === t) {
|
|
|
+ var a = i.getMediaOption(this, this._api);
|
|
|
+ a.length && E(a, function(t) {
|
|
|
+ this.mergeOption(t, e = !0)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ },
|
|
|
+ mergeOption: function(n) {
|
|
|
+ var l = this.option
|
|
|
+ , u = this._componentsMap
|
|
|
+ , i = [];
|
|
|
+ !function(t) {
|
|
|
+ Yu(t).datasetMap = Q()
|
|
|
+ }(this),
|
|
|
+ E(n, function(t, e) {
|
|
|
+ null != t && (ku.hasClass(e) ? e && i.push(e) : l[e] = null == l[e] ? k(t) : m(l[e], t, !0))
|
|
|
+ }),
|
|
|
+ ku.topologicalTravel(i, ku.getAllClassMainTypes(), function(r, t) {
|
|
|
+ var e = Vo(n[r])
|
|
|
+ , i = Ho(u.get(r), e);
|
|
|
+ Zo(i),
|
|
|
+ E(i, function(t, e) {
|
|
|
+ var i = t.option;
|
|
|
+ z(i) && (t.keyInfo.mainType = r,
|
|
|
+ t.keyInfo.subType = function(t, e, i) {
|
|
|
+ return e.type ? e.type : i ? i.subType : ku.determineSubType(t, e)
|
|
|
+ }(r, i, t.exist))
|
|
|
+ });
|
|
|
+ var s = function(e, t) {
|
|
|
+ L(t) || (t = t ? [t] : []);
|
|
|
+ var i = {};
|
|
|
+ return E(t, function(t) {
|
|
|
+ i[t] = (e.get(t) || []).slice()
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }(u, t);
|
|
|
+ l[r] = [],
|
|
|
+ u.set(r, []),
|
|
|
+ E(i, function(t, e) {
|
|
|
+ var i = t.exist
|
|
|
+ , n = t.option;
|
|
|
+ if (Y(z(n) || i, "Empty component definition"),
|
|
|
+ n) {
|
|
|
+ var o = ku.getClass(r, t.keyInfo.subType, !0);
|
|
|
+ if (i && i.constructor === o)
|
|
|
+ i.name = t.keyInfo.name,
|
|
|
+ i.mergeOption(n, this),
|
|
|
+ i.optionUpdated(n, !1);
|
|
|
+ else {
|
|
|
+ var a = P({
|
|
|
+ dependentModels: s,
|
|
|
+ componentIndex: e
|
|
|
+ }, t.keyInfo);
|
|
|
+ P(i = new o(n,this,this,a), a),
|
|
|
+ i.init(n, this, this, a),
|
|
|
+ i.optionUpdated(null, !0)
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ i.mergeOption({}, this),
|
|
|
+ i.optionUpdated({}, !1);
|
|
|
+ u.get(r)[e] = i,
|
|
|
+ l[r][e] = i.option
|
|
|
+ }, this),
|
|
|
+ "series" === r && nh(this, u.get("series"))
|
|
|
+ }, this),
|
|
|
+ this._seriesIndicesMap = Q(this._seriesIndices = this._seriesIndices || [])
|
|
|
+ },
|
|
|
+ getOption: function() {
|
|
|
+ var n = k(this.option);
|
|
|
+ return E(n, function(t, e) {
|
|
|
+ if (ku.hasClass(e)) {
|
|
|
+ for (var i = (t = Vo(t)).length - 1; 0 <= i; i--)
|
|
|
+ Xo(t[i]) && t.splice(i, 1);
|
|
|
+ n[e] = t
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ delete n[eh],
|
|
|
+ n
|
|
|
+ },
|
|
|
+ getTheme: function() {
|
|
|
+ return this._theme
|
|
|
+ },
|
|
|
+ getComponent: function(t, e) {
|
|
|
+ var i = this._componentsMap.get(t);
|
|
|
+ if (i)
|
|
|
+ return i[e || 0]
|
|
|
+ },
|
|
|
+ queryComponents: function(t) {
|
|
|
+ var e = t.mainType;
|
|
|
+ if (!e)
|
|
|
+ return [];
|
|
|
+ var i, n = t.index, o = t.id, a = t.name, r = this._componentsMap.get(e);
|
|
|
+ if (!r || !r.length)
|
|
|
+ return [];
|
|
|
+ if (null != n)
|
|
|
+ L(n) || (n = [n]),
|
|
|
+ i = M(O(n, function(t) {
|
|
|
+ return r[t]
|
|
|
+ }), function(t) {
|
|
|
+ return !!t
|
|
|
+ });
|
|
|
+ else if (null != o) {
|
|
|
+ var s = L(o);
|
|
|
+ i = M(r, function(t) {
|
|
|
+ return s && 0 <= _(o, t.id) || !s && t.id === o
|
|
|
+ })
|
|
|
+ } else if (null != a) {
|
|
|
+ var l = L(a);
|
|
|
+ i = M(r, function(t) {
|
|
|
+ return l && 0 <= _(a, t.name) || !l && t.name === a
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ i = r.slice();
|
|
|
+ return oh(i, t)
|
|
|
+ },
|
|
|
+ findComponents: function(t) {
|
|
|
+ var e, i, n, o, a, r = t.query, s = t.mainType, l = (i = s + "Index",
|
|
|
+ n = s + "Id",
|
|
|
+ o = s + "Name",
|
|
|
+ !(e = r) || null == e[i] && null == e[n] && null == e[o] ? null : {
|
|
|
+ mainType: s,
|
|
|
+ index: e[i],
|
|
|
+ id: e[n],
|
|
|
+ name: e[o]
|
|
|
+ }), u = l ? this.queryComponents(l) : this._componentsMap.get(s);
|
|
|
+ return a = oh(u, t),
|
|
|
+ t.filter ? M(a, t.filter) : a
|
|
|
+ },
|
|
|
+ eachComponent: function(t, n, o) {
|
|
|
+ var e = this._componentsMap;
|
|
|
+ if ("function" == typeof t)
|
|
|
+ o = n,
|
|
|
+ n = t,
|
|
|
+ e.each(function(t, i) {
|
|
|
+ E(t, function(t, e) {
|
|
|
+ n.call(o, i, t, e)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ else if (R(t))
|
|
|
+ E(e.get(t), n, o);
|
|
|
+ else if (z(t)) {
|
|
|
+ E(this.findComponents(t), n, o)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getSeriesByName: function(e) {
|
|
|
+ return M(this._componentsMap.get("series"), function(t) {
|
|
|
+ return t.name === e
|
|
|
+ })
|
|
|
+ },
|
|
|
+ getSeriesByIndex: function(t) {
|
|
|
+ return this._componentsMap.get("series")[t]
|
|
|
+ },
|
|
|
+ getSeriesByType: function(e) {
|
|
|
+ return M(this._componentsMap.get("series"), function(t) {
|
|
|
+ return t.subType === e
|
|
|
+ })
|
|
|
+ },
|
|
|
+ getSeries: function() {
|
|
|
+ return this._componentsMap.get("series").slice()
|
|
|
+ },
|
|
|
+ getSeriesCount: function() {
|
|
|
+ return this._componentsMap.get("series").length
|
|
|
+ },
|
|
|
+ eachSeries: function(i, n) {
|
|
|
+ E(this._seriesIndices, function(t) {
|
|
|
+ var e = this._componentsMap.get("series")[t];
|
|
|
+ i.call(n, e, t)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ eachRawSeries: function(t, e) {
|
|
|
+ E(this._componentsMap.get("series"), t, e)
|
|
|
+ },
|
|
|
+ eachSeriesByType: function(i, n, o) {
|
|
|
+ E(this._seriesIndices, function(t) {
|
|
|
+ var e = this._componentsMap.get("series")[t];
|
|
|
+ e.subType === i && n.call(o, e, t)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ eachRawSeriesByType: function(t, e, i) {
|
|
|
+ return E(this.getSeriesByType(t), e, i)
|
|
|
+ },
|
|
|
+ isSeriesFiltered: function(t) {
|
|
|
+ return null == this._seriesIndicesMap.get(t.componentIndex)
|
|
|
+ },
|
|
|
+ getCurrentSeriesIndices: function() {
|
|
|
+ return (this._seriesIndices || []).slice()
|
|
|
+ },
|
|
|
+ filterSeries: function(t, e) {
|
|
|
+ var i = M(this._componentsMap.get("series"), t, e);
|
|
|
+ nh(this, i)
|
|
|
+ },
|
|
|
+ restoreData: function(i) {
|
|
|
+ var n = this._componentsMap;
|
|
|
+ nh(this, n.get("series"));
|
|
|
+ var o = [];
|
|
|
+ n.each(function(t, e) {
|
|
|
+ o.push(e)
|
|
|
+ }),
|
|
|
+ ku.topologicalTravel(o, ku.getAllClassMainTypes(), function(e, t) {
|
|
|
+ E(n.get(e), function(t) {
|
|
|
+ "series" === e && function(t, e) {
|
|
|
+ if (e) {
|
|
|
+ var i = e.seiresIndex
|
|
|
+ , n = e.seriesId
|
|
|
+ , o = e.seriesName;
|
|
|
+ return null != i && t.componentIndex !== i || null != n && t.id !== n || null != o && t.name !== o
|
|
|
+ }
|
|
|
+ }(t, i) || t.restoreData()
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function nh(t, e) {
|
|
|
+ t._seriesIndicesMap = Q(t._seriesIndices = O(e, function(t) {
|
|
|
+ return t.componentIndex
|
|
|
+ }) || [])
|
|
|
+ }
|
|
|
+ function oh(t, e) {
|
|
|
+ return e.hasOwnProperty("subType") ? M(t, function(t) {
|
|
|
+ return t.subType === e.subType
|
|
|
+ }) : t
|
|
|
+ }
|
|
|
+ b(ih, Ru);
|
|
|
+ var ah = ["getDom", "getZr", "getWidth", "getHeight", "getDevicePixelRatio", "dispatchAction", "isDisposed", "on", "off", "getDataURL", "getConnectedDataURL", "getModel", "getOption", "getViewOfComponentModel", "getViewOfSeriesModel"];
|
|
|
+ function rh(e) {
|
|
|
+ E(ah, function(t) {
|
|
|
+ this[t] = A(e[t], e)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ var sh = {};
|
|
|
+ function lh() {
|
|
|
+ this._coordinateSystems = []
|
|
|
+ }
|
|
|
+ lh.prototype = {
|
|
|
+ constructor: lh,
|
|
|
+ create: function(n, o) {
|
|
|
+ var a = [];
|
|
|
+ E(sh, function(t, e) {
|
|
|
+ var i = t.create(n, o);
|
|
|
+ a = a.concat(i || [])
|
|
|
+ }),
|
|
|
+ this._coordinateSystems = a
|
|
|
+ },
|
|
|
+ update: function(e, i) {
|
|
|
+ E(this._coordinateSystems, function(t) {
|
|
|
+ t.update && t.update(e, i)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ getCoordinateSystems: function() {
|
|
|
+ return this._coordinateSystems.slice()
|
|
|
+ }
|
|
|
+ },
|
|
|
+ lh.register = function(t, e) {
|
|
|
+ sh[t] = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lh.get = function(t) {
|
|
|
+ return sh[t]
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var uh = E
|
|
|
+ , hh = k
|
|
|
+ , ch = O
|
|
|
+ , dh = m
|
|
|
+ , fh = /^(min|max)?(.+)$/;
|
|
|
+ function ph(t) {
|
|
|
+ this._api = t,
|
|
|
+ this._timelineOptions = [],
|
|
|
+ this._mediaList = [],
|
|
|
+ this._mediaDefault,
|
|
|
+ this._currentMediaIndices = [],
|
|
|
+ this._optionBackup,
|
|
|
+ this._newBaseOption
|
|
|
+ }
|
|
|
+ function gh(t, e, i) {
|
|
|
+ var a = {
|
|
|
+ width: e,
|
|
|
+ height: i,
|
|
|
+ aspectratio: e / i
|
|
|
+ }
|
|
|
+ , r = !0;
|
|
|
+ return E(t, function(t, e) {
|
|
|
+ var i = e.match(fh);
|
|
|
+ if (i && i[1] && i[2]) {
|
|
|
+ var n = i[1]
|
|
|
+ , o = i[2].toLowerCase();
|
|
|
+ !function(t, e, i) {
|
|
|
+ return "min" === i ? e <= t : "max" === i ? t <= e : t === e
|
|
|
+ }(a[o], t, n) && (r = !1)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ ph.prototype = {
|
|
|
+ constructor: ph,
|
|
|
+ setOption: function(t, e) {
|
|
|
+ t && E(Vo(t.series), function(t) {
|
|
|
+ t && t.data && V(t.data) && K(t.data)
|
|
|
+ }),
|
|
|
+ t = hh(t);
|
|
|
+ var i = this._optionBackup
|
|
|
+ , n = function(t, i, n) {
|
|
|
+ var e, o, a = [], r = [], s = t.timeline;
|
|
|
+ t.baseOption && (o = t.baseOption);
|
|
|
+ (s || t.options) && (o = o || {},
|
|
|
+ a = (t.options || []).slice());
|
|
|
+ if (t.media) {
|
|
|
+ o = o || {};
|
|
|
+ var l = t.media;
|
|
|
+ uh(l, function(t) {
|
|
|
+ t && t.option && (t.query ? r.push(t) : e = e || t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ o = o || t;
|
|
|
+ o.timeline || (o.timeline = s);
|
|
|
+ return uh([o].concat(a).concat(O(r, function(t) {
|
|
|
+ return t.option
|
|
|
+ })), function(e) {
|
|
|
+ uh(i, function(t) {
|
|
|
+ t(e, n)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ baseOption: o,
|
|
|
+ timelineOptions: a,
|
|
|
+ mediaDefault: e,
|
|
|
+ mediaList: r
|
|
|
+ }
|
|
|
+ }
|
|
|
+ .call(this, t, e, !i);
|
|
|
+ this._newBaseOption = n.baseOption,
|
|
|
+ i ? (function(o, t) {
|
|
|
+ uh(t = t || {}, function(t, e) {
|
|
|
+ if (null != t) {
|
|
|
+ var i = o[e];
|
|
|
+ if (ku.hasClass(e)) {
|
|
|
+ t = Vo(t);
|
|
|
+ var n = Ho(i = Vo(i), t);
|
|
|
+ o[e] = ch(n, function(t) {
|
|
|
+ return t.option && t.exist ? dh(t.exist, t.option, !0) : t.exist || t.option
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ o[e] = dh(i, t, !0)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }(i.baseOption, n.baseOption),
|
|
|
+ n.timelineOptions.length && (i.timelineOptions = n.timelineOptions),
|
|
|
+ n.mediaList.length && (i.mediaList = n.mediaList),
|
|
|
+ n.mediaDefault && (i.mediaDefault = n.mediaDefault)) : this._optionBackup = n
|
|
|
+ },
|
|
|
+ mountOption: function(t) {
|
|
|
+ var e = this._optionBackup;
|
|
|
+ return this._timelineOptions = ch(e.timelineOptions, hh),
|
|
|
+ this._mediaList = ch(e.mediaList, hh),
|
|
|
+ this._mediaDefault = hh(e.mediaDefault),
|
|
|
+ this._currentMediaIndices = [],
|
|
|
+ hh(t ? e.baseOption : this._newBaseOption)
|
|
|
+ },
|
|
|
+ getTimelineOption: function(t) {
|
|
|
+ var e, i = this._timelineOptions;
|
|
|
+ if (i.length) {
|
|
|
+ var n = t.getComponent("timeline");
|
|
|
+ n && (e = hh(i[n.getCurrentIndex()], !0))
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ },
|
|
|
+ getMediaOption: function(t) {
|
|
|
+ var e = this._api.getWidth()
|
|
|
+ , i = this._api.getHeight()
|
|
|
+ , n = this._mediaList
|
|
|
+ , o = this._mediaDefault
|
|
|
+ , a = []
|
|
|
+ , r = [];
|
|
|
+ if (!n.length && !o)
|
|
|
+ return r;
|
|
|
+ for (var s = 0, l = n.length; s < l; s++)
|
|
|
+ gh(n[s].query, e, i) && a.push(s);
|
|
|
+ return !a.length && o && (a = [-1]),
|
|
|
+ a.length && !function(t, e) {
|
|
|
+ return t.join(",") === e.join(",")
|
|
|
+ }(a, this._currentMediaIndices) && (r = ch(a, function(t) {
|
|
|
+ return hh(-1 === t ? o.option : n[t].option)
|
|
|
+ })),
|
|
|
+ this._currentMediaIndices = a,
|
|
|
+ r
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var mh = E
|
|
|
+ , vh = z
|
|
|
+ , yh = ["areaStyle", "lineStyle", "nodeStyle", "linkStyle", "chordStyle", "label", "labelLine"];
|
|
|
+ function xh(t) {
|
|
|
+ var e = t && t.itemStyle;
|
|
|
+ if (e)
|
|
|
+ for (var i = 0, n = yh.length; i < n; i++) {
|
|
|
+ var o = yh[i]
|
|
|
+ , a = e.normal
|
|
|
+ , r = e.emphasis;
|
|
|
+ a && a[o] && (t[o] = t[o] || {},
|
|
|
+ t[o].normal ? m(t[o].normal, a[o]) : t[o].normal = a[o],
|
|
|
+ a[o] = null),
|
|
|
+ r && r[o] && (t[o] = t[o] || {},
|
|
|
+ t[o].emphasis ? m(t[o].emphasis, r[o]) : t[o].emphasis = r[o],
|
|
|
+ r[o] = null)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function _h(t, e, i) {
|
|
|
+ if (t && t[e] && (t[e].normal || t[e].emphasis)) {
|
|
|
+ var n = t[e].normal
|
|
|
+ , o = t[e].emphasis;
|
|
|
+ n && (i ? (t[e].normal = t[e].emphasis = null,
|
|
|
+ D(t[e], n)) : t[e] = n),
|
|
|
+ o && (t.emphasis = t.emphasis || {},
|
|
|
+ t.emphasis[e] = o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function wh(t) {
|
|
|
+ _h(t, "itemStyle"),
|
|
|
+ _h(t, "lineStyle"),
|
|
|
+ _h(t, "areaStyle"),
|
|
|
+ _h(t, "label"),
|
|
|
+ _h(t, "labelLine"),
|
|
|
+ _h(t, "upperLabel"),
|
|
|
+ _h(t, "edgeLabel")
|
|
|
+ }
|
|
|
+ function bh(t, e) {
|
|
|
+ var i = vh(t) && t[e]
|
|
|
+ , n = vh(i) && i.textStyle;
|
|
|
+ if (n)
|
|
|
+ for (var o = 0, a = Fo.length; o < a; o++) {
|
|
|
+ e = Fo[o];
|
|
|
+ n.hasOwnProperty(e) && (i[e] = n[e])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Sh(t) {
|
|
|
+ t && (wh(t),
|
|
|
+ bh(t, "label"),
|
|
|
+ t.emphasis && bh(t.emphasis, "label"))
|
|
|
+ }
|
|
|
+ function Mh(t) {
|
|
|
+ return L(t) ? t : t ? [t] : []
|
|
|
+ }
|
|
|
+ function Ih(t) {
|
|
|
+ return (L(t) ? t[0] : t) || {}
|
|
|
+ }
|
|
|
+ function Th(e, t) {
|
|
|
+ mh(Mh(e.series), function(t) {
|
|
|
+ vh(t) && function(t) {
|
|
|
+ if (vh(t)) {
|
|
|
+ xh(t),
|
|
|
+ wh(t),
|
|
|
+ bh(t, "label"),
|
|
|
+ bh(t, "upperLabel"),
|
|
|
+ bh(t, "edgeLabel"),
|
|
|
+ t.emphasis && (bh(t.emphasis, "label"),
|
|
|
+ bh(t.emphasis, "upperLabel"),
|
|
|
+ bh(t.emphasis, "edgeLabel")),
|
|
|
+ (i = t.markPoint) && (xh(i),
|
|
|
+ Sh(i)),
|
|
|
+ (n = t.markLine) && (xh(n),
|
|
|
+ Sh(n));
|
|
|
+ var e = t.markArea;
|
|
|
+ e && Sh(e);
|
|
|
+ var i, n, o = t.data;
|
|
|
+ if ("graph" === t.type) {
|
|
|
+ o = o || t.nodes;
|
|
|
+ var a = t.links || t.edges;
|
|
|
+ if (a && !V(a))
|
|
|
+ for (var r = 0; r < a.length; r++)
|
|
|
+ Sh(a[r]);
|
|
|
+ E(t.categories, function(t) {
|
|
|
+ wh(t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ if (o && !V(o))
|
|
|
+ for (r = 0; r < o.length; r++)
|
|
|
+ Sh(o[r]);
|
|
|
+ if ((i = t.markPoint) && i.data) {
|
|
|
+ var s = i.data;
|
|
|
+ for (r = 0; r < s.length; r++)
|
|
|
+ Sh(s[r])
|
|
|
+ }
|
|
|
+ if ((n = t.markLine) && n.data) {
|
|
|
+ var l = n.data;
|
|
|
+ for (r = 0; r < l.length; r++)
|
|
|
+ L(l[r]) ? (Sh(l[r][0]),
|
|
|
+ Sh(l[r][1])) : Sh(l[r])
|
|
|
+ }
|
|
|
+ "gauge" === t.type ? (bh(t, "axisLabel"),
|
|
|
+ bh(t, "title"),
|
|
|
+ bh(t, "detail")) : "treemap" === t.type ? (_h(t.breadcrumb, "itemStyle"),
|
|
|
+ E(t.levels, function(t) {
|
|
|
+ wh(t)
|
|
|
+ })) : "tree" === t.type && wh(t.leaves)
|
|
|
+ }
|
|
|
+ }(t)
|
|
|
+ });
|
|
|
+ var i = ["xAxis", "yAxis", "radiusAxis", "angleAxis", "singleAxis", "parallelAxis", "radar"];
|
|
|
+ t && i.push("valueAxis", "categoryAxis", "logAxis", "timeAxis"),
|
|
|
+ mh(i, function(t) {
|
|
|
+ mh(Mh(e[t]), function(t) {
|
|
|
+ t && (bh(t, "axisLabel"),
|
|
|
+ bh(t.axisPointer, "label"))
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ mh(Mh(e.parallel), function(t) {
|
|
|
+ var e = t && t.parallelAxisDefault;
|
|
|
+ bh(e, "axisLabel"),
|
|
|
+ bh(e && e.axisPointer, "label")
|
|
|
+ }),
|
|
|
+ mh(Mh(e.calendar), function(t) {
|
|
|
+ _h(t, "itemStyle"),
|
|
|
+ bh(t, "dayLabel"),
|
|
|
+ bh(t, "monthLabel"),
|
|
|
+ bh(t, "yearLabel")
|
|
|
+ }),
|
|
|
+ mh(Mh(e.radar), function(t) {
|
|
|
+ bh(t, "name")
|
|
|
+ }),
|
|
|
+ mh(Mh(e.geo), function(t) {
|
|
|
+ vh(t) && (Sh(t),
|
|
|
+ mh(Mh(t.regions), function(t) {
|
|
|
+ Sh(t)
|
|
|
+ }))
|
|
|
+ }),
|
|
|
+ mh(Mh(e.timeline), function(t) {
|
|
|
+ Sh(t),
|
|
|
+ _h(t, "label"),
|
|
|
+ _h(t, "itemStyle"),
|
|
|
+ _h(t, "controlStyle", !0);
|
|
|
+ var e = t.data;
|
|
|
+ L(e) && E(e, function(t) {
|
|
|
+ z(t) && (_h(t, "label"),
|
|
|
+ _h(t, "itemStyle"))
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ mh(Mh(e.toolbox), function(t) {
|
|
|
+ _h(t, "iconStyle"),
|
|
|
+ mh(t.feature, function(t) {
|
|
|
+ _h(t, "iconStyle")
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ bh(Ih(e.axisPointer), "label"),
|
|
|
+ bh(Ih(e.tooltip).axisPointer, "label")
|
|
|
+ }
|
|
|
+ function Ah(e) {
|
|
|
+ E(Dh, function(t) {
|
|
|
+ t[0]in e && !(t[1]in e) && (e[t[1]] = e[t[0]])
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var Dh = [["x", "left"], ["y", "top"], ["x2", "right"], ["y2", "bottom"]]
|
|
|
+ , Ch = ["grid", "geo", "parallel", "legend", "toolbox", "title", "visualMap", "dataZoom", "timeline"]
|
|
|
+ , Lh = function(i, t) {
|
|
|
+ Th(i, t),
|
|
|
+ i.series = Vo(i.series),
|
|
|
+ E(i.series, function(t) {
|
|
|
+ if (z(t)) {
|
|
|
+ var e = t.type;
|
|
|
+ if ("line" === e)
|
|
|
+ null != t.clipOverflow && (t.clip = t.clipOverflow);
|
|
|
+ else if ("pie" === e || "gauge" === e)
|
|
|
+ null != t.clockWise && (t.clockwise = t.clockWise);
|
|
|
+ else if ("gauge" === e) {
|
|
|
+ var i = function(t, e) {
|
|
|
+ e = e.split(",");
|
|
|
+ for (var i = t, n = 0; n < e.length && null != (i = i && i[e[n]]); n++)
|
|
|
+ ;
|
|
|
+ return i
|
|
|
+ }(t, "pointer.color");
|
|
|
+ null != i && function(t, e, i, n) {
|
|
|
+ e = e.split(",");
|
|
|
+ for (var o, a = t, r = 0; r < e.length - 1; r++)
|
|
|
+ null == a[o = e[r]] && (a[o] = {}),
|
|
|
+ a = a[o];
|
|
|
+ !n && null != a[e[r]] || (a[e[r]] = i)
|
|
|
+ }(t, "itemStyle.color", i)
|
|
|
+ }
|
|
|
+ Ah(t)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ i.dataRange && (i.visualMap = i.dataRange),
|
|
|
+ E(Ch, function(t) {
|
|
|
+ var e = i[t];
|
|
|
+ e && (L(e) || (e = [e]),
|
|
|
+ E(e, function(t) {
|
|
|
+ Ah(t)
|
|
|
+ }))
|
|
|
+ })
|
|
|
+ };
|
|
|
+ function kh(m) {
|
|
|
+ E(m, function(h, c) {
|
|
|
+ var d = []
|
|
|
+ , f = [NaN, NaN]
|
|
|
+ , t = [h.stackResultDimension, h.stackedOverDimension]
|
|
|
+ , p = h.data
|
|
|
+ , g = h.isStackedByIndex
|
|
|
+ , e = p.map(t, function(t, e, i) {
|
|
|
+ var n, o, a = p.get(h.stackedDimension, i);
|
|
|
+ if (isNaN(a))
|
|
|
+ return f;
|
|
|
+ g ? o = p.getRawIndex(i) : n = p.get(h.stackedByDimension, i);
|
|
|
+ for (var r = NaN, s = c - 1; 0 <= s; s--) {
|
|
|
+ var l = m[s];
|
|
|
+ if (g || (o = l.data.rawIndexOf(l.stackedByDimension, n)),
|
|
|
+ 0 <= o) {
|
|
|
+ var u = l.data.getByRawIndex(l.stackResultDimension, o);
|
|
|
+ if (0 <= a && 0 < u || a <= 0 && u < 0) {
|
|
|
+ a += u,
|
|
|
+ r = u;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return d[0] = a,
|
|
|
+ d[1] = r,
|
|
|
+ d
|
|
|
+ });
|
|
|
+ p.hostModel.setData(e),
|
|
|
+ h.data = e
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Ph(t, e) {
|
|
|
+ Uu.isInstance(t) || (t = Uu.seriesDataToSource(t)),
|
|
|
+ this._source = t;
|
|
|
+ var i = this._data = t.data
|
|
|
+ , n = t.sourceFormat;
|
|
|
+ n === Wu && (this._offset = 0,
|
|
|
+ this._dimSize = e,
|
|
|
+ this._data = i),
|
|
|
+ P(this, Oh[n === Bu ? n + "_" + t.seriesLayoutBy : n])
|
|
|
+ }
|
|
|
+ var Nh = Ph.prototype;
|
|
|
+ Nh.pure = !1;
|
|
|
+ var Oh = {
|
|
|
+ arrayRows_column: {
|
|
|
+ pure: Nh.persistent = !0,
|
|
|
+ count: function() {
|
|
|
+ return Math.max(0, this._data.length - this._source.startIndex)
|
|
|
+ },
|
|
|
+ getItem: function(t) {
|
|
|
+ return this._data[t + this._source.startIndex]
|
|
|
+ },
|
|
|
+ appendData: zh
|
|
|
+ },
|
|
|
+ arrayRows_row: {
|
|
|
+ pure: !0,
|
|
|
+ count: function() {
|
|
|
+ var t = this._data[0];
|
|
|
+ return t ? Math.max(0, t.length - this._source.startIndex) : 0
|
|
|
+ },
|
|
|
+ getItem: function(t) {
|
|
|
+ t += this._source.startIndex;
|
|
|
+ for (var e = [], i = this._data, n = 0; n < i.length; n++) {
|
|
|
+ var o = i[n];
|
|
|
+ e.push(o ? o[t] : null)
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ },
|
|
|
+ appendData: function() {
|
|
|
+ throw new Error('Do not support appendData when set seriesLayoutBy: "row".')
|
|
|
+ }
|
|
|
+ },
|
|
|
+ objectRows: {
|
|
|
+ pure: !0,
|
|
|
+ count: Eh,
|
|
|
+ getItem: Rh,
|
|
|
+ appendData: zh
|
|
|
+ },
|
|
|
+ keyedColumns: {
|
|
|
+ pure: !0,
|
|
|
+ count: function() {
|
|
|
+ var t = this._source.dimensionsDefine[0].name
|
|
|
+ , e = this._data[t];
|
|
|
+ return e ? e.length : 0
|
|
|
+ },
|
|
|
+ getItem: function(t) {
|
|
|
+ for (var e = [], i = this._source.dimensionsDefine, n = 0; n < i.length; n++) {
|
|
|
+ var o = this._data[i[n].name];
|
|
|
+ e.push(o ? o[t] : null)
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ },
|
|
|
+ appendData: function(t) {
|
|
|
+ var o = this._data;
|
|
|
+ E(t, function(t, e) {
|
|
|
+ for (var i = o[e] || (o[e] = []), n = 0; n < (t || []).length; n++)
|
|
|
+ i.push(t[n])
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ original: {
|
|
|
+ count: Eh,
|
|
|
+ getItem: Rh,
|
|
|
+ appendData: zh
|
|
|
+ },
|
|
|
+ typedArray: {
|
|
|
+ persistent: !(Nh.getSource = function() {
|
|
|
+ return this._source
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ pure: !0,
|
|
|
+ count: function() {
|
|
|
+ return this._data ? this._data.length / this._dimSize : 0
|
|
|
+ },
|
|
|
+ getItem: function(t, e) {
|
|
|
+ t -= this._offset,
|
|
|
+ e = e || [];
|
|
|
+ for (var i = this._dimSize * t, n = 0; n < this._dimSize; n++)
|
|
|
+ e[n] = this._data[i + n];
|
|
|
+ return e
|
|
|
+ },
|
|
|
+ appendData: function(t) {
|
|
|
+ this._data = t
|
|
|
+ },
|
|
|
+ clean: function() {
|
|
|
+ this._offset += this.count(),
|
|
|
+ this._data = null
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Eh() {
|
|
|
+ return this._data.length
|
|
|
+ }
|
|
|
+ function Rh(t) {
|
|
|
+ return this._data[t]
|
|
|
+ }
|
|
|
+ function zh(t) {
|
|
|
+ for (var e = 0; e < t.length; e++)
|
|
|
+ this._data.push(t[e])
|
|
|
+ }
|
|
|
+ var Bh = {
|
|
|
+ arrayRows: Vh,
|
|
|
+ objectRows: function(t, e, i, n) {
|
|
|
+ return null != i ? t[n] : t
|
|
|
+ },
|
|
|
+ keyedColumns: Vh,
|
|
|
+ original: function(t, e, i, n) {
|
|
|
+ var o = Wo(t);
|
|
|
+ return null != i && o instanceof Array ? o[i] : o
|
|
|
+ },
|
|
|
+ typedArray: Vh
|
|
|
+ };
|
|
|
+ function Vh(t, e, i, n) {
|
|
|
+ return null != i ? t[i] : t
|
|
|
+ }
|
|
|
+ var Gh = {
|
|
|
+ arrayRows: Fh,
|
|
|
+ objectRows: function(t, e, i, n) {
|
|
|
+ return Wh(t[e], this._dimensionInfos[e])
|
|
|
+ },
|
|
|
+ keyedColumns: Fh,
|
|
|
+ original: function(t, e, i, n) {
|
|
|
+ var o = t && (null == t.value ? t : t.value);
|
|
|
+ return !this._rawData.pure && function(t) {
|
|
|
+ return Ro(t) && !(t instanceof Array)
|
|
|
+ }(t) && (this.hasItemOption = !0),
|
|
|
+ Wh(o instanceof Array ? o[n] : o, this._dimensionInfos[e])
|
|
|
+ },
|
|
|
+ typedArray: function(t, e, i, n) {
|
|
|
+ return t[n]
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Fh(t, e, i, n) {
|
|
|
+ return Wh(t[n], this._dimensionInfos[e])
|
|
|
+ }
|
|
|
+ function Wh(t, e) {
|
|
|
+ var i = e && e.type;
|
|
|
+ if ("ordinal" !== i)
|
|
|
+ return "time" === i && "number" != typeof t && null != t && "-" !== t && (t = +Yl(t)),
|
|
|
+ null == t || "" === t ? NaN : +t;
|
|
|
+ var n = e && e.ordinalMeta;
|
|
|
+ return n ? n.parseAndCollect(t) : t
|
|
|
+ }
|
|
|
+ function Hh(t, e, i) {
|
|
|
+ if (t) {
|
|
|
+ var n = t.getRawDataItem(e);
|
|
|
+ if (null != n) {
|
|
|
+ var o, a, r = t.getProvider().getSource().sourceFormat, s = t.getDimensionInfo(i);
|
|
|
+ return s && (o = s.name,
|
|
|
+ a = s.index),
|
|
|
+ Bh[r](n, e, a, o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Zh(t, e, i) {
|
|
|
+ if (t) {
|
|
|
+ var n = t.getProvider().getSource().sourceFormat;
|
|
|
+ if (n === zu || n === Vu) {
|
|
|
+ var o = t.getRawDataItem(e);
|
|
|
+ return n !== zu || z(o) || (o = null),
|
|
|
+ o ? o[i] : void 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Uh = /\{@(.+?)\}/g
|
|
|
+ , Xh = {
|
|
|
+ getDataParams: function(t, e) {
|
|
|
+ var i = this.getData(e)
|
|
|
+ , n = this.getRawValue(t, e)
|
|
|
+ , o = i.getRawIndex(t)
|
|
|
+ , a = i.getName(t)
|
|
|
+ , r = i.getRawDataItem(t)
|
|
|
+ , s = i.getItemVisual(t, "color")
|
|
|
+ , l = i.getItemVisual(t, "borderColor")
|
|
|
+ , u = this.ecModel.getComponent("tooltip")
|
|
|
+ , h = Qo(u && u.get("renderMode"))
|
|
|
+ , c = this.mainType
|
|
|
+ , d = "series" === c
|
|
|
+ , f = i.userOutput;
|
|
|
+ return {
|
|
|
+ componentType: c,
|
|
|
+ componentSubType: this.subType,
|
|
|
+ componentIndex: this.componentIndex,
|
|
|
+ seriesType: d ? this.subType : null,
|
|
|
+ seriesIndex: this.seriesIndex,
|
|
|
+ seriesId: d ? this.id : null,
|
|
|
+ seriesName: d ? this.name : null,
|
|
|
+ name: a,
|
|
|
+ dataIndex: o,
|
|
|
+ data: r,
|
|
|
+ dataType: e,
|
|
|
+ value: n,
|
|
|
+ color: s,
|
|
|
+ borderColor: l,
|
|
|
+ dimensionNames: f ? f.dimensionNames : null,
|
|
|
+ encode: f ? f.encode : null,
|
|
|
+ marker: hu({
|
|
|
+ color: s,
|
|
|
+ renderMode: h
|
|
|
+ }),
|
|
|
+ $vars: ["seriesName", "name", "value"]
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getFormattedLabel: function(n, t, e, i, o) {
|
|
|
+ t = t || "normal";
|
|
|
+ var a = this.getData(e)
|
|
|
+ , r = a.getItemModel(n)
|
|
|
+ , s = this.getDataParams(n, e);
|
|
|
+ null != i && s.value instanceof Array && (s.value = s.value[i]);
|
|
|
+ var l = r.get("normal" === t ? [o || "label", "formatter"] : [t, o || "label", "formatter"]);
|
|
|
+ return "function" == typeof l ? (s.status = t,
|
|
|
+ s.dimensionIndex = i,
|
|
|
+ l(s)) : "string" == typeof l ? lu(l, s).replace(Uh, function(t, e) {
|
|
|
+ var i = e.length;
|
|
|
+ return "[" === e.charAt(0) && "]" === e.charAt(i - 1) && (e = +e.slice(1, i - 1)),
|
|
|
+ Hh(a, n, e)
|
|
|
+ }) : void 0
|
|
|
+ },
|
|
|
+ getRawValue: function(t, e) {
|
|
|
+ return Hh(this.getData(e), t)
|
|
|
+ },
|
|
|
+ formatTooltip: function() {}
|
|
|
+ };
|
|
|
+ function Yh(t) {
|
|
|
+ return new jh(t)
|
|
|
+ }
|
|
|
+ function jh(t) {
|
|
|
+ t = t || {},
|
|
|
+ this._reset = t.reset,
|
|
|
+ this._plan = t.plan,
|
|
|
+ this._count = t.count,
|
|
|
+ this._onDirty = t.onDirty,
|
|
|
+ this._dirty = !0,
|
|
|
+ this.context
|
|
|
+ }
|
|
|
+ var qh = jh.prototype;
|
|
|
+ qh.perform = function(t) {
|
|
|
+ var e, i = this._upstream, n = t && t.skip;
|
|
|
+ if (this._dirty && i) {
|
|
|
+ var o = this.context;
|
|
|
+ o.data = o.outputData = i.context.outputData
|
|
|
+ }
|
|
|
+ this.__pipeline && (this.__pipeline.currentTask = this),
|
|
|
+ this._plan && !n && (e = this._plan(this.context));
|
|
|
+ var a, r = h(this._modBy), s = this._modDataCount || 0, l = h(t && t.modBy), u = t && t.modDataCount || 0;
|
|
|
+ function h(t) {
|
|
|
+ return 1 <= t || (t = 1),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ r === l && s === u || (e = "reset"),
|
|
|
+ !this._dirty && "reset" !== e || (this._dirty = !1,
|
|
|
+ a = function(t, e) {
|
|
|
+ var i, n;
|
|
|
+ t._dueIndex = t._outputDueEnd = t._dueEnd = 0,
|
|
|
+ t._settedOutputEnd = null,
|
|
|
+ !e && t._reset && ((i = t._reset(t.context)) && i.progress && (n = i.forceFirstProgress,
|
|
|
+ i = i.progress),
|
|
|
+ L(i) && !i.length && (i = null));
|
|
|
+ t._progress = i,
|
|
|
+ t._modBy = t._modDataCount = null;
|
|
|
+ var o = t._downstream;
|
|
|
+ return o && o.dirty(),
|
|
|
+ n
|
|
|
+ }(this, n)),
|
|
|
+ this._modBy = l,
|
|
|
+ this._modDataCount = u;
|
|
|
+ var c = t && t.step;
|
|
|
+ if (this._dueEnd = i ? i._outputDueEnd : this._count ? this._count(this.context) : 1 / 0,
|
|
|
+ this._progress) {
|
|
|
+ var d = this._dueIndex
|
|
|
+ , f = Math.min(null != c ? this._dueIndex + c : 1 / 0, this._dueEnd);
|
|
|
+ if (!n && (a || d < f)) {
|
|
|
+ var p = this._progress;
|
|
|
+ if (L(p))
|
|
|
+ for (var g = 0; g < p.length; g++)
|
|
|
+ ac(this, p[g], d, f, l, u);
|
|
|
+ else
|
|
|
+ ac(this, p, d, f, l, u)
|
|
|
+ }
|
|
|
+ this._dueIndex = f;
|
|
|
+ var m = null != this._settedOutputEnd ? this._settedOutputEnd : f;
|
|
|
+ this._outputDueEnd = m
|
|
|
+ } else
|
|
|
+ this._dueIndex = this._outputDueEnd = null != this._settedOutputEnd ? this._settedOutputEnd : this._dueEnd;
|
|
|
+ return this.unfinished()
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Kh, $h, Jh, Qh, tc, ec, ic = ec = {
|
|
|
+ reset: function(t, e, i, n) {
|
|
|
+ $h = t,
|
|
|
+ Kh = e,
|
|
|
+ Jh = i,
|
|
|
+ Qh = n,
|
|
|
+ tc = Math.ceil(Qh / Jh),
|
|
|
+ ec.next = 1 < Jh && 0 < Qh ? oc : nc
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function nc() {
|
|
|
+ return $h < Kh ? $h++ : null
|
|
|
+ }
|
|
|
+ function oc() {
|
|
|
+ var t = $h % tc * Jh + Math.ceil($h / tc)
|
|
|
+ , e = Kh <= $h ? null : t < Qh ? t : $h;
|
|
|
+ return $h++,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function ac(t, e, i, n, o, a) {
|
|
|
+ ic.reset(i, n, o, a),
|
|
|
+ t._callingProgress = e,
|
|
|
+ t._callingProgress({
|
|
|
+ start: i,
|
|
|
+ end: n,
|
|
|
+ count: n - i,
|
|
|
+ next: ic.next
|
|
|
+ }, t.context)
|
|
|
+ }
|
|
|
+ qh.dirty = function() {
|
|
|
+ this._dirty = !0,
|
|
|
+ this._onDirty && this._onDirty(this.context)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ qh.unfinished = function() {
|
|
|
+ return this._progress && this._dueIndex < this._dueEnd
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ qh.pipe = function(t) {
|
|
|
+ this._downstream === t && !this._dirty || ((this._downstream = t)._upstream = this,
|
|
|
+ t.dirty())
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ qh.dispose = function() {
|
|
|
+ this._disposed || (this._upstream && (this._upstream._downstream = null),
|
|
|
+ this._downstream && (this._downstream._upstream = null),
|
|
|
+ this._dirty = !1,
|
|
|
+ this._disposed = !0)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ qh.getUpstream = function() {
|
|
|
+ return this._upstream
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ qh.getDownstream = function() {
|
|
|
+ return this._downstream
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ qh.setOutputEnd = function(t) {
|
|
|
+ this._outputDueEnd = this._settedOutputEnd = t
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var rc = jo()
|
|
|
+ , sc = ku.extend({
|
|
|
+ type: "series.__base__",
|
|
|
+ seriesIndex: 0,
|
|
|
+ coordinateSystem: null,
|
|
|
+ defaultOption: null,
|
|
|
+ legendVisualProvider: null,
|
|
|
+ visualColorAccessPath: "itemStyle.color",
|
|
|
+ visualBorderColorAccessPath: "itemStyle.borderColor",
|
|
|
+ layoutMode: null,
|
|
|
+ init: function(t, e, i, n) {
|
|
|
+ this.seriesIndex = this.componentIndex,
|
|
|
+ this.dataTask = Yh({
|
|
|
+ count: uc,
|
|
|
+ reset: hc
|
|
|
+ }),
|
|
|
+ this.dataTask.context = {
|
|
|
+ model: this
|
|
|
+ },
|
|
|
+ this.mergeDefaultAndTheme(t, i),
|
|
|
+ ju(this);
|
|
|
+ var o = this.getInitialData(t, i);
|
|
|
+ dc(o, this),
|
|
|
+ this.dataTask.context.data = o,
|
|
|
+ rc(this).dataBeforeProcessed = o,
|
|
|
+ lc(this)
|
|
|
+ },
|
|
|
+ mergeDefaultAndTheme: function(t, e) {
|
|
|
+ var i = this.layoutMode
|
|
|
+ , n = i ? Iu(t) : {}
|
|
|
+ , o = this.subType;
|
|
|
+ ku.hasClass(o) && (o += "Series"),
|
|
|
+ m(t, e.getTheme().get(this.subType)),
|
|
|
+ m(t, this.getDefaultOption()),
|
|
|
+ Go(t, "label", ["show"]),
|
|
|
+ this.fillDataTextStyle(t.data),
|
|
|
+ i && Mu(t, n, i)
|
|
|
+ },
|
|
|
+ mergeOption: function(t, e) {
|
|
|
+ t = m(this.option, t, !0),
|
|
|
+ this.fillDataTextStyle(t.data);
|
|
|
+ var i = this.layoutMode;
|
|
|
+ i && Mu(this.option, t, i),
|
|
|
+ ju(this);
|
|
|
+ var n = this.getInitialData(t, e);
|
|
|
+ dc(n, this),
|
|
|
+ this.dataTask.dirty(),
|
|
|
+ this.dataTask.context.data = n,
|
|
|
+ rc(this).dataBeforeProcessed = n,
|
|
|
+ lc(this)
|
|
|
+ },
|
|
|
+ fillDataTextStyle: function(t) {
|
|
|
+ if (t && !V(t))
|
|
|
+ for (var e = ["show"], i = 0; i < t.length; i++)
|
|
|
+ t[i] && t[i].label && Go(t[i], "label", e)
|
|
|
+ },
|
|
|
+ getInitialData: function() {},
|
|
|
+ appendData: function(t) {
|
|
|
+ this.getRawData().appendData(t.data)
|
|
|
+ },
|
|
|
+ getData: function(t) {
|
|
|
+ var e = pc(this);
|
|
|
+ if (e) {
|
|
|
+ var i = e.context.data;
|
|
|
+ return null == t ? i : i.getLinkedData(t)
|
|
|
+ }
|
|
|
+ return rc(this).data
|
|
|
+ },
|
|
|
+ setData: function(t) {
|
|
|
+ var e = pc(this);
|
|
|
+ if (e) {
|
|
|
+ var i = e.context;
|
|
|
+ i.data !== t && e.modifyOutputEnd && e.setOutputEnd(t.count()),
|
|
|
+ i.outputData = t,
|
|
|
+ e !== this.dataTask && (i.data = t)
|
|
|
+ }
|
|
|
+ rc(this).data = t
|
|
|
+ },
|
|
|
+ getSource: function() {
|
|
|
+ return function(t) {
|
|
|
+ return Yu(t).source
|
|
|
+ }(this)
|
|
|
+ },
|
|
|
+ getRawData: function() {
|
|
|
+ return rc(this).dataBeforeProcessed
|
|
|
+ },
|
|
|
+ getBaseAxis: function() {
|
|
|
+ var t = this.coordinateSystem;
|
|
|
+ return t && t.getBaseAxis && t.getBaseAxis()
|
|
|
+ },
|
|
|
+ formatTooltip: function(o, h, t, c) {
|
|
|
+ var d = this
|
|
|
+ , e = "html" === (c = c || "html") ? "<br/>" : "\n"
|
|
|
+ , f = "richText" === c
|
|
|
+ , p = {}
|
|
|
+ , g = 0;
|
|
|
+ function i(t) {
|
|
|
+ return {
|
|
|
+ renderMode: c,
|
|
|
+ content: au(tu(t)),
|
|
|
+ style: p
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var m = this.getData()
|
|
|
+ , a = m.mapDimension("defaultedTooltip", !0)
|
|
|
+ , n = a.length
|
|
|
+ , r = this.getRawValue(o)
|
|
|
+ , s = L(r)
|
|
|
+ , v = m.getItemVisual(o, "color");
|
|
|
+ z(v) && v.colorStops && (v = (v.colorStops[0] || {}).color),
|
|
|
+ v = v || "transparent";
|
|
|
+ var l = (1 < n || s && !n ? function(t) {
|
|
|
+ var l = S(t, function(t, e, i) {
|
|
|
+ var n = m.getDimensionInfo(i);
|
|
|
+ return t | (n && !1 !== n.tooltip && null != n.displayName)
|
|
|
+ }, 0)
|
|
|
+ , u = [];
|
|
|
+ function e(t, e) {
|
|
|
+ var i = m.getDimensionInfo(e);
|
|
|
+ if (i && !1 !== i.otherDims.tooltip) {
|
|
|
+ var n = i.type
|
|
|
+ , o = "sub" + d.seriesIndex + "at" + g
|
|
|
+ , a = hu({
|
|
|
+ color: v,
|
|
|
+ type: "subItem",
|
|
|
+ renderMode: c,
|
|
|
+ markerId: o
|
|
|
+ })
|
|
|
+ , r = "string" == typeof a ? a : a.content
|
|
|
+ , s = (l ? r + au(i.displayName || "-") + ": " : "") + au("ordinal" === n ? t + "" : "time" === n ? h ? "" : du("yyyy/MM/dd hh:mm:ss", t) : tu(t));
|
|
|
+ s && u.push(s),
|
|
|
+ f && (p[o] = v,
|
|
|
+ ++g)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ a.length ? E(a, function(t) {
|
|
|
+ e(Hh(m, o, t), t)
|
|
|
+ }) : E(t, e);
|
|
|
+ var i = l ? f ? "\n" : "<br/>" : ""
|
|
|
+ , n = i + u.join(i || ", ");
|
|
|
+ return {
|
|
|
+ renderMode: c,
|
|
|
+ content: n,
|
|
|
+ style: p
|
|
|
+ }
|
|
|
+ }(r) : i(n ? Hh(m, o, a[0]) : s ? r[0] : r)).content
|
|
|
+ , u = d.seriesIndex + "at" + g
|
|
|
+ , y = hu({
|
|
|
+ color: v,
|
|
|
+ type: "item",
|
|
|
+ renderMode: c,
|
|
|
+ markerId: u
|
|
|
+ });
|
|
|
+ p[u] = v,
|
|
|
+ ++g;
|
|
|
+ var x = m.getName(o)
|
|
|
+ , _ = this.name;
|
|
|
+ Uo(this) || (_ = ""),
|
|
|
+ _ = _ ? au(_) + (h ? ": " : e) : "";
|
|
|
+ var w = "string" == typeof y ? y : y.content;
|
|
|
+ return {
|
|
|
+ html: h ? w + _ + l : _ + w + (x ? au(x) + ": " + l : l),
|
|
|
+ markers: p
|
|
|
+ }
|
|
|
+ },
|
|
|
+ isAnimationEnabled: function() {
|
|
|
+ if (v.node)
|
|
|
+ return !1;
|
|
|
+ var t = this.getShallow("animation");
|
|
|
+ return t && this.getData().count() > this.getShallow("animationThreshold") && (t = !1),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ restoreData: function() {
|
|
|
+ this.dataTask.dirty()
|
|
|
+ },
|
|
|
+ getColorFromPalette: function(t, e, i) {
|
|
|
+ var n = this.ecModel
|
|
|
+ , o = Ru.getColorFromPalette.call(this, t, e, i);
|
|
|
+ return o = o || n.getColorFromPalette(t, e, i)
|
|
|
+ },
|
|
|
+ coordDimToDataDim: function(t) {
|
|
|
+ return this.getRawData().mapDimension(t, !0)
|
|
|
+ },
|
|
|
+ getProgressive: function() {
|
|
|
+ return this.get("progressive")
|
|
|
+ },
|
|
|
+ getProgressiveThreshold: function() {
|
|
|
+ return this.get("progressiveThreshold")
|
|
|
+ },
|
|
|
+ getAxisTooltipData: null,
|
|
|
+ getTooltipPosition: null,
|
|
|
+ pipeTask: null,
|
|
|
+ preventIncremental: null,
|
|
|
+ pipelineContext: null
|
|
|
+ });
|
|
|
+ function lc(t) {
|
|
|
+ var e = t.name;
|
|
|
+ Uo(t) || (t.name = function(t) {
|
|
|
+ var i = t.getRawData()
|
|
|
+ , e = i.mapDimension("seriesName", !0)
|
|
|
+ , n = [];
|
|
|
+ return E(e, function(t) {
|
|
|
+ var e = i.getDimensionInfo(t);
|
|
|
+ e.displayName && n.push(e.displayName)
|
|
|
+ }),
|
|
|
+ n.join(" ")
|
|
|
+ }(t) || e)
|
|
|
+ }
|
|
|
+ function uc(t) {
|
|
|
+ return t.model.getRawData().count()
|
|
|
+ }
|
|
|
+ function hc(t) {
|
|
|
+ var e = t.model;
|
|
|
+ return e.setData(e.getRawData().cloneShallow()),
|
|
|
+ cc
|
|
|
+ }
|
|
|
+ function cc(t, e) {
|
|
|
+ e.outputData && t.end > e.outputData.count() && e.model.getRawData().cloneShallow(e.outputData)
|
|
|
+ }
|
|
|
+ function dc(e, i) {
|
|
|
+ E(e.CHANGABLE_METHODS, function(t) {
|
|
|
+ e.wrapMethod(t, T(fc, i))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function fc(t) {
|
|
|
+ var e = pc(t);
|
|
|
+ e && e.setOutputEnd(this.count())
|
|
|
+ }
|
|
|
+ function pc(t) {
|
|
|
+ var e = (t.ecModel || {}).scheduler
|
|
|
+ , i = e && e.getPipeline(t.uid);
|
|
|
+ if (i) {
|
|
|
+ var n = i.currentTask;
|
|
|
+ if (n) {
|
|
|
+ var o = n.agentStubMap;
|
|
|
+ o && (n = o.get(t.uid))
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ b(sc, Xh),
|
|
|
+ b(sc, Ru);
|
|
|
+ var gc = function() {
|
|
|
+ this.group = new Ci,
|
|
|
+ this.uid = Nl("viewComponent")
|
|
|
+ };
|
|
|
+ gc.prototype = {
|
|
|
+ constructor: gc,
|
|
|
+ init: function(t, e) {},
|
|
|
+ render: function(t, e, i, n) {},
|
|
|
+ dispose: function() {},
|
|
|
+ filterForExposedEvent: null
|
|
|
+ };
|
|
|
+ var mc = gc.prototype;
|
|
|
+ mc.updateView = mc.updateLayout = mc.updateVisual = function(t, e, i, n) {}
|
|
|
+ ,
|
|
|
+ oa(gc),
|
|
|
+ ua(gc, {
|
|
|
+ registerWhenExtend: !0
|
|
|
+ });
|
|
|
+ function vc() {
|
|
|
+ var s = jo();
|
|
|
+ return function(t) {
|
|
|
+ var e = s(t)
|
|
|
+ , i = t.pipelineContext
|
|
|
+ , n = e.large
|
|
|
+ , o = e.progressiveRender
|
|
|
+ , a = e.large = i && i.large
|
|
|
+ , r = e.progressiveRender = i && i.progressiveRender;
|
|
|
+ return !!(n ^ a || o ^ r) && "reset"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var yc = jo()
|
|
|
+ , xc = vc();
|
|
|
+ function _c() {
|
|
|
+ this.group = new Ci,
|
|
|
+ this.uid = Nl("viewChart"),
|
|
|
+ this.renderTask = Yh({
|
|
|
+ plan: Mc,
|
|
|
+ reset: Ic
|
|
|
+ }),
|
|
|
+ this.renderTask.context = {
|
|
|
+ view: this
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var wc = _c.prototype = {
|
|
|
+ type: "chart",
|
|
|
+ init: function(t, e) {},
|
|
|
+ render: function(t, e, i, n) {},
|
|
|
+ highlight: function(t, e, i, n) {
|
|
|
+ Sc(t.getData(), n, "emphasis")
|
|
|
+ },
|
|
|
+ downplay: function(t, e, i, n) {
|
|
|
+ Sc(t.getData(), n, "normal")
|
|
|
+ },
|
|
|
+ remove: function(t, e) {
|
|
|
+ this.group.removeAll()
|
|
|
+ },
|
|
|
+ dispose: function() {},
|
|
|
+ incrementalPrepareRender: null,
|
|
|
+ incrementalRender: null,
|
|
|
+ updateTransform: null,
|
|
|
+ filterForExposedEvent: null
|
|
|
+ };
|
|
|
+ function bc(t, e, i) {
|
|
|
+ if (t && (t.trigger(e, i),
|
|
|
+ t.isGroup && !Qs(t)))
|
|
|
+ for (var n = 0, o = t.childCount(); n < o; n++)
|
|
|
+ bc(t.childAt(n), e, i)
|
|
|
+ }
|
|
|
+ function Sc(e, t, i) {
|
|
|
+ var n = Yo(e, t)
|
|
|
+ , o = t && null != t.highlightKey ? tl(t.highlightKey) : null;
|
|
|
+ null != n ? E(Vo(n), function(t) {
|
|
|
+ bc(e.getItemGraphicEl(t), i, o)
|
|
|
+ }) : e.eachItemGraphicEl(function(t) {
|
|
|
+ bc(t, i, o)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Mc(t) {
|
|
|
+ return xc(t.model)
|
|
|
+ }
|
|
|
+ function Ic(t) {
|
|
|
+ var e = t.model
|
|
|
+ , i = t.ecModel
|
|
|
+ , n = t.api
|
|
|
+ , o = t.payload
|
|
|
+ , a = e.pipelineContext.progressiveRender
|
|
|
+ , r = t.view
|
|
|
+ , s = o && yc(o).updateMethod
|
|
|
+ , l = a ? "incrementalPrepareRender" : s && r[s] ? s : "render";
|
|
|
+ return "render" !== l && r[l](e, i, n, o),
|
|
|
+ Tc[l]
|
|
|
+ }
|
|
|
+ wc.updateView = wc.updateLayout = wc.updateVisual = function(t, e, i, n) {
|
|
|
+ this.render(t, e, i, n)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ oa(_c),
|
|
|
+ ua(_c, {
|
|
|
+ registerWhenExtend: !0
|
|
|
+ }),
|
|
|
+ _c.markUpdateMethod = function(t, e) {
|
|
|
+ yc(t).updateMethod = e
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Tc = {
|
|
|
+ incrementalPrepareRender: {
|
|
|
+ progress: function(t, e) {
|
|
|
+ e.view.incrementalRender(t, e.model, e.ecModel, e.api, e.payload)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ render: {
|
|
|
+ forceFirstProgress: !0,
|
|
|
+ progress: function(t, e) {
|
|
|
+ e.view.render(e.model, e.ecModel, e.api, e.payload)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Ac = "\0__throttleOriginMethod"
|
|
|
+ , Dc = "\0__throttleRate"
|
|
|
+ , Cc = "\0__throttleType";
|
|
|
+ function Lc(t, i, n) {
|
|
|
+ var o, a, r, s, l, u = 0, h = 0, c = null;
|
|
|
+ function d() {
|
|
|
+ h = (new Date).getTime(),
|
|
|
+ c = null,
|
|
|
+ t.apply(r, s || [])
|
|
|
+ }
|
|
|
+ i = i || 0;
|
|
|
+ function e() {
|
|
|
+ o = (new Date).getTime(),
|
|
|
+ r = this,
|
|
|
+ s = arguments;
|
|
|
+ var t = l || i
|
|
|
+ , e = l || n;
|
|
|
+ l = null,
|
|
|
+ a = o - (e ? u : h) - t,
|
|
|
+ clearTimeout(c),
|
|
|
+ e ? c = setTimeout(d, t) : 0 <= a ? d() : c = setTimeout(d, -a),
|
|
|
+ u = o
|
|
|
+ }
|
|
|
+ return e.clear = function() {
|
|
|
+ c && (clearTimeout(c),
|
|
|
+ c = null)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ e.debounceNextCall = function(t) {
|
|
|
+ l = t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function kc(t, e, i, n) {
|
|
|
+ var o = t[e];
|
|
|
+ if (o) {
|
|
|
+ var a = o[Ac] || o
|
|
|
+ , r = o[Cc];
|
|
|
+ if (o[Dc] !== i || r !== n) {
|
|
|
+ if (null == i || !n)
|
|
|
+ return t[e] = a;
|
|
|
+ (o = t[e] = Lc(a, i, "debounce" === n))[Ac] = a,
|
|
|
+ o[Cc] = n,
|
|
|
+ o[Dc] = i
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Pc(t, e) {
|
|
|
+ var i = t[e];
|
|
|
+ i && i[Ac] && (t[e] = i[Ac])
|
|
|
+ }
|
|
|
+ var Nc = {
|
|
|
+ createOnAllSeries: !0,
|
|
|
+ performRawSeries: !0,
|
|
|
+ reset: function(e, t) {
|
|
|
+ var i = e.getData()
|
|
|
+ , a = (e.visualColorAccessPath || "itemStyle.color").split(".")
|
|
|
+ , n = e.get(a)
|
|
|
+ , o = !C(n) || n instanceof cs ? null : n;
|
|
|
+ n && !o || (n = e.getColorFromPalette(e.name, null, t.getSeriesCount())),
|
|
|
+ i.setVisual("color", n);
|
|
|
+ var r = (e.visualBorderColorAccessPath || "itemStyle.borderColor").split(".")
|
|
|
+ , s = e.get(r);
|
|
|
+ if (i.setVisual("borderColor", s),
|
|
|
+ !t.isSeriesFiltered(e)) {
|
|
|
+ o && i.each(function(t) {
|
|
|
+ i.setItemVisual(t, "color", o(e.getDataParams(t)))
|
|
|
+ });
|
|
|
+ return {
|
|
|
+ dataEach: i.hasItemOption ? function(t, e) {
|
|
|
+ var i = t.getItemModel(e)
|
|
|
+ , n = i.get(a, !0)
|
|
|
+ , o = i.get(r, !0);
|
|
|
+ null != n && t.setItemVisual(e, "color", n),
|
|
|
+ null != o && t.setItemVisual(e, "borderColor", o)
|
|
|
+ }
|
|
|
+ : null
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Oc = {
|
|
|
+ legend: {
|
|
|
+ selector: {
|
|
|
+ all: "全选",
|
|
|
+ inverse: "反选"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ toolbox: {
|
|
|
+ brush: {
|
|
|
+ title: {
|
|
|
+ rect: "矩形选择",
|
|
|
+ polygon: "圈选",
|
|
|
+ lineX: "横向选择",
|
|
|
+ lineY: "纵向选择",
|
|
|
+ keep: "保持选择",
|
|
|
+ clear: "清除选择"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dataView: {
|
|
|
+ title: "数据视图",
|
|
|
+ lang: ["数据视图", "关闭", "刷新"]
|
|
|
+ },
|
|
|
+ dataZoom: {
|
|
|
+ title: {
|
|
|
+ zoom: "区域缩放",
|
|
|
+ back: "区域缩放还原"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ magicType: {
|
|
|
+ title: {
|
|
|
+ line: "切换为折线图",
|
|
|
+ bar: "切换为柱状图",
|
|
|
+ stack: "切换为堆叠",
|
|
|
+ tiled: "切换为平铺"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ restore: {
|
|
|
+ title: "还原"
|
|
|
+ },
|
|
|
+ saveAsImage: {
|
|
|
+ title: "保存为图片",
|
|
|
+ lang: ["右键另存为图片"]
|
|
|
+ }
|
|
|
+ },
|
|
|
+ series: {
|
|
|
+ typeNames: {
|
|
|
+ pie: "饼图",
|
|
|
+ bar: "柱状图",
|
|
|
+ line: "折线图",
|
|
|
+ scatter: "散点图",
|
|
|
+ effectScatter: "涟漪散点图",
|
|
|
+ radar: "雷达图",
|
|
|
+ tree: "树图",
|
|
|
+ treemap: "矩形树图",
|
|
|
+ boxplot: "箱型图",
|
|
|
+ candlestick: "K线图",
|
|
|
+ k: "K线图",
|
|
|
+ heatmap: "热力图",
|
|
|
+ map: "地图",
|
|
|
+ parallel: "平行坐标图",
|
|
|
+ lines: "线图",
|
|
|
+ graph: "关系图",
|
|
|
+ sankey: "桑基图",
|
|
|
+ funnel: "漏斗图",
|
|
|
+ gauge: "仪表盘图",
|
|
|
+ pictorialBar: "象形柱图",
|
|
|
+ themeRiver: "主题河流图",
|
|
|
+ sunburst: "旭日图"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ aria: {
|
|
|
+ general: {
|
|
|
+ withTitle: "这是一个关于“{title}”的图表。",
|
|
|
+ withoutTitle: "这是一个图表，"
|
|
|
+ },
|
|
|
+ series: {
|
|
|
+ single: {
|
|
|
+ prefix: "",
|
|
|
+ withName: "图表类型是{seriesType}，表示{seriesName}。",
|
|
|
+ withoutName: "图表类型是{seriesType}。"
|
|
|
+ },
|
|
|
+ multiple: {
|
|
|
+ prefix: "它由{seriesCount}个图表系列组成。",
|
|
|
+ withName: "第{seriesId}个系列是一个表示{seriesName}的{seriesType}，",
|
|
|
+ withoutName: "第{seriesId}个系列是一个{seriesType}，",
|
|
|
+ separator: {
|
|
|
+ middle: "；",
|
|
|
+ end: "。"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ data: {
|
|
|
+ allData: "其数据是——",
|
|
|
+ partialData: "其中，前{displayCnt}项是——",
|
|
|
+ withName: "{name}的数据是{value}",
|
|
|
+ withoutName: "{value}",
|
|
|
+ separator: {
|
|
|
+ middle: "，",
|
|
|
+ end: ""
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Ec = function(t, e) {
|
|
|
+ var a = e.getModel("aria");
|
|
|
+ if (a.get("show"))
|
|
|
+ if (a.get("description"))
|
|
|
+ t.setAttribute("aria-label", a.get("description"));
|
|
|
+ else {
|
|
|
+ var h = 0;
|
|
|
+ e.eachSeries(function(t, e) {
|
|
|
+ ++h
|
|
|
+ }, this);
|
|
|
+ var i, c = a.get("data.maxCount") || 10, n = a.get("series.maxCount") || 10, d = Math.min(h, n);
|
|
|
+ if (!(h < 1)) {
|
|
|
+ var o = function() {
|
|
|
+ var t = e.getModel("title").option;
|
|
|
+ t && t.length && (t = t[0]);
|
|
|
+ return t && t.text
|
|
|
+ }();
|
|
|
+ i = o ? p(g("general.withTitle"), {
|
|
|
+ title: o
|
|
|
+ }) : g("general.withoutTitle");
|
|
|
+ var f = [];
|
|
|
+ i += p(g(1 < h ? "series.multiple.prefix" : "series.single.prefix"), {
|
|
|
+ seriesCount: h
|
|
|
+ }),
|
|
|
+ e.eachSeries(function(t, e) {
|
|
|
+ if (e < d) {
|
|
|
+ var i, n = t.get("name"), o = "series." + (1 < h ? "multiple" : "single") + ".";
|
|
|
+ i = p(i = g(n ? o + "withName" : o + "withoutName"), {
|
|
|
+ seriesId: t.seriesIndex,
|
|
|
+ seriesName: t.get("name"),
|
|
|
+ seriesType: function(t) {
|
|
|
+ return Oc.series.typeNames[t] || "自定义图"
|
|
|
+ }(t.subType)
|
|
|
+ });
|
|
|
+ var a = t.getData();
|
|
|
+ (window.data = a).count() > c ? i += p(g("data.partialData"), {
|
|
|
+ displayCnt: c
|
|
|
+ }) : i += g("data.allData");
|
|
|
+ for (var r = [], s = 0; s < a.count(); s++)
|
|
|
+ if (s < c) {
|
|
|
+ var l = a.getName(s)
|
|
|
+ , u = Hh(a, s);
|
|
|
+ r.push(p(g(l ? "data.withName" : "data.withoutName"), {
|
|
|
+ name: l,
|
|
|
+ value: u
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ i += r.join(g("data.separator.middle")) + g("data.separator.end"),
|
|
|
+ f.push(i)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ i += f.join(g("series.multiple.separator.middle")) + g("series.multiple.separator.end"),
|
|
|
+ t.setAttribute("aria-label", i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function p(t, e) {
|
|
|
+ if ("string" != typeof t)
|
|
|
+ return t;
|
|
|
+ var i = t;
|
|
|
+ return E(e, function(t, e) {
|
|
|
+ i = i.replace(new RegExp("\\{\\s*" + e + "\\s*\\}","g"), t)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function g(t) {
|
|
|
+ var e = a.get(t);
|
|
|
+ if (null != e)
|
|
|
+ return e;
|
|
|
+ for (var i = t.split("."), n = Oc.aria, o = 0; o < i.length; ++o)
|
|
|
+ n = n[i[o]];
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Rc = Math.PI;
|
|
|
+ function zc(t, e, i, n) {
|
|
|
+ this.ecInstance = t,
|
|
|
+ this.api = e,
|
|
|
+ this.unfinished;
|
|
|
+ i = this._dataProcessorHandlers = i.slice(),
|
|
|
+ n = this._visualHandlers = n.slice();
|
|
|
+ this._allHandlers = i.concat(n),
|
|
|
+ this._stageTaskMap = Q()
|
|
|
+ }
|
|
|
+ var Bc = zc.prototype;
|
|
|
+ function Vc(l, t, u, h, c) {
|
|
|
+ var d;
|
|
|
+ function f(t, e) {
|
|
|
+ return t.setDirty && (!t.dirtyMap || t.dirtyMap.get(e.__pipeline.id))
|
|
|
+ }
|
|
|
+ c = c || {},
|
|
|
+ E(t, function(n, t) {
|
|
|
+ if (!c.visualType || c.visualType === n.visualType) {
|
|
|
+ var e = l._stageTaskMap.get(n.uid)
|
|
|
+ , i = e.seriesTaskMap
|
|
|
+ , o = e.overallTask;
|
|
|
+ if (o) {
|
|
|
+ var a, r = o.agentStubMap;
|
|
|
+ r.each(function(t) {
|
|
|
+ f(c, t) && (t.dirty(),
|
|
|
+ a = !0)
|
|
|
+ }),
|
|
|
+ a && o.dirty(),
|
|
|
+ Gc(o, h);
|
|
|
+ var s = l.getPerformArgs(o, c.block);
|
|
|
+ r.each(function(t) {
|
|
|
+ t.perform(s)
|
|
|
+ }),
|
|
|
+ d |= o.perform(s)
|
|
|
+ } else
|
|
|
+ i && i.each(function(t, e) {
|
|
|
+ f(c, t) && t.dirty();
|
|
|
+ var i = l.getPerformArgs(t, c.block);
|
|
|
+ i.skip = !n.performRawSeries && u.isSeriesFiltered(t.context.model),
|
|
|
+ Gc(t, h),
|
|
|
+ d |= t.perform(i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ l.unfinished |= d
|
|
|
+ }
|
|
|
+ Bc.restoreData = function(t, e) {
|
|
|
+ t.restoreData(e),
|
|
|
+ this._stageTaskMap.each(function(t) {
|
|
|
+ var e = t.overallTask;
|
|
|
+ e && e.dirty()
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.getPerformArgs = function(t, e) {
|
|
|
+ if (t.__pipeline) {
|
|
|
+ var i = this._pipelineMap.get(t.__pipeline.id)
|
|
|
+ , n = i.context
|
|
|
+ , o = !e && i.progressiveEnabled && (!n || n.progressiveRender) && t.__idxInPipeline > i.blockIndex ? i.step : null
|
|
|
+ , a = n && n.modDataCount;
|
|
|
+ return {
|
|
|
+ step: o,
|
|
|
+ modBy: null != a ? Math.ceil(a / o) : null,
|
|
|
+ modDataCount: a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.getPipeline = function(t) {
|
|
|
+ return this._pipelineMap.get(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.updateStreamModes = function(t, e) {
|
|
|
+ var i = this._pipelineMap.get(t.uid)
|
|
|
+ , n = t.getData().count()
|
|
|
+ , o = i.progressiveEnabled && e.incrementalPrepareRender && n >= i.threshold
|
|
|
+ , a = t.get("large") && n >= t.get("largeThreshold")
|
|
|
+ , r = "mod" === t.get("progressiveChunkMode") ? n : null;
|
|
|
+ t.pipelineContext = i.context = {
|
|
|
+ progressiveRender: o,
|
|
|
+ modDataCount: r,
|
|
|
+ large: a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.restorePipelines = function(t) {
|
|
|
+ var n = this
|
|
|
+ , o = n._pipelineMap = Q();
|
|
|
+ t.eachSeries(function(t) {
|
|
|
+ var e = t.getProgressive()
|
|
|
+ , i = t.uid;
|
|
|
+ o.set(i, {
|
|
|
+ id: i,
|
|
|
+ head: null,
|
|
|
+ tail: null,
|
|
|
+ threshold: t.getProgressiveThreshold(),
|
|
|
+ progressiveEnabled: e && !(t.preventIncremental && t.preventIncremental()),
|
|
|
+ blockIndex: -1,
|
|
|
+ step: Math.round(e || 700),
|
|
|
+ count: 0
|
|
|
+ }),
|
|
|
+ Kc(n, t, t.dataTask)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.prepareStageTasks = function() {
|
|
|
+ var i = this._stageTaskMap
|
|
|
+ , n = this.ecInstance.getModel()
|
|
|
+ , o = this.api;
|
|
|
+ E(this._allHandlers, function(t) {
|
|
|
+ var e = i.get(t.uid) || i.set(t.uid, []);
|
|
|
+ t.reset && function(n, o, t, a, r) {
|
|
|
+ var s = t.seriesTaskMap || (t.seriesTaskMap = Q())
|
|
|
+ , e = o.seriesType
|
|
|
+ , i = o.getTargetSeries;
|
|
|
+ o.createOnAllSeries ? a.eachRawSeries(l) : e ? a.eachRawSeriesByType(e, l) : i && i(a, r).each(l);
|
|
|
+ function l(t) {
|
|
|
+ var e = t.uid
|
|
|
+ , i = s.get(e) || s.set(e, Yh({
|
|
|
+ plan: Uc,
|
|
|
+ reset: Xc,
|
|
|
+ count: qc
|
|
|
+ }));
|
|
|
+ i.context = {
|
|
|
+ model: t,
|
|
|
+ ecModel: a,
|
|
|
+ api: r,
|
|
|
+ useClearVisual: o.isVisual && !o.isLayout,
|
|
|
+ plan: o.plan,
|
|
|
+ reset: o.reset,
|
|
|
+ scheduler: n
|
|
|
+ },
|
|
|
+ Kc(n, t, i)
|
|
|
+ }
|
|
|
+ var u = n._pipelineMap;
|
|
|
+ s.each(function(t, e) {
|
|
|
+ u.get(e) || (t.dispose(),
|
|
|
+ s.removeKey(e))
|
|
|
+ })
|
|
|
+ }(this, t, e, n, o),
|
|
|
+ t.overallReset && function(n, t, e, i, o) {
|
|
|
+ var a = e.overallTask = e.overallTask || Yh({
|
|
|
+ reset: Fc
|
|
|
+ });
|
|
|
+ a.context = {
|
|
|
+ ecModel: i,
|
|
|
+ api: o,
|
|
|
+ overallReset: t.overallReset,
|
|
|
+ scheduler: n
|
|
|
+ };
|
|
|
+ var r = a.agentStubMap = a.agentStubMap || Q()
|
|
|
+ , s = t.seriesType
|
|
|
+ , l = t.getTargetSeries
|
|
|
+ , u = !0
|
|
|
+ , h = t.modifyOutputEnd;
|
|
|
+ s ? i.eachRawSeriesByType(s, c) : l ? l(i, o).each(c) : (u = !1,
|
|
|
+ E(i.getSeries(), c));
|
|
|
+ function c(t) {
|
|
|
+ var e = t.uid
|
|
|
+ , i = r.get(e);
|
|
|
+ i || (i = r.set(e, Yh({
|
|
|
+ reset: Wc,
|
|
|
+ onDirty: Zc
|
|
|
+ })),
|
|
|
+ a.dirty()),
|
|
|
+ i.context = {
|
|
|
+ model: t,
|
|
|
+ overallProgress: u,
|
|
|
+ modifyOutputEnd: h
|
|
|
+ },
|
|
|
+ i.agent = a,
|
|
|
+ i.__block = u,
|
|
|
+ Kc(n, t, i)
|
|
|
+ }
|
|
|
+ var d = n._pipelineMap;
|
|
|
+ r.each(function(t, e) {
|
|
|
+ d.get(e) || (t.dispose(),
|
|
|
+ a.dirty(),
|
|
|
+ r.removeKey(e))
|
|
|
+ })
|
|
|
+ }(this, t, e, n, o)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.prepareView = function(t, e, i, n) {
|
|
|
+ var o = t.renderTask
|
|
|
+ , a = o.context;
|
|
|
+ a.model = e,
|
|
|
+ a.ecModel = i,
|
|
|
+ a.api = n,
|
|
|
+ o.__block = !t.incrementalPrepareRender,
|
|
|
+ Kc(this, e, o)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.performDataProcessorTasks = function(t, e) {
|
|
|
+ Vc(this, this._dataProcessorHandlers, t, e, {
|
|
|
+ block: !0
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.performVisualTasks = function(t, e, i) {
|
|
|
+ Vc(this, this._visualHandlers, t, e, i)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.performSeriesTasks = function(t) {
|
|
|
+ var e;
|
|
|
+ t.eachSeries(function(t) {
|
|
|
+ e |= t.dataTask.perform()
|
|
|
+ }),
|
|
|
+ this.unfinished |= e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Bc.plan = function() {
|
|
|
+ this._pipelineMap.each(function(t) {
|
|
|
+ var e = t.tail;
|
|
|
+ do {
|
|
|
+ if (e.__block) {
|
|
|
+ t.blockIndex = e.__idxInPipeline;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ e = e.getUpstream()
|
|
|
+ } while (e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Gc = Bc.updatePayload = function(t, e) {
|
|
|
+ "remain" !== e && (t.context.payload = e)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function Fc(t) {
|
|
|
+ t.overallReset(t.ecModel, t.api, t.payload)
|
|
|
+ }
|
|
|
+ function Wc(t, e) {
|
|
|
+ return t.overallProgress && Hc
|
|
|
+ }
|
|
|
+ function Hc() {
|
|
|
+ this.agent.dirty(),
|
|
|
+ this.getDownstream().dirty()
|
|
|
+ }
|
|
|
+ function Zc() {
|
|
|
+ this.agent && this.agent.dirty()
|
|
|
+ }
|
|
|
+ function Uc(t) {
|
|
|
+ return t.plan && t.plan(t.model, t.ecModel, t.api, t.payload)
|
|
|
+ }
|
|
|
+ function Xc(t) {
|
|
|
+ t.useClearVisual && t.data.clearAllVisual();
|
|
|
+ var e = t.resetDefines = Vo(t.reset(t.model, t.ecModel, t.api, t.payload));
|
|
|
+ return 1 < e.length ? O(e, function(t, e) {
|
|
|
+ return jc(e)
|
|
|
+ }) : Yc
|
|
|
+ }
|
|
|
+ var Yc = jc(0);
|
|
|
+ function jc(a) {
|
|
|
+ return function(t, e) {
|
|
|
+ var i = e.data
|
|
|
+ , n = e.resetDefines[a];
|
|
|
+ if (n && n.dataEach)
|
|
|
+ for (var o = t.start; o < t.end; o++)
|
|
|
+ n.dataEach(i, o);
|
|
|
+ else
|
|
|
+ n && n.progress && n.progress(t, i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function qc(t) {
|
|
|
+ return t.data.count()
|
|
|
+ }
|
|
|
+ function Kc(t, e, i) {
|
|
|
+ var n = e.uid
|
|
|
+ , o = t._pipelineMap.get(n);
|
|
|
+ o.head || (o.head = i),
|
|
|
+ o.tail && o.tail.pipe(i),
|
|
|
+ (o.tail = i).__idxInPipeline = o.count++,
|
|
|
+ i.__pipeline = o
|
|
|
+ }
|
|
|
+ zc.wrapStageHandler = function(t, e) {
|
|
|
+ return C(t) && (t = {
|
|
|
+ overallReset: t,
|
|
|
+ seriesType: function(t) {
|
|
|
+ $c = null;
|
|
|
+ try {
|
|
|
+ t(Jc, Qc)
|
|
|
+ } catch (t) {}
|
|
|
+ return $c
|
|
|
+ }(t)
|
|
|
+ }),
|
|
|
+ t.uid = Nl("stageHandler"),
|
|
|
+ e && (t.visualType = e),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var $c, Jc = {}, Qc = {};
|
|
|
+ function td(t, e) {
|
|
|
+ for (var i in e.prototype)
|
|
|
+ t[i] = et
|
|
|
+ }
|
|
|
+ td(Jc, ih),
|
|
|
+ td(Qc, rh),
|
|
|
+ Jc.eachSeriesByType = Jc.eachRawSeriesByType = function(t) {
|
|
|
+ $c = t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Jc.eachComponent = function(t) {
|
|
|
+ "series" === t.mainType && t.subType && ($c = t.subType)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function ed() {
|
|
|
+ return {
|
|
|
+ axisLine: {
|
|
|
+ lineStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ },
|
|
|
+ axisTick: {
|
|
|
+ lineStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ },
|
|
|
+ axisLabel: {
|
|
|
+ textStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ },
|
|
|
+ splitLine: {
|
|
|
+ lineStyle: {
|
|
|
+ type: "dashed",
|
|
|
+ color: "#aaa"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ splitArea: {
|
|
|
+ areaStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var id = ["#37A2DA", "#32C5E9", "#67E0E3", "#9FE6B8", "#FFDB5C", "#ff9f7f", "#fb7293", "#E062AE", "#E690D1", "#e7bcf3", "#9d96f5", "#8378EA", "#96BFFF"]
|
|
|
+ , nd = {
|
|
|
+ color: id,
|
|
|
+ colorLayer: [["#37A2DA", "#ffd85c", "#fd7b5f"], ["#37A2DA", "#67E0E3", "#FFDB5C", "#ff9f7f", "#E062AE", "#9d96f5"], ["#37A2DA", "#32C5E9", "#9FE6B8", "#FFDB5C", "#ff9f7f", "#fb7293", "#e7bcf3", "#8378EA", "#96BFFF"], id]
|
|
|
+ }
|
|
|
+ , od = "#eee"
|
|
|
+ , ad = ["#dd6b66", "#759aa0", "#e69d87", "#8dc1a9", "#ea7e53", "#eedd78", "#73a373", "#73b9bc", "#7289ab", "#91ca8c", "#f49f42"]
|
|
|
+ , rd = {
|
|
|
+ color: ad,
|
|
|
+ backgroundColor: "#333",
|
|
|
+ tooltip: {
|
|
|
+ axisPointer: {
|
|
|
+ lineStyle: {
|
|
|
+ color: od
|
|
|
+ },
|
|
|
+ crossStyle: {
|
|
|
+ color: od
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ color: "#000"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ legend: {
|
|
|
+ textStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ },
|
|
|
+ textStyle: {
|
|
|
+ color: od
|
|
|
+ },
|
|
|
+ title: {
|
|
|
+ textStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ },
|
|
|
+ toolbox: {
|
|
|
+ iconStyle: {
|
|
|
+ normal: {
|
|
|
+ borderColor: od
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dataZoom: {
|
|
|
+ textStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ },
|
|
|
+ visualMap: {
|
|
|
+ textStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ },
|
|
|
+ timeline: {
|
|
|
+ lineStyle: {
|
|
|
+ color: od
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ normal: {
|
|
|
+ color: ad[1]
|
|
|
+ }
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ normal: {
|
|
|
+ textStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ controlStyle: {
|
|
|
+ normal: {
|
|
|
+ color: od,
|
|
|
+ borderColor: od
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ timeAxis: ed(),
|
|
|
+ logAxis: ed(),
|
|
|
+ valueAxis: ed(),
|
|
|
+ categoryAxis: ed(),
|
|
|
+ line: {
|
|
|
+ symbol: "circle"
|
|
|
+ },
|
|
|
+ graph: {
|
|
|
+ color: ad
|
|
|
+ },
|
|
|
+ gauge: {
|
|
|
+ title: {
|
|
|
+ textStyle: {
|
|
|
+ color: od
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ candlestick: {
|
|
|
+ itemStyle: {
|
|
|
+ normal: {
|
|
|
+ color: "#FD1050",
|
|
|
+ color0: "#0CF49B",
|
|
|
+ borderColor: "#FD1050",
|
|
|
+ borderColor0: "#0CF49B"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ rd.categoryAxis.splitLine.show = !1,
|
|
|
+ ku.extend({
|
|
|
+ type: "dataset",
|
|
|
+ defaultOption: {
|
|
|
+ seriesLayoutBy: Hu,
|
|
|
+ sourceHeader: null,
|
|
|
+ dimensions: null,
|
|
|
+ source: null
|
|
|
+ },
|
|
|
+ optionUpdated: function() {
|
|
|
+ !function(t) {
|
|
|
+ var e = t.option.source
|
|
|
+ , i = Fu;
|
|
|
+ if (V(e))
|
|
|
+ i = Wu;
|
|
|
+ else if (L(e)) {
|
|
|
+ 0 === e.length && (i = Bu);
|
|
|
+ for (var n = 0, o = e.length; n < o; n++) {
|
|
|
+ var a = e[n];
|
|
|
+ if (null != a) {
|
|
|
+ if (L(a)) {
|
|
|
+ i = Bu;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ if (z(a)) {
|
|
|
+ i = Vu;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (z(e)) {
|
|
|
+ for (var r in e)
|
|
|
+ if (e.hasOwnProperty(r) && N(e[r])) {
|
|
|
+ i = Gu;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ } else if (null != e)
|
|
|
+ throw new Error("Invalid data");
|
|
|
+ Yu(t).sourceFormat = i
|
|
|
+ }(this)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ gc.extend({
|
|
|
+ type: "dataset"
|
|
|
+ });
|
|
|
+ var sd = Ar.extend({
|
|
|
+ type: "ellipse",
|
|
|
+ shape: {
|
|
|
+ cx: 0,
|
|
|
+ cy: 0,
|
|
|
+ rx: 0,
|
|
|
+ ry: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.cx
|
|
|
+ , n = e.cy
|
|
|
+ , o = e.rx
|
|
|
+ , a = e.ry
|
|
|
+ , r = .5522848 * o
|
|
|
+ , s = .5522848 * a;
|
|
|
+ t.moveTo(i - o, n),
|
|
|
+ t.bezierCurveTo(i - o, n - s, i - r, n - a, i, n - a),
|
|
|
+ t.bezierCurveTo(i + r, n - a, i + o, n - s, i + o, n),
|
|
|
+ t.bezierCurveTo(i + o, n + s, i + r, n + a, i, n + a),
|
|
|
+ t.bezierCurveTo(i - r, n + a, i - o, n + s, i - o, n),
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , ld = /[\s,]+/;
|
|
|
+ function ud(t) {
|
|
|
+ R(t) && (t = (new DOMParser).parseFromString(t, "text/xml"));
|
|
|
+ for (9 === t.nodeType && (t = t.firstChild); "svg" !== t.nodeName.toLowerCase() || 1 !== t.nodeType; )
|
|
|
+ t = t.nextSibling;
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function hd() {
|
|
|
+ this._defs = {},
|
|
|
+ this._root = null,
|
|
|
+ this._isDefine = !1,
|
|
|
+ this._isText = !1
|
|
|
+ }
|
|
|
+ hd.prototype.parse = function(t, e) {
|
|
|
+ e = e || {};
|
|
|
+ var i = ud(t);
|
|
|
+ if (!i)
|
|
|
+ throw new Error("Illegal svg");
|
|
|
+ var n = new Ci;
|
|
|
+ this._root = n;
|
|
|
+ var o = i.getAttribute("viewBox") || ""
|
|
|
+ , a = parseFloat(i.getAttribute("width") || e.width)
|
|
|
+ , r = parseFloat(i.getAttribute("height") || e.height);
|
|
|
+ isNaN(a) && (a = null),
|
|
|
+ isNaN(r) && (r = null),
|
|
|
+ md(i, n, null, !0);
|
|
|
+ for (var s, l, u = i.firstChild; u; )
|
|
|
+ this._parseNode(u, n),
|
|
|
+ u = u.nextSibling;
|
|
|
+ if (o) {
|
|
|
+ var h = j(o).split(ld);
|
|
|
+ 4 <= h.length && (s = {
|
|
|
+ x: parseFloat(h[0] || 0),
|
|
|
+ y: parseFloat(h[1] || 0),
|
|
|
+ width: parseFloat(h[2]),
|
|
|
+ height: parseFloat(h[3])
|
|
|
+ })
|
|
|
+ }
|
|
|
+ if (s && null != a && null != r && (l = wd(s, a, r),
|
|
|
+ !e.ignoreViewBox)) {
|
|
|
+ var c = n;
|
|
|
+ (n = new Ci).add(c),
|
|
|
+ c.scale = l.scale.slice(),
|
|
|
+ c.position = l.position.slice()
|
|
|
+ }
|
|
|
+ return e.ignoreRootClip || null == a || null == r || n.setClipPath(new rs({
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: a,
|
|
|
+ height: r
|
|
|
+ }
|
|
|
+ })),
|
|
|
+ {
|
|
|
+ root: n,
|
|
|
+ width: a,
|
|
|
+ height: r,
|
|
|
+ viewBoxRect: s,
|
|
|
+ viewBoxTransform: l
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ hd.prototype._parseNode = function(t, e) {
|
|
|
+ var i, n, o = t.nodeName.toLowerCase();
|
|
|
+ if ("defs" === o ? this._isDefine = !0 : "text" === o && (this._isText = !0),
|
|
|
+ this._isDefine) {
|
|
|
+ if (n = dd[o]) {
|
|
|
+ var a = n.call(this, t)
|
|
|
+ , r = t.getAttribute("id");
|
|
|
+ r && (this._defs[r] = a)
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ (n = cd[o]) && (i = n.call(this, t, e),
|
|
|
+ e.add(i));
|
|
|
+ for (var s = t.firstChild; s; )
|
|
|
+ 1 === s.nodeType && this._parseNode(s, i),
|
|
|
+ 3 === s.nodeType && this._isText && this._parseText(s, i),
|
|
|
+ s = s.nextSibling;
|
|
|
+ "defs" === o ? this._isDefine = !1 : "text" === o && (this._isText = !1)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ hd.prototype._parseText = function(t, e) {
|
|
|
+ if (1 === t.nodeType) {
|
|
|
+ var i = t.getAttribute("dx") || 0
|
|
|
+ , n = t.getAttribute("dy") || 0;
|
|
|
+ this._textX += parseFloat(i),
|
|
|
+ this._textY += parseFloat(n)
|
|
|
+ }
|
|
|
+ var o = new Ur({
|
|
|
+ style: {
|
|
|
+ text: t.textContent,
|
|
|
+ transformText: !0
|
|
|
+ },
|
|
|
+ position: [this._textX || 0, this._textY || 0]
|
|
|
+ });
|
|
|
+ fd(e, o),
|
|
|
+ md(t, o, this._defs);
|
|
|
+ var a = o.style.fontSize;
|
|
|
+ a && a < 9 && (o.style.fontSize = 9,
|
|
|
+ o.scale = o.scale || [1, 1],
|
|
|
+ o.scale[0] *= a / 9,
|
|
|
+ o.scale[1] *= a / 9);
|
|
|
+ var r = o.getBoundingRect();
|
|
|
+ return this._textX += r.width,
|
|
|
+ e.add(o),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var cd = {
|
|
|
+ g: function(t, e) {
|
|
|
+ var i = new Ci;
|
|
|
+ return fd(e, i),
|
|
|
+ md(t, i, this._defs),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ rect: function(t, e) {
|
|
|
+ var i = new rs;
|
|
|
+ return fd(e, i),
|
|
|
+ md(t, i, this._defs),
|
|
|
+ i.setShape({
|
|
|
+ x: parseFloat(t.getAttribute("x") || 0),
|
|
|
+ y: parseFloat(t.getAttribute("y") || 0),
|
|
|
+ width: parseFloat(t.getAttribute("width") || 0),
|
|
|
+ height: parseFloat(t.getAttribute("height") || 0)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ circle: function(t, e) {
|
|
|
+ var i = new Yr;
|
|
|
+ return fd(e, i),
|
|
|
+ md(t, i, this._defs),
|
|
|
+ i.setShape({
|
|
|
+ cx: parseFloat(t.getAttribute("cx") || 0),
|
|
|
+ cy: parseFloat(t.getAttribute("cy") || 0),
|
|
|
+ r: parseFloat(t.getAttribute("r") || 0)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ line: function(t, e) {
|
|
|
+ var i = new ls;
|
|
|
+ return fd(e, i),
|
|
|
+ md(t, i, this._defs),
|
|
|
+ i.setShape({
|
|
|
+ x1: parseFloat(t.getAttribute("x1") || 0),
|
|
|
+ y1: parseFloat(t.getAttribute("y1") || 0),
|
|
|
+ x2: parseFloat(t.getAttribute("x2") || 0),
|
|
|
+ y2: parseFloat(t.getAttribute("y2") || 0)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ ellipse: function(t, e) {
|
|
|
+ var i = new sd;
|
|
|
+ return fd(e, i),
|
|
|
+ md(t, i, this._defs),
|
|
|
+ i.setShape({
|
|
|
+ cx: parseFloat(t.getAttribute("cx") || 0),
|
|
|
+ cy: parseFloat(t.getAttribute("cy") || 0),
|
|
|
+ rx: parseFloat(t.getAttribute("rx") || 0),
|
|
|
+ ry: parseFloat(t.getAttribute("ry") || 0)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ polygon: function(t, e) {
|
|
|
+ var i = t.getAttribute("points");
|
|
|
+ i = i && pd(i);
|
|
|
+ var n = new Qr({
|
|
|
+ shape: {
|
|
|
+ points: i || []
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return fd(e, n),
|
|
|
+ md(t, n, this._defs),
|
|
|
+ n
|
|
|
+ },
|
|
|
+ polyline: function(t, e) {
|
|
|
+ var i = new Ar;
|
|
|
+ fd(e, i),
|
|
|
+ md(t, i, this._defs);
|
|
|
+ var n = t.getAttribute("points");
|
|
|
+ return n = n && pd(n),
|
|
|
+ new ts({
|
|
|
+ shape: {
|
|
|
+ points: n || []
|
|
|
+ }
|
|
|
+ })
|
|
|
+ },
|
|
|
+ image: function(t, e) {
|
|
|
+ var i = new Qn;
|
|
|
+ return fd(e, i),
|
|
|
+ md(t, i, this._defs),
|
|
|
+ i.setStyle({
|
|
|
+ image: t.getAttribute("xlink:href"),
|
|
|
+ x: t.getAttribute("x"),
|
|
|
+ y: t.getAttribute("y"),
|
|
|
+ width: t.getAttribute("width"),
|
|
|
+ height: t.getAttribute("height")
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ text: function(t, e) {
|
|
|
+ var i = t.getAttribute("x") || 0
|
|
|
+ , n = t.getAttribute("y") || 0
|
|
|
+ , o = t.getAttribute("dx") || 0
|
|
|
+ , a = t.getAttribute("dy") || 0;
|
|
|
+ this._textX = parseFloat(i) + parseFloat(o),
|
|
|
+ this._textY = parseFloat(n) + parseFloat(a);
|
|
|
+ var r = new Ci;
|
|
|
+ return fd(e, r),
|
|
|
+ md(t, r, this._defs),
|
|
|
+ r
|
|
|
+ },
|
|
|
+ tspan: function(t, e) {
|
|
|
+ var i = t.getAttribute("x")
|
|
|
+ , n = t.getAttribute("y");
|
|
|
+ null != i && (this._textX = parseFloat(i)),
|
|
|
+ null != n && (this._textY = parseFloat(n));
|
|
|
+ var o = t.getAttribute("dx") || 0
|
|
|
+ , a = t.getAttribute("dy") || 0
|
|
|
+ , r = new Ci;
|
|
|
+ return fd(e, r),
|
|
|
+ md(t, r, this._defs),
|
|
|
+ this._textX += o,
|
|
|
+ this._textY += a,
|
|
|
+ r
|
|
|
+ },
|
|
|
+ path: function(t, e) {
|
|
|
+ var i = Zr(t.getAttribute("d") || "");
|
|
|
+ return fd(e, i),
|
|
|
+ md(t, i, this._defs),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , dd = {
|
|
|
+ lineargradient: function(t) {
|
|
|
+ var e = parseInt(t.getAttribute("x1") || 0, 10)
|
|
|
+ , i = parseInt(t.getAttribute("y1") || 0, 10)
|
|
|
+ , n = parseInt(t.getAttribute("x2") || 10, 10)
|
|
|
+ , o = parseInt(t.getAttribute("y2") || 0, 10)
|
|
|
+ , a = new gs(e,i,n,o);
|
|
|
+ return function(t, e) {
|
|
|
+ var i = t.firstChild;
|
|
|
+ for (; i; ) {
|
|
|
+ if (1 === i.nodeType) {
|
|
|
+ var n = i.getAttribute("offset");
|
|
|
+ n = 0 < n.indexOf("%") ? parseInt(n, 10) / 100 : n ? parseFloat(n) : 0;
|
|
|
+ var o = i.getAttribute("stop-color") || "#000000";
|
|
|
+ e.addColorStop(n, o)
|
|
|
+ }
|
|
|
+ i = i.nextSibling
|
|
|
+ }
|
|
|
+ }(t, a),
|
|
|
+ a
|
|
|
+ },
|
|
|
+ radialgradient: function(t) {}
|
|
|
+ };
|
|
|
+ function fd(t, e) {
|
|
|
+ t && t.__inheritedStyle && (e.__inheritedStyle || (e.__inheritedStyle = {}),
|
|
|
+ D(e.__inheritedStyle, t.__inheritedStyle))
|
|
|
+ }
|
|
|
+ function pd(t) {
|
|
|
+ for (var e = j(t).split(ld), i = [], n = 0; n < e.length; n += 2) {
|
|
|
+ var o = parseFloat(e[n])
|
|
|
+ , a = parseFloat(e[n + 1]);
|
|
|
+ i.push([o, a])
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ var gd = {
|
|
|
+ fill: "fill",
|
|
|
+ stroke: "stroke",
|
|
|
+ "stroke-width": "lineWidth",
|
|
|
+ opacity: "opacity",
|
|
|
+ "fill-opacity": "fillOpacity",
|
|
|
+ "stroke-opacity": "strokeOpacity",
|
|
|
+ "stroke-dasharray": "lineDash",
|
|
|
+ "stroke-dashoffset": "lineDashOffset",
|
|
|
+ "stroke-linecap": "lineCap",
|
|
|
+ "stroke-linejoin": "lineJoin",
|
|
|
+ "stroke-miterlimit": "miterLimit",
|
|
|
+ "font-family": "fontFamily",
|
|
|
+ "font-size": "fontSize",
|
|
|
+ "font-style": "fontStyle",
|
|
|
+ "font-weight": "fontWeight",
|
|
|
+ "text-align": "textAlign",
|
|
|
+ "alignment-baseline": "textBaseline"
|
|
|
+ };
|
|
|
+ function md(t, e, i, n) {
|
|
|
+ var o = e.__inheritedStyle || {}
|
|
|
+ , a = "text" === e.type;
|
|
|
+ if (1 === t.nodeType && (function(t, e) {
|
|
|
+ var i = t.getAttribute("transform");
|
|
|
+ if (i) {
|
|
|
+ i = i.replace(/,/g, " ");
|
|
|
+ var n = null
|
|
|
+ , o = [];
|
|
|
+ i.replace(xd, function(t, e, i) {
|
|
|
+ o.push(e, i)
|
|
|
+ });
|
|
|
+ for (var a = o.length - 1; 0 < a; a -= 2) {
|
|
|
+ var r = o[a]
|
|
|
+ , s = o[a - 1];
|
|
|
+ switch (n = n || ae(),
|
|
|
+ s) {
|
|
|
+ case "translate":
|
|
|
+ r = j(r).split(ld),
|
|
|
+ ue(n, n, [parseFloat(r[0]), parseFloat(r[1] || 0)]);
|
|
|
+ break;
|
|
|
+ case "scale":
|
|
|
+ r = j(r).split(ld),
|
|
|
+ ce(n, n, [parseFloat(r[0]), parseFloat(r[1] || r[0])]);
|
|
|
+ break;
|
|
|
+ case "rotate":
|
|
|
+ r = j(r).split(ld),
|
|
|
+ he(n, n, parseFloat(r[0]));
|
|
|
+ break;
|
|
|
+ case "skew":
|
|
|
+ r = j(r).split(ld),
|
|
|
+ console.warn("Skew transform is not supported yet");
|
|
|
+ break;
|
|
|
+ case "matrix":
|
|
|
+ r = j(r).split(ld);
|
|
|
+ n[0] = parseFloat(r[0]),
|
|
|
+ n[1] = parseFloat(r[1]),
|
|
|
+ n[2] = parseFloat(r[2]),
|
|
|
+ n[3] = parseFloat(r[3]),
|
|
|
+ n[4] = parseFloat(r[4]),
|
|
|
+ n[5] = parseFloat(r[5])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ e.setLocalTransform(n)
|
|
|
+ }
|
|
|
+ }(t, e),
|
|
|
+ P(o, function(t) {
|
|
|
+ var e = t.getAttribute("style")
|
|
|
+ , i = {};
|
|
|
+ if (!e)
|
|
|
+ return i;
|
|
|
+ var n, o = {};
|
|
|
+ _d.lastIndex = 0;
|
|
|
+ for (; null != (n = _d.exec(e)); )
|
|
|
+ o[n[1]] = n[2];
|
|
|
+ for (var a in gd)
|
|
|
+ gd.hasOwnProperty(a) && null != o[a] && (i[gd[a]] = o[a]);
|
|
|
+ return i
|
|
|
+ }(t)),
|
|
|
+ !n))
|
|
|
+ for (var r in gd)
|
|
|
+ if (gd.hasOwnProperty(r)) {
|
|
|
+ var s = t.getAttribute(r);
|
|
|
+ null != s && (o[gd[r]] = s)
|
|
|
+ }
|
|
|
+ var l = a ? "textFill" : "fill"
|
|
|
+ , u = a ? "textStroke" : "stroke";
|
|
|
+ e.style = e.style || new Ui;
|
|
|
+ var h = e.style;
|
|
|
+ null != o.fill && h.set(l, yd(o.fill, i)),
|
|
|
+ null != o.stroke && h.set(u, yd(o.stroke, i)),
|
|
|
+ E(["lineWidth", "opacity", "fillOpacity", "strokeOpacity", "miterLimit", "fontSize"], function(t) {
|
|
|
+ var e = "lineWidth" === t && a ? "textStrokeWidth" : t;
|
|
|
+ null != o[t] && h.set(e, parseFloat(o[t]))
|
|
|
+ }),
|
|
|
+ o.textBaseline && "auto" !== o.textBaseline || (o.textBaseline = "alphabetic"),
|
|
|
+ "alphabetic" === o.textBaseline && (o.textBaseline = "bottom"),
|
|
|
+ "start" === o.textAlign && (o.textAlign = "left"),
|
|
|
+ "end" === o.textAlign && (o.textAlign = "right"),
|
|
|
+ E(["lineDashOffset", "lineCap", "lineJoin", "fontWeight", "fontFamily", "fontStyle", "textAlign", "textBaseline"], function(t) {
|
|
|
+ null != o[t] && h.set(t, o[t])
|
|
|
+ }),
|
|
|
+ o.lineDash && (e.style.lineDash = j(o.lineDash).split(ld)),
|
|
|
+ h[u] && "none" !== h[u] && (e[u] = !0),
|
|
|
+ e.__inheritedStyle = o
|
|
|
+ }
|
|
|
+ var vd = /url\(\s*#(.*?)\)/;
|
|
|
+ function yd(t, e) {
|
|
|
+ var i = e && t && t.match(vd);
|
|
|
+ return i ? e[j(i[1])] : t
|
|
|
+ }
|
|
|
+ var xd = /(translate|scale|rotate|skewX|skewY|matrix)\(([\-\s0-9\.e,]*)\)/g;
|
|
|
+ var _d = /([^\s:;]+)\s*:\s*([^:;]+)/g;
|
|
|
+ function wd(t, e, i) {
|
|
|
+ var n = e / t.width
|
|
|
+ , o = i / t.height
|
|
|
+ , a = Math.min(n, o);
|
|
|
+ return {
|
|
|
+ scale: [a, a],
|
|
|
+ position: [-(t.x + t.width / 2) * a + e / 2, -(t.y + t.height / 2) * a + i / 2]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var bd = Q()
|
|
|
+ , Sd = {
|
|
|
+ registerMap: function(t, e, i) {
|
|
|
+ var n;
|
|
|
+ return E(n = L(e) ? e : e.svg ? [{
|
|
|
+ type: "svg",
|
|
|
+ source: e.svg,
|
|
|
+ specialAreas: e.specialAreas
|
|
|
+ }] : (e.geoJson && !e.features && (i = e.specialAreas,
|
|
|
+ e = e.geoJson),
|
|
|
+ [{
|
|
|
+ type: "geoJSON",
|
|
|
+ source: e,
|
|
|
+ specialAreas: i
|
|
|
+ }]), function(t) {
|
|
|
+ var e = t.type;
|
|
|
+ "geoJson" === e && (e = t.type = "geoJSON"),
|
|
|
+ (0,
|
|
|
+ Md[e])(t)
|
|
|
+ }),
|
|
|
+ bd.set(t, n)
|
|
|
+ },
|
|
|
+ retrieveMap: function(t) {
|
|
|
+ return bd.get(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Md = {
|
|
|
+ geoJSON: function(t) {
|
|
|
+ var e = t.source;
|
|
|
+ t.geoJSON = R(e) ? "undefined" != typeof JSON && JSON.parse ? JSON.parse(e) : new Function("return (" + e + ");")() : e
|
|
|
+ },
|
|
|
+ svg: function(t) {
|
|
|
+ t.svgXML = ud(t.source)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Id = Y
|
|
|
+ , Td = E
|
|
|
+ , Ad = C
|
|
|
+ , Dd = z
|
|
|
+ , Cd = ku.parseClassType
|
|
|
+ , Ld = {
|
|
|
+ PROCESSOR: {
|
|
|
+ FILTER: 1e3,
|
|
|
+ SERIES_FILTER: 800,
|
|
|
+ STATISTIC: 5e3
|
|
|
+ },
|
|
|
+ VISUAL: {
|
|
|
+ LAYOUT: 1e3,
|
|
|
+ PROGRESSIVE_LAYOUT: 1100,
|
|
|
+ GLOBAL: 2e3,
|
|
|
+ CHART: 3e3,
|
|
|
+ POST_CHART_LAYOUT: 3500,
|
|
|
+ COMPONENT: 4e3,
|
|
|
+ BRUSH: 5e3
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , kd = "__flagInMainProcess"
|
|
|
+ , Pd = "__optionUpdated"
|
|
|
+ , Nd = /^[a-zA-Z0-9_]+$/;
|
|
|
+ function Od(n, o) {
|
|
|
+ return function(t, e, i) {
|
|
|
+ !o && this._disposed || (t = t && t.toLowerCase(),
|
|
|
+ Ct.prototype[n].call(this, t, e, i))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ed() {
|
|
|
+ Ct.call(this)
|
|
|
+ }
|
|
|
+ function Rd(t, e, i) {
|
|
|
+ i = i || {},
|
|
|
+ "string" == typeof e && (e = sf[e]),
|
|
|
+ this.id,
|
|
|
+ this.group,
|
|
|
+ this._dom = t;
|
|
|
+ var n = this._zr = ko(t, {
|
|
|
+ renderer: i.renderer || "canvas",
|
|
|
+ devicePixelRatio: i.devicePixelRatio,
|
|
|
+ width: i.width,
|
|
|
+ height: i.height
|
|
|
+ });
|
|
|
+ this._throttledZrFlush = Lc(A(n.flush, n), 17),
|
|
|
+ (e = k(e)) && Lh(e, !0),
|
|
|
+ this._theme = e,
|
|
|
+ this._chartsViews = [],
|
|
|
+ this._chartsMap = {},
|
|
|
+ this._componentsViews = [],
|
|
|
+ this._componentsMap = {},
|
|
|
+ this._coordSysMgr = new lh;
|
|
|
+ var o = this._api = function(i) {
|
|
|
+ var t = i._coordSysMgr;
|
|
|
+ return P(new rh(i), {
|
|
|
+ getCoordinateSystems: A(t.getCoordinateSystems, t),
|
|
|
+ getComponentByElement: function(t) {
|
|
|
+ for (; t; ) {
|
|
|
+ var e = t.__ecComponentInfo;
|
|
|
+ if (null != e)
|
|
|
+ return i._model.getComponent(e.mainType, e.index);
|
|
|
+ t = t.parent
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }(this);
|
|
|
+ function a(t, e) {
|
|
|
+ return t.__prio - e.__prio
|
|
|
+ }
|
|
|
+ zi(rf, a),
|
|
|
+ zi(nf, a),
|
|
|
+ this._scheduler = new zc(this,o,nf,rf),
|
|
|
+ Ct.call(this, this._ecEventProcessor = new Qd),
|
|
|
+ this._messageCenter = new Ed,
|
|
|
+ this._initEvents(),
|
|
|
+ this.resize = A(this.resize, this),
|
|
|
+ this._pendingActions = [],
|
|
|
+ n.animation.on("frame", this._onframe, this),
|
|
|
+ function(t, e) {
|
|
|
+ t.on("rendered", function() {
|
|
|
+ e.trigger("rendered"),
|
|
|
+ !t.animation.isFinished() || e[Pd] || e._scheduler.unfinished || e._pendingActions.length || e.trigger("finished")
|
|
|
+ })
|
|
|
+ }(n, this),
|
|
|
+ K(this)
|
|
|
+ }
|
|
|
+ Ed.prototype.on = Od("on", !0),
|
|
|
+ Ed.prototype.off = Od("off", !0),
|
|
|
+ Ed.prototype.one = Od("one", !0),
|
|
|
+ b(Ed, Ct);
|
|
|
+ var zd = Rd.prototype;
|
|
|
+ function Bd(t, e, i) {
|
|
|
+ if (!this._disposed) {
|
|
|
+ var n, o = this._model, a = this._coordSysMgr.getCoordinateSystems();
|
|
|
+ e = Ko(o, e);
|
|
|
+ for (var r = 0; r < a.length; r++) {
|
|
|
+ var s = a[r];
|
|
|
+ if (s[t] && null != (n = s[t](o, e, i)))
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ zd._onframe = function() {
|
|
|
+ if (!this._disposed) {
|
|
|
+ var t = this._scheduler;
|
|
|
+ if (this[Pd]) {
|
|
|
+ var e = this[Pd].silent;
|
|
|
+ this[kd] = !0,
|
|
|
+ Gd(this),
|
|
|
+ Vd.update.call(this),
|
|
|
+ this[kd] = !1,
|
|
|
+ this[Pd] = !1,
|
|
|
+ Zd.call(this, e),
|
|
|
+ Ud.call(this, e)
|
|
|
+ } else if (t.unfinished) {
|
|
|
+ var i = 1
|
|
|
+ , n = this._model
|
|
|
+ , o = this._api;
|
|
|
+ t.unfinished = !1;
|
|
|
+ do {
|
|
|
+ var a = +new Date;
|
|
|
+ t.performSeriesTasks(n),
|
|
|
+ t.performDataProcessorTasks(n),
|
|
|
+ Wd(this, n),
|
|
|
+ t.performVisualTasks(n),
|
|
|
+ qd(this, this._model, o, "remain"),
|
|
|
+ i -= +new Date - a
|
|
|
+ } while (0 < i && t.unfinished);
|
|
|
+ t.unfinished || this._zr.flush()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getDom = function() {
|
|
|
+ return this._dom
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getZr = function() {
|
|
|
+ return this._zr
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.setOption = function(t, e, i) {
|
|
|
+ if (!this._disposed) {
|
|
|
+ var n;
|
|
|
+ if (Dd(e) && (i = e.lazyUpdate,
|
|
|
+ n = e.silent,
|
|
|
+ e = e.notMerge),
|
|
|
+ this[kd] = !0,
|
|
|
+ !this._model || e) {
|
|
|
+ var o = new ph(this._api)
|
|
|
+ , a = this._theme
|
|
|
+ , r = this._model = new ih;
|
|
|
+ r.scheduler = this._scheduler,
|
|
|
+ r.init(null, null, a, o)
|
|
|
+ }
|
|
|
+ this._model.setOption(t, of),
|
|
|
+ i ? (this[Pd] = {
|
|
|
+ silent: n
|
|
|
+ },
|
|
|
+ this[kd] = !1) : (Gd(this),
|
|
|
+ Vd.update.call(this),
|
|
|
+ this._zr.flush(),
|
|
|
+ this[Pd] = !1,
|
|
|
+ this[kd] = !1,
|
|
|
+ Zd.call(this, n),
|
|
|
+ Ud.call(this, n))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.setTheme = function() {
|
|
|
+ console.error("ECharts#setTheme() is DEPRECATED in ECharts 3.0")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getModel = function() {
|
|
|
+ return this._model
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getOption = function() {
|
|
|
+ return this._model && this._model.getOption()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getWidth = function() {
|
|
|
+ return this._zr.getWidth()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getHeight = function() {
|
|
|
+ return this._zr.getHeight()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getDevicePixelRatio = function() {
|
|
|
+ return this._zr.painter.dpr || window.devicePixelRatio || 1
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getRenderedCanvas = function(t) {
|
|
|
+ if (v.canvasSupported)
|
|
|
+ return (t = t || {}).pixelRatio = t.pixelRatio || 1,
|
|
|
+ t.backgroundColor = t.backgroundColor || this._model.get("backgroundColor"),
|
|
|
+ this._zr.painter.getRenderedCanvas(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getSvgDataURL = function() {
|
|
|
+ if (v.svgSupported) {
|
|
|
+ var t = this._zr;
|
|
|
+ return E(t.storage.getDisplayList(), function(t) {
|
|
|
+ t.stopAnimation(!0)
|
|
|
+ }),
|
|
|
+ t.painter.toDataURL()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getDataURL = function(t) {
|
|
|
+ if (!this._disposed) {
|
|
|
+ var e = (t = t || {}).excludeComponents
|
|
|
+ , i = this._model
|
|
|
+ , n = []
|
|
|
+ , o = this;
|
|
|
+ Td(e, function(t) {
|
|
|
+ i.eachComponent({
|
|
|
+ mainType: t
|
|
|
+ }, function(t) {
|
|
|
+ var e = o._componentsMap[t.__viewId];
|
|
|
+ e.group.ignore || (n.push(e),
|
|
|
+ e.group.ignore = !0)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var a = "svg" === this._zr.painter.getType() ? this.getSvgDataURL() : this.getRenderedCanvas(t).toDataURL("image/" + (t && t.type || "png"));
|
|
|
+ return Td(n, function(t) {
|
|
|
+ t.group.ignore = !1
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getConnectedDataURL = function(o) {
|
|
|
+ if (!this._disposed && v.canvasSupported) {
|
|
|
+ var a = "svg" === o.type
|
|
|
+ , r = this.group
|
|
|
+ , s = Math.min
|
|
|
+ , l = Math.max;
|
|
|
+ if (hf[r]) {
|
|
|
+ var u = 1 / 0
|
|
|
+ , h = 1 / 0
|
|
|
+ , c = -1 / 0
|
|
|
+ , d = -1 / 0
|
|
|
+ , f = []
|
|
|
+ , i = o && o.pixelRatio || 1;
|
|
|
+ E(uf, function(t, e) {
|
|
|
+ if (t.group === r) {
|
|
|
+ var i = a ? t.getZr().painter.getSvgDom().innerHTML : t.getRenderedCanvas(k(o))
|
|
|
+ , n = t.getDom().getBoundingClientRect();
|
|
|
+ u = s(n.left, u),
|
|
|
+ h = s(n.top, h),
|
|
|
+ c = l(n.right, c),
|
|
|
+ d = l(n.bottom, d),
|
|
|
+ f.push({
|
|
|
+ dom: i,
|
|
|
+ left: n.left,
|
|
|
+ top: n.top
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var t = (c *= i) - (u *= i)
|
|
|
+ , e = (d *= i) - (h *= i)
|
|
|
+ , n = y()
|
|
|
+ , p = ko(n, {
|
|
|
+ renderer: a ? "svg" : "canvas"
|
|
|
+ });
|
|
|
+ if (p.resize({
|
|
|
+ width: t,
|
|
|
+ height: e
|
|
|
+ }),
|
|
|
+ a) {
|
|
|
+ var g = "";
|
|
|
+ return Td(f, function(t) {
|
|
|
+ var e = t.left - u
|
|
|
+ , i = t.top - h;
|
|
|
+ g += '<g transform="translate(' + e + "," + i + ')">' + t.dom + "</g>"
|
|
|
+ }),
|
|
|
+ p.painter.getSvgRoot().innerHTML = g,
|
|
|
+ o.connectedBackgroundColor && p.painter.setBackgroundColor(o.connectedBackgroundColor),
|
|
|
+ p.refreshImmediately(),
|
|
|
+ p.painter.toDataURL()
|
|
|
+ }
|
|
|
+ return o.connectedBackgroundColor && p.add(new rs({
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: t,
|
|
|
+ height: e
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ fill: o.connectedBackgroundColor
|
|
|
+ }
|
|
|
+ })),
|
|
|
+ Td(f, function(t) {
|
|
|
+ var e = new Qn({
|
|
|
+ style: {
|
|
|
+ x: t.left * i - u,
|
|
|
+ y: t.top * i - h,
|
|
|
+ image: t.dom
|
|
|
+ }
|
|
|
+ });
|
|
|
+ p.add(e)
|
|
|
+ }),
|
|
|
+ p.refreshImmediately(),
|
|
|
+ n.toDataURL("image/" + (o && o.type || "png"))
|
|
|
+ }
|
|
|
+ return this.getDataURL(o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.convertToPixel = T(Bd, "convertToPixel"),
|
|
|
+ zd.convertFromPixel = T(Bd, "convertFromPixel"),
|
|
|
+ zd.containPixel = function(t, o) {
|
|
|
+ var a;
|
|
|
+ if (!this._disposed)
|
|
|
+ return E(t = Ko(this._model, t), function(t, n) {
|
|
|
+ 0 <= n.indexOf("Models") && E(t, function(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ if (e && e.containPoint)
|
|
|
+ a |= !!e.containPoint(o);
|
|
|
+ else if ("seriesModels" === n) {
|
|
|
+ var i = this._chartsMap[t.__viewId];
|
|
|
+ i && i.containPoint && (a |= i.containPoint(o, t))
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }, this),
|
|
|
+ !!a
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getVisual = function(t, e) {
|
|
|
+ var i = (t = Ko(this._model, t, {
|
|
|
+ defaultMainType: "series"
|
|
|
+ })).seriesModel.getData()
|
|
|
+ , n = t.hasOwnProperty("dataIndexInside") ? t.dataIndexInside : t.hasOwnProperty("dataIndex") ? i.indexOfRawIndex(t.dataIndex) : null;
|
|
|
+ return null != n ? i.getItemVisual(n, e) : i.getVisual(e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getViewOfComponentModel = function(t) {
|
|
|
+ return this._componentsMap[t.__viewId]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.getViewOfSeriesModel = function(t) {
|
|
|
+ return this._chartsMap[t.__viewId]
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Vd = {
|
|
|
+ prepareAndUpdate: function(t) {
|
|
|
+ Gd(this),
|
|
|
+ Vd.update.call(this, t)
|
|
|
+ },
|
|
|
+ update: function(t) {
|
|
|
+ var e = this._model
|
|
|
+ , i = this._api
|
|
|
+ , n = this._zr
|
|
|
+ , o = this._coordSysMgr
|
|
|
+ , a = this._scheduler;
|
|
|
+ if (e) {
|
|
|
+ a.restoreData(e, t),
|
|
|
+ a.performSeriesTasks(e),
|
|
|
+ o.create(e, i),
|
|
|
+ a.performDataProcessorTasks(e, t),
|
|
|
+ Wd(this, e),
|
|
|
+ o.update(e, i),
|
|
|
+ Yd(e),
|
|
|
+ a.performVisualTasks(e, t),
|
|
|
+ jd(this, e, i, t);
|
|
|
+ var r = e.get("backgroundColor") || "transparent";
|
|
|
+ if (v.canvasSupported)
|
|
|
+ n.setBackgroundColor(r);
|
|
|
+ else {
|
|
|
+ var s = Fe(r);
|
|
|
+ r = $e(s, "rgb"),
|
|
|
+ 0 === s[3] && (r = "transparent")
|
|
|
+ }
|
|
|
+ Kd(e, i)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ updateTransform: function(o) {
|
|
|
+ var a = this._model
|
|
|
+ , r = this
|
|
|
+ , s = this._api;
|
|
|
+ if (a) {
|
|
|
+ var l = [];
|
|
|
+ a.eachComponent(function(t, e) {
|
|
|
+ var i = r.getViewOfComponentModel(e);
|
|
|
+ if (i && i.__alive)
|
|
|
+ if (i.updateTransform) {
|
|
|
+ var n = i.updateTransform(e, a, s, o);
|
|
|
+ n && n.update && l.push(i)
|
|
|
+ } else
|
|
|
+ l.push(i)
|
|
|
+ });
|
|
|
+ var n = Q();
|
|
|
+ a.eachSeries(function(t) {
|
|
|
+ var e = r._chartsMap[t.__viewId];
|
|
|
+ if (e.updateTransform) {
|
|
|
+ var i = e.updateTransform(t, a, s, o);
|
|
|
+ i && i.update && n.set(t.uid, 1)
|
|
|
+ } else
|
|
|
+ n.set(t.uid, 1)
|
|
|
+ }),
|
|
|
+ Yd(a),
|
|
|
+ this._scheduler.performVisualTasks(a, o, {
|
|
|
+ setDirty: !0,
|
|
|
+ dirtyMap: n
|
|
|
+ }),
|
|
|
+ qd(r, a, s, o, n),
|
|
|
+ Kd(a, this._api)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ updateView: function(t) {
|
|
|
+ var e = this._model;
|
|
|
+ e && (_c.markUpdateMethod(t, "updateView"),
|
|
|
+ Yd(e),
|
|
|
+ this._scheduler.performVisualTasks(e, t, {
|
|
|
+ setDirty: !0
|
|
|
+ }),
|
|
|
+ jd(this, this._model, this._api, t),
|
|
|
+ Kd(e, this._api))
|
|
|
+ },
|
|
|
+ updateVisual: function(t) {
|
|
|
+ Vd.update.call(this, t)
|
|
|
+ },
|
|
|
+ updateLayout: function(t) {
|
|
|
+ Vd.update.call(this, t)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Gd(t) {
|
|
|
+ var e = t._model
|
|
|
+ , i = t._scheduler;
|
|
|
+ i.restorePipelines(e),
|
|
|
+ i.prepareStageTasks(),
|
|
|
+ Xd(t, "component", e, i),
|
|
|
+ Xd(t, "chart", e, i),
|
|
|
+ i.plan()
|
|
|
+ }
|
|
|
+ function Fd(e, i, n, o, t) {
|
|
|
+ var a = e._model;
|
|
|
+ if (o) {
|
|
|
+ var r = {};
|
|
|
+ r[o + "Id"] = n[o + "Id"],
|
|
|
+ r[o + "Index"] = n[o + "Index"],
|
|
|
+ r[o + "Name"] = n[o + "Name"];
|
|
|
+ var s = {
|
|
|
+ mainType: o,
|
|
|
+ query: r
|
|
|
+ };
|
|
|
+ t && (s.subType = t);
|
|
|
+ var l = n.excludeSeriesId;
|
|
|
+ null != l && (l = Q(Vo(l))),
|
|
|
+ a && a.eachComponent(s, function(t) {
|
|
|
+ l && null != l.get(t.id) || u(e["series" === o ? "_chartsMap" : "_componentsMap"][t.__viewId])
|
|
|
+ }, e)
|
|
|
+ } else
|
|
|
+ Td(e._componentsViews.concat(e._chartsViews), u);
|
|
|
+ function u(t) {
|
|
|
+ t && t.__alive && t[i] && t[i](t.__model, a, e._api, n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Wd(t, e) {
|
|
|
+ var i = t._chartsMap
|
|
|
+ , n = t._scheduler;
|
|
|
+ e.eachSeries(function(t) {
|
|
|
+ n.updateStreamModes(t, i[t.__viewId])
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Hd(e, t) {
|
|
|
+ var i = e.type
|
|
|
+ , n = e.escapeConnect
|
|
|
+ , o = tf[i]
|
|
|
+ , a = o.actionInfo
|
|
|
+ , r = (a.update || "update").split(":")
|
|
|
+ , s = r.pop();
|
|
|
+ r = null != r[0] && Cd(r[0]),
|
|
|
+ this[kd] = !0;
|
|
|
+ var l = [e]
|
|
|
+ , u = !1;
|
|
|
+ e.batch && (u = !0,
|
|
|
+ l = O(e.batch, function(t) {
|
|
|
+ return (t = D(P({}, t), e)).batch = null,
|
|
|
+ t
|
|
|
+ }));
|
|
|
+ var h, c = [], d = "highlight" === i || "downplay" === i;
|
|
|
+ Td(l, function(t) {
|
|
|
+ (h = (h = o.action(t, this._model, this._api)) || P({}, t)).type = a.event || h.type,
|
|
|
+ c.push(h),
|
|
|
+ d ? Fd(this, s, t, "series") : r && Fd(this, s, t, r.main, r.sub)
|
|
|
+ }, this),
|
|
|
+ "none" === s || d || r || (this[Pd] ? (Gd(this),
|
|
|
+ Vd.update.call(this, e),
|
|
|
+ this[Pd] = !1) : Vd[s].call(this, e)),
|
|
|
+ h = u ? {
|
|
|
+ type: a.event || i,
|
|
|
+ escapeConnect: n,
|
|
|
+ batch: c
|
|
|
+ } : c[0],
|
|
|
+ this[kd] = !1,
|
|
|
+ t || this._messageCenter.trigger(h.type, h)
|
|
|
+ }
|
|
|
+ function Zd(t) {
|
|
|
+ for (var e = this._pendingActions; e.length; ) {
|
|
|
+ var i = e.shift();
|
|
|
+ Hd.call(this, i, t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ud(t) {
|
|
|
+ t || this.trigger("updated")
|
|
|
+ }
|
|
|
+ function Xd(t, e, o, a) {
|
|
|
+ for (var r = "component" === e, s = r ? t._componentsViews : t._chartsViews, l = r ? t._componentsMap : t._chartsMap, u = t._zr, h = t._api, i = 0; i < s.length; i++)
|
|
|
+ s[i].__alive = !1;
|
|
|
+ function n(t) {
|
|
|
+ var e = "_ec_" + t.id + "_" + t.type
|
|
|
+ , i = l[e];
|
|
|
+ if (!i) {
|
|
|
+ var n = Cd(t.type);
|
|
|
+ (i = new (r ? gc.getClass(n.main, n.sub) : _c.getClass(n.sub))).init(o, h),
|
|
|
+ l[e] = i,
|
|
|
+ s.push(i),
|
|
|
+ u.add(i.group)
|
|
|
+ }
|
|
|
+ t.__viewId = i.__id = e,
|
|
|
+ i.__alive = !0,
|
|
|
+ i.__model = t,
|
|
|
+ i.group.__ecComponentInfo = {
|
|
|
+ mainType: t.mainType,
|
|
|
+ index: t.componentIndex
|
|
|
+ },
|
|
|
+ r || a.prepareView(i, t, o, h)
|
|
|
+ }
|
|
|
+ r ? o.eachComponent(function(t, e) {
|
|
|
+ "series" !== t && n(e)
|
|
|
+ }) : o.eachSeries(n);
|
|
|
+ for (i = 0; i < s.length; ) {
|
|
|
+ var c = s[i];
|
|
|
+ c.__alive ? i++ : (r || c.renderTask.dispose(),
|
|
|
+ u.remove(c.group),
|
|
|
+ c.dispose(o, h),
|
|
|
+ s.splice(i, 1),
|
|
|
+ delete l[c.__id],
|
|
|
+ c.__id = c.group.__ecComponentInfo = null)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Yd(t) {
|
|
|
+ t.clearColorPalette(),
|
|
|
+ t.eachSeries(function(t) {
|
|
|
+ t.clearColorPalette()
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function jd(t, e, i, n) {
|
|
|
+ !function(t, i, n, o, e) {
|
|
|
+ Td(e || t._componentsViews, function(t) {
|
|
|
+ var e = t.__model;
|
|
|
+ t.render(e, i, n, o),
|
|
|
+ Jd(e, t)
|
|
|
+ })
|
|
|
+ }(t, e, i, n),
|
|
|
+ Td(t._chartsViews, function(t) {
|
|
|
+ t.__alive = !1
|
|
|
+ }),
|
|
|
+ qd(t, e, i, n),
|
|
|
+ Td(t._chartsViews, function(t) {
|
|
|
+ t.__alive || t.remove(e, i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function qd(n, t, e, o, a) {
|
|
|
+ var r, s = n._scheduler;
|
|
|
+ t.eachSeries(function(t) {
|
|
|
+ var e = n._chartsMap[t.__viewId];
|
|
|
+ e.__alive = !0;
|
|
|
+ var i = e.renderTask;
|
|
|
+ s.updatePayload(i, o),
|
|
|
+ a && a.get(t.uid) && i.dirty(),
|
|
|
+ r |= i.perform(s.getPerformArgs(i)),
|
|
|
+ e.group.silent = !!t.get("silent"),
|
|
|
+ Jd(t, e),
|
|
|
+ function(t, e) {
|
|
|
+ var i = t.get("blendMode") || null;
|
|
|
+ e.group.traverse(function(t) {
|
|
|
+ t.isGroup || t.style.blend !== i && t.setStyle("blend", i),
|
|
|
+ t.eachPendingDisplayable && t.eachPendingDisplayable(function(t) {
|
|
|
+ t.setStyle("blend", i)
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }(t, e)
|
|
|
+ }),
|
|
|
+ s.unfinished |= r,
|
|
|
+ function(i, t) {
|
|
|
+ var e = i._zr.storage
|
|
|
+ , n = 0;
|
|
|
+ e.traverse(function(t) {
|
|
|
+ n++
|
|
|
+ }),
|
|
|
+ n > t.get("hoverLayerThreshold") && !v.node && t.eachSeries(function(t) {
|
|
|
+ if (!t.preventUsingHoverLayer) {
|
|
|
+ var e = i._chartsMap[t.__viewId];
|
|
|
+ e.__alive && e.group.traverse(function(t) {
|
|
|
+ t.useHoverLayer = !0
|
|
|
+ })
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }(n, t),
|
|
|
+ Ec(n._zr.dom, t)
|
|
|
+ }
|
|
|
+ function Kd(e, i) {
|
|
|
+ Td(af, function(t) {
|
|
|
+ t(e, i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ zd.resize = function(t) {
|
|
|
+ if (!this._disposed) {
|
|
|
+ this._zr.resize(t);
|
|
|
+ var e = this._model;
|
|
|
+ if (this._loadingFX && this._loadingFX.resize(),
|
|
|
+ e) {
|
|
|
+ var i = e.resetOption("media")
|
|
|
+ , n = t && t.silent;
|
|
|
+ this[kd] = !0,
|
|
|
+ i && Gd(this),
|
|
|
+ Vd.update.call(this),
|
|
|
+ this[kd] = !1,
|
|
|
+ Zd.call(this, n),
|
|
|
+ Ud.call(this, n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.showLoading = function(t, e) {
|
|
|
+ if (!this._disposed && (Dd(t) && (e = t,
|
|
|
+ t = ""),
|
|
|
+ t = t || "default",
|
|
|
+ this.hideLoading(),
|
|
|
+ lf[t])) {
|
|
|
+ var i = lf[t](this._api, e)
|
|
|
+ , n = this._zr;
|
|
|
+ this._loadingFX = i,
|
|
|
+ n.add(i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.hideLoading = function() {
|
|
|
+ this._disposed || (this._loadingFX && this._zr.remove(this._loadingFX),
|
|
|
+ this._loadingFX = null)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.makeActionFromEvent = function(t) {
|
|
|
+ var e = P({}, t);
|
|
|
+ return e.type = ef[t.type],
|
|
|
+ e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.dispatchAction = function(t, e) {
|
|
|
+ this._disposed || (Dd(e) || (e = {
|
|
|
+ silent: !!e
|
|
|
+ }),
|
|
|
+ tf[t.type] && this._model && (this[kd] ? this._pendingActions.push(t) : (Hd.call(this, t, e.silent),
|
|
|
+ e.flush ? this._zr.flush(!0) : !1 !== e.flush && v.browser.weChat && this._throttledZrFlush(),
|
|
|
+ Zd.call(this, e.silent),
|
|
|
+ Ud.call(this, e.silent))))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.appendData = function(t) {
|
|
|
+ if (!this._disposed) {
|
|
|
+ var e = t.seriesIndex;
|
|
|
+ this.getModel().getSeriesByIndex(e).appendData(t),
|
|
|
+ this._scheduler.unfinished = !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.on = Od("on", !1),
|
|
|
+ zd.off = Od("off", !1),
|
|
|
+ zd.one = Od("one", !1);
|
|
|
+ var $d = ["click", "dblclick", "mouseover", "mouseout", "mousemove", "mousedown", "mouseup", "globalout", "contextmenu"];
|
|
|
+ function Jd(t, e) {
|
|
|
+ var i = t.get("z")
|
|
|
+ , n = t.get("zlevel");
|
|
|
+ e.group.traverse(function(t) {
|
|
|
+ "group" !== t.type && (null != i && (t.z = i),
|
|
|
+ null != n && (t.zlevel = n))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Qd() {
|
|
|
+ this.eventInfo
|
|
|
+ }
|
|
|
+ zd._initEvents = function() {
|
|
|
+ Td($d, function(u) {
|
|
|
+ function t(t) {
|
|
|
+ var e, i = this.getModel(), n = t.target;
|
|
|
+ if ("globalout" === u)
|
|
|
+ e = {};
|
|
|
+ else if (n && null != n.dataIndex) {
|
|
|
+ var o = n.dataModel || i.getSeriesByIndex(n.seriesIndex);
|
|
|
+ e = o && o.getDataParams(n.dataIndex, n.dataType, n) || {}
|
|
|
+ } else
|
|
|
+ n && n.eventData && (e = P({}, n.eventData));
|
|
|
+ if (e) {
|
|
|
+ var a = e.componentType
|
|
|
+ , r = e.componentIndex;
|
|
|
+ "markLine" !== a && "markPoint" !== a && "markArea" !== a || (a = "series",
|
|
|
+ r = e.seriesIndex);
|
|
|
+ var s = a && null != r && i.getComponent(a, r)
|
|
|
+ , l = s && this["series" === s.mainType ? "_chartsMap" : "_componentsMap"][s.__viewId];
|
|
|
+ e.event = t,
|
|
|
+ e.type = u,
|
|
|
+ this._ecEventProcessor.eventInfo = {
|
|
|
+ targetEl: n,
|
|
|
+ packedEvent: e,
|
|
|
+ model: s,
|
|
|
+ view: l
|
|
|
+ },
|
|
|
+ this.trigger(u, e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ t.zrEventfulCallAtLast = !0,
|
|
|
+ this._zr.on(u, t, this)
|
|
|
+ }, this),
|
|
|
+ Td(ef, function(t, e) {
|
|
|
+ this._messageCenter.on(e, function(t) {
|
|
|
+ this.trigger(e, t)
|
|
|
+ }, this)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.isDisposed = function() {
|
|
|
+ return this._disposed
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.clear = function() {
|
|
|
+ this._disposed || this.setOption({
|
|
|
+ series: []
|
|
|
+ }, !0)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ zd.dispose = function() {
|
|
|
+ if (!this._disposed) {
|
|
|
+ this._disposed = !0,
|
|
|
+ Jo(this.getDom(), ff, "");
|
|
|
+ var e = this._api
|
|
|
+ , i = this._model;
|
|
|
+ Td(this._componentsViews, function(t) {
|
|
|
+ t.dispose(i, e)
|
|
|
+ }),
|
|
|
+ Td(this._chartsViews, function(t) {
|
|
|
+ t.dispose(i, e)
|
|
|
+ }),
|
|
|
+ this._zr.dispose(),
|
|
|
+ delete uf[this.id]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ b(Rd, Ct),
|
|
|
+ Qd.prototype = {
|
|
|
+ constructor: Qd,
|
|
|
+ normalizeQuery: function(t) {
|
|
|
+ var s = {}
|
|
|
+ , l = {}
|
|
|
+ , u = {};
|
|
|
+ if (R(t)) {
|
|
|
+ var e = Cd(t);
|
|
|
+ s.mainType = e.main || null,
|
|
|
+ s.subType = e.sub || null
|
|
|
+ } else {
|
|
|
+ var h = ["Index", "Name", "Id"]
|
|
|
+ , c = {
|
|
|
+ name: 1,
|
|
|
+ dataIndex: 1,
|
|
|
+ dataType: 1
|
|
|
+ };
|
|
|
+ E(t, function(t, e) {
|
|
|
+ for (var i = !1, n = 0; n < h.length; n++) {
|
|
|
+ var o = h[n]
|
|
|
+ , a = e.lastIndexOf(o);
|
|
|
+ if (0 < a && a === e.length - o.length) {
|
|
|
+ var r = e.slice(0, a);
|
|
|
+ "data" !== r && (s.mainType = r,
|
|
|
+ s[o.toLowerCase()] = t,
|
|
|
+ i = !0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ c.hasOwnProperty(e) && (l[e] = t,
|
|
|
+ i = !0),
|
|
|
+ i || (u[e] = t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ cptQuery: s,
|
|
|
+ dataQuery: l,
|
|
|
+ otherQuery: u
|
|
|
+ }
|
|
|
+ },
|
|
|
+ filter: function(t, e, i) {
|
|
|
+ var n = this.eventInfo;
|
|
|
+ if (!n)
|
|
|
+ return !0;
|
|
|
+ var o = n.targetEl
|
|
|
+ , a = n.packedEvent
|
|
|
+ , r = n.model
|
|
|
+ , s = n.view;
|
|
|
+ if (!r || !s)
|
|
|
+ return !0;
|
|
|
+ var l = e.cptQuery
|
|
|
+ , u = e.dataQuery;
|
|
|
+ return h(l, r, "mainType") && h(l, r, "subType") && h(l, r, "index", "componentIndex") && h(l, r, "name") && h(l, r, "id") && h(u, a, "name") && h(u, a, "dataIndex") && h(u, a, "dataType") && (!s.filterForExposedEvent || s.filterForExposedEvent(t, e.otherQuery, o, a));
|
|
|
+ function h(t, e, i, n) {
|
|
|
+ return null == t[i] || e[n || i] === t[i]
|
|
|
+ }
|
|
|
+ },
|
|
|
+ afterTrigger: function() {
|
|
|
+ this.eventInfo = null
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var tf = {}
|
|
|
+ , ef = {}
|
|
|
+ , nf = []
|
|
|
+ , of = []
|
|
|
+ , af = []
|
|
|
+ , rf = []
|
|
|
+ , sf = {}
|
|
|
+ , lf = {}
|
|
|
+ , uf = {}
|
|
|
+ , hf = {}
|
|
|
+ , cf = new Date - 0
|
|
|
+ , df = new Date - 0
|
|
|
+ , ff = "_echarts_instance_";
|
|
|
+ function pf(t) {
|
|
|
+ hf[t] = !1
|
|
|
+ }
|
|
|
+ var gf = pf;
|
|
|
+ function mf(t) {
|
|
|
+ return uf[function(t, e) {
|
|
|
+ return t.getAttribute ? t.getAttribute(e) : t[e]
|
|
|
+ }(t, ff)]
|
|
|
+ }
|
|
|
+ function vf(t, e) {
|
|
|
+ sf[t] = e
|
|
|
+ }
|
|
|
+ function yf(t) {
|
|
|
+ of.push(t)
|
|
|
+ }
|
|
|
+ function xf(t, e) {
|
|
|
+ Mf(nf, t, e, 1e3)
|
|
|
+ }
|
|
|
+ function _f(t, e, i) {
|
|
|
+ "function" == typeof e && (i = e,
|
|
|
+ e = "");
|
|
|
+ var n = Dd(t) ? t.type : [t, t = {
|
|
|
+ event: e
|
|
|
+ }][0];
|
|
|
+ t.event = (t.event || n).toLowerCase(),
|
|
|
+ e = t.event,
|
|
|
+ Id(Nd.test(n) && Nd.test(e)),
|
|
|
+ tf[n] || (tf[n] = {
|
|
|
+ action: i,
|
|
|
+ actionInfo: t
|
|
|
+ }),
|
|
|
+ ef[e] = n
|
|
|
+ }
|
|
|
+ function wf(t, e) {
|
|
|
+ lh.register(t, e)
|
|
|
+ }
|
|
|
+ function bf(t, e) {
|
|
|
+ Mf(rf, t, e, 1e3, "layout")
|
|
|
+ }
|
|
|
+ function Sf(t, e) {
|
|
|
+ Mf(rf, t, e, 3e3, "visual")
|
|
|
+ }
|
|
|
+ function Mf(t, e, i, n, o) {
|
|
|
+ (Ad(e) || Dd(e)) && (i = e,
|
|
|
+ e = n);
|
|
|
+ var a = zc.wrapStageHandler(i, o);
|
|
|
+ return a.__prio = e,
|
|
|
+ a.__raw = i,
|
|
|
+ t.push(a),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ function If(t, e) {
|
|
|
+ lf[t] = e
|
|
|
+ }
|
|
|
+ function Tf(t) {
|
|
|
+ return ku.extend(t)
|
|
|
+ }
|
|
|
+ function Af(t) {
|
|
|
+ return gc.extend(t)
|
|
|
+ }
|
|
|
+ function Df(t) {
|
|
|
+ return sc.extend(t)
|
|
|
+ }
|
|
|
+ function Cf(t) {
|
|
|
+ return _c.extend(t)
|
|
|
+ }
|
|
|
+ Sf(2e3, Nc),
|
|
|
+ yf(Lh),
|
|
|
+ xf(900, function(t) {
|
|
|
+ var a = Q();
|
|
|
+ t.eachSeries(function(t) {
|
|
|
+ var e = t.get("stack");
|
|
|
+ if (e) {
|
|
|
+ var i = a.get(e) || a.set(e, [])
|
|
|
+ , n = t.getData()
|
|
|
+ , o = {
|
|
|
+ stackResultDimension: n.getCalculationInfo("stackResultDimension"),
|
|
|
+ stackedOverDimension: n.getCalculationInfo("stackedOverDimension"),
|
|
|
+ stackedDimension: n.getCalculationInfo("stackedDimension"),
|
|
|
+ stackedByDimension: n.getCalculationInfo("stackedByDimension"),
|
|
|
+ isStackedByIndex: n.getCalculationInfo("isStackedByIndex"),
|
|
|
+ data: n,
|
|
|
+ seriesModel: t
|
|
|
+ };
|
|
|
+ if (!o.stackedDimension || !o.isStackedByIndex && !o.stackedByDimension)
|
|
|
+ return;
|
|
|
+ i.length && n.setCalculationInfo("stackedOnSeries", i[i.length - 1].seriesModel),
|
|
|
+ i.push(o)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a.each(kh)
|
|
|
+ }),
|
|
|
+ If("default", function(o, a) {
|
|
|
+ D(a = a || {}, {
|
|
|
+ text: "loading",
|
|
|
+ textColor: "#000",
|
|
|
+ fontSize: "12px",
|
|
|
+ maskColor: "rgba(255, 255, 255, 0.8)",
|
|
|
+ showSpinner: !0,
|
|
|
+ color: "#c23531",
|
|
|
+ spinnerRadius: 10,
|
|
|
+ lineWidth: 5,
|
|
|
+ zlevel: 0
|
|
|
+ });
|
|
|
+ var t = new Ci
|
|
|
+ , r = new rs({
|
|
|
+ style: {
|
|
|
+ fill: a.maskColor
|
|
|
+ },
|
|
|
+ zlevel: a.zlevel,
|
|
|
+ z: 1e4
|
|
|
+ });
|
|
|
+ t.add(r);
|
|
|
+ var s = a.fontSize + " sans-serif"
|
|
|
+ , l = new rs({
|
|
|
+ style: {
|
|
|
+ fill: "none",
|
|
|
+ text: a.text,
|
|
|
+ font: s,
|
|
|
+ textPosition: "right",
|
|
|
+ textDistance: 10,
|
|
|
+ textFill: a.textColor
|
|
|
+ },
|
|
|
+ zlevel: a.zlevel,
|
|
|
+ z: 10001
|
|
|
+ });
|
|
|
+ if (t.add(l),
|
|
|
+ a.showSpinner) {
|
|
|
+ var u = new fs({
|
|
|
+ shape: {
|
|
|
+ startAngle: -Rc / 2,
|
|
|
+ endAngle: -Rc / 2 + .1,
|
|
|
+ r: a.spinnerRadius
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ stroke: a.color,
|
|
|
+ lineCap: "round",
|
|
|
+ lineWidth: a.lineWidth
|
|
|
+ },
|
|
|
+ zlevel: a.zlevel,
|
|
|
+ z: 10001
|
|
|
+ });
|
|
|
+ u.animateShape(!0).when(1e3, {
|
|
|
+ endAngle: 3 * Rc / 2
|
|
|
+ }).start("circularInOut"),
|
|
|
+ u.animateShape(!0).when(1e3, {
|
|
|
+ startAngle: 3 * Rc / 2
|
|
|
+ }).delay(300).start("circularInOut"),
|
|
|
+ t.add(u)
|
|
|
+ }
|
|
|
+ return t.resize = function() {
|
|
|
+ var t = pn(a.text, s)
|
|
|
+ , e = a.showSpinner ? a.spinnerRadius : 0
|
|
|
+ , i = (o.getWidth() - 2 * e - (a.showSpinner && t ? 10 : 0) - t) / 2 - (a.showSpinner ? 0 : t / 2)
|
|
|
+ , n = o.getHeight() / 2;
|
|
|
+ a.showSpinner && u.setShape({
|
|
|
+ cx: i,
|
|
|
+ cy: n
|
|
|
+ }),
|
|
|
+ l.setShape({
|
|
|
+ x: i - e,
|
|
|
+ y: n - e,
|
|
|
+ width: 2 * e,
|
|
|
+ height: 2 * e
|
|
|
+ }),
|
|
|
+ r.setShape({
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: o.getWidth(),
|
|
|
+ height: o.getHeight()
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.resize(),
|
|
|
+ t
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "highlight",
|
|
|
+ event: "highlight",
|
|
|
+ update: "highlight"
|
|
|
+ }, et),
|
|
|
+ _f({
|
|
|
+ type: "downplay",
|
|
|
+ event: "downplay",
|
|
|
+ update: "downplay"
|
|
|
+ }, et),
|
|
|
+ vf("light", nd),
|
|
|
+ vf("dark", rd);
|
|
|
+ function Lf(t) {
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function kf(t, e, i, n, o) {
|
|
|
+ this._old = t,
|
|
|
+ this._new = e,
|
|
|
+ this._oldKeyGetter = i || Lf,
|
|
|
+ this._newKeyGetter = n || Lf,
|
|
|
+ this.context = o
|
|
|
+ }
|
|
|
+ function Pf(t, e, i, n, o) {
|
|
|
+ for (var a = 0; a < t.length; a++) {
|
|
|
+ var r = "_ec_" + o[n](t[a], a)
|
|
|
+ , s = e[r];
|
|
|
+ null == s ? (i.push(r),
|
|
|
+ e[r] = a) : (s.length || (e[r] = s = [s]),
|
|
|
+ s.push(a))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ kf.prototype = {
|
|
|
+ constructor: kf,
|
|
|
+ add: function(t) {
|
|
|
+ return this._add = t,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ update: function(t) {
|
|
|
+ return this._update = t,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ remove: function(t) {
|
|
|
+ return this._remove = t,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ execute: function() {
|
|
|
+ var t = this._old
|
|
|
+ , e = this._new
|
|
|
+ , i = {}
|
|
|
+ , n = []
|
|
|
+ , o = [];
|
|
|
+ for (Pf(t, {}, n, "_oldKeyGetter", this),
|
|
|
+ Pf(e, i, o, "_newKeyGetter", this),
|
|
|
+ a = 0; a < t.length; a++) {
|
|
|
+ if (null != (s = i[r = n[a]]))
|
|
|
+ (u = s.length) ? (1 === u && (i[r] = null),
|
|
|
+ s = s.shift()) : i[r] = null,
|
|
|
+ this._update && this._update(s, a);
|
|
|
+ else
|
|
|
+ this._remove && this._remove(a)
|
|
|
+ }
|
|
|
+ for (var a = 0; a < o.length; a++) {
|
|
|
+ var r = o[a];
|
|
|
+ if (i.hasOwnProperty(r)) {
|
|
|
+ var s;
|
|
|
+ if (null == (s = i[r]))
|
|
|
+ continue;
|
|
|
+ if (s.length)
|
|
|
+ for (var l = 0, u = s.length; l < u; l++)
|
|
|
+ this._add && this._add(s[l]);
|
|
|
+ else
|
|
|
+ this._add && this._add(s)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var Nf = Q(["tooltip", "label", "itemName", "itemId", "seriesName"]);
|
|
|
+ function Of(t, e) {
|
|
|
+ return t.hasOwnProperty(e) || (t[e] = []),
|
|
|
+ t[e]
|
|
|
+ }
|
|
|
+ function Ef(t) {
|
|
|
+ return "category" === t ? "ordinal" : "time" === t ? "time" : "float"
|
|
|
+ }
|
|
|
+ function Rf(t) {
|
|
|
+ null != t && P(this, t),
|
|
|
+ this.otherDims = {}
|
|
|
+ }
|
|
|
+ var zf = z
|
|
|
+ , Bf = "undefined"
|
|
|
+ , Vf = {
|
|
|
+ float: typeof Float64Array == Bf ? Array : Float64Array,
|
|
|
+ int: typeof Int32Array == Bf ? Array : Int32Array,
|
|
|
+ ordinal: Array,
|
|
|
+ number: Array,
|
|
|
+ time: Array
|
|
|
+ }
|
|
|
+ , Gf = typeof Uint32Array == Bf ? Array : Uint32Array
|
|
|
+ , Ff = typeof Int32Array == Bf ? Array : Int32Array
|
|
|
+ , Wf = typeof Uint16Array == Bf ? Array : Uint16Array;
|
|
|
+ function Hf(t) {
|
|
|
+ return 65535 < t._rawCount ? Gf : Wf
|
|
|
+ }
|
|
|
+ var Zf = ["hasItemOption", "_nameList", "_idList", "_invertedIndicesMap", "_rawData", "_chunkSize", "_chunkCount", "_dimValueGetter", "_count", "_rawCount", "_nameDimIdx", "_idDimIdx"]
|
|
|
+ , Uf = ["_extent", "_approximateExtent", "_rawExtent"];
|
|
|
+ function Xf(e, i) {
|
|
|
+ E(Zf.concat(i.__wrappedMethods || []), function(t) {
|
|
|
+ i.hasOwnProperty(t) && (e[t] = i[t])
|
|
|
+ }),
|
|
|
+ e.__wrappedMethods = i.__wrappedMethods,
|
|
|
+ E(Uf, function(t) {
|
|
|
+ e[t] = k(i[t])
|
|
|
+ }),
|
|
|
+ e._calculationInfo = P(i._calculationInfo)
|
|
|
+ }
|
|
|
+ var Yf = function(t, e) {
|
|
|
+ t = t || ["x", "y"];
|
|
|
+ for (var i = {}, n = [], o = {}, a = 0; a < t.length; a++) {
|
|
|
+ var r = t[a];
|
|
|
+ R(r) ? r = new Rf({
|
|
|
+ name: r
|
|
|
+ }) : r instanceof Rf || (r = new Rf(r));
|
|
|
+ var s = r.name;
|
|
|
+ r.type = r.type || "float",
|
|
|
+ r.coordDim || (r.coordDim = s,
|
|
|
+ r.coordDimIndex = 0),
|
|
|
+ r.otherDims = r.otherDims || {},
|
|
|
+ n.push(s),
|
|
|
+ (i[s] = r).index = a,
|
|
|
+ r.createInvertedIndices && (o[s] = [])
|
|
|
+ }
|
|
|
+ this.dimensions = n,
|
|
|
+ this._dimensionInfos = i,
|
|
|
+ this.hostModel = e,
|
|
|
+ this.dataType,
|
|
|
+ this._indices = null,
|
|
|
+ this._count = 0,
|
|
|
+ this._rawCount = 0,
|
|
|
+ this._storage = {},
|
|
|
+ this._nameList = [],
|
|
|
+ this._idList = [],
|
|
|
+ this._optionModels = [],
|
|
|
+ this._visual = {},
|
|
|
+ this._layout = {},
|
|
|
+ this._itemVisuals = [],
|
|
|
+ this.hasItemVisual = {},
|
|
|
+ this._itemLayouts = [],
|
|
|
+ this._graphicEls = [],
|
|
|
+ this._chunkSize = 1e5,
|
|
|
+ this._chunkCount = 0,
|
|
|
+ this._rawData,
|
|
|
+ this._rawExtent = {},
|
|
|
+ this._extent = {},
|
|
|
+ this._approximateExtent = {},
|
|
|
+ this._dimensionsSummary = function(n) {
|
|
|
+ var t = {}
|
|
|
+ , a = t.encode = {}
|
|
|
+ , r = Q()
|
|
|
+ , s = []
|
|
|
+ , l = []
|
|
|
+ , u = t.userOutput = {
|
|
|
+ dimensionNames: n.dimensions.slice(),
|
|
|
+ encode: {}
|
|
|
+ };
|
|
|
+ E(n.dimensions, function(t) {
|
|
|
+ var o = n.getDimensionInfo(t)
|
|
|
+ , e = o.coordDim;
|
|
|
+ if (e) {
|
|
|
+ var i = o.coordDimIndex;
|
|
|
+ Of(a, e)[i] = t,
|
|
|
+ o.isExtraCoord || (r.set(e, 1),
|
|
|
+ function(t) {
|
|
|
+ return !("ordinal" === t || "time" === t)
|
|
|
+ }(o.type) && (s[0] = t),
|
|
|
+ Of(u.encode, e)[i] = o.index),
|
|
|
+ o.defaultTooltip && l.push(t)
|
|
|
+ }
|
|
|
+ Nf.each(function(t, e) {
|
|
|
+ var i = Of(a, e)
|
|
|
+ , n = o.otherDims[e];
|
|
|
+ null != n && !1 !== n && (i[n] = o.name)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var o = []
|
|
|
+ , h = {};
|
|
|
+ r.each(function(t, e) {
|
|
|
+ var i = a[e];
|
|
|
+ h[e] = i[0],
|
|
|
+ o = o.concat(i)
|
|
|
+ }),
|
|
|
+ t.dataDimsOnCoord = o,
|
|
|
+ t.encodeFirstDimNotExtra = h;
|
|
|
+ var e = a.label;
|
|
|
+ e && e.length && (s = e.slice());
|
|
|
+ var i = a.tooltip;
|
|
|
+ return i && i.length ? l = i.slice() : l.length || (l = s.slice()),
|
|
|
+ a.defaultedLabel = s,
|
|
|
+ a.defaultedTooltip = l,
|
|
|
+ t
|
|
|
+ }(this),
|
|
|
+ this._invertedIndicesMap = o,
|
|
|
+ this._calculationInfo = {},
|
|
|
+ this.userOutput = this._dimensionsSummary.userOutput
|
|
|
+ }
|
|
|
+ , jf = Yf.prototype;
|
|
|
+ function qf(t, e, i, n, o) {
|
|
|
+ var a = Vf[e.type]
|
|
|
+ , r = n - 1
|
|
|
+ , s = e.name
|
|
|
+ , l = t[s][r];
|
|
|
+ if (l && l.length < i) {
|
|
|
+ for (var u = new a(Math.min(o - r * i, i)), h = 0; h < l.length; h++)
|
|
|
+ u[h] = l[h];
|
|
|
+ t[s][r] = u
|
|
|
+ }
|
|
|
+ for (var c = n * i; c < o; c += i)
|
|
|
+ t[s].push(new a(Math.min(o - c, i)))
|
|
|
+ }
|
|
|
+ function Kf(o) {
|
|
|
+ var a = o._invertedIndicesMap;
|
|
|
+ E(a, function(t, e) {
|
|
|
+ var i = o._dimensionInfos[e].ordinalMeta;
|
|
|
+ if (i) {
|
|
|
+ t = a[e] = new Ff(i.categories.length);
|
|
|
+ for (var n = 0; n < t.length; n++)
|
|
|
+ t[n] = -1;
|
|
|
+ for (n = 0; n < o._count; n++)
|
|
|
+ t[o.get(e, n)] = n
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function $f(t, e, i) {
|
|
|
+ var n;
|
|
|
+ if (null != e) {
|
|
|
+ var o = t._chunkSize
|
|
|
+ , a = Math.floor(i / o)
|
|
|
+ , r = i % o
|
|
|
+ , s = t.dimensions[e]
|
|
|
+ , l = t._storage[s][a];
|
|
|
+ if (l) {
|
|
|
+ n = l[r];
|
|
|
+ var u = t._dimensionInfos[s].ordinalMeta;
|
|
|
+ u && u.categories.length && (n = u.categories[n])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function Jf(t) {
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ function Qf(t) {
|
|
|
+ return t < this._count && 0 <= t ? this._indices[t] : -1
|
|
|
+ }
|
|
|
+ function tp(t, e) {
|
|
|
+ var i = t._idList[e];
|
|
|
+ return null == i && (i = $f(t, t._idDimIdx, e)),
|
|
|
+ null == i && (i = "e\0\0" + e),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function ep(t) {
|
|
|
+ return L(t) || (t = [t]),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function ip(t, e) {
|
|
|
+ var i = t.dimensions
|
|
|
+ , n = new Yf(O(i, t.getDimensionInfo, t),t.hostModel);
|
|
|
+ Xf(n, t);
|
|
|
+ for (var o = n._storage = {}, a = t._storage, r = 0; r < i.length; r++) {
|
|
|
+ var s = i[r];
|
|
|
+ a[s] && (0 <= _(e, s) ? (o[s] = np(a[s]),
|
|
|
+ n._rawExtent[s] = op(),
|
|
|
+ n._extent[s] = null) : o[s] = a[s])
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function np(t) {
|
|
|
+ for (var e, i, n = new Array(t.length), o = 0; o < t.length; o++)
|
|
|
+ n[o] = (e = t[o],
|
|
|
+ i = void 0,
|
|
|
+ (i = e.constructor) === Array ? e.slice() : new i(e));
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function op() {
|
|
|
+ return [1 / 0, -1 / 0]
|
|
|
+ }
|
|
|
+ jf.type = "list",
|
|
|
+ jf.hasItemOption = !0,
|
|
|
+ jf.getDimension = function(t) {
|
|
|
+ return "number" != typeof t && (isNaN(t) || this._dimensionInfos.hasOwnProperty(t)) || (t = this.dimensions[t]),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getDimensionInfo = function(t) {
|
|
|
+ return this._dimensionInfos[this.getDimension(t)]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getDimensionsOnCoord = function() {
|
|
|
+ return this._dimensionsSummary.dataDimsOnCoord.slice()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.mapDimension = function(t, e) {
|
|
|
+ var i = this._dimensionsSummary;
|
|
|
+ if (null == e)
|
|
|
+ return i.encodeFirstDimNotExtra[t];
|
|
|
+ var n = i.encode[t];
|
|
|
+ return !0 === e ? (n || []).slice() : n && n[e]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.initData = function(t, e, i) {
|
|
|
+ (Uu.isInstance(t) || N(t)) && (t = new Ph(t,this.dimensions.length)),
|
|
|
+ this._rawData = t,
|
|
|
+ this._storage = {},
|
|
|
+ this._indices = null,
|
|
|
+ this._nameList = e || [],
|
|
|
+ this._idList = [],
|
|
|
+ this._nameRepeatCount = {},
|
|
|
+ i || (this.hasItemOption = !1),
|
|
|
+ this.defaultDimValueGetter = Gh[this._rawData.getSource().sourceFormat],
|
|
|
+ this._dimValueGetter = i = i || this.defaultDimValueGetter,
|
|
|
+ this._dimValueGetterArrayRows = Gh.arrayRows,
|
|
|
+ this._rawExtent = {},
|
|
|
+ this._initDataFromProvider(0, t.count()),
|
|
|
+ t.pure && (this.hasItemOption = !1)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getProvider = function() {
|
|
|
+ return this._rawData
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.appendData = function(t) {
|
|
|
+ var e = this._rawData
|
|
|
+ , i = this.count();
|
|
|
+ e.appendData(t);
|
|
|
+ var n = e.count();
|
|
|
+ e.persistent || (n += i),
|
|
|
+ this._initDataFromProvider(i, n)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.appendValues = function(t, e) {
|
|
|
+ for (var i = this._chunkSize, n = this._storage, o = this.dimensions, a = o.length, r = this._rawExtent, s = this.count(), l = s + Math.max(t.length, e ? e.length : 0), u = this._chunkCount, h = 0; h < a; h++) {
|
|
|
+ r[v = o[h]] || (r[v] = op()),
|
|
|
+ n[v] || (n[v] = []),
|
|
|
+ qf(n, this._dimensionInfos[v], i, u, l),
|
|
|
+ this._chunkCount = n[v].length
|
|
|
+ }
|
|
|
+ for (var c = new Array(a), d = s; d < l; d++) {
|
|
|
+ for (var f = d - s, p = Math.floor(d / i), g = d % i, m = 0; m < a; m++) {
|
|
|
+ var v = o[m]
|
|
|
+ , y = this._dimValueGetterArrayRows(t[f] || c, v, f, m);
|
|
|
+ n[v][p][g] = y;
|
|
|
+ var x = r[v];
|
|
|
+ y < x[0] && (x[0] = y),
|
|
|
+ y > x[1] && (x[1] = y)
|
|
|
+ }
|
|
|
+ e && (this._nameList[d] = e[f])
|
|
|
+ }
|
|
|
+ this._rawCount = this._count = l,
|
|
|
+ this._extent = {},
|
|
|
+ Kf(this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf._initDataFromProvider = function(t, e) {
|
|
|
+ if (!(e <= t)) {
|
|
|
+ for (var i, n = this._chunkSize, o = this._rawData, a = this._storage, r = this.dimensions, s = r.length, l = this._dimensionInfos, u = this._nameList, h = this._idList, c = this._rawExtent, d = this._nameRepeatCount = {}, f = this._chunkCount, p = 0; p < s; p++) {
|
|
|
+ c[w = r[p]] || (c[w] = op());
|
|
|
+ var g = l[w];
|
|
|
+ 0 === g.otherDims.itemName && (i = this._nameDimIdx = p),
|
|
|
+ 0 === g.otherDims.itemId && (this._idDimIdx = p),
|
|
|
+ a[w] || (a[w] = []),
|
|
|
+ qf(a, g, n, f, e),
|
|
|
+ this._chunkCount = a[w].length
|
|
|
+ }
|
|
|
+ for (var m = new Array(s), v = t; v < e; v++) {
|
|
|
+ m = o.getItem(v, m);
|
|
|
+ for (var y = Math.floor(v / n), x = v % n, _ = 0; _ < s; _++) {
|
|
|
+ var w, b = a[w = r[_]][y], S = this._dimValueGetter(m, w, v, _);
|
|
|
+ b[x] = S;
|
|
|
+ var M = c[w];
|
|
|
+ S < M[0] && (M[0] = S),
|
|
|
+ S > M[1] && (M[1] = S)
|
|
|
+ }
|
|
|
+ if (!o.pure) {
|
|
|
+ var I = u[v];
|
|
|
+ if (m && null == I)
|
|
|
+ if (null != m.name)
|
|
|
+ u[v] = I = m.name;
|
|
|
+ else if (null != i) {
|
|
|
+ var T = r[i]
|
|
|
+ , A = a[T][y];
|
|
|
+ if (A) {
|
|
|
+ I = A[x];
|
|
|
+ var D = l[T].ordinalMeta;
|
|
|
+ D && D.categories.length && (I = D.categories[I])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var C = null == m ? null : m.id;
|
|
|
+ null == C && null != I && (d[I] = d[I] || 0,
|
|
|
+ 0 < d[C = I] && (C += "__ec__" + d[I]),
|
|
|
+ d[I]++),
|
|
|
+ null != C && (h[v] = C)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ !o.persistent && o.clean && o.clean(),
|
|
|
+ this._rawCount = this._count = e,
|
|
|
+ this._extent = {},
|
|
|
+ Kf(this)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.count = function() {
|
|
|
+ return this._count
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getIndices = function() {
|
|
|
+ var t = this._indices;
|
|
|
+ if (t) {
|
|
|
+ var e = t.constructor
|
|
|
+ , i = this._count;
|
|
|
+ if (e === Array) {
|
|
|
+ o = new e(i);
|
|
|
+ for (var n = 0; n < i; n++)
|
|
|
+ o[n] = t[n]
|
|
|
+ } else
|
|
|
+ o = new e(t.buffer,0,i)
|
|
|
+ } else {
|
|
|
+ var o = new (e = Hf(this))(this.count());
|
|
|
+ for (n = 0; n < o.length; n++)
|
|
|
+ o[n] = n
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.get = function(t, e) {
|
|
|
+ if (!(0 <= e && e < this._count))
|
|
|
+ return NaN;
|
|
|
+ var i = this._storage;
|
|
|
+ if (!i[t])
|
|
|
+ return NaN;
|
|
|
+ e = this.getRawIndex(e);
|
|
|
+ var n = Math.floor(e / this._chunkSize)
|
|
|
+ , o = e % this._chunkSize;
|
|
|
+ return i[t][n][o]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getByRawIndex = function(t, e) {
|
|
|
+ if (!(0 <= e && e < this._rawCount))
|
|
|
+ return NaN;
|
|
|
+ var i = this._storage[t];
|
|
|
+ if (!i)
|
|
|
+ return NaN;
|
|
|
+ var n = Math.floor(e / this._chunkSize)
|
|
|
+ , o = e % this._chunkSize;
|
|
|
+ return i[n][o]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf._getFast = function(t, e) {
|
|
|
+ var i = Math.floor(e / this._chunkSize)
|
|
|
+ , n = e % this._chunkSize;
|
|
|
+ return this._storage[t][i][n]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getValues = function(t, e) {
|
|
|
+ var i = [];
|
|
|
+ L(t) || (e = t,
|
|
|
+ t = this.dimensions);
|
|
|
+ for (var n = 0, o = t.length; n < o; n++)
|
|
|
+ i.push(this.get(t[n], e));
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.hasValue = function(t) {
|
|
|
+ for (var e = this._dimensionsSummary.dataDimsOnCoord, i = 0, n = e.length; i < n; i++)
|
|
|
+ if (isNaN(this.get(e[i], t)))
|
|
|
+ return !1;
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getDataExtent = function(t) {
|
|
|
+ t = this.getDimension(t);
|
|
|
+ var e = this._storage[t]
|
|
|
+ , i = op();
|
|
|
+ if (!e)
|
|
|
+ return i;
|
|
|
+ var n, o = this.count();
|
|
|
+ if (!this._indices)
|
|
|
+ return this._rawExtent[t].slice();
|
|
|
+ if (n = this._extent[t])
|
|
|
+ return n.slice();
|
|
|
+ for (var a = (n = i)[0], r = n[1], s = 0; s < o; s++) {
|
|
|
+ var l = this._getFast(t, this.getRawIndex(s));
|
|
|
+ l < a && (a = l),
|
|
|
+ r < l && (r = l)
|
|
|
+ }
|
|
|
+ return n = [a, r],
|
|
|
+ this._extent[t] = n
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getApproximateExtent = function(t) {
|
|
|
+ return t = this.getDimension(t),
|
|
|
+ this._approximateExtent[t] || this.getDataExtent(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.setApproximateExtent = function(t, e) {
|
|
|
+ e = this.getDimension(e),
|
|
|
+ this._approximateExtent[e] = t.slice()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getCalculationInfo = function(t) {
|
|
|
+ return this._calculationInfo[t]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.setCalculationInfo = function(t, e) {
|
|
|
+ zf(t) ? P(this._calculationInfo, t) : this._calculationInfo[t] = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getSum = function(t) {
|
|
|
+ var e = 0;
|
|
|
+ if (this._storage[t])
|
|
|
+ for (var i = 0, n = this.count(); i < n; i++) {
|
|
|
+ var o = this.get(t, i);
|
|
|
+ isNaN(o) || (e += o)
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getMedian = function(t) {
|
|
|
+ var i = [];
|
|
|
+ this.each(t, function(t, e) {
|
|
|
+ isNaN(t) || i.push(t)
|
|
|
+ });
|
|
|
+ var e = [].concat(i).sort(function(t, e) {
|
|
|
+ return t - e
|
|
|
+ })
|
|
|
+ , n = this.count();
|
|
|
+ return 0 === n ? 0 : n % 2 == 1 ? e[(n - 1) / 2] : (e[n / 2] + e[n / 2 - 1]) / 2
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.rawIndexOf = function(t, e) {
|
|
|
+ var i = (t && this._invertedIndicesMap[t])[e];
|
|
|
+ return null == i || isNaN(i) ? -1 : i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.indexOfName = function(t) {
|
|
|
+ for (var e = 0, i = this.count(); e < i; e++)
|
|
|
+ if (this.getName(e) === t)
|
|
|
+ return e;
|
|
|
+ return -1
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.indexOfRawIndex = function(t) {
|
|
|
+ if (t >= this._rawCount || t < 0)
|
|
|
+ return -1;
|
|
|
+ if (!this._indices)
|
|
|
+ return t;
|
|
|
+ var e = this._indices
|
|
|
+ , i = e[t];
|
|
|
+ if (null != i && i < this._count && i === t)
|
|
|
+ return t;
|
|
|
+ for (var n = 0, o = this._count - 1; n <= o; ) {
|
|
|
+ var a = (n + o) / 2 | 0;
|
|
|
+ if (e[a] < t)
|
|
|
+ n = 1 + a;
|
|
|
+ else {
|
|
|
+ if (!(e[a] > t))
|
|
|
+ return a;
|
|
|
+ o = a - 1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.indicesOfNearest = function(t, e, i) {
|
|
|
+ var n = [];
|
|
|
+ if (!this._storage[t])
|
|
|
+ return n;
|
|
|
+ null == i && (i = 1 / 0);
|
|
|
+ for (var o = 1 / 0, a = -1, r = 0, s = 0, l = this.count(); s < l; s++) {
|
|
|
+ var u = e - this.get(t, s)
|
|
|
+ , h = Math.abs(u);
|
|
|
+ h <= i && ((h < o || h === o && 0 <= u && a < 0) && (o = h,
|
|
|
+ a = u,
|
|
|
+ r = 0),
|
|
|
+ u === a && (n[r++] = s))
|
|
|
+ }
|
|
|
+ return n.length = r,
|
|
|
+ n
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getRawIndex = Jf,
|
|
|
+ jf.getRawDataItem = function(t) {
|
|
|
+ if (this._rawData.persistent)
|
|
|
+ return this._rawData.getItem(this.getRawIndex(t));
|
|
|
+ for (var e = [], i = 0; i < this.dimensions.length; i++) {
|
|
|
+ var n = this.dimensions[i];
|
|
|
+ e.push(this.get(n, t))
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getName = function(t) {
|
|
|
+ var e = this.getRawIndex(t);
|
|
|
+ return this._nameList[e] || $f(this, this._nameDimIdx, e) || ""
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getId = function(t) {
|
|
|
+ return tp(this, this.getRawIndex(t))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.each = function(t, e, i, n) {
|
|
|
+ if (this._count) {
|
|
|
+ "function" == typeof t && (n = i,
|
|
|
+ i = e,
|
|
|
+ e = t,
|
|
|
+ t = []),
|
|
|
+ i = i || n || this;
|
|
|
+ for (var o = (t = O(ep(t), this.getDimension, this)).length, a = 0; a < this.count(); a++)
|
|
|
+ switch (o) {
|
|
|
+ case 0:
|
|
|
+ e.call(i, a);
|
|
|
+ break;
|
|
|
+ case 1:
|
|
|
+ e.call(i, this.get(t[0], a), a);
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ e.call(i, this.get(t[0], a), this.get(t[1], a), a);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ for (var r = 0, s = []; r < o; r++)
|
|
|
+ s[r] = this.get(t[r], a);
|
|
|
+ s[r] = a,
|
|
|
+ e.apply(i, s)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.filterSelf = function(t, e, i, n) {
|
|
|
+ if (this._count) {
|
|
|
+ "function" == typeof t && (n = i,
|
|
|
+ i = e,
|
|
|
+ e = t,
|
|
|
+ t = []),
|
|
|
+ i = i || n || this,
|
|
|
+ t = O(ep(t), this.getDimension, this);
|
|
|
+ for (var o = this.count(), a = new (Hf(this))(o), r = [], s = t.length, l = 0, u = t[0], h = 0; h < o; h++) {
|
|
|
+ var c, d = this.getRawIndex(h);
|
|
|
+ if (0 === s)
|
|
|
+ c = e.call(i, h);
|
|
|
+ else if (1 === s) {
|
|
|
+ var f = this._getFast(u, d);
|
|
|
+ c = e.call(i, f, h)
|
|
|
+ } else {
|
|
|
+ for (var p = 0; p < s; p++)
|
|
|
+ r[p] = this._getFast(u, d);
|
|
|
+ r[p] = h,
|
|
|
+ c = e.apply(i, r)
|
|
|
+ }
|
|
|
+ c && (a[l++] = d)
|
|
|
+ }
|
|
|
+ return l < o && (this._indices = a),
|
|
|
+ this._count = l,
|
|
|
+ this._extent = {},
|
|
|
+ this.getRawIndex = this._indices ? Qf : Jf,
|
|
|
+ this
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.selectRange = function(t) {
|
|
|
+ if (this._count) {
|
|
|
+ var e = [];
|
|
|
+ for (var i in t)
|
|
|
+ t.hasOwnProperty(i) && e.push(i);
|
|
|
+ var n = e.length;
|
|
|
+ if (n) {
|
|
|
+ var o = this.count()
|
|
|
+ , a = new (Hf(this))(o)
|
|
|
+ , r = 0
|
|
|
+ , s = e[0]
|
|
|
+ , l = t[s][0]
|
|
|
+ , u = t[s][1]
|
|
|
+ , h = !1;
|
|
|
+ if (!this._indices) {
|
|
|
+ var c = 0;
|
|
|
+ if (1 === n) {
|
|
|
+ for (var d = this._storage[e[0]], f = 0; f < this._chunkCount; f++)
|
|
|
+ for (var p = d[f], g = Math.min(this._count - f * this._chunkSize, this._chunkSize), m = 0; m < g; m++) {
|
|
|
+ (l <= (w = p[m]) && w <= u || isNaN(w)) && (a[r++] = c),
|
|
|
+ c++
|
|
|
+ }
|
|
|
+ h = !0
|
|
|
+ } else if (2 === n) {
|
|
|
+ d = this._storage[s];
|
|
|
+ var v = this._storage[e[1]]
|
|
|
+ , y = t[e[1]][0]
|
|
|
+ , x = t[e[1]][1];
|
|
|
+ for (f = 0; f < this._chunkCount; f++) {
|
|
|
+ p = d[f];
|
|
|
+ var _ = v[f];
|
|
|
+ for (g = Math.min(this._count - f * this._chunkSize, this._chunkSize),
|
|
|
+ m = 0; m < g; m++) {
|
|
|
+ var w = p[m]
|
|
|
+ , b = _[m];
|
|
|
+ (l <= w && w <= u || isNaN(w)) && (y <= b && b <= x || isNaN(b)) && (a[r++] = c),
|
|
|
+ c++
|
|
|
+ }
|
|
|
+ }
|
|
|
+ h = !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!h)
|
|
|
+ if (1 === n)
|
|
|
+ for (m = 0; m < o; m++) {
|
|
|
+ var S = this.getRawIndex(m);
|
|
|
+ (l <= (w = this._getFast(s, S)) && w <= u || isNaN(w)) && (a[r++] = S)
|
|
|
+ }
|
|
|
+ else
|
|
|
+ for (m = 0; m < o; m++) {
|
|
|
+ var M = !0;
|
|
|
+ for (S = this.getRawIndex(m),
|
|
|
+ f = 0; f < n; f++) {
|
|
|
+ var I = e[f];
|
|
|
+ ((w = this._getFast(i, S)) < t[I][0] || w > t[I][1]) && (M = !1)
|
|
|
+ }
|
|
|
+ M && (a[r++] = this.getRawIndex(m))
|
|
|
+ }
|
|
|
+ return r < o && (this._indices = a),
|
|
|
+ this._count = r,
|
|
|
+ this._extent = {},
|
|
|
+ this.getRawIndex = this._indices ? Qf : Jf,
|
|
|
+ this
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.mapArray = function(t, e, i, n) {
|
|
|
+ "function" == typeof t && (n = i,
|
|
|
+ i = e,
|
|
|
+ e = t,
|
|
|
+ t = []),
|
|
|
+ i = i || n || this;
|
|
|
+ var o = [];
|
|
|
+ return this.each(t, function() {
|
|
|
+ o.push(e && e.apply(this, arguments))
|
|
|
+ }, i),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.map = function(t, e, i, n) {
|
|
|
+ i = i || n || this;
|
|
|
+ var o = ip(this, t = O(ep(t), this.getDimension, this));
|
|
|
+ o._indices = this._indices,
|
|
|
+ o.getRawIndex = o._indices ? Qf : Jf;
|
|
|
+ for (var a = o._storage, r = [], s = this._chunkSize, l = t.length, u = this.count(), h = [], c = o._rawExtent, d = 0; d < u; d++) {
|
|
|
+ for (var f = 0; f < l; f++)
|
|
|
+ h[f] = this.get(t[f], d);
|
|
|
+ h[l] = d;
|
|
|
+ var p = e && e.apply(i, h);
|
|
|
+ if (null != p) {
|
|
|
+ "object" != typeof p && (r[0] = p,
|
|
|
+ p = r);
|
|
|
+ for (var g = this.getRawIndex(d), m = Math.floor(g / s), v = g % s, y = 0; y < p.length; y++) {
|
|
|
+ var x = t[y]
|
|
|
+ , _ = p[y]
|
|
|
+ , w = c[x]
|
|
|
+ , b = a[x];
|
|
|
+ b && (b[m][v] = _),
|
|
|
+ _ < w[0] && (w[0] = _),
|
|
|
+ _ > w[1] && (w[1] = _)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.downSample = function(t, e, i, n) {
|
|
|
+ for (var o = ip(this, [t]), a = o._storage, r = [], s = Math.floor(1 / e), l = a[t], u = this.count(), h = this._chunkSize, c = o._rawExtent[t], d = new (Hf(this))(u), f = 0, p = 0; p < u; p += s) {
|
|
|
+ u - p < s && (s = u - p,
|
|
|
+ r.length = s);
|
|
|
+ for (var g = 0; g < s; g++) {
|
|
|
+ var m = this.getRawIndex(p + g)
|
|
|
+ , v = Math.floor(m / h)
|
|
|
+ , y = m % h;
|
|
|
+ r[g] = l[v][y]
|
|
|
+ }
|
|
|
+ var x = i(r)
|
|
|
+ , _ = this.getRawIndex(Math.min(p + n(r, x) || 0, u - 1))
|
|
|
+ , w = _ % h;
|
|
|
+ (l[Math.floor(_ / h)][w] = x) < c[0] && (c[0] = x),
|
|
|
+ x > c[1] && (c[1] = x),
|
|
|
+ d[f++] = _
|
|
|
+ }
|
|
|
+ return o._count = f,
|
|
|
+ o._indices = d,
|
|
|
+ o.getRawIndex = Qf,
|
|
|
+ o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getItemModel = function(t) {
|
|
|
+ var e = this.hostModel;
|
|
|
+ return new Cl(this.getRawDataItem(t),e,e && e.ecModel)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.diff = function(e) {
|
|
|
+ var i = this;
|
|
|
+ return new kf(e ? e.getIndices() : [],this.getIndices(),function(t) {
|
|
|
+ return tp(e, t)
|
|
|
+ }
|
|
|
+ ,function(t) {
|
|
|
+ return tp(i, t)
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getVisual = function(t) {
|
|
|
+ var e = this._visual;
|
|
|
+ return e && e[t]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.setVisual = function(t, e) {
|
|
|
+ if (zf(t))
|
|
|
+ for (var i in t)
|
|
|
+ t.hasOwnProperty(i) && this.setVisual(i, t[i]);
|
|
|
+ else
|
|
|
+ this._visual = this._visual || {},
|
|
|
+ this._visual[t] = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.setLayout = function(t, e) {
|
|
|
+ if (zf(t))
|
|
|
+ for (var i in t)
|
|
|
+ t.hasOwnProperty(i) && this.setLayout(i, t[i]);
|
|
|
+ else
|
|
|
+ this._layout[t] = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getLayout = function(t) {
|
|
|
+ return this._layout[t]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getItemLayout = function(t) {
|
|
|
+ return this._itemLayouts[t]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.setItemLayout = function(t, e, i) {
|
|
|
+ this._itemLayouts[t] = i ? P(this._itemLayouts[t] || {}, e) : e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.clearItemLayouts = function() {
|
|
|
+ this._itemLayouts.length = 0
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getItemVisual = function(t, e, i) {
|
|
|
+ var n = this._itemVisuals[t]
|
|
|
+ , o = n && n[e];
|
|
|
+ return null != o || i ? o : this.getVisual(e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.setItemVisual = function(t, e, i) {
|
|
|
+ var n = this._itemVisuals[t] || {}
|
|
|
+ , o = this.hasItemVisual;
|
|
|
+ if (this._itemVisuals[t] = n,
|
|
|
+ zf(e))
|
|
|
+ for (var a in e)
|
|
|
+ e.hasOwnProperty(a) && (n[a] = e[a],
|
|
|
+ o[a] = !0);
|
|
|
+ else
|
|
|
+ n[e] = i,
|
|
|
+ o[e] = !0
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.clearAllVisual = function() {
|
|
|
+ this._visual = {},
|
|
|
+ this._itemVisuals = [],
|
|
|
+ this.hasItemVisual = {}
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function ap(t) {
|
|
|
+ t.seriesIndex = this.seriesIndex,
|
|
|
+ t.dataIndex = this.dataIndex,
|
|
|
+ t.dataType = this.dataType
|
|
|
+ }
|
|
|
+ function rp(t, e, i) {
|
|
|
+ Uu.isInstance(e) || (e = Uu.seriesDataToSource(e)),
|
|
|
+ i = i || {},
|
|
|
+ t = (t || []).slice();
|
|
|
+ for (var n = (i.dimsDef || []).slice(), o = Q(), a = Q(), l = [], r = function(t, e, i, n) {
|
|
|
+ var o = Math.max(t.dimensionsDetectCount || 1, e.length, i.length, n || 0);
|
|
|
+ return E(e, function(t) {
|
|
|
+ var e = t.dimsDef;
|
|
|
+ e && (o = Math.max(o, e.length))
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ }(e, t, n, i.dimCount), s = 0; s < r; s++) {
|
|
|
+ var u = n[s] = P({}, z(n[s]) ? n[s] : {
|
|
|
+ name: n[s]
|
|
|
+ })
|
|
|
+ , h = u.name
|
|
|
+ , c = l[s] = new Rf;
|
|
|
+ null != h && null == o.get(h) && (c.name = c.displayName = h,
|
|
|
+ o.set(h, s)),
|
|
|
+ null != u.type && (c.type = u.type),
|
|
|
+ null != u.displayName && (c.displayName = u.displayName)
|
|
|
+ }
|
|
|
+ var d = i.encodeDef;
|
|
|
+ !d && i.encodeDefaulter && (d = i.encodeDefaulter(e, r)),
|
|
|
+ (d = Q(d)).each(function(t, i) {
|
|
|
+ if (1 === (t = Vo(t).slice()).length && !R(t[0]) && t[0] < 0)
|
|
|
+ d.set(i, !1);
|
|
|
+ else {
|
|
|
+ var n = d.set(i, []);
|
|
|
+ E(t, function(t, e) {
|
|
|
+ R(t) && (t = o.get(t)),
|
|
|
+ null != t && t < r && (n[e] = t,
|
|
|
+ p(l[t], i, e))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var f = 0;
|
|
|
+ function p(t, e, i) {
|
|
|
+ null != Nf.get(e) ? t.otherDims[e] = i : (t.coordDim = e,
|
|
|
+ t.coordDimIndex = i,
|
|
|
+ a.set(e, !0))
|
|
|
+ }
|
|
|
+ E(t, function(o, t) {
|
|
|
+ var a, r, s;
|
|
|
+ if (R(o))
|
|
|
+ a = o,
|
|
|
+ o = {};
|
|
|
+ else {
|
|
|
+ a = o.name;
|
|
|
+ var e = o.ordinalMeta;
|
|
|
+ o.ordinalMeta = null,
|
|
|
+ (o = k(o)).ordinalMeta = e,
|
|
|
+ r = o.dimsDef,
|
|
|
+ s = o.otherDims,
|
|
|
+ o.name = o.coordDim = o.coordDimIndex = o.dimsDef = o.otherDims = null
|
|
|
+ }
|
|
|
+ if (!1 !== (i = d.get(a))) {
|
|
|
+ var i;
|
|
|
+ if (!(i = Vo(i)).length)
|
|
|
+ for (var n = 0; n < (r && r.length || 1); n++) {
|
|
|
+ for (; f < l.length && null != l[f].coordDim; )
|
|
|
+ f++;
|
|
|
+ f < l.length && i.push(f++)
|
|
|
+ }
|
|
|
+ E(i, function(t, e) {
|
|
|
+ var i = l[t];
|
|
|
+ if (p(D(i, o), a, e),
|
|
|
+ null == i.name && r) {
|
|
|
+ var n = r[e];
|
|
|
+ z(n) || (n = {
|
|
|
+ name: n
|
|
|
+ }),
|
|
|
+ i.name = i.displayName = n.name,
|
|
|
+ i.defaultTooltip = n.defaultTooltip
|
|
|
+ }
|
|
|
+ s && D(i.otherDims, s)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var g = i.generateCoord
|
|
|
+ , m = i.generateCoordCount
|
|
|
+ , v = null != m;
|
|
|
+ m = g ? m || 1 : 0;
|
|
|
+ for (var y, x, _ = g || "value", w = 0; w < r; w++) {
|
|
|
+ null == (c = l[w] = l[w] || new Rf).coordDim && (c.coordDim = sp(_, a, v),
|
|
|
+ c.coordDimIndex = 0,
|
|
|
+ (!g || m <= 0) && (c.isExtraCoord = !0),
|
|
|
+ m--),
|
|
|
+ null == c.name && (c.name = sp(c.coordDim, o)),
|
|
|
+ null == c.type && (y = e,
|
|
|
+ x = w,
|
|
|
+ c.name,
|
|
|
+ th(y.data, y.sourceFormat, y.seriesLayoutBy, y.dimensionsDefine, y.startIndex, x) === Xu.Must || c.isExtraCoord && (null != c.otherDims.itemName || null != c.otherDims.seriesName)) && (c.type = "ordinal")
|
|
|
+ }
|
|
|
+ return l
|
|
|
+ }
|
|
|
+ function sp(t, e, i) {
|
|
|
+ if (i || null != e.get(t)) {
|
|
|
+ for (var n = 0; null != e.get(t + n); )
|
|
|
+ n++;
|
|
|
+ t += n
|
|
|
+ }
|
|
|
+ return e.set(t, !0),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ jf.setItemGraphicEl = function(t, e) {
|
|
|
+ var i = this.hostModel;
|
|
|
+ e && (e.dataIndex = t,
|
|
|
+ e.dataType = this.dataType,
|
|
|
+ e.seriesIndex = i && i.seriesIndex,
|
|
|
+ "group" === e.type && e.traverse(ap, e)),
|
|
|
+ this._graphicEls[t] = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.getItemGraphicEl = function(t) {
|
|
|
+ return this._graphicEls[t]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.eachItemGraphicEl = function(i, n) {
|
|
|
+ E(this._graphicEls, function(t, e) {
|
|
|
+ t && i && i.call(n, t, e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.cloneShallow = function(t) {
|
|
|
+ if (!t) {
|
|
|
+ var e = O(this.dimensions, this.getDimensionInfo, this);
|
|
|
+ t = new Yf(e,this.hostModel)
|
|
|
+ }
|
|
|
+ if (t._storage = this._storage,
|
|
|
+ Xf(t, this),
|
|
|
+ this._indices) {
|
|
|
+ var i = this._indices.constructor;
|
|
|
+ t._indices = new i(this._indices)
|
|
|
+ } else
|
|
|
+ t._indices = null;
|
|
|
+ return t.getRawIndex = t._indices ? Qf : Jf,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.wrapMethod = function(t, e) {
|
|
|
+ var i = this[t];
|
|
|
+ "function" == typeof i && (this.__wrappedMethods = this.__wrappedMethods || [],
|
|
|
+ this.__wrappedMethods.push(t),
|
|
|
+ this[t] = function() {
|
|
|
+ var t = i.apply(this, arguments);
|
|
|
+ return e.apply(this, [t].concat(U(arguments)))
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ jf.TRANSFERABLE_METHODS = ["cloneShallow", "downSample", "map"],
|
|
|
+ jf.CHANGABLE_METHODS = ["filterSelf", "selectRange"];
|
|
|
+ var lp = function(t, e) {
|
|
|
+ return rp((e = e || {}).coordDimensions || [], t, {
|
|
|
+ dimsDef: e.dimensionsDefine || t.dimensionsDefine,
|
|
|
+ encodeDef: e.encodeDefine || t.encodeDefine,
|
|
|
+ dimCount: e.dimensionsCount,
|
|
|
+ encodeDefaulter: e.encodeDefaulter,
|
|
|
+ generateCoord: e.generateCoord,
|
|
|
+ generateCoordCount: e.generateCoordCount
|
|
|
+ })
|
|
|
+ };
|
|
|
+ function up(t) {
|
|
|
+ this.coordSysName = t,
|
|
|
+ this.coordSysDims = [],
|
|
|
+ this.axisMap = Q(),
|
|
|
+ this.categoryAxisMap = Q(),
|
|
|
+ this.firstCategoryDimIndex = null
|
|
|
+ }
|
|
|
+ var hp = {
|
|
|
+ cartesian2d: function(t, e, i, n) {
|
|
|
+ var o = t.getReferringComponents("xAxis")[0]
|
|
|
+ , a = t.getReferringComponents("yAxis")[0];
|
|
|
+ e.coordSysDims = ["x", "y"],
|
|
|
+ i.set("x", o),
|
|
|
+ i.set("y", a),
|
|
|
+ cp(o) && (n.set("x", o),
|
|
|
+ e.firstCategoryDimIndex = 0),
|
|
|
+ cp(a) && (n.set("y", a),
|
|
|
+ e.firstCategoryDimIndex,
|
|
|
+ e.firstCategoryDimIndex = 1)
|
|
|
+ },
|
|
|
+ singleAxis: function(t, e, i, n) {
|
|
|
+ var o = t.getReferringComponents("singleAxis")[0];
|
|
|
+ e.coordSysDims = ["single"],
|
|
|
+ i.set("single", o),
|
|
|
+ cp(o) && (n.set("single", o),
|
|
|
+ e.firstCategoryDimIndex = 0)
|
|
|
+ },
|
|
|
+ polar: function(t, e, i, n) {
|
|
|
+ var o = t.getReferringComponents("polar")[0]
|
|
|
+ , a = o.findAxisModel("radiusAxis")
|
|
|
+ , r = o.findAxisModel("angleAxis");
|
|
|
+ e.coordSysDims = ["radius", "angle"],
|
|
|
+ i.set("radius", a),
|
|
|
+ i.set("angle", r),
|
|
|
+ cp(a) && (n.set("radius", a),
|
|
|
+ e.firstCategoryDimIndex = 0),
|
|
|
+ cp(r) && (n.set("angle", r),
|
|
|
+ null == e.firstCategoryDimIndex && (e.firstCategoryDimIndex = 1))
|
|
|
+ },
|
|
|
+ geo: function(t, e, i, n) {
|
|
|
+ e.coordSysDims = ["lng", "lat"]
|
|
|
+ },
|
|
|
+ parallel: function(t, o, a, r) {
|
|
|
+ var s = t.ecModel
|
|
|
+ , e = s.getComponent("parallel", t.get("parallelIndex"))
|
|
|
+ , l = o.coordSysDims = e.dimensions.slice();
|
|
|
+ E(e.parallelAxisIndex, function(t, e) {
|
|
|
+ var i = s.getComponent("parallelAxis", t)
|
|
|
+ , n = l[e];
|
|
|
+ a.set(n, i),
|
|
|
+ cp(i) && null == o.firstCategoryDimIndex && (r.set(n, i),
|
|
|
+ o.firstCategoryDimIndex = e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function cp(t) {
|
|
|
+ return "category" === t.get("type")
|
|
|
+ }
|
|
|
+ function dp(t, i, e) {
|
|
|
+ var n, o, a, r, s = (e = e || {}).byIndex, l = e.stackedCoordDimension, u = !(!t || !t.get("stack"));
|
|
|
+ if (E(i, function(t, e) {
|
|
|
+ R(t) && (i[e] = t = {
|
|
|
+ name: t
|
|
|
+ }),
|
|
|
+ u && !t.isExtraCoord && (s || n || !t.ordinalMeta || (n = t),
|
|
|
+ o || "ordinal" === t.type || "time" === t.type || l && l !== t.coordDim || (o = t))
|
|
|
+ }),
|
|
|
+ !o || s || n || (s = !0),
|
|
|
+ o) {
|
|
|
+ a = "__\0ecstackresult",
|
|
|
+ r = "__\0ecstackedover",
|
|
|
+ n && (n.createInvertedIndices = !0);
|
|
|
+ var h = o.coordDim
|
|
|
+ , c = o.type
|
|
|
+ , d = 0;
|
|
|
+ E(i, function(t) {
|
|
|
+ t.coordDim === h && d++
|
|
|
+ }),
|
|
|
+ i.push({
|
|
|
+ name: a,
|
|
|
+ coordDim: h,
|
|
|
+ coordDimIndex: d,
|
|
|
+ type: c,
|
|
|
+ isExtraCoord: !0,
|
|
|
+ isCalculationCoord: !0
|
|
|
+ }),
|
|
|
+ d++,
|
|
|
+ i.push({
|
|
|
+ name: r,
|
|
|
+ coordDim: r,
|
|
|
+ coordDimIndex: d,
|
|
|
+ type: c,
|
|
|
+ isExtraCoord: !0,
|
|
|
+ isCalculationCoord: !0
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ stackedDimension: o && o.name,
|
|
|
+ stackedByDimension: n && n.name,
|
|
|
+ isStackedByIndex: s,
|
|
|
+ stackedOverDimension: r,
|
|
|
+ stackResultDimension: a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function fp(t, e) {
|
|
|
+ return !!e && e === t.getCalculationInfo("stackedDimension")
|
|
|
+ }
|
|
|
+ function pp(t, e) {
|
|
|
+ return fp(t, e) ? t.getCalculationInfo("stackResultDimension") : e
|
|
|
+ }
|
|
|
+ function gp(t, e, i) {
|
|
|
+ i = i || {},
|
|
|
+ Uu.isInstance(t) || (t = Uu.seriesDataToSource(t));
|
|
|
+ var n, o = e.get("coordinateSystem"), a = lh.get(o), r = function(t) {
|
|
|
+ var e = t.get("coordinateSystem")
|
|
|
+ , i = new up(e)
|
|
|
+ , n = hp[e];
|
|
|
+ if (n)
|
|
|
+ return n(t, i, i.axisMap, i.categoryAxisMap),
|
|
|
+ i
|
|
|
+ }(e);
|
|
|
+ r && (n = O(r.coordSysDims, function(t) {
|
|
|
+ var e = {
|
|
|
+ name: t
|
|
|
+ }
|
|
|
+ , i = r.axisMap.get(t);
|
|
|
+ if (i) {
|
|
|
+ var n = i.get("type");
|
|
|
+ e.type = Ef(n)
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ })),
|
|
|
+ n = n || (a && (a.getDimensionsInfo ? a.getDimensionsInfo() : a.dimensions.slice()) || ["x", "y"]);
|
|
|
+ var s, l, u = lp(t, {
|
|
|
+ coordDimensions: n,
|
|
|
+ generateCoord: i.generateCoord,
|
|
|
+ encodeDefaulter: i.useEncodeDefaulter ? T($u, n, e) : null
|
|
|
+ });
|
|
|
+ r && E(u, function(t, e) {
|
|
|
+ var i = t.coordDim
|
|
|
+ , n = r.categoryAxisMap.get(i);
|
|
|
+ n && (null == s && (s = e),
|
|
|
+ t.ordinalMeta = n.getOrdinalMeta()),
|
|
|
+ null != t.otherDims.itemName && (l = !0)
|
|
|
+ }),
|
|
|
+ l || null == s || (u[s].otherDims.itemName = 0);
|
|
|
+ var h = dp(e, u)
|
|
|
+ , c = new Yf(u,e);
|
|
|
+ c.setCalculationInfo(h);
|
|
|
+ var d = null != s && function(t) {
|
|
|
+ if (t.sourceFormat === zu) {
|
|
|
+ var e = function(t) {
|
|
|
+ var e = 0;
|
|
|
+ for (; e < t.length && null == t[e]; )
|
|
|
+ e++;
|
|
|
+ return t[e]
|
|
|
+ }(t.data || []);
|
|
|
+ return null != e && !L(Wo(e))
|
|
|
+ }
|
|
|
+ }(t) ? function(t, e, i, n) {
|
|
|
+ return n === s ? i : this.defaultDimValueGetter(t, e, i, n)
|
|
|
+ }
|
|
|
+ : null;
|
|
|
+ return c.hasItemOption = !1,
|
|
|
+ c.initData(t, null, d),
|
|
|
+ c
|
|
|
+ }
|
|
|
+ function mp(t) {
|
|
|
+ this._setting = t || {},
|
|
|
+ this._extent = [1 / 0, -1 / 0],
|
|
|
+ this._interval = 0,
|
|
|
+ this.init && this.init.apply(this, arguments)
|
|
|
+ }
|
|
|
+ function vp(t) {
|
|
|
+ this.categories = t.categories || [],
|
|
|
+ this._needCollect = t.needCollect,
|
|
|
+ this._deduplication = t.deduplication,
|
|
|
+ this._map
|
|
|
+ }
|
|
|
+ mp.prototype.parse = function(t) {
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.getSetting = function(t) {
|
|
|
+ return this._setting[t]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.contain = function(t) {
|
|
|
+ var e = this._extent;
|
|
|
+ return t >= e[0] && t <= e[1]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.normalize = function(t) {
|
|
|
+ var e = this._extent;
|
|
|
+ return e[1] === e[0] ? .5 : (t - e[0]) / (e[1] - e[0])
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.scale = function(t) {
|
|
|
+ var e = this._extent;
|
|
|
+ return t * (e[1] - e[0]) + e[0]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.unionExtent = function(t) {
|
|
|
+ var e = this._extent;
|
|
|
+ t[0] < e[0] && (e[0] = t[0]),
|
|
|
+ t[1] > e[1] && (e[1] = t[1])
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.unionExtentFromData = function(t, e) {
|
|
|
+ this.unionExtent(t.getApproximateExtent(e))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.getExtent = function() {
|
|
|
+ return this._extent.slice()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.setExtent = function(t, e) {
|
|
|
+ var i = this._extent;
|
|
|
+ isNaN(t) || (i[0] = t),
|
|
|
+ isNaN(e) || (i[1] = e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.isBlank = function() {
|
|
|
+ return this._isBlank
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.setBlank = function(t) {
|
|
|
+ this._isBlank = t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mp.prototype.getLabel = null,
|
|
|
+ oa(mp),
|
|
|
+ ua(mp, {
|
|
|
+ registerWhenExtend: !0
|
|
|
+ }),
|
|
|
+ vp.createByAxisModel = function(t) {
|
|
|
+ var e = t.option
|
|
|
+ , i = e.data
|
|
|
+ , n = i && O(i, _p);
|
|
|
+ return new vp({
|
|
|
+ categories: n,
|
|
|
+ needCollect: !n,
|
|
|
+ deduplication: !1 !== e.dedplication
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var yp = vp.prototype;
|
|
|
+ function xp(t) {
|
|
|
+ return t._map || (t._map = Q(t.categories))
|
|
|
+ }
|
|
|
+ function _p(t) {
|
|
|
+ return z(t) && null != t.value ? t.value : t + ""
|
|
|
+ }
|
|
|
+ yp.getOrdinal = function(t) {
|
|
|
+ return xp(this).get(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ yp.parseAndCollect = function(t) {
|
|
|
+ var e, i = this._needCollect;
|
|
|
+ if ("string" != typeof t && !i)
|
|
|
+ return t;
|
|
|
+ if (i && !this._deduplication)
|
|
|
+ return e = this.categories.length,
|
|
|
+ this.categories[e] = t,
|
|
|
+ e;
|
|
|
+ var n = xp(this);
|
|
|
+ return null == (e = n.get(t)) && (i ? (e = this.categories.length,
|
|
|
+ this.categories[e] = t,
|
|
|
+ n.set(t, e)) : e = NaN),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var wp = mp.prototype
|
|
|
+ , bp = mp.extend({
|
|
|
+ type: "ordinal",
|
|
|
+ init: function(t, e) {
|
|
|
+ t && !L(t) || (t = new vp({
|
|
|
+ categories: t
|
|
|
+ })),
|
|
|
+ this._ordinalMeta = t,
|
|
|
+ this._extent = e || [0, t.categories.length - 1]
|
|
|
+ },
|
|
|
+ parse: function(t) {
|
|
|
+ return "string" == typeof t ? this._ordinalMeta.getOrdinal(t) : Math.round(t)
|
|
|
+ },
|
|
|
+ contain: function(t) {
|
|
|
+ return t = this.parse(t),
|
|
|
+ wp.contain.call(this, t) && null != this._ordinalMeta.categories[t]
|
|
|
+ },
|
|
|
+ normalize: function(t) {
|
|
|
+ return wp.normalize.call(this, this.parse(t))
|
|
|
+ },
|
|
|
+ scale: function(t) {
|
|
|
+ return Math.round(wp.scale.call(this, t))
|
|
|
+ },
|
|
|
+ getTicks: function() {
|
|
|
+ for (var t = [], e = this._extent, i = e[0]; i <= e[1]; )
|
|
|
+ t.push(i),
|
|
|
+ i++;
|
|
|
+ return t
|
|
|
+ },
|
|
|
+ getLabel: function(t) {
|
|
|
+ if (!this.isBlank())
|
|
|
+ return this._ordinalMeta.categories[t]
|
|
|
+ },
|
|
|
+ count: function() {
|
|
|
+ return this._extent[1] - this._extent[0] + 1
|
|
|
+ },
|
|
|
+ unionExtentFromData: function(t, e) {
|
|
|
+ this.unionExtent(t.getApproximateExtent(e))
|
|
|
+ },
|
|
|
+ getOrdinalMeta: function() {
|
|
|
+ return this._ordinalMeta
|
|
|
+ },
|
|
|
+ niceTicks: et,
|
|
|
+ niceExtent: et
|
|
|
+ });
|
|
|
+ bp.create = function() {
|
|
|
+ return new bp
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Sp = zl;
|
|
|
+ function Mp(t) {
|
|
|
+ return Gl(t) + 2
|
|
|
+ }
|
|
|
+ function Ip(t, e, i) {
|
|
|
+ t[e] = Math.max(Math.min(t[e], i[1]), i[0])
|
|
|
+ }
|
|
|
+ function Tp(t, e) {
|
|
|
+ isFinite(t[0]) || (t[0] = e[0]),
|
|
|
+ isFinite(t[1]) || (t[1] = e[1]),
|
|
|
+ Ip(t, 0, e),
|
|
|
+ Ip(t, 1, e),
|
|
|
+ t[0] > t[1] && (t[0] = t[1])
|
|
|
+ }
|
|
|
+ var Ap = zl
|
|
|
+ , Dp = mp.extend({
|
|
|
+ type: "interval",
|
|
|
+ _interval: 0,
|
|
|
+ _intervalPrecision: 2,
|
|
|
+ setExtent: function(t, e) {
|
|
|
+ var i = this._extent;
|
|
|
+ isNaN(t) || (i[0] = parseFloat(t)),
|
|
|
+ isNaN(e) || (i[1] = parseFloat(e))
|
|
|
+ },
|
|
|
+ unionExtent: function(t) {
|
|
|
+ var e = this._extent;
|
|
|
+ t[0] < e[0] && (e[0] = t[0]),
|
|
|
+ t[1] > e[1] && (e[1] = t[1]),
|
|
|
+ Dp.prototype.setExtent.call(this, e[0], e[1])
|
|
|
+ },
|
|
|
+ getInterval: function() {
|
|
|
+ return this._interval
|
|
|
+ },
|
|
|
+ setInterval: function(t) {
|
|
|
+ this._interval = t,
|
|
|
+ this._niceExtent = this._extent.slice(),
|
|
|
+ this._intervalPrecision = Mp(t)
|
|
|
+ },
|
|
|
+ getTicks: function(t) {
|
|
|
+ var e = this._interval
|
|
|
+ , i = this._extent
|
|
|
+ , n = this._niceExtent
|
|
|
+ , o = this._intervalPrecision
|
|
|
+ , a = [];
|
|
|
+ if (!e)
|
|
|
+ return a;
|
|
|
+ i[0] < n[0] && (t ? a.push(Ap(n[0] - e, o)) : a.push(i[0]));
|
|
|
+ for (var r = n[0]; r <= n[1] && (a.push(r),
|
|
|
+ (r = Ap(r + e, o)) !== a[a.length - 1]); )
|
|
|
+ if (1e4 < a.length)
|
|
|
+ return [];
|
|
|
+ var s = a.length ? a[a.length - 1] : n[1];
|
|
|
+ return i[1] > s && (t ? a.push(Ap(s + e, o)) : a.push(i[1])),
|
|
|
+ a
|
|
|
+ },
|
|
|
+ getMinorTicks: function(t) {
|
|
|
+ for (var e = this.getTicks(!0), i = [], n = this.getExtent(), o = 1; o < e.length; o++) {
|
|
|
+ for (var a = e[o], r = e[o - 1], s = 0, l = [], u = (a - r) / t; s < t - 1; ) {
|
|
|
+ var h = zl(r + (s + 1) * u);
|
|
|
+ h > n[0] && h < n[1] && l.push(h),
|
|
|
+ s++
|
|
|
+ }
|
|
|
+ i.push(l)
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ },
|
|
|
+ getLabel: function(t, e) {
|
|
|
+ if (null == t)
|
|
|
+ return "";
|
|
|
+ var i = e && e.precision;
|
|
|
+ return null == i ? i = Gl(t) || 0 : "auto" === i && (i = this._intervalPrecision),
|
|
|
+ tu(t = Ap(t, i, !0))
|
|
|
+ },
|
|
|
+ niceTicks: function(t, e, i) {
|
|
|
+ t = t || 5;
|
|
|
+ var n = this._extent
|
|
|
+ , o = n[1] - n[0];
|
|
|
+ if (isFinite(o)) {
|
|
|
+ o < 0 && (o = -o,
|
|
|
+ n.reverse());
|
|
|
+ var a = function(t, e, i, n) {
|
|
|
+ var o = {}
|
|
|
+ , a = t[1] - t[0]
|
|
|
+ , r = o.interval = Kl(a / e, !0);
|
|
|
+ null != i && r < i && (r = o.interval = i),
|
|
|
+ null != n && n < r && (r = o.interval = n);
|
|
|
+ var s = o.intervalPrecision = Mp(r);
|
|
|
+ return Tp(o.niceTickExtent = [Sp(Math.ceil(t[0] / r) * r, s), Sp(Math.floor(t[1] / r) * r, s)], t),
|
|
|
+ o
|
|
|
+ }(n, t, e, i);
|
|
|
+ this._intervalPrecision = a.intervalPrecision,
|
|
|
+ this._interval = a.interval,
|
|
|
+ this._niceExtent = a.niceTickExtent
|
|
|
+ }
|
|
|
+ },
|
|
|
+ niceExtent: function(t) {
|
|
|
+ var e = this._extent;
|
|
|
+ if (e[0] === e[1])
|
|
|
+ if (0 !== e[0]) {
|
|
|
+ var i = e[0];
|
|
|
+ t.fixMax || (e[1] += i / 2),
|
|
|
+ e[0] -= i / 2
|
|
|
+ } else
|
|
|
+ e[1] = 1;
|
|
|
+ var n = e[1] - e[0];
|
|
|
+ isFinite(n) || (e[0] = 0,
|
|
|
+ e[1] = 1),
|
|
|
+ this.niceTicks(t.splitNumber, t.minInterval, t.maxInterval);
|
|
|
+ var o = this._interval;
|
|
|
+ t.fixMin || (e[0] = Ap(Math.floor(e[0] / o) * o)),
|
|
|
+ t.fixMax || (e[1] = Ap(Math.ceil(e[1] / o) * o))
|
|
|
+ }
|
|
|
+ });
|
|
|
+ Dp.create = function() {
|
|
|
+ return new Dp
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Cp = "__ec_stack_"
|
|
|
+ , Lp = "undefined" != typeof Float32Array ? Float32Array : Array;
|
|
|
+ function kp(t) {
|
|
|
+ return t.get("stack") || Cp + t.seriesIndex
|
|
|
+ }
|
|
|
+ function Pp(t) {
|
|
|
+ return t.dim + t.index
|
|
|
+ }
|
|
|
+ function Np(t, e) {
|
|
|
+ var i = [];
|
|
|
+ return e.eachSeriesByType(t, function(t) {
|
|
|
+ Vp(t) && !Gp(t) && i.push(t)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function Op(t) {
|
|
|
+ var g = function(t) {
|
|
|
+ var l = {};
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = t.coordinateSystem.getBaseAxis();
|
|
|
+ if ("time" === e.type || "value" === e.type)
|
|
|
+ for (var i = t.getData(), n = e.dim + "_" + e.index, o = i.mapDimension(e.dim), a = 0, r = i.count(); a < r; ++a) {
|
|
|
+ var s = i.get(o, a);
|
|
|
+ l[n] ? l[n].push(s) : l[n] = [s]
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var e = [];
|
|
|
+ for (var i in l)
|
|
|
+ if (l.hasOwnProperty(i)) {
|
|
|
+ var n = l[i];
|
|
|
+ if (n) {
|
|
|
+ n.sort(function(t, e) {
|
|
|
+ return t - e
|
|
|
+ });
|
|
|
+ for (var o = null, a = 1; a < n.length; ++a) {
|
|
|
+ var r = n[a] - n[a - 1];
|
|
|
+ 0 < r && (o = null === o ? r : Math.min(o, r))
|
|
|
+ }
|
|
|
+ e[i] = o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }(t)
|
|
|
+ , m = [];
|
|
|
+ return E(t, function(t) {
|
|
|
+ var e, i = t.coordinateSystem.getBaseAxis(), n = i.getExtent();
|
|
|
+ if ("category" === i.type)
|
|
|
+ e = i.getBandWidth();
|
|
|
+ else if ("value" === i.type || "time" === i.type) {
|
|
|
+ var o = i.dim + "_" + i.index
|
|
|
+ , a = g[o]
|
|
|
+ , r = Math.abs(n[1] - n[0])
|
|
|
+ , s = i.scale.getExtent()
|
|
|
+ , l = Math.abs(s[1] - s[0]);
|
|
|
+ e = a ? r / l * a : r
|
|
|
+ } else {
|
|
|
+ var u = t.getData();
|
|
|
+ e = Math.abs(n[1] - n[0]) / u.count()
|
|
|
+ }
|
|
|
+ var h = Rl(t.get("barWidth"), e)
|
|
|
+ , c = Rl(t.get("barMaxWidth"), e)
|
|
|
+ , d = Rl(t.get("barMinWidth") || 1, e)
|
|
|
+ , f = t.get("barGap")
|
|
|
+ , p = t.get("barCategoryGap");
|
|
|
+ m.push({
|
|
|
+ bandWidth: e,
|
|
|
+ barWidth: h,
|
|
|
+ barMaxWidth: c,
|
|
|
+ barMinWidth: d,
|
|
|
+ barGap: f,
|
|
|
+ barCategoryGap: p,
|
|
|
+ axisKey: Pp(i),
|
|
|
+ stackId: kp(t)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ Ep(m)
|
|
|
+ }
|
|
|
+ function Ep(t) {
|
|
|
+ var d = {};
|
|
|
+ E(t, function(t, e) {
|
|
|
+ var i = t.axisKey
|
|
|
+ , n = t.bandWidth
|
|
|
+ , o = d[i] || {
|
|
|
+ bandWidth: n,
|
|
|
+ remainedWidth: n,
|
|
|
+ autoWidthCount: 0,
|
|
|
+ categoryGap: "20%",
|
|
|
+ gap: "30%",
|
|
|
+ stacks: {}
|
|
|
+ }
|
|
|
+ , a = o.stacks;
|
|
|
+ d[i] = o;
|
|
|
+ var r = t.stackId;
|
|
|
+ a[r] || o.autoWidthCount++,
|
|
|
+ a[r] = a[r] || {
|
|
|
+ width: 0,
|
|
|
+ maxWidth: 0
|
|
|
+ };
|
|
|
+ var s = t.barWidth;
|
|
|
+ s && !a[r].width && (a[r].width = s,
|
|
|
+ s = Math.min(o.remainedWidth, s),
|
|
|
+ o.remainedWidth -= s);
|
|
|
+ var l = t.barMaxWidth;
|
|
|
+ l && (a[r].maxWidth = l);
|
|
|
+ var u = t.barMinWidth;
|
|
|
+ u && (a[r].minWidth = u);
|
|
|
+ var h = t.barGap;
|
|
|
+ null != h && (o.gap = h);
|
|
|
+ var c = t.barCategoryGap;
|
|
|
+ null != c && (o.categoryGap = c)
|
|
|
+ });
|
|
|
+ var f = {};
|
|
|
+ return E(d, function(t, i) {
|
|
|
+ f[i] = {};
|
|
|
+ var e = t.stacks
|
|
|
+ , n = t.bandWidth
|
|
|
+ , o = Rl(t.categoryGap, n)
|
|
|
+ , a = Rl(t.gap, 1)
|
|
|
+ , r = t.remainedWidth
|
|
|
+ , s = t.autoWidthCount
|
|
|
+ , l = (r - o) / (s + (s - 1) * a);
|
|
|
+ l = Math.max(l, 0),
|
|
|
+ E(e, function(t) {
|
|
|
+ var e = t.maxWidth
|
|
|
+ , i = t.minWidth;
|
|
|
+ if (t.width) {
|
|
|
+ n = t.width;
|
|
|
+ e && (n = Math.min(n, e)),
|
|
|
+ i && (n = Math.max(n, i)),
|
|
|
+ t.width = n,
|
|
|
+ r -= n + a * n,
|
|
|
+ s--
|
|
|
+ } else {
|
|
|
+ var n = l;
|
|
|
+ e && e < n && (n = Math.min(e, r)),
|
|
|
+ i && n < i && (n = i),
|
|
|
+ n !== l && (t.width = n,
|
|
|
+ r -= n + a * n,
|
|
|
+ s--)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ l = (r - o) / (s + (s - 1) * a),
|
|
|
+ l = Math.max(l, 0);
|
|
|
+ var u, h = 0;
|
|
|
+ E(e, function(t, e) {
|
|
|
+ t.width || (t.width = l),
|
|
|
+ h += (u = t).width * (1 + a)
|
|
|
+ }),
|
|
|
+ u && (h -= u.width * a);
|
|
|
+ var c = -h / 2;
|
|
|
+ E(e, function(t, e) {
|
|
|
+ f[i][e] = f[i][e] || {
|
|
|
+ bandWidth: n,
|
|
|
+ offset: c,
|
|
|
+ width: t.width
|
|
|
+ },
|
|
|
+ c += t.width * (1 + a)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ f
|
|
|
+ }
|
|
|
+ function Rp(t, e, i) {
|
|
|
+ if (t && e) {
|
|
|
+ var n = t[Pp(e)];
|
|
|
+ return null != n && null != i && (n = n[kp(i)]),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function zp(t, e) {
|
|
|
+ var i = Np(t, e)
|
|
|
+ , T = Op(i)
|
|
|
+ , A = {};
|
|
|
+ E(i, function(t) {
|
|
|
+ var e = t.getData()
|
|
|
+ , i = t.coordinateSystem
|
|
|
+ , n = i.getBaseAxis()
|
|
|
+ , o = kp(t)
|
|
|
+ , a = T[Pp(n)][o]
|
|
|
+ , r = a.offset
|
|
|
+ , s = a.width
|
|
|
+ , l = i.getOtherAxis(n)
|
|
|
+ , u = t.get("barMinHeight") || 0;
|
|
|
+ A[o] = A[o] || [],
|
|
|
+ e.setLayout({
|
|
|
+ bandWidth: a.bandWidth,
|
|
|
+ offset: r,
|
|
|
+ size: s
|
|
|
+ });
|
|
|
+ for (var h = e.mapDimension(l.dim), c = e.mapDimension(n.dim), d = fp(e, h), f = l.isHorizontal(), p = Fp(n, l, d), g = 0, m = e.count(); g < m; g++) {
|
|
|
+ var v, y, x, _, w, b = e.get(h, g), S = e.get(c, g), M = 0 <= b ? "p" : "n", I = p;
|
|
|
+ if (d && (A[o][S] || (A[o][S] = {
|
|
|
+ p: p,
|
|
|
+ n: p
|
|
|
+ }),
|
|
|
+ I = A[o][S][M]),
|
|
|
+ f)
|
|
|
+ v = I,
|
|
|
+ y = (w = i.dataToPoint([b, S]))[1] + r,
|
|
|
+ x = w[0] - p,
|
|
|
+ _ = s,
|
|
|
+ Math.abs(x) < u && (x = (x < 0 ? -1 : 1) * u),
|
|
|
+ isNaN(x) || d && (A[o][S][M] += x);
|
|
|
+ else
|
|
|
+ v = (w = i.dataToPoint([S, b]))[0] + r,
|
|
|
+ y = I,
|
|
|
+ x = s,
|
|
|
+ _ = w[1] - p,
|
|
|
+ Math.abs(_) < u && (_ = (_ <= 0 ? -1 : 1) * u),
|
|
|
+ isNaN(_) || d && (A[o][S][M] += _);
|
|
|
+ e.setItemLayout(g, {
|
|
|
+ x: v,
|
|
|
+ y: y,
|
|
|
+ width: x,
|
|
|
+ height: _
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ var Bp = {
|
|
|
+ seriesType: "bar",
|
|
|
+ plan: vc(),
|
|
|
+ reset: function(t) {
|
|
|
+ if (Vp(t) && Gp(t)) {
|
|
|
+ var e = t.getData()
|
|
|
+ , c = t.coordinateSystem
|
|
|
+ , d = c.grid.getRect()
|
|
|
+ , f = c.getBaseAxis()
|
|
|
+ , p = c.getOtherAxis(f)
|
|
|
+ , g = e.mapDimension(p.dim)
|
|
|
+ , m = e.mapDimension(f.dim)
|
|
|
+ , v = p.isHorizontal()
|
|
|
+ , y = v ? 0 : 1
|
|
|
+ , x = Rp(Op([t]), f, t).width;
|
|
|
+ return .5 < x || (x = .5),
|
|
|
+ {
|
|
|
+ progress: function(t, e) {
|
|
|
+ var i, n = t.count, o = new Lp(2 * n), a = new Lp(2 * n), r = new Lp(n), s = [], l = [], u = 0, h = 0;
|
|
|
+ for (; null != (i = t.next()); )
|
|
|
+ l[y] = e.get(g, i),
|
|
|
+ l[1 - y] = e.get(m, i),
|
|
|
+ s = c.dataToPoint(l, null, s),
|
|
|
+ a[u] = v ? d.x + d.width : s[0],
|
|
|
+ o[u++] = s[0],
|
|
|
+ a[u] = v ? s[1] : d.y + d.height,
|
|
|
+ o[u++] = s[1],
|
|
|
+ r[h++] = i;
|
|
|
+ e.setLayout({
|
|
|
+ largePoints: o,
|
|
|
+ largeDataIndices: r,
|
|
|
+ largeBackgroundPoints: a,
|
|
|
+ barWidth: x,
|
|
|
+ valueAxisStart: Fp(f, p, !1),
|
|
|
+ backgroundStart: v ? d.x : d.y,
|
|
|
+ valueAxisHorizontal: v
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Vp(t) {
|
|
|
+ return t.coordinateSystem && "cartesian2d" === t.coordinateSystem.type
|
|
|
+ }
|
|
|
+ function Gp(t) {
|
|
|
+ return t.pipelineContext && t.pipelineContext.large
|
|
|
+ }
|
|
|
+ function Fp(t, e) {
|
|
|
+ return e.toGlobalCoord(e.dataToCoord("log" === e.type ? 1 : 0))
|
|
|
+ }
|
|
|
+ var Wp = Dp.prototype
|
|
|
+ , Hp = Math.ceil
|
|
|
+ , Zp = Math.floor
|
|
|
+ , Up = 36e5
|
|
|
+ , Xp = 864e5
|
|
|
+ , Yp = Dp.extend({
|
|
|
+ type: "time",
|
|
|
+ getLabel: function(t) {
|
|
|
+ var e = this._stepLvl
|
|
|
+ , i = new Date(t);
|
|
|
+ return du(e[0], i, this.getSetting("useUTC"))
|
|
|
+ },
|
|
|
+ niceExtent: function(t) {
|
|
|
+ var e = this._extent;
|
|
|
+ if (e[0] === e[1] && (e[0] -= Xp,
|
|
|
+ e[1] += Xp),
|
|
|
+ e[1] === -1 / 0 && e[0] === 1 / 0) {
|
|
|
+ var i = new Date;
|
|
|
+ e[1] = +new Date(i.getFullYear(),i.getMonth(),i.getDate()),
|
|
|
+ e[0] = e[1] - Xp
|
|
|
+ }
|
|
|
+ this.niceTicks(t.splitNumber, t.minInterval, t.maxInterval);
|
|
|
+ var n = this._interval;
|
|
|
+ t.fixMin || (e[0] = zl(Zp(e[0] / n) * n)),
|
|
|
+ t.fixMax || (e[1] = zl(Hp(e[1] / n) * n))
|
|
|
+ },
|
|
|
+ niceTicks: function(t, e, i) {
|
|
|
+ t = t || 10;
|
|
|
+ var n = this._extent
|
|
|
+ , o = n[1] - n[0]
|
|
|
+ , a = o / t;
|
|
|
+ null != e && a < e && (a = e),
|
|
|
+ null != i && i < a && (a = i);
|
|
|
+ var r = jp.length
|
|
|
+ , s = function(t, e, i, n) {
|
|
|
+ for (; i < n; ) {
|
|
|
+ var o = i + n >>> 1;
|
|
|
+ t[o][1] < e ? i = 1 + o : n = o
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }(jp, a, 0, r)
|
|
|
+ , l = jp[Math.min(s, r - 1)]
|
|
|
+ , u = l[1];
|
|
|
+ "year" === l[0] && (u *= Kl(o / u / t, !0));
|
|
|
+ var h = this.getSetting("useUTC") ? 0 : 60 * new Date(+n[0] || +n[1]).getTimezoneOffset() * 1e3
|
|
|
+ , c = [Math.round(Hp((n[0] - h) / u) * u + h), Math.round(Zp((n[1] - h) / u) * u + h)];
|
|
|
+ Tp(c, n),
|
|
|
+ this._stepLvl = l,
|
|
|
+ this._interval = u,
|
|
|
+ this._niceExtent = c
|
|
|
+ },
|
|
|
+ parse: function(t) {
|
|
|
+ return +Yl(t)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ E(["contain", "normalize"], function(e) {
|
|
|
+ Yp.prototype[e] = function(t) {
|
|
|
+ return Wp[e].call(this, this.parse(t))
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var jp = [["hh:mm:ss", 1e3], ["hh:mm:ss", 5e3], ["hh:mm:ss", 1e4], ["hh:mm:ss", 15e3], ["hh:mm:ss", 3e4], ["hh:mm\nMM-dd", 6e4], ["hh:mm\nMM-dd", 3e5], ["hh:mm\nMM-dd", 6e5], ["hh:mm\nMM-dd", 9e5], ["hh:mm\nMM-dd", 18e5], ["hh:mm\nMM-dd", Up], ["hh:mm\nMM-dd", 72e5], ["hh:mm\nMM-dd", 6 * Up], ["hh:mm\nMM-dd", 432e5], ["MM-dd\nyyyy", Xp], ["MM-dd\nyyyy", 2 * Xp], ["MM-dd\nyyyy", 3 * Xp], ["MM-dd\nyyyy", 4 * Xp], ["MM-dd\nyyyy", 5 * Xp], ["MM-dd\nyyyy", 6 * Xp], ["week", 7 * Xp], ["MM-dd\nyyyy", 864e6], ["week", 14 * Xp], ["week", 21 * Xp], ["month", 31 * Xp], ["week", 42 * Xp], ["month", 62 * Xp], ["week", 70 * Xp], ["quarter", 95 * Xp], ["month", 31 * Xp * 4], ["month", 13392e6], ["half-year", 16416e6], ["month", 31 * Xp * 8], ["month", 26784e6], ["year", 380 * Xp]];
|
|
|
+ Yp.create = function(t) {
|
|
|
+ return new Yp({
|
|
|
+ useUTC: t.ecModel.get("useUTC")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var qp = mp.prototype
|
|
|
+ , Kp = Dp.prototype
|
|
|
+ , $p = Gl
|
|
|
+ , Jp = zl
|
|
|
+ , Qp = Math.floor
|
|
|
+ , tg = Math.ceil
|
|
|
+ , eg = Math.pow
|
|
|
+ , ig = Math.log
|
|
|
+ , ng = mp.extend({
|
|
|
+ type: "log",
|
|
|
+ base: 10,
|
|
|
+ $constructor: function() {
|
|
|
+ mp.apply(this, arguments),
|
|
|
+ this._originalScale = new Dp
|
|
|
+ },
|
|
|
+ getTicks: function(t) {
|
|
|
+ var i = this._originalScale
|
|
|
+ , n = this._extent
|
|
|
+ , o = i.getExtent();
|
|
|
+ return O(Kp.getTicks.call(this, t), function(t) {
|
|
|
+ var e = zl(eg(this.base, t));
|
|
|
+ return e = t === n[0] && i.__fixMin ? og(e, o[0]) : e,
|
|
|
+ e = t === n[1] && i.__fixMax ? og(e, o[1]) : e
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ getMinorTicks: Kp.getMinorTicks,
|
|
|
+ getLabel: Kp.getLabel,
|
|
|
+ scale: function(t) {
|
|
|
+ return t = qp.scale.call(this, t),
|
|
|
+ eg(this.base, t)
|
|
|
+ },
|
|
|
+ setExtent: function(t, e) {
|
|
|
+ var i = this.base;
|
|
|
+ t = ig(t) / ig(i),
|
|
|
+ e = ig(e) / ig(i),
|
|
|
+ Kp.setExtent.call(this, t, e)
|
|
|
+ },
|
|
|
+ getExtent: function() {
|
|
|
+ var t = this.base
|
|
|
+ , e = qp.getExtent.call(this);
|
|
|
+ e[0] = eg(t, e[0]),
|
|
|
+ e[1] = eg(t, e[1]);
|
|
|
+ var i = this._originalScale
|
|
|
+ , n = i.getExtent();
|
|
|
+ return i.__fixMin && (e[0] = og(e[0], n[0])),
|
|
|
+ i.__fixMax && (e[1] = og(e[1], n[1])),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ unionExtent: function(t) {
|
|
|
+ this._originalScale.unionExtent(t);
|
|
|
+ var e = this.base;
|
|
|
+ t[0] = ig(t[0]) / ig(e),
|
|
|
+ t[1] = ig(t[1]) / ig(e),
|
|
|
+ qp.unionExtent.call(this, t)
|
|
|
+ },
|
|
|
+ unionExtentFromData: function(t, e) {
|
|
|
+ this.unionExtent(t.getApproximateExtent(e))
|
|
|
+ },
|
|
|
+ niceTicks: function(t) {
|
|
|
+ t = t || 10;
|
|
|
+ var e = this._extent
|
|
|
+ , i = e[1] - e[0];
|
|
|
+ if (!(i == 1 / 0 || i <= 0)) {
|
|
|
+ var n = jl(i);
|
|
|
+ for (t / i * n <= .5 && (n *= 10); !isNaN(n) && Math.abs(n) < 1 && 0 < Math.abs(n); )
|
|
|
+ n *= 10;
|
|
|
+ var o = [zl(tg(e[0] / n) * n), zl(Qp(e[1] / n) * n)];
|
|
|
+ this._interval = n,
|
|
|
+ this._niceExtent = o
|
|
|
+ }
|
|
|
+ },
|
|
|
+ niceExtent: function(t) {
|
|
|
+ Kp.niceExtent.call(this, t);
|
|
|
+ var e = this._originalScale;
|
|
|
+ e.__fixMin = t.fixMin,
|
|
|
+ e.__fixMax = t.fixMax
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function og(t, e) {
|
|
|
+ return Jp(t, $p(e))
|
|
|
+ }
|
|
|
+ function ag(t, e) {
|
|
|
+ var i, n, o, a = t.type, r = e.getMin(), s = e.getMax(), l = t.getExtent();
|
|
|
+ "ordinal" === a ? i = e.getCategories().length : (L(n = e.get("boundaryGap")) || (n = [n || 0, n || 0]),
|
|
|
+ "boolean" == typeof n[0] && (n = [0, 0]),
|
|
|
+ n[0] = Rl(n[0], 1),
|
|
|
+ n[1] = Rl(n[1], 1),
|
|
|
+ o = l[1] - l[0] || Math.abs(l[0])),
|
|
|
+ "dataMin" === r ? r = l[0] : "function" == typeof r && (r = r({
|
|
|
+ min: l[0],
|
|
|
+ max: l[1]
|
|
|
+ })),
|
|
|
+ "dataMax" === s ? s = l[1] : "function" == typeof s && (s = s({
|
|
|
+ min: l[0],
|
|
|
+ max: l[1]
|
|
|
+ }));
|
|
|
+ var u = null != r
|
|
|
+ , h = null != s;
|
|
|
+ null == r && (r = "ordinal" === a ? i ? 0 : NaN : l[0] - n[0] * o),
|
|
|
+ null == s && (s = "ordinal" === a ? i ? i - 1 : NaN : l[1] + n[1] * o),
|
|
|
+ null != r && isFinite(r) || (r = NaN),
|
|
|
+ null != s && isFinite(s) || (s = NaN),
|
|
|
+ t.setBlank(F(r) || F(s) || "ordinal" === a && !t.getOrdinalMeta().categories.length),
|
|
|
+ e.getNeedCrossZero() && (0 < r && 0 < s && !u && (r = 0),
|
|
|
+ r < 0 && s < 0 && !h && (s = 0));
|
|
|
+ var c = e.ecModel;
|
|
|
+ if (c && "time" === a) {
|
|
|
+ var d, f = Np("bar", c);
|
|
|
+ if (E(f, function(t) {
|
|
|
+ d |= t.getBaseAxis() === e.axis
|
|
|
+ }),
|
|
|
+ d) {
|
|
|
+ var p = Op(f)
|
|
|
+ , g = function(t, e, i, n) {
|
|
|
+ var o = i.axis.getExtent()
|
|
|
+ , a = o[1] - o[0]
|
|
|
+ , r = Rp(n, i.axis);
|
|
|
+ if (void 0 === r)
|
|
|
+ return {
|
|
|
+ min: t,
|
|
|
+ max: e
|
|
|
+ };
|
|
|
+ var s = 1 / 0;
|
|
|
+ E(r, function(t) {
|
|
|
+ s = Math.min(t.offset, s)
|
|
|
+ });
|
|
|
+ var l = -1 / 0;
|
|
|
+ E(r, function(t) {
|
|
|
+ l = Math.max(t.offset + t.width, l)
|
|
|
+ }),
|
|
|
+ s = Math.abs(s),
|
|
|
+ l = Math.abs(l);
|
|
|
+ var u = s + l
|
|
|
+ , h = e - t
|
|
|
+ , c = h / (1 - (s + l) / a) - h;
|
|
|
+ return {
|
|
|
+ min: t -= s / u * c,
|
|
|
+ max: e += l / u * c
|
|
|
+ }
|
|
|
+ }(r, s, e, p);
|
|
|
+ r = g.min,
|
|
|
+ s = g.max
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ extent: [r, s],
|
|
|
+ fixMin: u,
|
|
|
+ fixMax: h
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function rg(t, e) {
|
|
|
+ var i = ag(t, e)
|
|
|
+ , n = i.extent
|
|
|
+ , o = e.get("splitNumber");
|
|
|
+ "log" === t.type && (t.base = e.get("logBase"));
|
|
|
+ var a = t.type;
|
|
|
+ t.setExtent(n[0], n[1]),
|
|
|
+ t.niceExtent({
|
|
|
+ splitNumber: o,
|
|
|
+ fixMin: i.fixMin,
|
|
|
+ fixMax: i.fixMax,
|
|
|
+ minInterval: "interval" === a || "time" === a ? e.get("minInterval") : null,
|
|
|
+ maxInterval: "interval" === a || "time" === a ? e.get("maxInterval") : null
|
|
|
+ });
|
|
|
+ var r = e.get("interval");
|
|
|
+ null != r && t.setInterval && t.setInterval(r)
|
|
|
+ }
|
|
|
+ function sg(t, e) {
|
|
|
+ if (e = e || t.get("type"))
|
|
|
+ switch (e) {
|
|
|
+ case "category":
|
|
|
+ return new bp(t.getOrdinalMeta ? t.getOrdinalMeta() : t.getCategories(),[1 / 0, -1 / 0]);
|
|
|
+ case "value":
|
|
|
+ return new Dp;
|
|
|
+ default:
|
|
|
+ return (mp.getClass(e) || Dp).create(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function lg(i) {
|
|
|
+ var e, n = i.getLabelModel().get("formatter"), o = "category" === i.type ? i.scale.getExtent()[0] : null;
|
|
|
+ return "string" == typeof n ? (e = n,
|
|
|
+ n = function(t) {
|
|
|
+ return t = i.scale.getLabel(t),
|
|
|
+ e.replace("{value}", null != t ? t : "")
|
|
|
+ }
|
|
|
+ ) : "function" == typeof n ? function(t, e) {
|
|
|
+ return null != o && (e = t - o),
|
|
|
+ n(ug(i, t), e)
|
|
|
+ }
|
|
|
+ : function(t) {
|
|
|
+ return i.scale.getLabel(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ug(t, e) {
|
|
|
+ return "category" === t.type ? t.scale.getLabel(e) : e
|
|
|
+ }
|
|
|
+ function hg(t) {
|
|
|
+ var e = t.get("interval");
|
|
|
+ return null == e ? "auto" : e
|
|
|
+ }
|
|
|
+ function cg(t) {
|
|
|
+ return "category" === t.type && 0 === hg(t.getLabelModel())
|
|
|
+ }
|
|
|
+ E(["contain", "normalize"], function(e) {
|
|
|
+ ng.prototype[e] = function(t) {
|
|
|
+ return t = ig(t) / ig(this.base),
|
|
|
+ qp[e].call(this, t)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ ng.create = function() {
|
|
|
+ return new ng
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var dg = {
|
|
|
+ getMin: function(t) {
|
|
|
+ var e = this.option
|
|
|
+ , i = t || null == e.rangeStart ? e.min : e.rangeStart;
|
|
|
+ return this.axis && null != i && "dataMin" !== i && "function" != typeof i && !F(i) && (i = this.axis.scale.parse(i)),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ getMax: function(t) {
|
|
|
+ var e = this.option
|
|
|
+ , i = t || null == e.rangeEnd ? e.max : e.rangeEnd;
|
|
|
+ return this.axis && null != i && "dataMax" !== i && "function" != typeof i && !F(i) && (i = this.axis.scale.parse(i)),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ getNeedCrossZero: function() {
|
|
|
+ var t = this.option;
|
|
|
+ return null == t.rangeStart && null == t.rangeEnd && !t.scale
|
|
|
+ },
|
|
|
+ getCoordSysModel: et,
|
|
|
+ setRange: function(t, e) {
|
|
|
+ this.option.rangeStart = t,
|
|
|
+ this.option.rangeEnd = e
|
|
|
+ },
|
|
|
+ resetRange: function() {
|
|
|
+ this.option.rangeStart = this.option.rangeEnd = null
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , fg = Cs({
|
|
|
+ type: "triangle",
|
|
|
+ shape: {
|
|
|
+ cx: 0,
|
|
|
+ cy: 0,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.cx
|
|
|
+ , n = e.cy
|
|
|
+ , o = e.width / 2
|
|
|
+ , a = e.height / 2;
|
|
|
+ t.moveTo(i, n - a),
|
|
|
+ t.lineTo(i + o, n + a),
|
|
|
+ t.lineTo(i - o, n + a),
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , pg = Cs({
|
|
|
+ type: "diamond",
|
|
|
+ shape: {
|
|
|
+ cx: 0,
|
|
|
+ cy: 0,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.cx
|
|
|
+ , n = e.cy
|
|
|
+ , o = e.width / 2
|
|
|
+ , a = e.height / 2;
|
|
|
+ t.moveTo(i, n - a),
|
|
|
+ t.lineTo(i + o, n),
|
|
|
+ t.lineTo(i, n + a),
|
|
|
+ t.lineTo(i - o, n),
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , gg = Cs({
|
|
|
+ type: "pin",
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.x
|
|
|
+ , n = e.y
|
|
|
+ , o = e.width / 5 * 3
|
|
|
+ , a = Math.max(o, e.height)
|
|
|
+ , r = o / 2
|
|
|
+ , s = r * r / (a - r)
|
|
|
+ , l = n - a + r + s
|
|
|
+ , u = Math.asin(s / r)
|
|
|
+ , h = Math.cos(u) * r
|
|
|
+ , c = Math.sin(u)
|
|
|
+ , d = Math.cos(u)
|
|
|
+ , f = .6 * r
|
|
|
+ , p = .7 * r;
|
|
|
+ t.moveTo(i - h, l + s),
|
|
|
+ t.arc(i, l, r, Math.PI - u, 2 * Math.PI + u),
|
|
|
+ t.bezierCurveTo(i + h - c * f, l + s + d * f, i, n - p, i, n),
|
|
|
+ t.bezierCurveTo(i, n - p, i - h + c * f, l + s + d * f, i - h, l + s),
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , mg = Cs({
|
|
|
+ type: "arrow",
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.height
|
|
|
+ , n = e.width
|
|
|
+ , o = e.x
|
|
|
+ , a = e.y
|
|
|
+ , r = n / 3 * 2;
|
|
|
+ t.moveTo(o, a),
|
|
|
+ t.lineTo(o + r, a + i),
|
|
|
+ t.lineTo(o, a + i / 4 * 3),
|
|
|
+ t.lineTo(o - r, a + i),
|
|
|
+ t.lineTo(o, a),
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , vg = {
|
|
|
+ line: function(t, e, i, n, o) {
|
|
|
+ o.x1 = t,
|
|
|
+ o.y1 = e + n / 2,
|
|
|
+ o.x2 = t + i,
|
|
|
+ o.y2 = e + n / 2
|
|
|
+ },
|
|
|
+ rect: function(t, e, i, n, o) {
|
|
|
+ o.x = t,
|
|
|
+ o.y = e,
|
|
|
+ o.width = i,
|
|
|
+ o.height = n
|
|
|
+ },
|
|
|
+ roundRect: function(t, e, i, n, o) {
|
|
|
+ o.x = t,
|
|
|
+ o.y = e,
|
|
|
+ o.width = i,
|
|
|
+ o.height = n,
|
|
|
+ o.r = Math.min(i, n) / 4
|
|
|
+ },
|
|
|
+ square: function(t, e, i, n, o) {
|
|
|
+ var a = Math.min(i, n);
|
|
|
+ o.x = t,
|
|
|
+ o.y = e,
|
|
|
+ o.width = a,
|
|
|
+ o.height = a
|
|
|
+ },
|
|
|
+ circle: function(t, e, i, n, o) {
|
|
|
+ o.cx = t + i / 2,
|
|
|
+ o.cy = e + n / 2,
|
|
|
+ o.r = Math.min(i, n) / 2
|
|
|
+ },
|
|
|
+ diamond: function(t, e, i, n, o) {
|
|
|
+ o.cx = t + i / 2,
|
|
|
+ o.cy = e + n / 2,
|
|
|
+ o.width = i,
|
|
|
+ o.height = n
|
|
|
+ },
|
|
|
+ pin: function(t, e, i, n, o) {
|
|
|
+ o.x = t + i / 2,
|
|
|
+ o.y = e + n / 2,
|
|
|
+ o.width = i,
|
|
|
+ o.height = n
|
|
|
+ },
|
|
|
+ arrow: function(t, e, i, n, o) {
|
|
|
+ o.x = t + i / 2,
|
|
|
+ o.y = e + n / 2,
|
|
|
+ o.width = i,
|
|
|
+ o.height = n
|
|
|
+ },
|
|
|
+ triangle: function(t, e, i, n, o) {
|
|
|
+ o.cx = t + i / 2,
|
|
|
+ o.cy = e + n / 2,
|
|
|
+ o.width = i,
|
|
|
+ o.height = n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , yg = {};
|
|
|
+ E({
|
|
|
+ line: ls,
|
|
|
+ rect: rs,
|
|
|
+ roundRect: rs,
|
|
|
+ square: rs,
|
|
|
+ circle: Yr,
|
|
|
+ diamond: pg,
|
|
|
+ pin: gg,
|
|
|
+ arrow: mg,
|
|
|
+ triangle: fg
|
|
|
+ }, function(t, e) {
|
|
|
+ yg[e] = new t
|
|
|
+ });
|
|
|
+ var xg = Cs({
|
|
|
+ type: "symbol",
|
|
|
+ shape: {
|
|
|
+ symbolType: "",
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ },
|
|
|
+ calculateTextPosition: function(t, e, i) {
|
|
|
+ var n = yn(t, e, i)
|
|
|
+ , o = this.shape;
|
|
|
+ return o && "pin" === o.symbolType && "inside" === e.textPosition && (n.y = i.y + .4 * i.height),
|
|
|
+ n
|
|
|
+ },
|
|
|
+ buildPath: function(t, e, i) {
|
|
|
+ var n = e.symbolType;
|
|
|
+ if ("none" !== n) {
|
|
|
+ var o = yg[n];
|
|
|
+ o = o || yg[n = "rect"],
|
|
|
+ vg[n](e.x, e.y, e.width, e.height, o.shape),
|
|
|
+ o.buildPath(t, o.shape, i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function _g(t, e) {
|
|
|
+ if ("image" !== this.type) {
|
|
|
+ var i = this.style
|
|
|
+ , n = this.shape;
|
|
|
+ n && "line" === n.symbolType ? i.stroke = t : this.__isEmptyBrush ? (i.stroke = t,
|
|
|
+ i.fill = e || "#fff") : (i.fill && (i.fill = t),
|
|
|
+ i.stroke && (i.stroke = t)),
|
|
|
+ this.dirty(!1)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function wg(t, e, i, n, o, a, r) {
|
|
|
+ var s, l = 0 === t.indexOf("empty");
|
|
|
+ return l && (t = t.substr(5, 1).toLowerCase() + t.substr(6)),
|
|
|
+ (s = 0 === t.indexOf("image://") ? Ns(t.slice(8), new Di(e,i,n,o), r ? "center" : "cover") : 0 === t.indexOf("path://") ? Ps(t.slice(7), {}, new Di(e,i,n,o), r ? "center" : "cover") : new xg({
|
|
|
+ shape: {
|
|
|
+ symbolType: t,
|
|
|
+ x: e,
|
|
|
+ y: i,
|
|
|
+ width: n,
|
|
|
+ height: o
|
|
|
+ }
|
|
|
+ })).__isEmptyBrush = l,
|
|
|
+ s.setColor = _g,
|
|
|
+ s.setColor(a),
|
|
|
+ s
|
|
|
+ }
|
|
|
+ var bg = {
|
|
|
+ isDimensionStacked: fp,
|
|
|
+ enableDataStack: dp,
|
|
|
+ getStackedDimension: pp
|
|
|
+ };
|
|
|
+ var Sg = (Object.freeze || Object)({
|
|
|
+ createList: function(t) {
|
|
|
+ return gp(t.getSource(), t)
|
|
|
+ },
|
|
|
+ getLayoutRect: bu,
|
|
|
+ dataStack: bg,
|
|
|
+ createScale: function(t, e) {
|
|
|
+ var i = e;
|
|
|
+ Cl.isInstance(e) || b(i = new Cl(e), dg);
|
|
|
+ var n = sg(i);
|
|
|
+ return n.setExtent(t[0], t[1]),
|
|
|
+ rg(n, i),
|
|
|
+ n
|
|
|
+ },
|
|
|
+ mixinAxisModelCommonMethods: function(t) {
|
|
|
+ b(t, dg)
|
|
|
+ },
|
|
|
+ completeDimensions: rp,
|
|
|
+ createDimensions: lp,
|
|
|
+ createSymbol: wg
|
|
|
+ })
|
|
|
+ , Mg = 1e-8;
|
|
|
+ function Ig(t, e) {
|
|
|
+ return Math.abs(t - e) < Mg
|
|
|
+ }
|
|
|
+ function Tg(t, e, i) {
|
|
|
+ var n = 0
|
|
|
+ , o = t[0];
|
|
|
+ if (!o)
|
|
|
+ return !1;
|
|
|
+ for (var a = 1; a < t.length; a++) {
|
|
|
+ var r = t[a];
|
|
|
+ n += pr(o[0], o[1], r[0], r[1], e, i),
|
|
|
+ o = r
|
|
|
+ }
|
|
|
+ var s = t[0];
|
|
|
+ return Ig(o[0], s[0]) && Ig(o[1], s[1]) || (n += pr(o[0], o[1], s[0], s[1], e, i)),
|
|
|
+ 0 !== n
|
|
|
+ }
|
|
|
+ function Ag(t, e, i) {
|
|
|
+ if (this.name = t,
|
|
|
+ this.geometries = e,
|
|
|
+ i)
|
|
|
+ i = [i[0], i[1]];
|
|
|
+ else {
|
|
|
+ var n = this.getBoundingRect();
|
|
|
+ i = [n.x + n.width / 2, n.y + n.height / 2]
|
|
|
+ }
|
|
|
+ this.center = i
|
|
|
+ }
|
|
|
+ function Dg(t, e, i) {
|
|
|
+ for (var n = [], o = e[0], a = e[1], r = 0; r < t.length; r += 2) {
|
|
|
+ var s = t.charCodeAt(r) - 64
|
|
|
+ , l = t.charCodeAt(r + 1) - 64;
|
|
|
+ s = s >> 1 ^ -(1 & s),
|
|
|
+ l = l >> 1 ^ -(1 & l),
|
|
|
+ o = s += o,
|
|
|
+ a = l += a,
|
|
|
+ n.push([s / i, l / i])
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ Ag.prototype = {
|
|
|
+ constructor: Ag,
|
|
|
+ properties: null,
|
|
|
+ getBoundingRect: function() {
|
|
|
+ var t = this._rect;
|
|
|
+ if (t)
|
|
|
+ return t;
|
|
|
+ for (var e = Number.MAX_VALUE, i = [e, e], n = [-e, -e], o = [], a = [], r = this.geometries, s = 0; s < r.length; s++) {
|
|
|
+ if ("polygon" === r[s].type)
|
|
|
+ Wa(r[s].exterior, o, a),
|
|
|
+ St(i, i, o),
|
|
|
+ Mt(n, n, a)
|
|
|
+ }
|
|
|
+ return 0 === s && (i[0] = i[1] = n[0] = n[1] = 0),
|
|
|
+ this._rect = new Di(i[0],i[1],n[0] - i[0],n[1] - i[1])
|
|
|
+ },
|
|
|
+ contain: function(t) {
|
|
|
+ var e = this.getBoundingRect()
|
|
|
+ , i = this.geometries;
|
|
|
+ if (!e.contain(t[0], t[1]))
|
|
|
+ return !1;
|
|
|
+ t: for (var n = 0, o = i.length; n < o; n++)
|
|
|
+ if ("polygon" === i[n].type) {
|
|
|
+ var a = i[n].exterior
|
|
|
+ , r = i[n].interiors;
|
|
|
+ if (Tg(a, t[0], t[1])) {
|
|
|
+ for (var s = 0; s < (r ? r.length : 0); s++)
|
|
|
+ if (Tg(r[s]))
|
|
|
+ continue t;
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ },
|
|
|
+ transformTo: function(t, e, i, n) {
|
|
|
+ var o = this.getBoundingRect()
|
|
|
+ , a = o.width / o.height;
|
|
|
+ i ? n = n || i / a : i = a * n;
|
|
|
+ for (var r = new Di(t,e,i,n), s = o.calculateTransform(r), l = this.geometries, u = 0; u < l.length; u++)
|
|
|
+ if ("polygon" === l[u].type) {
|
|
|
+ for (var h = l[u].exterior, c = l[u].interiors, d = 0; d < h.length; d++)
|
|
|
+ bt(h[d], h[d], s);
|
|
|
+ for (var f = 0; f < (c ? c.length : 0); f++)
|
|
|
+ for (d = 0; d < c[f].length; d++)
|
|
|
+ bt(c[f][d], c[f][d], s)
|
|
|
+ }
|
|
|
+ (o = this._rect).copy(r),
|
|
|
+ this.center = [o.x + o.width / 2, o.y + o.height / 2]
|
|
|
+ },
|
|
|
+ cloneShallow: function(t) {
|
|
|
+ null == t && (t = this.name);
|
|
|
+ var e = new Ag(t,this.geometries,this.center);
|
|
|
+ return e._rect = this._rect,
|
|
|
+ e.transformTo = null,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Cg(t, r) {
|
|
|
+ return function(t) {
|
|
|
+ if (!t.UTF8Encoding)
|
|
|
+ return;
|
|
|
+ var e = t.UTF8Scale;
|
|
|
+ null == e && (e = 1024);
|
|
|
+ for (var i = t.features, n = 0; n < i.length; n++)
|
|
|
+ for (var o = i[n].geometry, a = o.coordinates, r = o.encodeOffsets, s = 0; s < a.length; s++) {
|
|
|
+ var l = a[s];
|
|
|
+ if ("Polygon" === o.type)
|
|
|
+ a[s] = Dg(l, r[s], e);
|
|
|
+ else if ("MultiPolygon" === o.type)
|
|
|
+ for (var u = 0; u < l.length; u++) {
|
|
|
+ var h = l[u];
|
|
|
+ l[u] = Dg(h, r[s][u], e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ t.UTF8Encoding = !1
|
|
|
+ }(t),
|
|
|
+ O(M(t.features, function(t) {
|
|
|
+ return t.geometry && t.properties && 0 < t.geometry.coordinates.length
|
|
|
+ }), function(t) {
|
|
|
+ var e = t.properties
|
|
|
+ , i = t.geometry
|
|
|
+ , n = i.coordinates
|
|
|
+ , o = [];
|
|
|
+ "Polygon" === i.type && o.push({
|
|
|
+ type: "polygon",
|
|
|
+ exterior: n[0],
|
|
|
+ interiors: n.slice(1)
|
|
|
+ }),
|
|
|
+ "MultiPolygon" === i.type && E(n, function(t) {
|
|
|
+ t[0] && o.push({
|
|
|
+ type: "polygon",
|
|
|
+ exterior: t[0],
|
|
|
+ interiors: t.slice(1)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var a = new Ag(e[r || "name"],o,e.cp);
|
|
|
+ return a.properties = e,
|
|
|
+ a
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var Lg = jo();
|
|
|
+ function kg(t) {
|
|
|
+ return "category" === t.type ? function(t) {
|
|
|
+ var e = t.getLabelModel()
|
|
|
+ , i = Ng(t, e);
|
|
|
+ return !e.get("show") || t.scale.isBlank() ? {
|
|
|
+ labels: [],
|
|
|
+ labelCategoryInterval: i.labelCategoryInterval
|
|
|
+ } : i
|
|
|
+ }(t) : function(i) {
|
|
|
+ var t = i.scale.getTicks()
|
|
|
+ , n = lg(i);
|
|
|
+ return {
|
|
|
+ labels: O(t, function(t, e) {
|
|
|
+ return {
|
|
|
+ formattedLabel: n(t, e),
|
|
|
+ rawLabel: i.scale.getLabel(t),
|
|
|
+ tickValue: t
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }(t)
|
|
|
+ }
|
|
|
+ function Pg(t, e) {
|
|
|
+ return "category" === t.type ? function(t, e) {
|
|
|
+ var i, n, o = Og(t, "ticks"), a = hg(e), r = Eg(o, a);
|
|
|
+ if (r)
|
|
|
+ return r;
|
|
|
+ e.get("show") && !t.scale.isBlank() || (i = []);
|
|
|
+ if (C(a))
|
|
|
+ i = Bg(t, a, !0);
|
|
|
+ else if ("auto" === a) {
|
|
|
+ var s = Ng(t, t.getLabelModel());
|
|
|
+ n = s.labelCategoryInterval,
|
|
|
+ i = O(s.labels, function(t) {
|
|
|
+ return t.tickValue
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ i = zg(t, n = a, !0);
|
|
|
+ return Rg(o, a, {
|
|
|
+ ticks: i,
|
|
|
+ tickCategoryInterval: n
|
|
|
+ })
|
|
|
+ }(t, e) : {
|
|
|
+ ticks: t.scale.getTicks()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ng(t, e) {
|
|
|
+ var i, n = Og(t, "labels"), o = hg(e), a = Eg(n, o);
|
|
|
+ return a || Rg(n, o, {
|
|
|
+ labels: C(o) ? Bg(t, o) : zg(t, i = "auto" === o ? function(t) {
|
|
|
+ var e = Lg(t).autoInterval;
|
|
|
+ return null != e ? e : Lg(t).autoInterval = t.calculateCategoryInterval()
|
|
|
+ }(t) : o),
|
|
|
+ labelCategoryInterval: i
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Og(t, e) {
|
|
|
+ return Lg(t)[e] || (Lg(t)[e] = [])
|
|
|
+ }
|
|
|
+ function Eg(t, e) {
|
|
|
+ for (var i = 0; i < t.length; i++)
|
|
|
+ if (t[i].key === e)
|
|
|
+ return t[i].value
|
|
|
+ }
|
|
|
+ function Rg(t, e, i) {
|
|
|
+ return t.push({
|
|
|
+ key: e,
|
|
|
+ value: i
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function zg(t, e, i) {
|
|
|
+ var n = lg(t)
|
|
|
+ , o = t.scale
|
|
|
+ , a = o.getExtent()
|
|
|
+ , r = t.getLabelModel()
|
|
|
+ , s = []
|
|
|
+ , l = Math.max((e || 0) + 1, 1)
|
|
|
+ , u = a[0]
|
|
|
+ , h = o.count();
|
|
|
+ 0 !== u && 1 < l && 2 < h / l && (u = Math.round(Math.ceil(u / l) * l));
|
|
|
+ var c = cg(t)
|
|
|
+ , d = r.get("showMinLabel") || c
|
|
|
+ , f = r.get("showMaxLabel") || c;
|
|
|
+ d && u !== a[0] && g(a[0]);
|
|
|
+ for (var p = u; p <= a[1]; p += l)
|
|
|
+ g(p);
|
|
|
+ function g(t) {
|
|
|
+ s.push(i ? t : {
|
|
|
+ formattedLabel: n(t),
|
|
|
+ rawLabel: o.getLabel(t),
|
|
|
+ tickValue: t
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return f && p - l !== a[1] && g(a[1]),
|
|
|
+ s
|
|
|
+ }
|
|
|
+ function Bg(t, i, n) {
|
|
|
+ var o = t.scale
|
|
|
+ , a = lg(t)
|
|
|
+ , r = [];
|
|
|
+ return E(o.getTicks(), function(t) {
|
|
|
+ var e = o.getLabel(t);
|
|
|
+ i(t, e) && r.push(n ? t : {
|
|
|
+ formattedLabel: a(t),
|
|
|
+ rawLabel: e,
|
|
|
+ tickValue: t
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ var Vg = [0, 1]
|
|
|
+ , Gg = function(t, e, i) {
|
|
|
+ this.dim = t,
|
|
|
+ this.scale = e,
|
|
|
+ this._extent = i || [0, 0],
|
|
|
+ this.inverse = !1,
|
|
|
+ this.onBand = !1
|
|
|
+ };
|
|
|
+ function Fg(t, e) {
|
|
|
+ var i = (t[1] - t[0]) / e / 2;
|
|
|
+ t[0] += i,
|
|
|
+ t[1] -= i
|
|
|
+ }
|
|
|
+ Gg.prototype = {
|
|
|
+ constructor: Gg,
|
|
|
+ contain: function(t) {
|
|
|
+ var e = this._extent
|
|
|
+ , i = Math.min(e[0], e[1])
|
|
|
+ , n = Math.max(e[0], e[1]);
|
|
|
+ return i <= t && t <= n
|
|
|
+ },
|
|
|
+ containData: function(t) {
|
|
|
+ return this.scale.contain(t)
|
|
|
+ },
|
|
|
+ getExtent: function() {
|
|
|
+ return this._extent.slice()
|
|
|
+ },
|
|
|
+ getPixelPrecision: function(t) {
|
|
|
+ return Fl(t || this.scale.getExtent(), this._extent)
|
|
|
+ },
|
|
|
+ setExtent: function(t, e) {
|
|
|
+ var i = this._extent;
|
|
|
+ i[0] = t,
|
|
|
+ i[1] = e
|
|
|
+ },
|
|
|
+ dataToCoord: function(t, e) {
|
|
|
+ var i = this._extent
|
|
|
+ , n = this.scale;
|
|
|
+ return t = n.normalize(t),
|
|
|
+ this.onBand && "ordinal" === n.type && Fg(i = i.slice(), n.count()),
|
|
|
+ El(t, Vg, i, e)
|
|
|
+ },
|
|
|
+ coordToData: function(t, e) {
|
|
|
+ var i = this._extent
|
|
|
+ , n = this.scale;
|
|
|
+ this.onBand && "ordinal" === n.type && Fg(i = i.slice(), n.count());
|
|
|
+ var o = El(t, i, Vg, e);
|
|
|
+ return this.scale.scale(o)
|
|
|
+ },
|
|
|
+ pointToData: function(t, e) {},
|
|
|
+ getTicksCoords: function(t) {
|
|
|
+ var e = (t = t || {}).tickModel || this.getTickModel()
|
|
|
+ , i = O(Pg(this, e).ticks, function(t) {
|
|
|
+ return {
|
|
|
+ coord: this.dataToCoord(t),
|
|
|
+ tickValue: t
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+ return function(t, e, i, n) {
|
|
|
+ var o = e.length;
|
|
|
+ if (!t.onBand || i || !o)
|
|
|
+ return;
|
|
|
+ var a, r, s = t.getExtent();
|
|
|
+ if (1 === o)
|
|
|
+ e[0].coord = s[0],
|
|
|
+ a = e[1] = {
|
|
|
+ coord: s[0]
|
|
|
+ };
|
|
|
+ else {
|
|
|
+ var l = e[o - 1].tickValue - e[0].tickValue
|
|
|
+ , u = (e[o - 1].coord - e[0].coord) / l;
|
|
|
+ E(e, function(t) {
|
|
|
+ t.coord -= u / 2
|
|
|
+ });
|
|
|
+ var h = t.scale.getExtent();
|
|
|
+ r = 1 + h[1] - e[o - 1].tickValue,
|
|
|
+ a = {
|
|
|
+ coord: e[o - 1].coord + u * r
|
|
|
+ },
|
|
|
+ e.push(a)
|
|
|
+ }
|
|
|
+ var c = s[0] > s[1];
|
|
|
+ d(e[0].coord, s[0]) && (n ? e[0].coord = s[0] : e.shift());
|
|
|
+ n && d(s[0], e[0].coord) && e.unshift({
|
|
|
+ coord: s[0]
|
|
|
+ });
|
|
|
+ d(s[1], a.coord) && (n ? a.coord = s[1] : e.pop());
|
|
|
+ n && d(a.coord, s[1]) && e.push({
|
|
|
+ coord: s[1]
|
|
|
+ });
|
|
|
+ function d(t, e) {
|
|
|
+ return t = zl(t),
|
|
|
+ e = zl(e),
|
|
|
+ c ? e < t : t < e
|
|
|
+ }
|
|
|
+ }(this, i, e.get("alignWithLabel"), t.clamp),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ getMinorTicksCoords: function() {
|
|
|
+ if ("ordinal" === this.scale.type)
|
|
|
+ return [];
|
|
|
+ var t = this.model.getModel("minorTick").get("splitNumber");
|
|
|
+ return 0 < t && t < 100 || (t = 5),
|
|
|
+ O(this.scale.getMinorTicks(t), function(t) {
|
|
|
+ return O(t, function(t) {
|
|
|
+ return {
|
|
|
+ coord: this.dataToCoord(t),
|
|
|
+ tickValue: t
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ getViewLabels: function() {
|
|
|
+ return kg(this).labels
|
|
|
+ },
|
|
|
+ getLabelModel: function() {
|
|
|
+ return this.model.getModel("axisLabel")
|
|
|
+ },
|
|
|
+ getTickModel: function() {
|
|
|
+ return this.model.getModel("axisTick")
|
|
|
+ },
|
|
|
+ getBandWidth: function() {
|
|
|
+ var t = this._extent
|
|
|
+ , e = this.scale.getExtent()
|
|
|
+ , i = e[1] - e[0] + (this.onBand ? 1 : 0);
|
|
|
+ 0 === i && (i = 1);
|
|
|
+ var n = Math.abs(t[1] - t[0]);
|
|
|
+ return Math.abs(n) / i
|
|
|
+ },
|
|
|
+ isHorizontal: null,
|
|
|
+ getRotate: null,
|
|
|
+ calculateCategoryInterval: function() {
|
|
|
+ return function(t) {
|
|
|
+ var e = function(t) {
|
|
|
+ var e = t.getLabelModel();
|
|
|
+ return {
|
|
|
+ axisRotate: t.getRotate ? t.getRotate() : t.isHorizontal && !t.isHorizontal() ? 90 : 0,
|
|
|
+ labelRotate: e.get("rotate") || 0,
|
|
|
+ font: e.getFont()
|
|
|
+ }
|
|
|
+ }(t)
|
|
|
+ , i = lg(t)
|
|
|
+ , n = (e.axisRotate - e.labelRotate) / 180 * Math.PI
|
|
|
+ , o = t.scale
|
|
|
+ , a = o.getExtent()
|
|
|
+ , r = o.count();
|
|
|
+ if (a[1] - a[0] < 1)
|
|
|
+ return 0;
|
|
|
+ var s = 1;
|
|
|
+ 40 < r && (s = Math.max(1, Math.floor(r / 40)));
|
|
|
+ for (var l = a[0], u = t.dataToCoord(l + 1) - t.dataToCoord(l), h = Math.abs(u * Math.cos(n)), c = Math.abs(u * Math.sin(n)), d = 0, f = 0; l <= a[1]; l += s) {
|
|
|
+ var p, g, m = gn(i(l), e.font, "center", "top");
|
|
|
+ p = 1.3 * m.width,
|
|
|
+ g = 1.3 * m.height,
|
|
|
+ d = Math.max(d, p, 7),
|
|
|
+ f = Math.max(f, g, 7)
|
|
|
+ }
|
|
|
+ var v = d / h
|
|
|
+ , y = f / c;
|
|
|
+ isNaN(v) && (v = 1 / 0),
|
|
|
+ isNaN(y) && (y = 1 / 0);
|
|
|
+ var x = Math.max(0, Math.floor(Math.min(v, y)))
|
|
|
+ , _ = Lg(t.model)
|
|
|
+ , w = t.getExtent()
|
|
|
+ , b = _.lastAutoInterval
|
|
|
+ , S = _.lastTickCount;
|
|
|
+ return null != b && null != S && Math.abs(b - x) <= 1 && Math.abs(S - r) <= 1 && x < b && _.axisExtend0 === w[0] && _.axisExtend1 === w[1] ? x = b : (_.lastTickCount = r,
|
|
|
+ _.lastAutoInterval = x,
|
|
|
+ _.axisExtend0 = w[0],
|
|
|
+ _.axisExtend1 = w[1]),
|
|
|
+ x
|
|
|
+ }(this)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var Wg = Cg
|
|
|
+ , Hg = {};
|
|
|
+ E(["map", "each", "filter", "indexOf", "inherits", "reduce", "filter", "bind", "curry", "isArray", "isString", "isObject", "isFunction", "extend", "defaults", "clone", "merge"], function(t) {
|
|
|
+ Hg[t] = it[t]
|
|
|
+ });
|
|
|
+ var Zg = {};
|
|
|
+ function Ug(t, e) {
|
|
|
+ var i = t.mapDimension("defaultedLabel", !0)
|
|
|
+ , n = i.length;
|
|
|
+ if (1 === n)
|
|
|
+ return Hh(t, e, i[0]);
|
|
|
+ if (n) {
|
|
|
+ for (var o = [], a = 0; a < i.length; a++) {
|
|
|
+ var r = Hh(t, e, i[a]);
|
|
|
+ o.push(r)
|
|
|
+ }
|
|
|
+ return o.join(" ")
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Xg(t, e, i) {
|
|
|
+ Ci.call(this),
|
|
|
+ this.updateData(t, e, i)
|
|
|
+ }
|
|
|
+ E(["extendShape", "extendPath", "makePath", "makeImage", "mergePath", "resizePath", "createIcon", "setHoverStyle", "setLabelStyle", "setTextStyle", "setText", "getFont", "updateProps", "initProps", "getTransform", "clipPointsByRect", "clipRectByRect", "registerShape", "getShapeClass", "Group", "Image", "Text", "Circle", "Sector", "Ring", "Polygon", "Polyline", "Rect", "Line", "BezierCurve", "Arc", "IncrementalDisplayable", "CompoundPath", "LinearGradient", "RadialGradient", "BoundingRect"], function(t) {
|
|
|
+ Zg[t] = bl[t]
|
|
|
+ }),
|
|
|
+ sc.extend({
|
|
|
+ type: "series.line",
|
|
|
+ dependencies: ["grid", "polar"],
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return gp(this.getSource(), this, {
|
|
|
+ useEncodeDefaulter: !0
|
|
|
+ })
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "cartesian2d",
|
|
|
+ legendHoverLink: !0,
|
|
|
+ hoverAnimation: !0,
|
|
|
+ clip: !0,
|
|
|
+ label: {
|
|
|
+ position: "top"
|
|
|
+ },
|
|
|
+ lineStyle: {
|
|
|
+ width: 2,
|
|
|
+ type: "solid"
|
|
|
+ },
|
|
|
+ step: !1,
|
|
|
+ smooth: !1,
|
|
|
+ smoothMonotone: null,
|
|
|
+ symbol: "emptyCircle",
|
|
|
+ symbolSize: 4,
|
|
|
+ symbolRotate: null,
|
|
|
+ showSymbol: !0,
|
|
|
+ showAllSymbol: "auto",
|
|
|
+ connectNulls: !1,
|
|
|
+ sampling: "none",
|
|
|
+ animationEasing: "linear",
|
|
|
+ progressive: 0,
|
|
|
+ hoverLayerThreshold: 1 / 0
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var Yg = Xg.prototype
|
|
|
+ , jg = Xg.getSymbolSize = function(t, e) {
|
|
|
+ var i = t.getItemVisual(e, "symbolSize");
|
|
|
+ return i instanceof Array ? i.slice() : [+i, +i]
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function qg(t) {
|
|
|
+ return [t[0] / 2, t[1] / 2]
|
|
|
+ }
|
|
|
+ function Kg(t, e) {
|
|
|
+ this.parent.drift(t, e)
|
|
|
+ }
|
|
|
+ Yg._createSymbol = function(t, e, i, n, o) {
|
|
|
+ this.removeAll();
|
|
|
+ var a = wg(t, -1, -1, 2, 2, e.getItemVisual(i, "color"), o);
|
|
|
+ a.attr({
|
|
|
+ z2: 100,
|
|
|
+ culling: !0,
|
|
|
+ scale: qg(n)
|
|
|
+ }),
|
|
|
+ a.drift = Kg,
|
|
|
+ this._symbolType = t,
|
|
|
+ this.add(a)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.stopSymbolAnimation = function(t) {
|
|
|
+ this.childAt(0).stopAnimation(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.getSymbolPath = function() {
|
|
|
+ return this.childAt(0)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.getScale = function() {
|
|
|
+ return this.childAt(0).scale
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.highlight = function() {
|
|
|
+ this.childAt(0).trigger("emphasis")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.downplay = function() {
|
|
|
+ this.childAt(0).trigger("normal")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.setZ = function(t, e) {
|
|
|
+ var i = this.childAt(0);
|
|
|
+ i.zlevel = t,
|
|
|
+ i.z = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.setDraggable = function(t) {
|
|
|
+ var e = this.childAt(0);
|
|
|
+ e.draggable = t,
|
|
|
+ e.cursor = t ? "move" : e.cursor
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.updateData = function(t, e, i) {
|
|
|
+ this.silent = !1;
|
|
|
+ var n = t.getItemVisual(e, "symbol") || "circle"
|
|
|
+ , o = t.hostModel
|
|
|
+ , a = jg(t, e)
|
|
|
+ , r = n !== this._symbolType;
|
|
|
+ if (r) {
|
|
|
+ var s = t.getItemVisual(e, "symbolKeepAspect");
|
|
|
+ this._createSymbol(n, t, e, a, s)
|
|
|
+ } else {
|
|
|
+ (l = this.childAt(0)).silent = !1,
|
|
|
+ cl(l, {
|
|
|
+ scale: qg(a)
|
|
|
+ }, o, e)
|
|
|
+ }
|
|
|
+ if (this._updateCommon(t, e, a, i),
|
|
|
+ r) {
|
|
|
+ var l = this.childAt(0)
|
|
|
+ , u = i && i.fadeIn
|
|
|
+ , h = {
|
|
|
+ scale: l.scale.slice()
|
|
|
+ };
|
|
|
+ u && (h.style = {
|
|
|
+ opacity: l.style.opacity
|
|
|
+ }),
|
|
|
+ l.scale = [0, 0],
|
|
|
+ u && (l.style.opacity = 0),
|
|
|
+ dl(l, h, o, e)
|
|
|
+ }
|
|
|
+ this._seriesModel = o
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var $g = ["itemStyle"]
|
|
|
+ , Jg = ["emphasis", "itemStyle"]
|
|
|
+ , Qg = ["label"]
|
|
|
+ , tm = ["emphasis", "label"];
|
|
|
+ function em(t, e) {
|
|
|
+ if (!this.incremental && !this.useHoverLayer)
|
|
|
+ if ("emphasis" === e) {
|
|
|
+ var i = this.__symbolOriginalScale
|
|
|
+ , n = i[1] / i[0]
|
|
|
+ , o = {
|
|
|
+ scale: [Math.max(1.1 * i[0], i[0] + 3), Math.max(1.1 * i[1], i[1] + 3 * n)]
|
|
|
+ };
|
|
|
+ this.animateTo(o, 400, "elasticOut")
|
|
|
+ } else
|
|
|
+ "normal" === e && this.animateTo({
|
|
|
+ scale: this.__symbolOriginalScale
|
|
|
+ }, 400, "elasticOut")
|
|
|
+ }
|
|
|
+ function im(t) {
|
|
|
+ this.group = new Ci,
|
|
|
+ this._symbolCtor = t || Xg
|
|
|
+ }
|
|
|
+ Yg._updateCommon = function(i, t, e, n) {
|
|
|
+ var o = this.childAt(0)
|
|
|
+ , a = i.hostModel
|
|
|
+ , r = i.getItemVisual(t, "color");
|
|
|
+ "image" !== o.type ? o.useStyle({
|
|
|
+ strokeNoScale: !0
|
|
|
+ }) : o.setStyle({
|
|
|
+ opacity: null,
|
|
|
+ shadowBlur: null,
|
|
|
+ shadowOffsetX: null,
|
|
|
+ shadowOffsetY: null,
|
|
|
+ shadowColor: null
|
|
|
+ });
|
|
|
+ var s = n && n.itemStyle
|
|
|
+ , l = n && n.hoverItemStyle
|
|
|
+ , u = n && n.symbolOffset
|
|
|
+ , h = n && n.labelModel
|
|
|
+ , c = n && n.hoverLabelModel
|
|
|
+ , d = n && n.hoverAnimation
|
|
|
+ , f = n && n.cursorStyle;
|
|
|
+ if (!n || i.hasItemOption) {
|
|
|
+ var p = n && n.itemModel ? n.itemModel : i.getItemModel(t);
|
|
|
+ s = p.getModel($g).getItemStyle(["color"]),
|
|
|
+ l = p.getModel(Jg).getItemStyle(),
|
|
|
+ u = p.getShallow("symbolOffset"),
|
|
|
+ h = p.getModel(Qg),
|
|
|
+ c = p.getModel(tm),
|
|
|
+ d = p.getShallow("hoverAnimation"),
|
|
|
+ f = p.getShallow("cursor")
|
|
|
+ } else
|
|
|
+ l = P({}, l);
|
|
|
+ var g = o.style
|
|
|
+ , m = i.getItemVisual(t, "symbolRotate");
|
|
|
+ o.attr("rotation", (m || 0) * Math.PI / 180 || 0),
|
|
|
+ u && o.attr("position", [Rl(u[0], e[0]), Rl(u[1], e[1])]),
|
|
|
+ f && o.attr("cursor", f),
|
|
|
+ o.setColor(r, n && n.symbolInnerColor),
|
|
|
+ o.setStyle(s);
|
|
|
+ var v = i.getItemVisual(t, "opacity");
|
|
|
+ null != v && (g.opacity = v);
|
|
|
+ var y = i.getItemVisual(t, "liftZ")
|
|
|
+ , x = o.__z2Origin;
|
|
|
+ null != y ? null == x && (o.__z2Origin = o.z2,
|
|
|
+ o.z2 += y) : null != x && (o.z2 = x,
|
|
|
+ o.__z2Origin = null);
|
|
|
+ var _ = n && n.useNameLabel;
|
|
|
+ el(g, l, h, c, {
|
|
|
+ labelFetcher: a,
|
|
|
+ labelDataIndex: t,
|
|
|
+ defaultText: function(t, e) {
|
|
|
+ return _ ? i.getName(t) : Ug(i, t)
|
|
|
+ },
|
|
|
+ isRectText: !0,
|
|
|
+ autoColor: r
|
|
|
+ }),
|
|
|
+ o.__symbolOriginalScale = qg(e),
|
|
|
+ o.hoverStyle = l,
|
|
|
+ o.highDownOnUpdate = d && a.isAnimationEnabled() ? em : null,
|
|
|
+ $s(o)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Yg.fadeOut = function(t, e) {
|
|
|
+ var i = this.childAt(0);
|
|
|
+ this.silent = i.silent = !0,
|
|
|
+ e && e.keepLabel || (i.style.text = null),
|
|
|
+ cl(i, {
|
|
|
+ style: {
|
|
|
+ opacity: 0
|
|
|
+ },
|
|
|
+ scale: [0, 0]
|
|
|
+ }, this._seriesModel, this.dataIndex, t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(Xg, Ci);
|
|
|
+ var nm = im.prototype;
|
|
|
+ function om(t, e, i, n) {
|
|
|
+ return e && !isNaN(e[0]) && !isNaN(e[1]) && !(n.isIgnore && n.isIgnore(i)) && !(n.clipShape && !n.clipShape.contain(e[0], e[1])) && "none" !== t.getItemVisual(i, "symbol")
|
|
|
+ }
|
|
|
+ function am(t) {
|
|
|
+ return null == t || z(t) || (t = {
|
|
|
+ isIgnore: t
|
|
|
+ }),
|
|
|
+ t || {}
|
|
|
+ }
|
|
|
+ function rm(t) {
|
|
|
+ var e = t.hostModel;
|
|
|
+ return {
|
|
|
+ itemStyle: e.getModel("itemStyle").getItemStyle(["color"]),
|
|
|
+ hoverItemStyle: e.getModel("emphasis.itemStyle").getItemStyle(),
|
|
|
+ symbolRotate: e.get("symbolRotate"),
|
|
|
+ symbolOffset: e.get("symbolOffset"),
|
|
|
+ hoverAnimation: e.get("hoverAnimation"),
|
|
|
+ labelModel: e.getModel("label"),
|
|
|
+ hoverLabelModel: e.getModel("emphasis.label"),
|
|
|
+ cursorStyle: e.get("cursor")
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function sm(t, e, i) {
|
|
|
+ var n, o = t.getBaseAxis(), a = t.getOtherAxis(o), r = function(t, e) {
|
|
|
+ var i = 0
|
|
|
+ , n = t.scale.getExtent();
|
|
|
+ "start" === e ? i = n[0] : "end" === e ? i = n[1] : 0 < n[0] ? i = n[0] : n[1] < 0 && (i = n[1]);
|
|
|
+ return i
|
|
|
+ }(a, i), s = o.dim, l = a.dim, u = e.mapDimension(l), h = e.mapDimension(s), c = "x" === l || "radius" === l ? 1 : 0, d = O(t.dimensions, function(t) {
|
|
|
+ return e.mapDimension(t)
|
|
|
+ }), f = e.getCalculationInfo("stackResultDimension");
|
|
|
+ return (n |= fp(e, d[0])) && (d[0] = f),
|
|
|
+ (n |= fp(e, d[1])) && (d[1] = f),
|
|
|
+ {
|
|
|
+ dataDimsForPoint: d,
|
|
|
+ valueStart: r,
|
|
|
+ valueAxisDim: l,
|
|
|
+ baseAxisDim: s,
|
|
|
+ stacked: !!n,
|
|
|
+ valueDim: u,
|
|
|
+ baseDim: h,
|
|
|
+ baseDataOffset: c,
|
|
|
+ stackedOverDimension: e.getCalculationInfo("stackedOverDimension")
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function lm(t, e, i, n) {
|
|
|
+ var o = NaN;
|
|
|
+ t.stacked && (o = i.get(i.getCalculationInfo("stackedOverDimension"), n)),
|
|
|
+ isNaN(o) && (o = t.valueStart);
|
|
|
+ var a = t.baseDataOffset
|
|
|
+ , r = [];
|
|
|
+ return r[a] = i.get(t.baseDim, n),
|
|
|
+ r[1 - a] = o,
|
|
|
+ e.dataToPoint(r)
|
|
|
+ }
|
|
|
+ nm.updateData = function(o, a) {
|
|
|
+ a = am(a);
|
|
|
+ var r = this.group
|
|
|
+ , s = o.hostModel
|
|
|
+ , l = this._data
|
|
|
+ , u = this._symbolCtor
|
|
|
+ , h = rm(o);
|
|
|
+ l || r.removeAll(),
|
|
|
+ o.diff(l).add(function(t) {
|
|
|
+ var e = o.getItemLayout(t);
|
|
|
+ if (om(o, e, t, a)) {
|
|
|
+ var i = new u(o,t,h);
|
|
|
+ i.attr("position", e),
|
|
|
+ o.setItemGraphicEl(t, i),
|
|
|
+ r.add(i)
|
|
|
+ }
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = l.getItemGraphicEl(e)
|
|
|
+ , n = o.getItemLayout(t);
|
|
|
+ om(o, n, t, a) ? (i ? (i.updateData(o, t, h),
|
|
|
+ cl(i, {
|
|
|
+ position: n
|
|
|
+ }, s)) : (i = new u(o,t)).attr("position", n),
|
|
|
+ r.add(i),
|
|
|
+ o.setItemGraphicEl(t, i)) : r.remove(i)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = l.getItemGraphicEl(t);
|
|
|
+ e && e.fadeOut(function() {
|
|
|
+ r.remove(e)
|
|
|
+ })
|
|
|
+ }).execute(),
|
|
|
+ this._data = o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nm.isPersistent = function() {
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nm.updateLayout = function() {
|
|
|
+ var n = this._data;
|
|
|
+ n && n.eachItemGraphicEl(function(t, e) {
|
|
|
+ var i = n.getItemLayout(e);
|
|
|
+ t.attr("position", i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nm.incrementalPrepareUpdate = function(t) {
|
|
|
+ this._seriesScope = rm(t),
|
|
|
+ this._data = null,
|
|
|
+ this.group.removeAll()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nm.incrementalUpdate = function(t, e, i) {
|
|
|
+ function n(t) {
|
|
|
+ t.isGroup || (t.incremental = t.useHoverLayer = !0)
|
|
|
+ }
|
|
|
+ i = am(i);
|
|
|
+ for (var o = t.start; o < t.end; o++) {
|
|
|
+ var a = e.getItemLayout(o);
|
|
|
+ if (om(e, a, o, i)) {
|
|
|
+ var r = new this._symbolCtor(e,o,this._seriesScope);
|
|
|
+ r.traverse(n),
|
|
|
+ r.attr("position", a),
|
|
|
+ this.group.add(r),
|
|
|
+ e.setItemGraphicEl(o, r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nm.remove = function(t) {
|
|
|
+ var e = this.group
|
|
|
+ , i = this._data;
|
|
|
+ i && t ? i.eachItemGraphicEl(function(t) {
|
|
|
+ t.fadeOut(function() {
|
|
|
+ e.remove(t)
|
|
|
+ })
|
|
|
+ }) : e.removeAll()
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var um = St
|
|
|
+ , hm = Mt
|
|
|
+ , cm = ut
|
|
|
+ , dm = at
|
|
|
+ , fm = []
|
|
|
+ , pm = []
|
|
|
+ , gm = [];
|
|
|
+ function mm(t) {
|
|
|
+ return isNaN(t[0]) || isNaN(t[1])
|
|
|
+ }
|
|
|
+ function vm(t, e, i, n, o, a, r, s, l, u) {
|
|
|
+ return "none" !== u && u ? function(t, e, i, n, o, a, r, s, l, u, h) {
|
|
|
+ for (var c = 0, d = i, f = 0; f < n; f++) {
|
|
|
+ var p = e[d];
|
|
|
+ if (o <= d || d < 0)
|
|
|
+ break;
|
|
|
+ if (mm(p)) {
|
|
|
+ if (h) {
|
|
|
+ d += a;
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ break
|
|
|
+ }
|
|
|
+ if (d === i)
|
|
|
+ t[0 < a ? "moveTo" : "lineTo"](p[0], p[1]);
|
|
|
+ else if (0 < l) {
|
|
|
+ var g = e[c]
|
|
|
+ , m = "y" === u ? 1 : 0
|
|
|
+ , v = (p[m] - g[m]) * l;
|
|
|
+ dm(pm, g),
|
|
|
+ pm[m] = g[m] + v,
|
|
|
+ dm(gm, p),
|
|
|
+ gm[m] = p[m] - v,
|
|
|
+ t.bezierCurveTo(pm[0], pm[1], gm[0], gm[1], p[0], p[1])
|
|
|
+ } else
|
|
|
+ t.lineTo(p[0], p[1]);
|
|
|
+ c = d,
|
|
|
+ d += a
|
|
|
+ }
|
|
|
+ return f
|
|
|
+ }
|
|
|
+ .apply(this, arguments) : function(t, e, i, n, o, a, r, s, l, u, h) {
|
|
|
+ for (var c = 0, d = i, f = 0; f < n; f++) {
|
|
|
+ var p = e[d];
|
|
|
+ if (o <= d || d < 0)
|
|
|
+ break;
|
|
|
+ if (mm(p)) {
|
|
|
+ if (h) {
|
|
|
+ d += a;
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ break
|
|
|
+ }
|
|
|
+ if (d === i)
|
|
|
+ t[0 < a ? "moveTo" : "lineTo"](p[0], p[1]),
|
|
|
+ dm(pm, p);
|
|
|
+ else if (0 < l) {
|
|
|
+ var g = d + a
|
|
|
+ , m = e[g];
|
|
|
+ if (h)
|
|
|
+ for (; m && mm(e[g]); )
|
|
|
+ m = e[g += a];
|
|
|
+ var v = .5
|
|
|
+ , y = e[c];
|
|
|
+ if (!(m = e[g]) || mm(m))
|
|
|
+ dm(gm, p);
|
|
|
+ else {
|
|
|
+ var x, _;
|
|
|
+ if (mm(m) && !h && (m = p),
|
|
|
+ ht(fm, m, y),
|
|
|
+ "x" === u || "y" === u) {
|
|
|
+ var w = "x" === u ? 0 : 1;
|
|
|
+ x = Math.abs(p[w] - y[w]),
|
|
|
+ _ = Math.abs(p[w] - m[w])
|
|
|
+ } else
|
|
|
+ x = yt(p, y),
|
|
|
+ _ = yt(p, m);
|
|
|
+ cm(gm, p, fm, -l * (1 - (v = _ / (_ + x))))
|
|
|
+ }
|
|
|
+ um(pm, pm, s),
|
|
|
+ hm(pm, pm, r),
|
|
|
+ um(gm, gm, s),
|
|
|
+ hm(gm, gm, r),
|
|
|
+ t.bezierCurveTo(pm[0], pm[1], gm[0], gm[1], p[0], p[1]),
|
|
|
+ cm(pm, p, fm, l * v)
|
|
|
+ } else
|
|
|
+ t.lineTo(p[0], p[1]);
|
|
|
+ c = d,
|
|
|
+ d += a
|
|
|
+ }
|
|
|
+ return f
|
|
|
+ }
|
|
|
+ .apply(this, arguments)
|
|
|
+ }
|
|
|
+ function ym(t, e) {
|
|
|
+ var i = [1 / 0, 1 / 0]
|
|
|
+ , n = [-1 / 0, -1 / 0];
|
|
|
+ if (e)
|
|
|
+ for (var o = 0; o < t.length; o++) {
|
|
|
+ var a = t[o];
|
|
|
+ a[0] < i[0] && (i[0] = a[0]),
|
|
|
+ a[1] < i[1] && (i[1] = a[1]),
|
|
|
+ a[0] > n[0] && (n[0] = a[0]),
|
|
|
+ a[1] > n[1] && (n[1] = a[1])
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ min: e ? i : n,
|
|
|
+ max: e ? n : i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var xm = Ar.extend({
|
|
|
+ type: "ec-polyline",
|
|
|
+ shape: {
|
|
|
+ points: [],
|
|
|
+ smooth: 0,
|
|
|
+ smoothConstraint: !0,
|
|
|
+ smoothMonotone: null,
|
|
|
+ connectNulls: !1
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ fill: null,
|
|
|
+ stroke: "#000"
|
|
|
+ },
|
|
|
+ brush: Xr(Ar.prototype.brush),
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.points
|
|
|
+ , n = 0
|
|
|
+ , o = i.length
|
|
|
+ , a = ym(i, e.smoothConstraint);
|
|
|
+ if (e.connectNulls) {
|
|
|
+ for (; 0 < o && mm(i[o - 1]); o--)
|
|
|
+ ;
|
|
|
+ for (; n < o && mm(i[n]); n++)
|
|
|
+ ;
|
|
|
+ }
|
|
|
+ for (; n < o; )
|
|
|
+ n += vm(t, i, n, o, o, 1, a.min, a.max, e.smooth, e.smoothMonotone, e.connectNulls) + 1
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , _m = Ar.extend({
|
|
|
+ type: "ec-polygon",
|
|
|
+ shape: {
|
|
|
+ points: [],
|
|
|
+ stackedOnPoints: [],
|
|
|
+ smooth: 0,
|
|
|
+ stackedOnSmooth: 0,
|
|
|
+ smoothConstraint: !0,
|
|
|
+ smoothMonotone: null,
|
|
|
+ connectNulls: !1
|
|
|
+ },
|
|
|
+ brush: Xr(Ar.prototype.brush),
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.points
|
|
|
+ , n = e.stackedOnPoints
|
|
|
+ , o = 0
|
|
|
+ , a = i.length
|
|
|
+ , r = e.smoothMonotone
|
|
|
+ , s = ym(i, e.smoothConstraint)
|
|
|
+ , l = ym(n, e.smoothConstraint);
|
|
|
+ if (e.connectNulls) {
|
|
|
+ for (; 0 < a && mm(i[a - 1]); a--)
|
|
|
+ ;
|
|
|
+ for (; o < a && mm(i[o]); o++)
|
|
|
+ ;
|
|
|
+ }
|
|
|
+ for (; o < a; ) {
|
|
|
+ var u = vm(t, i, o, a, a, 1, s.min, s.max, e.smooth, r, e.connectNulls);
|
|
|
+ vm(t, n, o + u - 1, u, a, -1, l.min, l.max, e.stackedOnSmooth, r, e.connectNulls),
|
|
|
+ o += u + 1,
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function wm(t, e, i) {
|
|
|
+ var n = t.getArea()
|
|
|
+ , o = t.getBaseAxis().isHorizontal()
|
|
|
+ , a = n.x
|
|
|
+ , r = n.y
|
|
|
+ , s = n.width
|
|
|
+ , l = n.height
|
|
|
+ , u = i.get("lineStyle.width") || 2;
|
|
|
+ a -= u / 2,
|
|
|
+ r -= u / 2,
|
|
|
+ s += u,
|
|
|
+ l += u,
|
|
|
+ a = Math.floor(a),
|
|
|
+ s = Math.round(s);
|
|
|
+ var h = new rs({
|
|
|
+ shape: {
|
|
|
+ x: a,
|
|
|
+ y: r,
|
|
|
+ width: s,
|
|
|
+ height: l
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return e && (h.shape[o ? "width" : "height"] = 0,
|
|
|
+ dl(h, {
|
|
|
+ shape: {
|
|
|
+ width: s,
|
|
|
+ height: l
|
|
|
+ }
|
|
|
+ }, i)),
|
|
|
+ h
|
|
|
+ }
|
|
|
+ function bm(t, e, i) {
|
|
|
+ var n = t.getArea()
|
|
|
+ , o = new qr({
|
|
|
+ shape: {
|
|
|
+ cx: zl(t.cx, 1),
|
|
|
+ cy: zl(t.cy, 1),
|
|
|
+ r0: zl(n.r0, 1),
|
|
|
+ r: zl(n.r, 1),
|
|
|
+ startAngle: n.startAngle,
|
|
|
+ endAngle: n.endAngle,
|
|
|
+ clockwise: n.clockwise
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return e && (o.shape.endAngle = n.startAngle,
|
|
|
+ dl(o, {
|
|
|
+ shape: {
|
|
|
+ endAngle: n.endAngle
|
|
|
+ }
|
|
|
+ }, i)),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ function Sm(t, e, i) {
|
|
|
+ return t ? "polar" === t.type ? bm(t, e, i) : "cartesian2d" === t.type ? wm(t, e, i) : null : null
|
|
|
+ }
|
|
|
+ function Mm(t, e) {
|
|
|
+ if (t.length === e.length) {
|
|
|
+ for (var i = 0; i < t.length; i++) {
|
|
|
+ var n = t[i]
|
|
|
+ , o = e[i];
|
|
|
+ if (n[0] !== o[0] || n[1] !== o[1])
|
|
|
+ return
|
|
|
+ }
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Im(t, e) {
|
|
|
+ var i = []
|
|
|
+ , n = []
|
|
|
+ , o = []
|
|
|
+ , a = [];
|
|
|
+ return Wa(t, i, n),
|
|
|
+ Wa(e, o, a),
|
|
|
+ Math.max(Math.abs(i[0] - o[0]), Math.abs(i[1] - o[1]), Math.abs(n[0] - a[0]), Math.abs(n[1] - a[1]))
|
|
|
+ }
|
|
|
+ function Tm(t) {
|
|
|
+ return "number" == typeof t ? t : t ? .5 : 0
|
|
|
+ }
|
|
|
+ function Am(t, e, i) {
|
|
|
+ for (var n = e.getBaseAxis(), o = "x" === n.dim || "radius" === n.dim ? 0 : 1, a = [], r = 0; r < t.length - 1; r++) {
|
|
|
+ var s = t[r + 1]
|
|
|
+ , l = t[r];
|
|
|
+ a.push(l);
|
|
|
+ var u = [];
|
|
|
+ switch (i) {
|
|
|
+ case "end":
|
|
|
+ u[o] = s[o],
|
|
|
+ u[1 - o] = l[1 - o],
|
|
|
+ a.push(u);
|
|
|
+ break;
|
|
|
+ case "middle":
|
|
|
+ var h = (l[o] + s[o]) / 2
|
|
|
+ , c = [];
|
|
|
+ u[o] = c[o] = h,
|
|
|
+ u[1 - o] = l[1 - o],
|
|
|
+ c[1 - o] = s[1 - o],
|
|
|
+ a.push(u),
|
|
|
+ a.push(c);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ u[o] = l[o],
|
|
|
+ u[1 - o] = s[1 - o],
|
|
|
+ a.push(u)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return t[r] && a.push(t[r]),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ function Dm(t, e, i) {
|
|
|
+ var n = t.get("showAllSymbol")
|
|
|
+ , o = "auto" === n;
|
|
|
+ if (!n || o) {
|
|
|
+ var a = i.getAxesByScale("ordinal")[0];
|
|
|
+ if (a && (!o || !function(t, e) {
|
|
|
+ var i = t.getExtent()
|
|
|
+ , n = Math.abs(i[1] - i[0]) / t.scale.count();
|
|
|
+ isNaN(n) && (n = 0);
|
|
|
+ for (var o = e.count(), a = Math.max(1, Math.round(o / 5)), r = 0; r < o; r += a)
|
|
|
+ if (1.5 * Xg.getSymbolSize(e, r)[t.isHorizontal() ? 1 : 0] > n)
|
|
|
+ return !1;
|
|
|
+ return !0
|
|
|
+ }(a, e))) {
|
|
|
+ var r = e.mapDimension(a.dim)
|
|
|
+ , s = {};
|
|
|
+ return E(a.getViewLabels(), function(t) {
|
|
|
+ s[t.tickValue] = 1
|
|
|
+ }),
|
|
|
+ function(t) {
|
|
|
+ return !s.hasOwnProperty(e.get(r, t))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Cm(t, e, i) {
|
|
|
+ if ("cartesian2d" !== t.type)
|
|
|
+ return bm(t, e, i);
|
|
|
+ var n = t.getBaseAxis().isHorizontal()
|
|
|
+ , o = wm(t, e, i);
|
|
|
+ if (!i.get("clip", !0)) {
|
|
|
+ var a = o.shape
|
|
|
+ , r = Math.max(a.width, a.height);
|
|
|
+ n ? (a.y -= r,
|
|
|
+ a.height += 2 * r) : (a.x -= r,
|
|
|
+ a.width += 2 * r)
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ _c.extend({
|
|
|
+ type: "line",
|
|
|
+ init: function() {
|
|
|
+ var t = new Ci
|
|
|
+ , e = new im;
|
|
|
+ this.group.add(e.group),
|
|
|
+ this._symbolDraw = e,
|
|
|
+ this._lineGroup = t
|
|
|
+ },
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var n = t.coordinateSystem
|
|
|
+ , o = this.group
|
|
|
+ , a = t.getData()
|
|
|
+ , r = t.getModel("lineStyle")
|
|
|
+ , s = t.getModel("areaStyle")
|
|
|
+ , l = a.mapArray(a.getItemLayout)
|
|
|
+ , u = "polar" === n.type
|
|
|
+ , h = this._coordSys
|
|
|
+ , c = this._symbolDraw
|
|
|
+ , d = this._polyline
|
|
|
+ , f = this._polygon
|
|
|
+ , p = this._lineGroup
|
|
|
+ , g = t.get("animation")
|
|
|
+ , m = !s.isEmpty()
|
|
|
+ , v = s.get("origin")
|
|
|
+ , y = function(t, e, i) {
|
|
|
+ if (!i.valueDim)
|
|
|
+ return [];
|
|
|
+ for (var n = [], o = 0, a = e.count(); o < a; o++)
|
|
|
+ n.push(lm(i, t, e, o));
|
|
|
+ return n
|
|
|
+ }(n, a, sm(n, a, v))
|
|
|
+ , x = t.get("showSymbol")
|
|
|
+ , _ = x && !u && Dm(t, a, n)
|
|
|
+ , w = this._data;
|
|
|
+ w && w.eachItemGraphicEl(function(t, e) {
|
|
|
+ t.__temp && (o.remove(t),
|
|
|
+ w.setItemGraphicEl(e, null))
|
|
|
+ }),
|
|
|
+ x || c.remove(),
|
|
|
+ o.add(p);
|
|
|
+ var b, S = !u && t.get("step");
|
|
|
+ n && n.getArea && t.get("clip", !0) && (null != (b = n.getArea()).width ? (b.x -= .1,
|
|
|
+ b.y -= .1,
|
|
|
+ b.width += .2,
|
|
|
+ b.height += .2) : b.r0 && (b.r0 -= .5,
|
|
|
+ b.r1 += .5)),
|
|
|
+ this._clipShapeForSymbol = b,
|
|
|
+ d && h.type === n.type && S === this._step ? (m && !f ? f = this._newPolygon(l, y, n, g) : f && !m && (p.remove(f),
|
|
|
+ f = this._polygon = null),
|
|
|
+ p.setClipPath(Cm(n, !1, t)),
|
|
|
+ x && c.updateData(a, {
|
|
|
+ isIgnore: _,
|
|
|
+ clipShape: b
|
|
|
+ }),
|
|
|
+ a.eachItemGraphicEl(function(t) {
|
|
|
+ t.stopAnimation(!0)
|
|
|
+ }),
|
|
|
+ Mm(this._stackedOnPoints, y) && Mm(this._points, l) || (g ? this._updateAnimation(a, y, n, i, S, v) : (S && (l = Am(l, n, S),
|
|
|
+ y = Am(y, n, S)),
|
|
|
+ d.setShape({
|
|
|
+ points: l
|
|
|
+ }),
|
|
|
+ f && f.setShape({
|
|
|
+ points: l,
|
|
|
+ stackedOnPoints: y
|
|
|
+ })))) : (x && c.updateData(a, {
|
|
|
+ isIgnore: _,
|
|
|
+ clipShape: b
|
|
|
+ }),
|
|
|
+ S && (l = Am(l, n, S),
|
|
|
+ y = Am(y, n, S)),
|
|
|
+ d = this._newPolyline(l, n, g),
|
|
|
+ m && (f = this._newPolygon(l, y, n, g)),
|
|
|
+ p.setClipPath(Cm(n, !0, t)));
|
|
|
+ var M = function(t, e) {
|
|
|
+ var i = t.getVisual("visualMeta");
|
|
|
+ if (i && i.length && t.count() && "cartesian2d" === e.type) {
|
|
|
+ for (var n, o, a = i.length - 1; 0 <= a; a--) {
|
|
|
+ var r = i[a].dimension
|
|
|
+ , s = t.dimensions[r]
|
|
|
+ , l = t.getDimensionInfo(s);
|
|
|
+ if ("x" === (n = l && l.coordDim) || "y" === n) {
|
|
|
+ o = i[a];
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (o) {
|
|
|
+ var u = e.getAxis(n)
|
|
|
+ , h = O(o.stops, function(t) {
|
|
|
+ return {
|
|
|
+ coord: u.toGlobalCoord(u.dataToCoord(t.value)),
|
|
|
+ color: t.color
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , c = h.length
|
|
|
+ , d = o.outerColors.slice();
|
|
|
+ c && h[0].coord > h[c - 1].coord && (h.reverse(),
|
|
|
+ d.reverse());
|
|
|
+ var f = h[0].coord - 10
|
|
|
+ , p = h[c - 1].coord + 10
|
|
|
+ , g = p - f;
|
|
|
+ if (g < .001)
|
|
|
+ return "transparent";
|
|
|
+ E(h, function(t) {
|
|
|
+ t.offset = (t.coord - f) / g
|
|
|
+ }),
|
|
|
+ h.push({
|
|
|
+ offset: c ? h[c - 1].offset : .5,
|
|
|
+ color: d[1] || "transparent"
|
|
|
+ }),
|
|
|
+ h.unshift({
|
|
|
+ offset: c ? h[0].offset : .5,
|
|
|
+ color: d[0] || "transparent"
|
|
|
+ });
|
|
|
+ var m = new gs(0,0,0,0,h,!0);
|
|
|
+ return m[n] = f,
|
|
|
+ m[n + "2"] = p,
|
|
|
+ m
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }(a, n) || a.getVisual("color");
|
|
|
+ d.useStyle(D(r.getLineStyle(), {
|
|
|
+ fill: "none",
|
|
|
+ stroke: M,
|
|
|
+ lineJoin: "bevel"
|
|
|
+ }));
|
|
|
+ var I = t.get("smooth");
|
|
|
+ if (I = Tm(t.get("smooth")),
|
|
|
+ d.setShape({
|
|
|
+ smooth: I,
|
|
|
+ smoothMonotone: t.get("smoothMonotone"),
|
|
|
+ connectNulls: t.get("connectNulls")
|
|
|
+ }),
|
|
|
+ f) {
|
|
|
+ var T = a.getCalculationInfo("stackedOnSeries")
|
|
|
+ , A = 0;
|
|
|
+ f.useStyle(D(s.getAreaStyle(), {
|
|
|
+ fill: M,
|
|
|
+ opacity: .7,
|
|
|
+ lineJoin: "bevel"
|
|
|
+ })),
|
|
|
+ T && (A = Tm(T.get("smooth"))),
|
|
|
+ f.setShape({
|
|
|
+ smooth: I,
|
|
|
+ stackedOnSmooth: A,
|
|
|
+ smoothMonotone: t.get("smoothMonotone"),
|
|
|
+ connectNulls: t.get("connectNulls")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ this._data = a,
|
|
|
+ this._coordSys = n,
|
|
|
+ this._stackedOnPoints = y,
|
|
|
+ this._points = l,
|
|
|
+ this._step = S,
|
|
|
+ this._valueOrigin = v
|
|
|
+ },
|
|
|
+ dispose: function() {},
|
|
|
+ highlight: function(t, e, i, n) {
|
|
|
+ var o = t.getData()
|
|
|
+ , a = Yo(o, n);
|
|
|
+ if (!(a instanceof Array) && null != a && 0 <= a) {
|
|
|
+ var r = o.getItemGraphicEl(a);
|
|
|
+ if (!r) {
|
|
|
+ var s = o.getItemLayout(a);
|
|
|
+ if (!s)
|
|
|
+ return;
|
|
|
+ if (this._clipShapeForSymbol && !this._clipShapeForSymbol.contain(s[0], s[1]))
|
|
|
+ return;
|
|
|
+ (r = new Xg(o,a)).position = s,
|
|
|
+ r.setZ(t.get("zlevel"), t.get("z")),
|
|
|
+ r.ignore = isNaN(s[0]) || isNaN(s[1]),
|
|
|
+ r.__temp = !0,
|
|
|
+ o.setItemGraphicEl(a, r),
|
|
|
+ r.stopSymbolAnimation(!0),
|
|
|
+ this.group.add(r)
|
|
|
+ }
|
|
|
+ r.highlight()
|
|
|
+ } else
|
|
|
+ _c.prototype.highlight.call(this, t, e, i, n)
|
|
|
+ },
|
|
|
+ downplay: function(t, e, i, n) {
|
|
|
+ var o = t.getData()
|
|
|
+ , a = Yo(o, n);
|
|
|
+ if (null != a && 0 <= a) {
|
|
|
+ var r = o.getItemGraphicEl(a);
|
|
|
+ r && (r.__temp ? (o.setItemGraphicEl(a, null),
|
|
|
+ this.group.remove(r)) : r.downplay())
|
|
|
+ } else
|
|
|
+ _c.prototype.downplay.call(this, t, e, i, n)
|
|
|
+ },
|
|
|
+ _newPolyline: function(t) {
|
|
|
+ var e = this._polyline;
|
|
|
+ return e && this._lineGroup.remove(e),
|
|
|
+ e = new xm({
|
|
|
+ shape: {
|
|
|
+ points: t
|
|
|
+ },
|
|
|
+ silent: !0,
|
|
|
+ z2: 10
|
|
|
+ }),
|
|
|
+ this._lineGroup.add(e),
|
|
|
+ this._polyline = e
|
|
|
+ },
|
|
|
+ _newPolygon: function(t, e) {
|
|
|
+ var i = this._polygon;
|
|
|
+ return i && this._lineGroup.remove(i),
|
|
|
+ i = new _m({
|
|
|
+ shape: {
|
|
|
+ points: t,
|
|
|
+ stackedOnPoints: e
|
|
|
+ },
|
|
|
+ silent: !0
|
|
|
+ }),
|
|
|
+ this._lineGroup.add(i),
|
|
|
+ this._polygon = i
|
|
|
+ },
|
|
|
+ _updateAnimation: function(t, e, i, n, o, a) {
|
|
|
+ var r = this._polyline
|
|
|
+ , s = this._polygon
|
|
|
+ , l = t.hostModel
|
|
|
+ , u = function(t, e, i, n, o, a, r, s) {
|
|
|
+ for (var l = function(t, e) {
|
|
|
+ var i = [];
|
|
|
+ return e.diff(t).add(function(t) {
|
|
|
+ i.push({
|
|
|
+ cmd: "+",
|
|
|
+ idx: t
|
|
|
+ })
|
|
|
+ }).update(function(t, e) {
|
|
|
+ i.push({
|
|
|
+ cmd: "=",
|
|
|
+ idx: e,
|
|
|
+ idx1: t
|
|
|
+ })
|
|
|
+ }).remove(function(t) {
|
|
|
+ i.push({
|
|
|
+ cmd: "-",
|
|
|
+ idx: t
|
|
|
+ })
|
|
|
+ }).execute(),
|
|
|
+ i
|
|
|
+ }(t, e), u = [], h = [], c = [], d = [], f = [], p = [], g = [], m = sm(o, e, r), v = sm(a, t, s), y = 0; y < l.length; y++) {
|
|
|
+ var x = l[y]
|
|
|
+ , _ = !0;
|
|
|
+ switch (x.cmd) {
|
|
|
+ case "=":
|
|
|
+ var w = t.getItemLayout(x.idx)
|
|
|
+ , b = e.getItemLayout(x.idx1);
|
|
|
+ (isNaN(w[0]) || isNaN(w[1])) && (w = b.slice()),
|
|
|
+ u.push(w),
|
|
|
+ h.push(b),
|
|
|
+ c.push(i[x.idx]),
|
|
|
+ d.push(n[x.idx1]),
|
|
|
+ g.push(e.getRawIndex(x.idx1));
|
|
|
+ break;
|
|
|
+ case "+":
|
|
|
+ var S = x.idx;
|
|
|
+ u.push(o.dataToPoint([e.get(m.dataDimsForPoint[0], S), e.get(m.dataDimsForPoint[1], S)])),
|
|
|
+ h.push(e.getItemLayout(S).slice()),
|
|
|
+ c.push(lm(m, o, e, S)),
|
|
|
+ d.push(n[S]),
|
|
|
+ g.push(e.getRawIndex(S));
|
|
|
+ break;
|
|
|
+ case "-":
|
|
|
+ S = x.idx;
|
|
|
+ var M = t.getRawIndex(S);
|
|
|
+ M !== S ? (u.push(t.getItemLayout(S)),
|
|
|
+ h.push(a.dataToPoint([t.get(v.dataDimsForPoint[0], S), t.get(v.dataDimsForPoint[1], S)])),
|
|
|
+ c.push(i[S]),
|
|
|
+ d.push(lm(v, a, t, S)),
|
|
|
+ g.push(M)) : _ = !1
|
|
|
+ }
|
|
|
+ _ && (f.push(x),
|
|
|
+ p.push(p.length))
|
|
|
+ }
|
|
|
+ p.sort(function(t, e) {
|
|
|
+ return g[t] - g[e]
|
|
|
+ });
|
|
|
+ var I = []
|
|
|
+ , T = []
|
|
|
+ , A = []
|
|
|
+ , D = []
|
|
|
+ , C = [];
|
|
|
+ for (y = 0; y < p.length; y++) {
|
|
|
+ S = p[y];
|
|
|
+ I[y] = u[S],
|
|
|
+ T[y] = h[S],
|
|
|
+ A[y] = c[S],
|
|
|
+ D[y] = d[S],
|
|
|
+ C[y] = f[S]
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ current: I,
|
|
|
+ next: T,
|
|
|
+ stackedOnCurrent: A,
|
|
|
+ stackedOnNext: D,
|
|
|
+ status: C
|
|
|
+ }
|
|
|
+ }(this._data, t, this._stackedOnPoints, e, this._coordSys, i, this._valueOrigin, a)
|
|
|
+ , h = u.current
|
|
|
+ , c = u.stackedOnCurrent
|
|
|
+ , d = u.next
|
|
|
+ , f = u.stackedOnNext;
|
|
|
+ if (o && (h = Am(u.current, i, o),
|
|
|
+ c = Am(u.stackedOnCurrent, i, o),
|
|
|
+ d = Am(u.next, i, o),
|
|
|
+ f = Am(u.stackedOnNext, i, o)),
|
|
|
+ 3e3 < Im(h, d) || s && 3e3 < Im(c, f))
|
|
|
+ return r.setShape({
|
|
|
+ points: d
|
|
|
+ }),
|
|
|
+ void (s && s.setShape({
|
|
|
+ points: d,
|
|
|
+ stackedOnPoints: f
|
|
|
+ }));
|
|
|
+ r.shape.__points = u.current,
|
|
|
+ r.shape.points = h,
|
|
|
+ cl(r, {
|
|
|
+ shape: {
|
|
|
+ points: d
|
|
|
+ }
|
|
|
+ }, l),
|
|
|
+ s && (s.setShape({
|
|
|
+ points: h,
|
|
|
+ stackedOnPoints: c
|
|
|
+ }),
|
|
|
+ cl(s, {
|
|
|
+ shape: {
|
|
|
+ points: d,
|
|
|
+ stackedOnPoints: f
|
|
|
+ }
|
|
|
+ }, l));
|
|
|
+ for (var p = [], g = u.status, m = 0; m < g.length; m++) {
|
|
|
+ if ("=" === g[m].cmd) {
|
|
|
+ var v = t.getItemGraphicEl(g[m].idx1);
|
|
|
+ v && p.push({
|
|
|
+ el: v,
|
|
|
+ ptIdx: m
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ r.animators && r.animators.length && r.animators[0].during(function() {
|
|
|
+ for (var t = 0; t < p.length; t++) {
|
|
|
+ p[t].el.attr("position", r.shape.__points[p[t].ptIdx])
|
|
|
+ }
|
|
|
+ })
|
|
|
+ },
|
|
|
+ remove: function(t) {
|
|
|
+ var i = this.group
|
|
|
+ , n = this._data;
|
|
|
+ this._lineGroup.removeAll(),
|
|
|
+ this._symbolDraw.remove(!0),
|
|
|
+ n && n.eachItemGraphicEl(function(t, e) {
|
|
|
+ t.__temp && (i.remove(t),
|
|
|
+ n.setItemGraphicEl(e, null))
|
|
|
+ }),
|
|
|
+ this._polyline = this._polygon = this._coordSys = this._points = this._stackedOnPoints = this._data = null
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function Lm(t, r, s) {
|
|
|
+ return {
|
|
|
+ seriesType: t,
|
|
|
+ performRawSeries: !0,
|
|
|
+ reset: function(u, t, e) {
|
|
|
+ var i = u.getData()
|
|
|
+ , h = u.get("symbol")
|
|
|
+ , c = u.get("symbolSize")
|
|
|
+ , n = u.get("symbolKeepAspect")
|
|
|
+ , d = u.get("symbolRotate")
|
|
|
+ , f = C(h)
|
|
|
+ , p = C(c)
|
|
|
+ , g = C(d)
|
|
|
+ , m = f || p || g
|
|
|
+ , o = !f && h ? h : r
|
|
|
+ , a = p ? null : c;
|
|
|
+ if (i.setVisual({
|
|
|
+ legendSymbol: s || o,
|
|
|
+ symbol: o,
|
|
|
+ symbolSize: a,
|
|
|
+ symbolKeepAspect: n,
|
|
|
+ symbolRotate: d
|
|
|
+ }),
|
|
|
+ !t.isSeriesFiltered(u))
|
|
|
+ return {
|
|
|
+ dataEach: i.hasItemOption || m ? function(t, e) {
|
|
|
+ if (m) {
|
|
|
+ var i = u.getRawValue(e)
|
|
|
+ , n = u.getDataParams(e);
|
|
|
+ f && t.setItemVisual(e, "symbol", h(i, n)),
|
|
|
+ p && t.setItemVisual(e, "symbolSize", c(i, n)),
|
|
|
+ g && t.setItemVisual(e, "symbolRotate", d(i, n))
|
|
|
+ }
|
|
|
+ if (t.hasItemOption) {
|
|
|
+ var o = t.getItemModel(e)
|
|
|
+ , a = o.getShallow("symbol", !0)
|
|
|
+ , r = o.getShallow("symbolSize", !0)
|
|
|
+ , s = o.getShallow("symbolRotate", !0)
|
|
|
+ , l = o.getShallow("symbolKeepAspect", !0);
|
|
|
+ null != a && t.setItemVisual(e, "symbol", a),
|
|
|
+ null != r && t.setItemVisual(e, "symbolSize", r),
|
|
|
+ null != s && t.setItemVisual(e, "symbolRotate", s),
|
|
|
+ null != l && t.setItemVisual(e, "symbolKeepAspect", l)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ : null
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function km(t) {
|
|
|
+ return {
|
|
|
+ seriesType: t,
|
|
|
+ plan: vc(),
|
|
|
+ reset: function(t) {
|
|
|
+ var e = t.getData()
|
|
|
+ , c = t.coordinateSystem
|
|
|
+ , d = t.pipelineContext.large;
|
|
|
+ if (c) {
|
|
|
+ var f = O(c.dimensions, function(t) {
|
|
|
+ return e.mapDimension(t)
|
|
|
+ }).slice(0, 2)
|
|
|
+ , p = f.length
|
|
|
+ , i = e.getCalculationInfo("stackResultDimension");
|
|
|
+ return fp(e, f[0]) && (f[0] = i),
|
|
|
+ fp(e, f[1]) && (f[1] = i),
|
|
|
+ p && {
|
|
|
+ progress: function(t, e) {
|
|
|
+ for (var i = t.end - t.start, n = d && new Float32Array(i * p), o = t.start, a = 0, r = [], s = []; o < t.end; o++) {
|
|
|
+ var l;
|
|
|
+ if (1 === p) {
|
|
|
+ var u = e.get(f[0], o);
|
|
|
+ l = !isNaN(u) && c.dataToPoint(u, null, s)
|
|
|
+ } else {
|
|
|
+ u = r[0] = e.get(f[0], o);
|
|
|
+ var h = r[1] = e.get(f[1], o);
|
|
|
+ l = !isNaN(u) && !isNaN(h) && c.dataToPoint(r, null, s)
|
|
|
+ }
|
|
|
+ d ? (n[a++] = l ? l[0] : NaN,
|
|
|
+ n[a++] = l ? l[1] : NaN) : e.setItemLayout(o, l && l.slice() || [NaN, NaN])
|
|
|
+ }
|
|
|
+ d && e.setLayout("symbolPoints", n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Pm(t, e) {
|
|
|
+ return Math.round(t.length / 2)
|
|
|
+ }
|
|
|
+ var Nm = {
|
|
|
+ average: function(t) {
|
|
|
+ for (var e = 0, i = 0, n = 0; n < t.length; n++)
|
|
|
+ isNaN(t[n]) || (e += t[n],
|
|
|
+ i++);
|
|
|
+ return 0 === i ? NaN : e / i
|
|
|
+ },
|
|
|
+ sum: function(t) {
|
|
|
+ for (var e = 0, i = 0; i < t.length; i++)
|
|
|
+ e += t[i] || 0;
|
|
|
+ return e
|
|
|
+ },
|
|
|
+ max: function(t) {
|
|
|
+ for (var e = -1 / 0, i = 0; i < t.length; i++)
|
|
|
+ t[i] > e && (e = t[i]);
|
|
|
+ return isFinite(e) ? e : NaN
|
|
|
+ },
|
|
|
+ min: function(t) {
|
|
|
+ for (var e = 1 / 0, i = 0; i < t.length; i++)
|
|
|
+ t[i] < e && (e = t[i]);
|
|
|
+ return isFinite(e) ? e : NaN
|
|
|
+ },
|
|
|
+ nearest: function(t) {
|
|
|
+ return t[0]
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Om(t) {
|
|
|
+ return this._axes[t]
|
|
|
+ }
|
|
|
+ function Em(t) {
|
|
|
+ this._axes = {},
|
|
|
+ this._dimList = [],
|
|
|
+ this.name = t || ""
|
|
|
+ }
|
|
|
+ function Rm(t) {
|
|
|
+ Em.call(this, t)
|
|
|
+ }
|
|
|
+ Em.prototype = {
|
|
|
+ constructor: Em,
|
|
|
+ type: "cartesian",
|
|
|
+ getAxis: function(t) {
|
|
|
+ return this._axes[t]
|
|
|
+ },
|
|
|
+ getAxes: function() {
|
|
|
+ return O(this._dimList, Om, this)
|
|
|
+ },
|
|
|
+ getAxesByScale: function(e) {
|
|
|
+ return e = e.toLowerCase(),
|
|
|
+ M(this.getAxes(), function(t) {
|
|
|
+ return t.scale.type === e
|
|
|
+ })
|
|
|
+ },
|
|
|
+ addAxis: function(t) {
|
|
|
+ var e = t.dim;
|
|
|
+ this._axes[e] = t,
|
|
|
+ this._dimList.push(e)
|
|
|
+ },
|
|
|
+ dataToCoord: function(t) {
|
|
|
+ return this._dataCoordConvert(t, "dataToCoord")
|
|
|
+ },
|
|
|
+ coordToData: function(t) {
|
|
|
+ return this._dataCoordConvert(t, "coordToData")
|
|
|
+ },
|
|
|
+ _dataCoordConvert: function(t, e) {
|
|
|
+ for (var i = this._dimList, n = t instanceof Array ? [] : {}, o = 0; o < i.length; o++) {
|
|
|
+ var a = i[o]
|
|
|
+ , r = this._axes[a];
|
|
|
+ n[a] = r[e](t[a])
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Rm.prototype = {
|
|
|
+ constructor: Rm,
|
|
|
+ type: "cartesian2d",
|
|
|
+ dimensions: ["x", "y"],
|
|
|
+ getBaseAxis: function() {
|
|
|
+ return this.getAxesByScale("ordinal")[0] || this.getAxesByScale("time")[0] || this.getAxis("x")
|
|
|
+ },
|
|
|
+ containPoint: function(t) {
|
|
|
+ var e = this.getAxis("x")
|
|
|
+ , i = this.getAxis("y");
|
|
|
+ return e.contain(e.toLocalCoord(t[0])) && i.contain(i.toLocalCoord(t[1]))
|
|
|
+ },
|
|
|
+ containData: function(t) {
|
|
|
+ return this.getAxis("x").containData(t[0]) && this.getAxis("y").containData(t[1])
|
|
|
+ },
|
|
|
+ dataToPoint: function(t, e, i) {
|
|
|
+ var n = this.getAxis("x")
|
|
|
+ , o = this.getAxis("y");
|
|
|
+ return (i = i || [])[0] = n.toGlobalCoord(n.dataToCoord(t[0])),
|
|
|
+ i[1] = o.toGlobalCoord(o.dataToCoord(t[1])),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ clampData: function(t, e) {
|
|
|
+ var i = this.getAxis("x").scale
|
|
|
+ , n = this.getAxis("y").scale
|
|
|
+ , o = i.getExtent()
|
|
|
+ , a = n.getExtent()
|
|
|
+ , r = i.parse(t[0])
|
|
|
+ , s = n.parse(t[1]);
|
|
|
+ return (e = e || [])[0] = Math.min(Math.max(Math.min(o[0], o[1]), r), Math.max(o[0], o[1])),
|
|
|
+ e[1] = Math.min(Math.max(Math.min(a[0], a[1]), s), Math.max(a[0], a[1])),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ pointToData: function(t, e) {
|
|
|
+ var i = this.getAxis("x")
|
|
|
+ , n = this.getAxis("y");
|
|
|
+ return (e = e || [])[0] = i.coordToData(i.toLocalCoord(t[0])),
|
|
|
+ e[1] = n.coordToData(n.toLocalCoord(t[1])),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ getOtherAxis: function(t) {
|
|
|
+ return this.getAxis("x" === t.dim ? "y" : "x")
|
|
|
+ },
|
|
|
+ getArea: function() {
|
|
|
+ var t = this.getAxis("x").getGlobalExtent()
|
|
|
+ , e = this.getAxis("y").getGlobalExtent()
|
|
|
+ , i = Math.min(t[0], t[1])
|
|
|
+ , n = Math.min(e[0], e[1]);
|
|
|
+ return new Di(i,n,Math.max(t[0], t[1]) - i,Math.max(e[0], e[1]) - n)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ w(Rm, Em);
|
|
|
+ function zm(t, e, i, n, o) {
|
|
|
+ Gg.call(this, t, e, i),
|
|
|
+ this.type = n || "value",
|
|
|
+ this.position = o || "bottom"
|
|
|
+ }
|
|
|
+ zm.prototype = {
|
|
|
+ constructor: zm,
|
|
|
+ index: 0,
|
|
|
+ getAxesOnZeroOf: null,
|
|
|
+ model: null,
|
|
|
+ isHorizontal: function() {
|
|
|
+ var t = this.position;
|
|
|
+ return "top" === t || "bottom" === t
|
|
|
+ },
|
|
|
+ getGlobalExtent: function(t) {
|
|
|
+ var e = this.getExtent();
|
|
|
+ return e[0] = this.toGlobalCoord(e[0]),
|
|
|
+ e[1] = this.toGlobalCoord(e[1]),
|
|
|
+ t && e[0] > e[1] && e.reverse(),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ getOtherAxis: function() {
|
|
|
+ this.grid.getOtherAxis()
|
|
|
+ },
|
|
|
+ pointToData: function(t, e) {
|
|
|
+ return this.coordToData(this.toLocalCoord(t["x" === this.dim ? 0 : 1]), e)
|
|
|
+ },
|
|
|
+ toLocalCoord: null,
|
|
|
+ toGlobalCoord: null
|
|
|
+ },
|
|
|
+ w(zm, Gg);
|
|
|
+ var Bm = {
|
|
|
+ show: !0,
|
|
|
+ zlevel: 0,
|
|
|
+ z: 0,
|
|
|
+ inverse: !1,
|
|
|
+ name: "",
|
|
|
+ nameLocation: "end",
|
|
|
+ nameRotate: null,
|
|
|
+ nameTruncate: {
|
|
|
+ maxWidth: null,
|
|
|
+ ellipsis: "...",
|
|
|
+ placeholder: "."
|
|
|
+ },
|
|
|
+ nameTextStyle: {},
|
|
|
+ nameGap: 15,
|
|
|
+ silent: !1,
|
|
|
+ triggerEvent: !1,
|
|
|
+ tooltip: {
|
|
|
+ show: !1
|
|
|
+ },
|
|
|
+ axisPointer: {},
|
|
|
+ axisLine: {
|
|
|
+ show: !0,
|
|
|
+ onZero: !0,
|
|
|
+ onZeroAxisIndex: null,
|
|
|
+ lineStyle: {
|
|
|
+ color: "#333",
|
|
|
+ width: 1,
|
|
|
+ type: "solid"
|
|
|
+ },
|
|
|
+ symbol: ["none", "none"],
|
|
|
+ symbolSize: [10, 15]
|
|
|
+ },
|
|
|
+ axisTick: {
|
|
|
+ show: !0,
|
|
|
+ inside: !1,
|
|
|
+ length: 5,
|
|
|
+ lineStyle: {
|
|
|
+ width: 1
|
|
|
+ }
|
|
|
+ },
|
|
|
+ axisLabel: {
|
|
|
+ show: !0,
|
|
|
+ inside: !1,
|
|
|
+ rotate: 0,
|
|
|
+ showMinLabel: null,
|
|
|
+ showMaxLabel: null,
|
|
|
+ margin: 8,
|
|
|
+ fontSize: 12
|
|
|
+ },
|
|
|
+ splitLine: {
|
|
|
+ show: !0,
|
|
|
+ lineStyle: {
|
|
|
+ color: ["#ccc"],
|
|
|
+ width: 1,
|
|
|
+ type: "solid"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ splitArea: {
|
|
|
+ show: !1,
|
|
|
+ areaStyle: {
|
|
|
+ color: ["rgba(250,250,250,0.3)", "rgba(200,200,200,0.3)"]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Vm = {};
|
|
|
+ Vm.categoryAxis = m({
|
|
|
+ boundaryGap: !0,
|
|
|
+ deduplication: null,
|
|
|
+ splitLine: {
|
|
|
+ show: !1
|
|
|
+ },
|
|
|
+ axisTick: {
|
|
|
+ alignWithLabel: !1,
|
|
|
+ interval: "auto"
|
|
|
+ },
|
|
|
+ axisLabel: {
|
|
|
+ interval: "auto"
|
|
|
+ }
|
|
|
+ }, Bm),
|
|
|
+ Vm.valueAxis = m({
|
|
|
+ boundaryGap: [0, 0],
|
|
|
+ splitNumber: 5,
|
|
|
+ minorTick: {
|
|
|
+ show: !1,
|
|
|
+ splitNumber: 5,
|
|
|
+ length: 3,
|
|
|
+ lineStyle: {}
|
|
|
+ },
|
|
|
+ minorSplitLine: {
|
|
|
+ show: !1,
|
|
|
+ lineStyle: {
|
|
|
+ color: "#eee",
|
|
|
+ width: 1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, Bm),
|
|
|
+ Vm.timeAxis = D({
|
|
|
+ scale: !0,
|
|
|
+ min: "dataMin",
|
|
|
+ max: "dataMax"
|
|
|
+ }, Vm.valueAxis),
|
|
|
+ Vm.logAxis = D({
|
|
|
+ scale: !0,
|
|
|
+ logBase: 10
|
|
|
+ }, Vm.valueAxis);
|
|
|
+ function Gm(a, t, r, e) {
|
|
|
+ E(Fm, function(o) {
|
|
|
+ t.extend({
|
|
|
+ type: a + "Axis." + o,
|
|
|
+ mergeDefaultAndTheme: function(t, e) {
|
|
|
+ var i = this.layoutMode
|
|
|
+ , n = i ? Iu(t) : {};
|
|
|
+ m(t, e.getTheme().get(o + "Axis")),
|
|
|
+ m(t, this.getDefaultOption()),
|
|
|
+ t.type = r(a, t),
|
|
|
+ i && Mu(t, n, i)
|
|
|
+ },
|
|
|
+ optionUpdated: function() {
|
|
|
+ "category" === this.option.type && (this.__ordinalMeta = vp.createByAxisModel(this))
|
|
|
+ },
|
|
|
+ getCategories: function(t) {
|
|
|
+ var e = this.option;
|
|
|
+ if ("category" === e.type)
|
|
|
+ return t ? e.data : this.__ordinalMeta.categories
|
|
|
+ },
|
|
|
+ getOrdinalMeta: function() {
|
|
|
+ return this.__ordinalMeta
|
|
|
+ },
|
|
|
+ defaultOption: p([{}, Vm[o + "Axis"], e], !0)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ ku.registerSubTypeDefaulter(a + "Axis", T(r, a))
|
|
|
+ }
|
|
|
+ var Fm = ["value", "category", "time", "log"]
|
|
|
+ , Wm = ku.extend({
|
|
|
+ type: "cartesian2dAxis",
|
|
|
+ axis: null,
|
|
|
+ init: function() {
|
|
|
+ Wm.superApply(this, "init", arguments),
|
|
|
+ this.resetRange()
|
|
|
+ },
|
|
|
+ mergeOption: function() {
|
|
|
+ Wm.superApply(this, "mergeOption", arguments),
|
|
|
+ this.resetRange()
|
|
|
+ },
|
|
|
+ restoreData: function() {
|
|
|
+ Wm.superApply(this, "restoreData", arguments),
|
|
|
+ this.resetRange()
|
|
|
+ },
|
|
|
+ getCoordSysModel: function() {
|
|
|
+ return this.ecModel.queryComponents({
|
|
|
+ mainType: "grid",
|
|
|
+ index: this.option.gridIndex,
|
|
|
+ id: this.option.gridId
|
|
|
+ })[0]
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function Hm(t, e) {
|
|
|
+ return e.type || (e.data ? "category" : "value")
|
|
|
+ }
|
|
|
+ m(Wm.prototype, dg);
|
|
|
+ var Zm = {
|
|
|
+ offset: 0
|
|
|
+ };
|
|
|
+ function Um(t, e) {
|
|
|
+ return t.getCoordSysModel() === e
|
|
|
+ }
|
|
|
+ function Xm(t, e, i) {
|
|
|
+ this._coordsMap = {},
|
|
|
+ this._coordsList = [],
|
|
|
+ this._axesMap = {},
|
|
|
+ this._axesList = [],
|
|
|
+ this._initCartesian(t, e, i),
|
|
|
+ this.model = t
|
|
|
+ }
|
|
|
+ Gm("x", Wm, Hm, Zm),
|
|
|
+ Gm("y", Wm, Hm, Zm),
|
|
|
+ ku.extend({
|
|
|
+ type: "grid",
|
|
|
+ dependencies: ["xAxis", "yAxis"],
|
|
|
+ layoutMode: "box",
|
|
|
+ coordinateSystem: null,
|
|
|
+ defaultOption: {
|
|
|
+ show: !1,
|
|
|
+ zlevel: 0,
|
|
|
+ z: 0,
|
|
|
+ left: "10%",
|
|
|
+ top: 60,
|
|
|
+ right: "10%",
|
|
|
+ bottom: 60,
|
|
|
+ containLabel: !1,
|
|
|
+ backgroundColor: "rgba(0,0,0,0)",
|
|
|
+ borderWidth: 1,
|
|
|
+ borderColor: "#ccc"
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var Ym = Xm.prototype;
|
|
|
+ function jm(t, e, i, n) {
|
|
|
+ i.getAxesOnZeroOf = function() {
|
|
|
+ return o ? [o] : []
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var o, a = t[e], r = i.model, s = r.get("axisLine.onZero"), l = r.get("axisLine.onZeroAxisIndex");
|
|
|
+ if (s) {
|
|
|
+ if (null != l)
|
|
|
+ qm(a[l]) && (o = a[l]);
|
|
|
+ else
|
|
|
+ for (var u in a)
|
|
|
+ if (a.hasOwnProperty(u) && qm(a[u]) && !n[h(a[u])]) {
|
|
|
+ o = a[u];
|
|
|
+ break
|
|
|
+ }
|
|
|
+ o && (n[h(o)] = !0)
|
|
|
+ }
|
|
|
+ function h(t) {
|
|
|
+ return t.dim + "_" + t.index
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function qm(t) {
|
|
|
+ return t && "category" !== t.type && "time" !== t.type && function(t) {
|
|
|
+ var e = t.scale.getExtent()
|
|
|
+ , i = e[0]
|
|
|
+ , n = e[1];
|
|
|
+ return !(0 < i && 0 < n || i < 0 && n < 0)
|
|
|
+ }(t)
|
|
|
+ }
|
|
|
+ Ym.type = "grid",
|
|
|
+ Ym.axisPointerEnabled = !0,
|
|
|
+ Ym.getRect = function() {
|
|
|
+ return this._rect
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.update = function(t, e) {
|
|
|
+ var i = this._axesMap;
|
|
|
+ this._updateScale(t, this.model),
|
|
|
+ E(i.x, function(t) {
|
|
|
+ rg(t.scale, t.model)
|
|
|
+ }),
|
|
|
+ E(i.y, function(t) {
|
|
|
+ rg(t.scale, t.model)
|
|
|
+ });
|
|
|
+ var n = {};
|
|
|
+ E(i.x, function(t) {
|
|
|
+ jm(i, "y", t, n)
|
|
|
+ }),
|
|
|
+ E(i.y, function(t) {
|
|
|
+ jm(i, "x", t, n)
|
|
|
+ }),
|
|
|
+ this.resize(this.model, e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.resize = function(t, e, i) {
|
|
|
+ var o = bu(t.getBoxLayoutParams(), {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ });
|
|
|
+ this._rect = o;
|
|
|
+ var n = this._axesList;
|
|
|
+ function a() {
|
|
|
+ E(n, function(t) {
|
|
|
+ var e = t.isHorizontal()
|
|
|
+ , i = e ? [0, o.width] : [0, o.height]
|
|
|
+ , n = t.inverse ? 1 : 0;
|
|
|
+ t.setExtent(i[n], i[1 - n]),
|
|
|
+ function(t, e) {
|
|
|
+ var i = t.getExtent()
|
|
|
+ , n = i[0] + i[1];
|
|
|
+ t.toGlobalCoord = "x" === t.dim ? function(t) {
|
|
|
+ return t + e
|
|
|
+ }
|
|
|
+ : function(t) {
|
|
|
+ return n - t + e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.toLocalCoord = "x" === t.dim ? function(t) {
|
|
|
+ return t - e
|
|
|
+ }
|
|
|
+ : function(t) {
|
|
|
+ return n - t + e
|
|
|
+ }
|
|
|
+ }(t, e ? o.x : o.y)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ a(),
|
|
|
+ !i && t.get("containLabel") && (E(n, function(t) {
|
|
|
+ if (!t.model.get("axisLabel.inside")) {
|
|
|
+ var e = function(t) {
|
|
|
+ var e = t.model
|
|
|
+ , i = t.scale;
|
|
|
+ if (e.get("axisLabel.show") && !i.isBlank()) {
|
|
|
+ var n, o, a = "category" === t.type, r = i.getExtent();
|
|
|
+ o = a ? i.count() : (n = i.getTicks()).length;
|
|
|
+ var s, l, u, h, c, d, f, p, g, m = t.getLabelModel(), v = lg(t), y = 1;
|
|
|
+ 40 < o && (y = Math.ceil(o / 40));
|
|
|
+ for (var x = 0; x < o; x += y) {
|
|
|
+ var _ = v(n ? n[x] : r[0] + x)
|
|
|
+ , w = m.getTextRect(_)
|
|
|
+ , b = (l = w,
|
|
|
+ u = m.get("rotate") || 0,
|
|
|
+ void 0,
|
|
|
+ h = u * Math.PI / 180,
|
|
|
+ c = l.plain(),
|
|
|
+ d = c.width,
|
|
|
+ f = c.height,
|
|
|
+ p = d * Math.cos(h) + f * Math.sin(h),
|
|
|
+ g = d * Math.sin(h) + f * Math.cos(h),
|
|
|
+ new Di(c.x,c.y,p,g));
|
|
|
+ s ? s.union(b) : s = b
|
|
|
+ }
|
|
|
+ return s
|
|
|
+ }
|
|
|
+ }(t);
|
|
|
+ if (e) {
|
|
|
+ var i = t.isHorizontal() ? "height" : "width"
|
|
|
+ , n = t.model.get("axisLabel.margin");
|
|
|
+ o[i] -= e[i] + n,
|
|
|
+ "top" === t.position ? o.y += e.height + n : "left" === t.position && (o.x += e.width + n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a())
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.getAxis = function(t, e) {
|
|
|
+ var i = this._axesMap[t];
|
|
|
+ if (null != i) {
|
|
|
+ if (null == e)
|
|
|
+ for (var n in i)
|
|
|
+ if (i.hasOwnProperty(n))
|
|
|
+ return i[n];
|
|
|
+ return i[e]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.getAxes = function() {
|
|
|
+ return this._axesList.slice()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.getCartesian = function(t, e) {
|
|
|
+ if (null != t && null != e) {
|
|
|
+ var i = "x" + t + "y" + e;
|
|
|
+ return this._coordsMap[i]
|
|
|
+ }
|
|
|
+ z(t) && (e = t.yAxisIndex,
|
|
|
+ t = t.xAxisIndex);
|
|
|
+ for (var n = 0, o = this._coordsList; n < o.length; n++)
|
|
|
+ if (o[n].getAxis("x").index === t || o[n].getAxis("y").index === e)
|
|
|
+ return o[n]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.getCartesians = function() {
|
|
|
+ return this._coordsList.slice()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.convertToPixel = function(t, e, i) {
|
|
|
+ var n = this._findConvertTarget(t, e);
|
|
|
+ return n.cartesian ? n.cartesian.dataToPoint(i) : n.axis ? n.axis.toGlobalCoord(n.axis.dataToCoord(i)) : null
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.convertFromPixel = function(t, e, i) {
|
|
|
+ var n = this._findConvertTarget(t, e);
|
|
|
+ return n.cartesian ? n.cartesian.pointToData(i) : n.axis ? n.axis.coordToData(n.axis.toLocalCoord(i)) : null
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym._findConvertTarget = function(t, e) {
|
|
|
+ var i, n, o = e.seriesModel, a = e.xAxisModel || o && o.getReferringComponents("xAxis")[0], r = e.yAxisModel || o && o.getReferringComponents("yAxis")[0], s = e.gridModel, l = this._coordsList;
|
|
|
+ if (o)
|
|
|
+ _(l, i = o.coordinateSystem) < 0 && (i = null);
|
|
|
+ else if (a && r)
|
|
|
+ i = this.getCartesian(a.componentIndex, r.componentIndex);
|
|
|
+ else if (a)
|
|
|
+ n = this.getAxis("x", a.componentIndex);
|
|
|
+ else if (r)
|
|
|
+ n = this.getAxis("y", r.componentIndex);
|
|
|
+ else if (s) {
|
|
|
+ s.coordinateSystem === this && (i = this._coordsList[0])
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ cartesian: i,
|
|
|
+ axis: n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.containPoint = function(t) {
|
|
|
+ var e = this._coordsList[0];
|
|
|
+ if (e)
|
|
|
+ return e.containPoint(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym._initCartesian = function(r, t, e) {
|
|
|
+ var s = {
|
|
|
+ left: !1,
|
|
|
+ right: !1,
|
|
|
+ top: !1,
|
|
|
+ bottom: !1
|
|
|
+ }
|
|
|
+ , l = {
|
|
|
+ x: {},
|
|
|
+ y: {}
|
|
|
+ }
|
|
|
+ , u = {
|
|
|
+ x: 0,
|
|
|
+ y: 0
|
|
|
+ };
|
|
|
+ if (t.eachComponent("xAxis", i("x"), this),
|
|
|
+ t.eachComponent("yAxis", i("y"), this),
|
|
|
+ !u.x || !u.y)
|
|
|
+ return this._axesMap = {},
|
|
|
+ void (this._axesList = []);
|
|
|
+ function i(a) {
|
|
|
+ return function(t, e) {
|
|
|
+ if (Um(t, r)) {
|
|
|
+ var i = t.get("position");
|
|
|
+ "x" === a ? "top" !== i && "bottom" !== i && (i = s.bottom ? "top" : "bottom") : "left" !== i && "right" !== i && (i = s.left ? "right" : "left"),
|
|
|
+ s[i] = !0;
|
|
|
+ var n = new zm(a,sg(t),[0, 0],t.get("type"),i)
|
|
|
+ , o = "category" === n.type;
|
|
|
+ n.onBand = o && t.get("boundaryGap"),
|
|
|
+ n.inverse = t.get("inverse"),
|
|
|
+ (t.axis = n).model = t,
|
|
|
+ n.grid = this,
|
|
|
+ n.index = e,
|
|
|
+ this._axesList.push(n),
|
|
|
+ l[a][e] = n,
|
|
|
+ u[a]++
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ E((this._axesMap = l).x, function(o, a) {
|
|
|
+ E(l.y, function(t, e) {
|
|
|
+ var i = "x" + a + "y" + e
|
|
|
+ , n = new Rm(i);
|
|
|
+ n.grid = this,
|
|
|
+ n.model = r,
|
|
|
+ this._coordsMap[i] = n,
|
|
|
+ this._coordsList.push(n),
|
|
|
+ n.addAxis(o),
|
|
|
+ n.addAxis(t)
|
|
|
+ }, this)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym._updateScale = function(l, u) {
|
|
|
+ function h(e, i) {
|
|
|
+ E(e.mapDimension(i.dim, !0), function(t) {
|
|
|
+ i.scale.unionExtentFromData(e, pp(e, t))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ E(this._axesList, function(t) {
|
|
|
+ t.scale.setExtent(1 / 0, -1 / 0)
|
|
|
+ }),
|
|
|
+ l.eachSeries(function(t) {
|
|
|
+ if (Jm(t)) {
|
|
|
+ var e = $m(t, l)
|
|
|
+ , i = e[0]
|
|
|
+ , n = e[1];
|
|
|
+ if (!Um(i, u) || !Um(n, u))
|
|
|
+ return;
|
|
|
+ var o = this.getCartesian(i.componentIndex, n.componentIndex)
|
|
|
+ , a = t.getData()
|
|
|
+ , r = o.getAxis("x")
|
|
|
+ , s = o.getAxis("y");
|
|
|
+ "list" === a.type && (h(a, r, t),
|
|
|
+ h(a, s, t))
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ym.getTooltipAxes = function(n) {
|
|
|
+ var o = []
|
|
|
+ , a = [];
|
|
|
+ return E(this.getCartesians(), function(t) {
|
|
|
+ var e = null != n && "auto" !== n ? t.getAxis(n) : t.getBaseAxis()
|
|
|
+ , i = t.getOtherAxis(e);
|
|
|
+ _(o, e) < 0 && o.push(e),
|
|
|
+ _(a, i) < 0 && a.push(i)
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ baseAxes: o,
|
|
|
+ otherAxes: a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Km = ["xAxis", "yAxis"];
|
|
|
+ function $m(e) {
|
|
|
+ return O(Km, function(t) {
|
|
|
+ return e.getReferringComponents(t)[0]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Jm(t) {
|
|
|
+ return "cartesian2d" === t.get("coordinateSystem")
|
|
|
+ }
|
|
|
+ Xm.create = function(n, o) {
|
|
|
+ var a = [];
|
|
|
+ return n.eachComponent("grid", function(t, e) {
|
|
|
+ var i = new Xm(t,n,o);
|
|
|
+ i.name = "grid_" + e,
|
|
|
+ i.resize(t, o, !0),
|
|
|
+ t.coordinateSystem = i,
|
|
|
+ a.push(i)
|
|
|
+ }),
|
|
|
+ n.eachSeries(function(t) {
|
|
|
+ if (Jm(t)) {
|
|
|
+ var e = $m(t)
|
|
|
+ , i = e[0]
|
|
|
+ , n = e[1]
|
|
|
+ , o = i.getCoordSysModel().coordinateSystem;
|
|
|
+ t.coordinateSystem = o.getCartesian(i.componentIndex, n.componentIndex)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Xm.dimensions = Xm.prototype.dimensions = Rm.prototype.dimensions,
|
|
|
+ lh.register("cartesian2d", Xm);
|
|
|
+ function Qm(t, e) {
|
|
|
+ this.opt = e,
|
|
|
+ this.axisModel = t,
|
|
|
+ D(e, {
|
|
|
+ labelOffset: 0,
|
|
|
+ nameDirection: 1,
|
|
|
+ tickDirection: 1,
|
|
|
+ labelDirection: 1,
|
|
|
+ silent: !0
|
|
|
+ }),
|
|
|
+ this.group = new Ci;
|
|
|
+ var i = new Ci({
|
|
|
+ position: e.position.slice(),
|
|
|
+ rotation: e.rotation
|
|
|
+ });
|
|
|
+ i.updateTransform(),
|
|
|
+ this._transform = i.transform,
|
|
|
+ this._dumbGroup = i
|
|
|
+ }
|
|
|
+ var tv = Math.PI;
|
|
|
+ Qm.prototype = {
|
|
|
+ constructor: Qm,
|
|
|
+ hasBuilder: function(t) {
|
|
|
+ return !!ev[t]
|
|
|
+ },
|
|
|
+ add: function(t) {
|
|
|
+ ev[t].call(this)
|
|
|
+ },
|
|
|
+ getGroup: function() {
|
|
|
+ return this.group
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var ev = {
|
|
|
+ axisLine: function() {
|
|
|
+ var a = this.opt
|
|
|
+ , t = this.axisModel;
|
|
|
+ if (t.get("axisLine.show")) {
|
|
|
+ var e = this.axisModel.axis.getExtent()
|
|
|
+ , i = this._transform
|
|
|
+ , r = [e[0], 0]
|
|
|
+ , n = [e[1], 0];
|
|
|
+ i && (bt(r, r, i),
|
|
|
+ bt(n, n, i));
|
|
|
+ var s = P({
|
|
|
+ lineCap: "round"
|
|
|
+ }, t.getModel("axisLine.lineStyle").getLineStyle());
|
|
|
+ this.group.add(new ls({
|
|
|
+ anid: "line",
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ shape: {
|
|
|
+ x1: r[0],
|
|
|
+ y1: r[1],
|
|
|
+ x2: n[0],
|
|
|
+ y2: n[1]
|
|
|
+ },
|
|
|
+ style: s,
|
|
|
+ strokeContainThreshold: a.strokeContainThreshold || 5,
|
|
|
+ silent: !0,
|
|
|
+ z2: 1
|
|
|
+ }));
|
|
|
+ var l = t.get("axisLine.symbol")
|
|
|
+ , o = t.get("axisLine.symbolSize")
|
|
|
+ , u = t.get("axisLine.symbolOffset") || 0;
|
|
|
+ if ("number" == typeof u && (u = [u, u]),
|
|
|
+ null != l) {
|
|
|
+ "string" == typeof l && (l = [l, l]),
|
|
|
+ "string" != typeof o && "number" != typeof o || (o = [o, o]);
|
|
|
+ var h = o[0]
|
|
|
+ , c = o[1];
|
|
|
+ E([{
|
|
|
+ rotate: a.rotation + Math.PI / 2,
|
|
|
+ offset: u[0],
|
|
|
+ r: 0
|
|
|
+ }, {
|
|
|
+ rotate: a.rotation - Math.PI / 2,
|
|
|
+ offset: u[1],
|
|
|
+ r: Math.sqrt((r[0] - n[0]) * (r[0] - n[0]) + (r[1] - n[1]) * (r[1] - n[1]))
|
|
|
+ }], function(t, e) {
|
|
|
+ if ("none" !== l[e] && null != l[e]) {
|
|
|
+ var i = wg(l[e], -h / 2, -c / 2, h, c, s.stroke, !0)
|
|
|
+ , n = t.r + t.offset
|
|
|
+ , o = [r[0] + n * Math.cos(a.rotation), r[1] - n * Math.sin(a.rotation)];
|
|
|
+ i.attr({
|
|
|
+ rotation: t.rotate,
|
|
|
+ position: o,
|
|
|
+ silent: !0,
|
|
|
+ z2: 11
|
|
|
+ }),
|
|
|
+ this.group.add(i)
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ axisTickLabel: function() {
|
|
|
+ var t = this.axisModel
|
|
|
+ , e = this.opt
|
|
|
+ , i = function(t, e, i) {
|
|
|
+ var n = e.axis
|
|
|
+ , o = e.getModel("axisTick");
|
|
|
+ if (!o.get("show") || n.scale.isBlank())
|
|
|
+ return;
|
|
|
+ for (var a = o.getModel("lineStyle"), r = i.tickDirection * o.get("length"), s = lv(n.getTicksCoords(), t._transform, r, D(a.getLineStyle(), {
|
|
|
+ stroke: e.get("axisLine.lineStyle.color")
|
|
|
+ }), "ticks"), l = 0; l < s.length; l++)
|
|
|
+ t.group.add(s[l]);
|
|
|
+ return s
|
|
|
+ }(this, t, e);
|
|
|
+ !function(t, e, i) {
|
|
|
+ if (cg(t.axis))
|
|
|
+ return;
|
|
|
+ var n = t.get("axisLabel.showMinLabel")
|
|
|
+ , o = t.get("axisLabel.showMaxLabel");
|
|
|
+ i = i || [];
|
|
|
+ var a = (e = e || [])[0]
|
|
|
+ , r = e[1]
|
|
|
+ , s = e[e.length - 1]
|
|
|
+ , l = e[e.length - 2]
|
|
|
+ , u = i[0]
|
|
|
+ , h = i[1]
|
|
|
+ , c = i[i.length - 1]
|
|
|
+ , d = i[i.length - 2];
|
|
|
+ !1 === n ? (av(a),
|
|
|
+ av(u)) : rv(a, r) && (n ? (av(r),
|
|
|
+ av(h)) : (av(a),
|
|
|
+ av(u)));
|
|
|
+ !1 === o ? (av(s),
|
|
|
+ av(c)) : rv(l, s) && (o ? (av(l),
|
|
|
+ av(d)) : (av(s),
|
|
|
+ av(c)))
|
|
|
+ }(t, function(u, h, c) {
|
|
|
+ var d = h.axis;
|
|
|
+ if (!W(c.axisLabelShow, h.get("axisLabel.show")) || d.scale.isBlank())
|
|
|
+ return;
|
|
|
+ var f = h.getModel("axisLabel")
|
|
|
+ , p = f.get("margin")
|
|
|
+ , t = d.getViewLabels()
|
|
|
+ , e = (W(c.labelRotate, f.get("rotate")) || 0) * tv / 180
|
|
|
+ , g = nv(c.rotation, e, c.labelDirection)
|
|
|
+ , m = h.getCategories && h.getCategories(!0)
|
|
|
+ , v = []
|
|
|
+ , y = ov(h)
|
|
|
+ , x = h.get("triggerEvent");
|
|
|
+ return E(t, function(t, e) {
|
|
|
+ var i = t.tickValue
|
|
|
+ , n = t.formattedLabel
|
|
|
+ , o = t.rawLabel
|
|
|
+ , a = f;
|
|
|
+ m && m[i] && m[i].textStyle && (a = new Cl(m[i].textStyle,f,h.ecModel));
|
|
|
+ var r = a.getTextColor() || h.get("axisLine.lineStyle.color")
|
|
|
+ , s = [d.dataToCoord(i), c.labelOffset + c.labelDirection * p]
|
|
|
+ , l = new Ur({
|
|
|
+ anid: "label_" + i,
|
|
|
+ position: s,
|
|
|
+ rotation: g.rotation,
|
|
|
+ silent: y,
|
|
|
+ z2: 10
|
|
|
+ });
|
|
|
+ nl(l.style, a, {
|
|
|
+ text: n,
|
|
|
+ textAlign: a.getShallow("align", !0) || g.textAlign,
|
|
|
+ textVerticalAlign: a.getShallow("verticalAlign", !0) || a.getShallow("baseline", !0) || g.textVerticalAlign,
|
|
|
+ textFill: "function" == typeof r ? r("category" === d.type ? o : "value" === d.type ? i + "" : i, e) : r
|
|
|
+ }),
|
|
|
+ x && (l.eventData = iv(h),
|
|
|
+ l.eventData.targetType = "axisLabel",
|
|
|
+ l.eventData.value = o),
|
|
|
+ u._dumbGroup.add(l),
|
|
|
+ l.updateTransform(),
|
|
|
+ v.push(l),
|
|
|
+ u.group.add(l),
|
|
|
+ l.decomposeTransform()
|
|
|
+ }),
|
|
|
+ v
|
|
|
+ }(this, t, e), i),
|
|
|
+ function(t, e, i) {
|
|
|
+ var n = e.axis
|
|
|
+ , o = e.getModel("minorTick");
|
|
|
+ if (!o.get("show") || n.scale.isBlank())
|
|
|
+ return;
|
|
|
+ var a = n.getMinorTicksCoords();
|
|
|
+ if (!a.length)
|
|
|
+ return;
|
|
|
+ for (var r = o.getModel("lineStyle"), s = i.tickDirection * o.get("length"), l = D(r.getLineStyle(), D(e.getModel("axisTick").getLineStyle(), {
|
|
|
+ stroke: e.get("axisLine.lineStyle.color")
|
|
|
+ })), u = 0; u < a.length; u++)
|
|
|
+ for (var h = lv(a[u], t._transform, s, l, "minorticks_" + u), c = 0; c < h.length; c++)
|
|
|
+ t.group.add(h[c])
|
|
|
+ }(this, t, e)
|
|
|
+ },
|
|
|
+ axisName: function() {
|
|
|
+ var t = this.opt
|
|
|
+ , e = this.axisModel
|
|
|
+ , i = W(t.axisName, e.get("name"));
|
|
|
+ if (i) {
|
|
|
+ var n, o, a = e.get("nameLocation"), r = t.nameDirection, s = e.getModel("nameTextStyle"), l = e.get("nameGap") || 0, u = this.axisModel.axis.getExtent(), h = u[0] > u[1] ? -1 : 1, c = ["start" === a ? u[0] - h * l : "end" === a ? u[1] + h * l : (u[0] + u[1]) / 2, sv(a) ? t.labelOffset + r * l : 0], d = e.get("nameRotate");
|
|
|
+ null != d && (d = d * tv / 180),
|
|
|
+ sv(a) ? n = nv(t.rotation, null != d ? d : t.rotation, r) : (n = function(t, e, i, n) {
|
|
|
+ var o, a, r = Zl(i - t.rotation), s = n[0] > n[1], l = "start" === e && !s || "start" !== e && s;
|
|
|
+ o = Ul(r - tv / 2) ? (a = l ? "bottom" : "top",
|
|
|
+ "center") : Ul(r - 1.5 * tv) ? (a = l ? "top" : "bottom",
|
|
|
+ "center") : (a = "middle",
|
|
|
+ r < 1.5 * tv && tv / 2 < r ? l ? "left" : "right" : l ? "right" : "left");
|
|
|
+ return {
|
|
|
+ rotation: r,
|
|
|
+ textAlign: o,
|
|
|
+ textVerticalAlign: a
|
|
|
+ }
|
|
|
+ }(t, a, d || 0, u),
|
|
|
+ null != (o = t.axisNameAvailableWidth) && (o = Math.abs(o / Math.sin(n.rotation)),
|
|
|
+ isFinite(o) || (o = null)));
|
|
|
+ var f = s.getFont()
|
|
|
+ , p = e.get("nameTruncate", !0) || {}
|
|
|
+ , g = p.ellipsis
|
|
|
+ , m = W(t.nameTruncateMaxWidth, p.maxWidth, o)
|
|
|
+ , v = null != g && null != m ? pu(i, m, f, g, {
|
|
|
+ minChar: 2,
|
|
|
+ placeholder: p.placeholder
|
|
|
+ }) : i
|
|
|
+ , y = e.get("tooltip", !0)
|
|
|
+ , x = e.mainType
|
|
|
+ , _ = {
|
|
|
+ componentType: x,
|
|
|
+ name: i,
|
|
|
+ $vars: ["name"]
|
|
|
+ };
|
|
|
+ _[x + "Index"] = e.componentIndex;
|
|
|
+ var w = new Ur({
|
|
|
+ anid: "name",
|
|
|
+ __fullText: i,
|
|
|
+ __truncatedText: v,
|
|
|
+ position: c,
|
|
|
+ rotation: n.rotation,
|
|
|
+ silent: ov(e),
|
|
|
+ z2: 1,
|
|
|
+ tooltip: y && y.show ? P({
|
|
|
+ content: i,
|
|
|
+ formatter: function() {
|
|
|
+ return i
|
|
|
+ },
|
|
|
+ formatterParams: _
|
|
|
+ }, y) : null
|
|
|
+ });
|
|
|
+ nl(w.style, s, {
|
|
|
+ text: v,
|
|
|
+ textFont: f,
|
|
|
+ textFill: s.getTextColor() || e.get("axisLine.lineStyle.color"),
|
|
|
+ textAlign: s.get("align") || n.textAlign,
|
|
|
+ textVerticalAlign: s.get("verticalAlign") || n.textVerticalAlign
|
|
|
+ }),
|
|
|
+ e.get("triggerEvent") && (w.eventData = iv(e),
|
|
|
+ w.eventData.targetType = "axisName",
|
|
|
+ w.eventData.name = i),
|
|
|
+ this._dumbGroup.add(w),
|
|
|
+ w.updateTransform(),
|
|
|
+ this.group.add(w),
|
|
|
+ w.decomposeTransform()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , iv = Qm.makeAxisEventDataBase = function(t) {
|
|
|
+ var e = {
|
|
|
+ componentType: t.mainType,
|
|
|
+ componentIndex: t.componentIndex
|
|
|
+ };
|
|
|
+ return e[t.mainType + "Index"] = t.componentIndex,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ , nv = Qm.innerTextLayout = function(t, e, i) {
|
|
|
+ var n, o = Zl(e - t);
|
|
|
+ return {
|
|
|
+ rotation: o,
|
|
|
+ textAlign: Ul(o) ? (n = 0 < i ? "top" : "bottom",
|
|
|
+ "center") : Ul(o - tv) ? (n = 0 < i ? "bottom" : "top",
|
|
|
+ "center") : (n = "middle",
|
|
|
+ 0 < o && o < tv ? 0 < i ? "right" : "left" : 0 < i ? "left" : "right"),
|
|
|
+ textVerticalAlign: n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var ov = Qm.isLabelSilent = function(t) {
|
|
|
+ var e = t.get("tooltip");
|
|
|
+ return t.get("silent") || !(t.get("triggerEvent") || e && e.show)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function av(t) {
|
|
|
+ t && (t.ignore = !0)
|
|
|
+ }
|
|
|
+ function rv(t, e) {
|
|
|
+ var i = t && t.getBoundingRect().clone()
|
|
|
+ , n = e && e.getBoundingRect().clone();
|
|
|
+ if (i && n) {
|
|
|
+ var o = re([]);
|
|
|
+ return he(o, o, -t.rotation),
|
|
|
+ i.applyTransform(le([], o, t.getLocalTransform())),
|
|
|
+ n.applyTransform(le([], o, e.getLocalTransform())),
|
|
|
+ i.intersect(n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function sv(t) {
|
|
|
+ return "middle" === t || "center" === t
|
|
|
+ }
|
|
|
+ function lv(t, e, i, n, o) {
|
|
|
+ for (var a = [], r = [], s = [], l = 0; l < t.length; l++) {
|
|
|
+ var u = t[l].coord;
|
|
|
+ r[0] = u,
|
|
|
+ s[r[1] = 0] = u,
|
|
|
+ s[1] = i,
|
|
|
+ e && (bt(r, r, e),
|
|
|
+ bt(s, s, e));
|
|
|
+ var h = new ls({
|
|
|
+ anid: o + "_" + t[l].tickValue,
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ shape: {
|
|
|
+ x1: r[0],
|
|
|
+ y1: r[1],
|
|
|
+ x2: s[0],
|
|
|
+ y2: s[1]
|
|
|
+ },
|
|
|
+ style: n,
|
|
|
+ z2: 2,
|
|
|
+ silent: !0
|
|
|
+ });
|
|
|
+ a.push(h)
|
|
|
+ }
|
|
|
+ return a
|
|
|
+ }
|
|
|
+ var uv = E
|
|
|
+ , hv = T;
|
|
|
+ function cv(t, e) {
|
|
|
+ var i = {
|
|
|
+ axesInfo: {},
|
|
|
+ seriesInvolved: !1,
|
|
|
+ coordSysAxesInfo: {},
|
|
|
+ coordSysMap: {}
|
|
|
+ };
|
|
|
+ return function(p, g, t) {
|
|
|
+ var a = g.getComponent("tooltip")
|
|
|
+ , m = g.getComponent("axisPointer")
|
|
|
+ , v = m.get("link", !0) || []
|
|
|
+ , y = [];
|
|
|
+ uv(t.getCoordinateSystems(), function(c) {
|
|
|
+ if (c.axisPointerEnabled) {
|
|
|
+ var t = gv(c.model)
|
|
|
+ , d = p.coordSysAxesInfo[t] = {}
|
|
|
+ , f = (p.coordSysMap[t] = c).model.getModel("tooltip", a);
|
|
|
+ if (uv(c.getAxes(), hv(o, !1, null)),
|
|
|
+ c.getTooltipAxes && a && f.get("show")) {
|
|
|
+ var e = "axis" === f.get("trigger")
|
|
|
+ , i = "cross" === f.get("axisPointer.type")
|
|
|
+ , n = c.getTooltipAxes(f.get("axisPointer.axis"));
|
|
|
+ (e || i) && uv(n.baseAxes, hv(o, !i || "cross", e)),
|
|
|
+ i && uv(n.otherAxes, hv(o, "cross", !1))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function o(t, e, i) {
|
|
|
+ var n = i.model.getModel("axisPointer", m)
|
|
|
+ , o = n.get("show");
|
|
|
+ if (o && ("auto" !== o || t || pv(n))) {
|
|
|
+ null == e && (e = n.get("triggerTooltip"));
|
|
|
+ var a = (n = t ? function(t, e, i, n, o, a) {
|
|
|
+ var r = e.getModel("axisPointer")
|
|
|
+ , s = {};
|
|
|
+ uv(["type", "snap", "lineStyle", "shadowStyle", "label", "animation", "animationDurationUpdate", "animationEasingUpdate", "z"], function(t) {
|
|
|
+ s[t] = k(r.get(t))
|
|
|
+ }),
|
|
|
+ s.snap = "category" !== t.type && !!a,
|
|
|
+ "cross" === r.get("type") && (s.type = "line");
|
|
|
+ var l = s.label || (s.label = {});
|
|
|
+ if (null == l.show && (l.show = !1),
|
|
|
+ "cross" === o) {
|
|
|
+ var u = r.get("label.show");
|
|
|
+ if (l.show = null == u || u,
|
|
|
+ !a) {
|
|
|
+ var h = s.lineStyle = r.get("crossStyle");
|
|
|
+ h && D(l, h.textStyle)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return t.model.getModel("axisPointer", new Cl(s,i,n))
|
|
|
+ }(i, f, m, g, t, e) : n).get("snap")
|
|
|
+ , r = gv(i.model)
|
|
|
+ , s = e || a || "category" === i.type
|
|
|
+ , l = p.axesInfo[r] = {
|
|
|
+ key: r,
|
|
|
+ axis: i,
|
|
|
+ coordSys: c,
|
|
|
+ axisPointerModel: n,
|
|
|
+ triggerTooltip: e,
|
|
|
+ involveSeries: s,
|
|
|
+ snap: a,
|
|
|
+ useHandle: pv(n),
|
|
|
+ seriesModels: []
|
|
|
+ };
|
|
|
+ d[r] = l,
|
|
|
+ p.seriesInvolved |= s;
|
|
|
+ var u = function(t, e) {
|
|
|
+ for (var i = e.model, n = e.dim, o = 0; o < t.length; o++) {
|
|
|
+ var a = t[o] || {};
|
|
|
+ if (dv(a[n + "AxisId"], i.id) || dv(a[n + "AxisIndex"], i.componentIndex) || dv(a[n + "AxisName"], i.name))
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ }(v, i);
|
|
|
+ if (null != u) {
|
|
|
+ var h = y[u] || (y[u] = {
|
|
|
+ axesInfo: {}
|
|
|
+ });
|
|
|
+ h.axesInfo[r] = l,
|
|
|
+ h.mapper = v[u].mapper,
|
|
|
+ l.linkGroup = h
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }(i, t, e),
|
|
|
+ i.seriesInvolved && function(o, t) {
|
|
|
+ t.eachSeries(function(i) {
|
|
|
+ var n = i.coordinateSystem
|
|
|
+ , t = i.get("tooltip.trigger", !0)
|
|
|
+ , e = i.get("tooltip.show", !0);
|
|
|
+ n && "none" !== t && !1 !== t && "item" !== t && !1 !== e && !1 !== i.get("axisPointer.show", !0) && uv(o.coordSysAxesInfo[gv(n.model)], function(t) {
|
|
|
+ var e = t.axis;
|
|
|
+ n.getAxis(e.dim) === e && (t.seriesModels.push(i),
|
|
|
+ null == t.seriesDataCount && (t.seriesDataCount = 0),
|
|
|
+ t.seriesDataCount += i.getData().count())
|
|
|
+ })
|
|
|
+ }, this)
|
|
|
+ }(i, t),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function dv(t, e) {
|
|
|
+ return "all" === t || L(t) && 0 <= _(t, e) || t === e
|
|
|
+ }
|
|
|
+ function fv(t) {
|
|
|
+ var e = (t.ecModel.getComponent("axisPointer") || {}).coordSysAxesInfo;
|
|
|
+ return e && e.axesInfo[gv(t)]
|
|
|
+ }
|
|
|
+ function pv(t) {
|
|
|
+ return !!t.get("handle.show")
|
|
|
+ }
|
|
|
+ function gv(t) {
|
|
|
+ return t.type + "||" + t.id
|
|
|
+ }
|
|
|
+ var mv = Af({
|
|
|
+ type: "axis",
|
|
|
+ _axisPointer: null,
|
|
|
+ axisPointerClass: null,
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ this.axisPointerClass && function(t) {
|
|
|
+ var e = fv(t);
|
|
|
+ if (e) {
|
|
|
+ var i = e.axisPointerModel
|
|
|
+ , n = e.axis.scale
|
|
|
+ , o = i.option
|
|
|
+ , a = i.get("status")
|
|
|
+ , r = i.get("value");
|
|
|
+ null != r && (r = n.parse(r));
|
|
|
+ var s = pv(i);
|
|
|
+ null == a && (o.status = s ? "show" : "hide");
|
|
|
+ var l = n.getExtent().slice();
|
|
|
+ l[0] > l[1] && l.reverse(),
|
|
|
+ (null == r || r > l[1]) && (r = l[1]),
|
|
|
+ r < l[0] && (r = l[0]),
|
|
|
+ o.value = r,
|
|
|
+ s && (o.status = e.axis.scale.isBlank() ? "hide" : "show")
|
|
|
+ }
|
|
|
+ }(t),
|
|
|
+ mv.superApply(this, "render", arguments),
|
|
|
+ vv(this, t, e, i, n, !0)
|
|
|
+ },
|
|
|
+ updateAxisPointer: function(t, e, i, n, o) {
|
|
|
+ vv(this, t, e, i, n, !1)
|
|
|
+ },
|
|
|
+ remove: function(t, e) {
|
|
|
+ var i = this._axisPointer;
|
|
|
+ i && i.remove(e),
|
|
|
+ mv.superApply(this, "remove", arguments)
|
|
|
+ },
|
|
|
+ dispose: function(t, e) {
|
|
|
+ yv(this, e),
|
|
|
+ mv.superApply(this, "dispose", arguments)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function vv(t, e, i, n, o, a) {
|
|
|
+ var r = mv.getAxisPointerClass(t.axisPointerClass);
|
|
|
+ if (r) {
|
|
|
+ var s = function(t) {
|
|
|
+ var e = fv(t);
|
|
|
+ return e && e.axisPointerModel
|
|
|
+ }(e);
|
|
|
+ s ? (t._axisPointer || (t._axisPointer = new r)).render(e, s, n, a) : yv(t, n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function yv(t, e, i) {
|
|
|
+ var n = t._axisPointer;
|
|
|
+ n && n.dispose(e, i),
|
|
|
+ t._axisPointer = null
|
|
|
+ }
|
|
|
+ var xv = [];
|
|
|
+ function _v(t, e, i) {
|
|
|
+ i = i || {};
|
|
|
+ var n = t.coordinateSystem
|
|
|
+ , o = e.axis
|
|
|
+ , a = {}
|
|
|
+ , r = o.getAxesOnZeroOf()[0]
|
|
|
+ , s = o.position
|
|
|
+ , l = r ? "onZero" : s
|
|
|
+ , u = o.dim
|
|
|
+ , h = n.getRect()
|
|
|
+ , c = [h.x, h.x + h.width, h.y, h.y + h.height]
|
|
|
+ , d = {
|
|
|
+ left: 0,
|
|
|
+ right: 1,
|
|
|
+ top: 0,
|
|
|
+ bottom: 1,
|
|
|
+ onZero: 2
|
|
|
+ }
|
|
|
+ , f = e.get("offset") || 0
|
|
|
+ , p = "x" === u ? [c[2] - f, c[3] + f] : [c[0] - f, c[1] + f];
|
|
|
+ if (r) {
|
|
|
+ var g = r.toGlobalCoord(r.dataToCoord(0));
|
|
|
+ p[d.onZero] = Math.max(Math.min(g, p[1]), p[0])
|
|
|
+ }
|
|
|
+ a.position = ["y" === u ? p[d[l]] : c[0], "x" === u ? p[d[l]] : c[3]],
|
|
|
+ a.rotation = Math.PI / 2 * ("x" === u ? 0 : 1);
|
|
|
+ a.labelDirection = a.tickDirection = a.nameDirection = {
|
|
|
+ top: -1,
|
|
|
+ bottom: 1,
|
|
|
+ left: -1,
|
|
|
+ right: 1
|
|
|
+ }[s],
|
|
|
+ a.labelOffset = r ? p[d[s]] - p[d.onZero] : 0,
|
|
|
+ e.get("axisTick.inside") && (a.tickDirection = -a.tickDirection),
|
|
|
+ W(i.labelInside, e.get("axisLabel.inside")) && (a.labelDirection = -a.labelDirection);
|
|
|
+ var m = e.get("axisLabel.rotate");
|
|
|
+ return a.labelRotate = "top" === l ? -m : m,
|
|
|
+ a.z2 = 1,
|
|
|
+ a
|
|
|
+ }
|
|
|
+ function wv(t, e, i, n) {
|
|
|
+ var o = i.axis;
|
|
|
+ if (!o.scale.isBlank()) {
|
|
|
+ var a = i.getModel("splitArea")
|
|
|
+ , r = a.getModel("areaStyle")
|
|
|
+ , s = r.get("color")
|
|
|
+ , l = n.coordinateSystem.getRect()
|
|
|
+ , u = o.getTicksCoords({
|
|
|
+ tickModel: a,
|
|
|
+ clamp: !0
|
|
|
+ });
|
|
|
+ if (u.length) {
|
|
|
+ var h = s.length
|
|
|
+ , c = t.__splitAreaColors
|
|
|
+ , d = Q()
|
|
|
+ , f = 0;
|
|
|
+ if (c)
|
|
|
+ for (var p = 0; p < u.length; p++) {
|
|
|
+ var g = c.get(u[p].tickValue);
|
|
|
+ if (null != g) {
|
|
|
+ f = (g + (h - 1) * p) % h;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var m = o.toGlobalCoord(u[0].coord)
|
|
|
+ , v = r.getAreaStyle();
|
|
|
+ s = L(s) ? s : [s];
|
|
|
+ for (p = 1; p < u.length; p++) {
|
|
|
+ var y, x, _, w, b = o.toGlobalCoord(u[p].coord);
|
|
|
+ m = o.isHorizontal() ? (y = m,
|
|
|
+ x = l.y,
|
|
|
+ _ = b - y,
|
|
|
+ w = l.height,
|
|
|
+ y + _) : (y = l.x,
|
|
|
+ x = m,
|
|
|
+ _ = l.width,
|
|
|
+ x + (w = b - x));
|
|
|
+ var S = u[p - 1].tickValue;
|
|
|
+ null != S && d.set(S, f),
|
|
|
+ e.add(new rs({
|
|
|
+ anid: null != S ? "area_" + S : null,
|
|
|
+ shape: {
|
|
|
+ x: y,
|
|
|
+ y: x,
|
|
|
+ width: _,
|
|
|
+ height: w
|
|
|
+ },
|
|
|
+ style: D({
|
|
|
+ fill: s[f]
|
|
|
+ }, v),
|
|
|
+ silent: !0
|
|
|
+ })),
|
|
|
+ f = (f + 1) % h
|
|
|
+ }
|
|
|
+ t.__splitAreaColors = d
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function bv(t) {
|
|
|
+ t.__splitAreaColors = null
|
|
|
+ }
|
|
|
+ mv.registerAxisPointerClass = function(t, e) {
|
|
|
+ xv[t] = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mv.getAxisPointerClass = function(t) {
|
|
|
+ return t && xv[t]
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Sv = ["axisLine", "axisTickLabel", "axisName"]
|
|
|
+ , Mv = ["splitArea", "splitLine", "minorSplitLine"]
|
|
|
+ , Iv = mv.extend({
|
|
|
+ type: "cartesianAxis",
|
|
|
+ axisPointerClass: "CartesianAxisPointer",
|
|
|
+ render: function(e, t, i, n) {
|
|
|
+ this.group.removeAll();
|
|
|
+ var o = this._axisGroup;
|
|
|
+ if (this._axisGroup = new Ci,
|
|
|
+ this.group.add(this._axisGroup),
|
|
|
+ e.get("show")) {
|
|
|
+ var a = e.getCoordSysModel()
|
|
|
+ , r = _v(a, e)
|
|
|
+ , s = new Qm(e,r);
|
|
|
+ E(Sv, s.add, s),
|
|
|
+ this._axisGroup.add(s.getGroup()),
|
|
|
+ E(Mv, function(t) {
|
|
|
+ e.get(t + ".show") && this["_" + t](e, a)
|
|
|
+ }, this),
|
|
|
+ ml(o, this._axisGroup, e),
|
|
|
+ Iv.superCall(this, "render", e, t, i, n)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ bv(this)
|
|
|
+ },
|
|
|
+ _splitLine: function(t, e) {
|
|
|
+ var i = t.axis;
|
|
|
+ if (!i.scale.isBlank()) {
|
|
|
+ var n = t.getModel("splitLine")
|
|
|
+ , o = n.getModel("lineStyle")
|
|
|
+ , a = o.get("color");
|
|
|
+ a = L(a) ? a : [a];
|
|
|
+ for (var r = e.coordinateSystem.getRect(), s = i.isHorizontal(), l = 0, u = i.getTicksCoords({
|
|
|
+ tickModel: n
|
|
|
+ }), h = [], c = [], d = o.getLineStyle(), f = 0; f < u.length; f++) {
|
|
|
+ var p = i.toGlobalCoord(u[f].coord);
|
|
|
+ s ? (h[0] = p,
|
|
|
+ h[1] = r.y,
|
|
|
+ c[0] = p,
|
|
|
+ c[1] = r.y + r.height) : (h[0] = r.x,
|
|
|
+ h[1] = p,
|
|
|
+ c[0] = r.x + r.width,
|
|
|
+ c[1] = p);
|
|
|
+ var g = l++ % a.length
|
|
|
+ , m = u[f].tickValue;
|
|
|
+ this._axisGroup.add(new ls({
|
|
|
+ anid: null != m ? "line_" + u[f].tickValue : null,
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ shape: {
|
|
|
+ x1: h[0],
|
|
|
+ y1: h[1],
|
|
|
+ x2: c[0],
|
|
|
+ y2: c[1]
|
|
|
+ },
|
|
|
+ style: D({
|
|
|
+ stroke: a[g]
|
|
|
+ }, d),
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _minorSplitLine: function(t, e) {
|
|
|
+ var i = t.axis
|
|
|
+ , n = t.getModel("minorSplitLine").getModel("lineStyle")
|
|
|
+ , o = e.coordinateSystem.getRect()
|
|
|
+ , a = i.isHorizontal()
|
|
|
+ , r = i.getMinorTicksCoords();
|
|
|
+ if (r.length)
|
|
|
+ for (var s = [], l = [], u = n.getLineStyle(), h = 0; h < r.length; h++)
|
|
|
+ for (var c = 0; c < r[h].length; c++) {
|
|
|
+ var d = i.toGlobalCoord(r[h][c].coord);
|
|
|
+ a ? (s[0] = d,
|
|
|
+ s[1] = o.y,
|
|
|
+ l[0] = d,
|
|
|
+ l[1] = o.y + o.height) : (s[0] = o.x,
|
|
|
+ s[1] = d,
|
|
|
+ l[0] = o.x + o.width,
|
|
|
+ l[1] = d),
|
|
|
+ this._axisGroup.add(new ls({
|
|
|
+ anid: "minor_line_" + r[h][c].tickValue,
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ shape: {
|
|
|
+ x1: s[0],
|
|
|
+ y1: s[1],
|
|
|
+ x2: l[0],
|
|
|
+ y2: l[1]
|
|
|
+ },
|
|
|
+ style: u,
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _splitArea: function(t, e) {
|
|
|
+ wv(this, this._axisGroup, t, e)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ Iv.extend({
|
|
|
+ type: "xAxis"
|
|
|
+ }),
|
|
|
+ Iv.extend({
|
|
|
+ type: "yAxis"
|
|
|
+ }),
|
|
|
+ Af({
|
|
|
+ type: "grid",
|
|
|
+ render: function(t, e) {
|
|
|
+ this.group.removeAll(),
|
|
|
+ t.get("show") && this.group.add(new rs({
|
|
|
+ shape: t.coordinateSystem.getRect(),
|
|
|
+ style: D({
|
|
|
+ fill: t.get("backgroundColor")
|
|
|
+ }, t.getItemStyle()),
|
|
|
+ silent: !0,
|
|
|
+ z2: -1
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ yf(function(t) {
|
|
|
+ t.xAxis && t.yAxis && !t.grid && (t.grid = {})
|
|
|
+ }),
|
|
|
+ Sf(Lm("line", "circle", "line")),
|
|
|
+ bf(km("line")),
|
|
|
+ xf(Ld.PROCESSOR.STATISTIC, {
|
|
|
+ seriesType: "line",
|
|
|
+ modifyOutputEnd: !0,
|
|
|
+ reset: function(t, e, i) {
|
|
|
+ var n = t.getData()
|
|
|
+ , o = t.get("sampling")
|
|
|
+ , a = t.coordinateSystem;
|
|
|
+ if ("cartesian2d" === a.type && o) {
|
|
|
+ var r, s = a.getBaseAxis(), l = a.getOtherAxis(s), u = s.getExtent(), h = u[1] - u[0], c = Math.round(n.count() / h);
|
|
|
+ 1 < c && ("string" == typeof o ? r = Nm[o] : "function" == typeof o && (r = o),
|
|
|
+ r && t.setData(n.downSample(n.mapDimension(l.dim), 1 / c, r, Pm)))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var Tv = sc.extend({
|
|
|
+ type: "series.__base_bar__",
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return gp(this.getSource(), this, {
|
|
|
+ useEncodeDefaulter: !0
|
|
|
+ })
|
|
|
+ },
|
|
|
+ getMarkerPosition: function(t) {
|
|
|
+ var e = this.coordinateSystem;
|
|
|
+ if (e) {
|
|
|
+ var i = e.dataToPoint(e.clampData(t))
|
|
|
+ , n = this.getData()
|
|
|
+ , o = n.getLayout("offset")
|
|
|
+ , a = n.getLayout("size");
|
|
|
+ return i[e.getBaseAxis().isHorizontal() ? 0 : 1] += o + a / 2,
|
|
|
+ i
|
|
|
+ }
|
|
|
+ return [NaN, NaN]
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "cartesian2d",
|
|
|
+ legendHoverLink: !0,
|
|
|
+ barMinHeight: 0,
|
|
|
+ barMinAngle: 0,
|
|
|
+ large: !1,
|
|
|
+ largeThreshold: 400,
|
|
|
+ progressive: 3e3,
|
|
|
+ progressiveChunkMode: "mod",
|
|
|
+ itemStyle: {},
|
|
|
+ emphasis: {}
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function Av(t, e, i, n, o, a) {
|
|
|
+ el(t, e, i.getModel("label"), i.getModel("emphasis.label"), {
|
|
|
+ labelFetcher: o,
|
|
|
+ labelDataIndex: a,
|
|
|
+ defaultText: Ug(o.getData(), a),
|
|
|
+ isRectText: !0,
|
|
|
+ autoColor: n
|
|
|
+ }),
|
|
|
+ Dv(t),
|
|
|
+ Dv(e)
|
|
|
+ }
|
|
|
+ function Dv(t, e) {
|
|
|
+ "outside" === t.textPosition && (t.textPosition = e)
|
|
|
+ }
|
|
|
+ Tv.extend({
|
|
|
+ type: "series.bar",
|
|
|
+ dependencies: ["grid", "polar"],
|
|
|
+ brushSelector: "rect",
|
|
|
+ getProgressive: function() {
|
|
|
+ return !!this.get("large") && this.get("progressive")
|
|
|
+ },
|
|
|
+ getProgressiveThreshold: function() {
|
|
|
+ var t = this.get("progressiveThreshold")
|
|
|
+ , e = this.get("largeThreshold");
|
|
|
+ return t < e && (t = e),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ clip: !0,
|
|
|
+ roundCap: !1,
|
|
|
+ showBackground: !1,
|
|
|
+ backgroundStyle: {
|
|
|
+ color: "rgba(180, 180, 180, 0.2)",
|
|
|
+ borderColor: null,
|
|
|
+ borderWidth: 0,
|
|
|
+ borderType: "solid",
|
|
|
+ borderRadius: 0,
|
|
|
+ shadowBlur: 0,
|
|
|
+ shadowColor: null,
|
|
|
+ shadowOffsetX: 0,
|
|
|
+ shadowOffsetY: 0,
|
|
|
+ opacity: 1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var Cv = ha([["fill", "color"], ["stroke", "borderColor"], ["lineWidth", "borderWidth"], ["stroke", "barBorderColor"], ["lineWidth", "barBorderWidth"], ["opacity"], ["shadowBlur"], ["shadowOffsetX"], ["shadowOffsetY"], ["shadowColor"]])
|
|
|
+ , Lv = {
|
|
|
+ getBarItemStyle: function(t) {
|
|
|
+ var e = Cv(this, t);
|
|
|
+ if (this.getBorderLineDash) {
|
|
|
+ var i = this.getBorderLineDash();
|
|
|
+ i && (e.lineDash = i)
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , kv = Cs({
|
|
|
+ type: "sausage",
|
|
|
+ shape: {
|
|
|
+ cx: 0,
|
|
|
+ cy: 0,
|
|
|
+ r0: 0,
|
|
|
+ r: 0,
|
|
|
+ startAngle: 0,
|
|
|
+ endAngle: 2 * Math.PI,
|
|
|
+ clockwise: !0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.cx
|
|
|
+ , n = e.cy
|
|
|
+ , o = Math.max(e.r0 || 0, 0)
|
|
|
+ , a = Math.max(e.r, 0)
|
|
|
+ , r = .5 * (a - o)
|
|
|
+ , s = o + r
|
|
|
+ , l = e.startAngle
|
|
|
+ , u = e.endAngle
|
|
|
+ , h = e.clockwise
|
|
|
+ , c = Math.cos(l)
|
|
|
+ , d = Math.sin(l)
|
|
|
+ , f = Math.cos(u)
|
|
|
+ , p = Math.sin(u);
|
|
|
+ (h ? u - l < 2 * Math.PI : l - u < 2 * Math.PI) && (t.moveTo(c * o + i, d * o + n),
|
|
|
+ t.arc(c * s + i, d * s + n, r, -Math.PI + l, l, !h)),
|
|
|
+ t.arc(i, n, a, l, u, !h),
|
|
|
+ t.moveTo(f * a + i, p * a + n),
|
|
|
+ t.arc(f * s + i, p * s + n, r, u - 2 * Math.PI, u - Math.PI, !h),
|
|
|
+ 0 !== o && (t.arc(i, n, o, u, l, h),
|
|
|
+ t.moveTo(c * o + i, p * o + n)),
|
|
|
+ t.closePath()
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , Pv = ["itemStyle", "barBorderWidth"]
|
|
|
+ , Nv = [0, 0];
|
|
|
+ P(Cl.prototype, Lv),
|
|
|
+ Cf({
|
|
|
+ type: "bar",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ this._updateDrawMode(t);
|
|
|
+ var n = t.get("coordinateSystem");
|
|
|
+ return "cartesian2d" !== n && "polar" !== n || (this._isLargeDraw ? this._renderLarge(t, e, i) : this._renderNormal(t, e, i)),
|
|
|
+ this.group
|
|
|
+ },
|
|
|
+ incrementalPrepareRender: function(t, e, i) {
|
|
|
+ this._clear(),
|
|
|
+ this._updateDrawMode(t)
|
|
|
+ },
|
|
|
+ incrementalRender: function(t, e, i, n) {
|
|
|
+ this._incrementalRenderLarge(t, e)
|
|
|
+ },
|
|
|
+ _updateDrawMode: function(t) {
|
|
|
+ var e = t.pipelineContext.large;
|
|
|
+ (null == this._isLargeDraw || e ^ this._isLargeDraw) && (this._isLargeDraw = e,
|
|
|
+ this._clear())
|
|
|
+ },
|
|
|
+ _renderNormal: function(s, t, e) {
|
|
|
+ var l, u = this.group, h = s.getData(), c = this._data, d = s.coordinateSystem, i = d.getBaseAxis();
|
|
|
+ "cartesian2d" === d.type ? l = i.isHorizontal() : "polar" === d.type && (l = "angle" === i.dim);
|
|
|
+ var f = s.isAnimationEnabled() ? s : null
|
|
|
+ , p = s.get("clip", !0)
|
|
|
+ , g = function(t, e) {
|
|
|
+ var i = t.getArea && t.getArea();
|
|
|
+ if ("cartesian2d" === t.type) {
|
|
|
+ var n = t.getBaseAxis();
|
|
|
+ if ("category" !== n.type || !n.onBand) {
|
|
|
+ var o = e.getLayout("bandWidth");
|
|
|
+ n.isHorizontal() ? (i.x -= o,
|
|
|
+ i.width += 2 * o) : (i.y -= o,
|
|
|
+ i.height += 2 * o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }(d, h);
|
|
|
+ u.removeClipPath();
|
|
|
+ var m = s.get("roundCap", !0)
|
|
|
+ , v = s.get("showBackground", !0)
|
|
|
+ , y = s.getModel("backgroundStyle")
|
|
|
+ , x = y.get("barBorderRadius") || 0
|
|
|
+ , _ = []
|
|
|
+ , w = this._backgroundEls || [];
|
|
|
+ h.diff(c).add(function(t) {
|
|
|
+ var e = h.getItemModel(t)
|
|
|
+ , i = Gv[d.type](h, t, e);
|
|
|
+ if (v) {
|
|
|
+ var n = Gv[d.type](h, t)
|
|
|
+ , o = function(t, e, i) {
|
|
|
+ return new ("polar" === t.type ? qr : rs)({
|
|
|
+ shape: Xv(e, i, t),
|
|
|
+ silent: !0,
|
|
|
+ z2: 0
|
|
|
+ })
|
|
|
+ }(d, l, n);
|
|
|
+ o.useStyle(y.getBarItemStyle()),
|
|
|
+ "cartesian2d" === d.type && o.setShape("r", x),
|
|
|
+ _[t] = o
|
|
|
+ }
|
|
|
+ if (h.hasValue(t)) {
|
|
|
+ if (p)
|
|
|
+ if (Rv[d.type](g, i))
|
|
|
+ return void u.remove(a);
|
|
|
+ var a = zv[d.type](t, i, l, f, !1, m);
|
|
|
+ h.setItemGraphicEl(t, a),
|
|
|
+ u.add(a),
|
|
|
+ Wv(a, h, t, e, i, s, l, "polar" === d.type)
|
|
|
+ }
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = h.getItemModel(t)
|
|
|
+ , n = Gv[d.type](h, t, i);
|
|
|
+ if (v) {
|
|
|
+ var o = w[e];
|
|
|
+ o.useStyle(y.getBarItemStyle()),
|
|
|
+ "cartesian2d" === d.type && o.setShape("r", x),
|
|
|
+ _[t] = o;
|
|
|
+ var a = Gv[d.type](h, t);
|
|
|
+ cl(o, {
|
|
|
+ shape: Xv(l, a, d)
|
|
|
+ }, f, t)
|
|
|
+ }
|
|
|
+ var r = c.getItemGraphicEl(e);
|
|
|
+ if (h.hasValue(t)) {
|
|
|
+ if (p)
|
|
|
+ if (Rv[d.type](g, n))
|
|
|
+ return void u.remove(r);
|
|
|
+ r ? cl(r, {
|
|
|
+ shape: n
|
|
|
+ }, f, t) : r = zv[d.type](t, n, l, f, !0, m),
|
|
|
+ h.setItemGraphicEl(t, r),
|
|
|
+ u.add(r),
|
|
|
+ Wv(r, h, t, i, n, s, l, "polar" === d.type)
|
|
|
+ } else
|
|
|
+ u.remove(r)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = c.getItemGraphicEl(t);
|
|
|
+ "cartesian2d" === d.type ? e && Bv(t, f, e) : e && Vv(t, f, e)
|
|
|
+ }).execute();
|
|
|
+ var n = this._backgroundGroup || (this._backgroundGroup = new Ci);
|
|
|
+ n.removeAll();
|
|
|
+ for (var o = 0; o < _.length; ++o)
|
|
|
+ n.add(_[o]);
|
|
|
+ u.add(n),
|
|
|
+ this._backgroundEls = _,
|
|
|
+ this._data = h
|
|
|
+ },
|
|
|
+ _renderLarge: function(t, e, i) {
|
|
|
+ this._clear(),
|
|
|
+ Zv(t, this.group);
|
|
|
+ var n = t.get("clip", !0) ? Sm(t.coordinateSystem, !1, t) : null;
|
|
|
+ n ? this.group.setClipPath(n) : this.group.removeClipPath()
|
|
|
+ },
|
|
|
+ _incrementalRenderLarge: function(t, e) {
|
|
|
+ this._removeBackground(),
|
|
|
+ Zv(e, this.group, !0)
|
|
|
+ },
|
|
|
+ dispose: et,
|
|
|
+ remove: function(t) {
|
|
|
+ this._clear(t)
|
|
|
+ },
|
|
|
+ _clear: function(e) {
|
|
|
+ var t = this.group
|
|
|
+ , i = this._data;
|
|
|
+ e && e.get("animation") && i && !this._isLargeDraw ? (this._removeBackground(),
|
|
|
+ this._backgroundEls = [],
|
|
|
+ i.eachItemGraphicEl(function(t) {
|
|
|
+ "sector" === t.type ? Vv(t.dataIndex, e, t) : Bv(t.dataIndex, e, t)
|
|
|
+ })) : t.removeAll(),
|
|
|
+ this._data = null
|
|
|
+ },
|
|
|
+ _removeBackground: function() {
|
|
|
+ this.group.remove(this._backgroundGroup),
|
|
|
+ this._backgroundGroup = null
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var Ov = Math.max
|
|
|
+ , Ev = Math.min
|
|
|
+ , Rv = {
|
|
|
+ cartesian2d: function(t, e) {
|
|
|
+ var i = e.width < 0 ? -1 : 1
|
|
|
+ , n = e.height < 0 ? -1 : 1;
|
|
|
+ i < 0 && (e.x += e.width,
|
|
|
+ e.width = -e.width),
|
|
|
+ n < 0 && (e.y += e.height,
|
|
|
+ e.height = -e.height);
|
|
|
+ var o = Ov(e.x, t.x)
|
|
|
+ , a = Ev(e.x + e.width, t.x + t.width)
|
|
|
+ , r = Ov(e.y, t.y)
|
|
|
+ , s = Ev(e.y + e.height, t.y + t.height);
|
|
|
+ e.x = o,
|
|
|
+ e.y = r,
|
|
|
+ e.width = a - o,
|
|
|
+ e.height = s - r;
|
|
|
+ var l = e.width < 0 || e.height < 0;
|
|
|
+ return i < 0 && (e.x += e.width,
|
|
|
+ e.width = -e.width),
|
|
|
+ n < 0 && (e.y += e.height,
|
|
|
+ e.height = -e.height),
|
|
|
+ l
|
|
|
+ },
|
|
|
+ polar: function(t) {
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , zv = {
|
|
|
+ cartesian2d: function(t, e, i, n, o) {
|
|
|
+ var a = new rs({
|
|
|
+ shape: P({}, e),
|
|
|
+ z2: 1
|
|
|
+ });
|
|
|
+ if (a.name = "item",
|
|
|
+ n) {
|
|
|
+ var r = i ? "height" : "width"
|
|
|
+ , s = {};
|
|
|
+ a.shape[r] = 0,
|
|
|
+ s[r] = e[r],
|
|
|
+ bl[o ? "updateProps" : "initProps"](a, {
|
|
|
+ shape: s
|
|
|
+ }, n, t)
|
|
|
+ }
|
|
|
+ return a
|
|
|
+ },
|
|
|
+ polar: function(t, e, i, n, o, a) {
|
|
|
+ var r = e.startAngle < e.endAngle
|
|
|
+ , s = new (!i && a ? kv : qr)({
|
|
|
+ shape: D({
|
|
|
+ clockwise: r
|
|
|
+ }, e),
|
|
|
+ z2: 1
|
|
|
+ });
|
|
|
+ if (s.name = "item",
|
|
|
+ n) {
|
|
|
+ var l = i ? "r" : "endAngle"
|
|
|
+ , u = {};
|
|
|
+ s.shape[l] = i ? 0 : e.startAngle,
|
|
|
+ u[l] = e[l],
|
|
|
+ bl[o ? "updateProps" : "initProps"](s, {
|
|
|
+ shape: u
|
|
|
+ }, n, t)
|
|
|
+ }
|
|
|
+ return s
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Bv(t, e, i) {
|
|
|
+ i.style.text = null,
|
|
|
+ cl(i, {
|
|
|
+ shape: {
|
|
|
+ width: 0
|
|
|
+ }
|
|
|
+ }, e, t, function() {
|
|
|
+ i.parent && i.parent.remove(i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Vv(t, e, i) {
|
|
|
+ i.style.text = null,
|
|
|
+ cl(i, {
|
|
|
+ shape: {
|
|
|
+ r: i.shape.r0
|
|
|
+ }
|
|
|
+ }, e, t, function() {
|
|
|
+ i.parent && i.parent.remove(i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var Gv = {
|
|
|
+ cartesian2d: function(t, e, i) {
|
|
|
+ var n = t.getItemLayout(e)
|
|
|
+ , o = i ? function(t, e) {
|
|
|
+ var i = t.get(Pv) || 0
|
|
|
+ , n = isNaN(e.width) ? Number.MAX_VALUE : Math.abs(e.width)
|
|
|
+ , o = isNaN(e.height) ? Number.MAX_VALUE : Math.abs(e.height);
|
|
|
+ return Math.min(i, n, o)
|
|
|
+ }(i, n) : 0
|
|
|
+ , a = 0 < n.width ? 1 : -1
|
|
|
+ , r = 0 < n.height ? 1 : -1;
|
|
|
+ return {
|
|
|
+ x: n.x + a * o / 2,
|
|
|
+ y: n.y + r * o / 2,
|
|
|
+ width: n.width - a * o,
|
|
|
+ height: n.height - r * o
|
|
|
+ }
|
|
|
+ },
|
|
|
+ polar: function(t, e, i) {
|
|
|
+ var n = t.getItemLayout(e);
|
|
|
+ return {
|
|
|
+ cx: n.cx,
|
|
|
+ cy: n.cy,
|
|
|
+ r0: n.r0,
|
|
|
+ r: n.r,
|
|
|
+ startAngle: n.startAngle,
|
|
|
+ endAngle: n.endAngle
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Fv(t) {
|
|
|
+ return null != t.startAngle && null != t.endAngle && t.startAngle === t.endAngle
|
|
|
+ }
|
|
|
+ function Wv(t, e, i, n, o, a, r, s) {
|
|
|
+ var l = e.getItemVisual(i, "color")
|
|
|
+ , u = e.getItemVisual(i, "opacity")
|
|
|
+ , h = e.getVisual("borderColor")
|
|
|
+ , c = n.getModel("itemStyle")
|
|
|
+ , d = n.getModel("emphasis.itemStyle").getBarItemStyle();
|
|
|
+ s || t.setShape("r", c.get("barBorderRadius") || 0),
|
|
|
+ t.useStyle(D({
|
|
|
+ stroke: Fv(o) ? "none" : h,
|
|
|
+ fill: Fv(o) ? "none" : l,
|
|
|
+ opacity: u
|
|
|
+ }, c.getBarItemStyle()));
|
|
|
+ var f = n.getShallow("cursor");
|
|
|
+ f && t.attr("cursor", f);
|
|
|
+ r ? o.height : o.width;
|
|
|
+ s || Av(t.style, d, n, l, a, i),
|
|
|
+ Fv(o) && (d.fill = d.stroke = "none"),
|
|
|
+ $s(t, d)
|
|
|
+ }
|
|
|
+ var Hv = Ar.extend({
|
|
|
+ type: "largeBar",
|
|
|
+ shape: {
|
|
|
+ points: []
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ for (var i = e.points, n = this.__startPoint, o = this.__baseDimIdx, a = 0; a < i.length; a += 2)
|
|
|
+ n[o] = i[a + o],
|
|
|
+ t.moveTo(n[0], n[1]),
|
|
|
+ t.lineTo(i[a], i[a + 1])
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function Zv(t, e, i) {
|
|
|
+ var n = t.getData()
|
|
|
+ , o = []
|
|
|
+ , a = n.getLayout("valueAxisHorizontal") ? 1 : 0;
|
|
|
+ o[1 - a] = n.getLayout("valueAxisStart");
|
|
|
+ var r = n.getLayout("largeDataIndices")
|
|
|
+ , s = n.getLayout("barWidth")
|
|
|
+ , l = t.getModel("backgroundStyle");
|
|
|
+ if (t.get("showBackground", !0)) {
|
|
|
+ var u = n.getLayout("largeBackgroundPoints")
|
|
|
+ , h = [];
|
|
|
+ h[1 - a] = n.getLayout("backgroundStart");
|
|
|
+ var c = new Hv({
|
|
|
+ shape: {
|
|
|
+ points: u
|
|
|
+ },
|
|
|
+ incremental: !!i,
|
|
|
+ __startPoint: h,
|
|
|
+ __baseDimIdx: a,
|
|
|
+ __largeDataIndices: r,
|
|
|
+ __barWidth: s,
|
|
|
+ silent: !0,
|
|
|
+ z2: 0
|
|
|
+ });
|
|
|
+ !function(t, e, i) {
|
|
|
+ var n = e.get("borderColor") || e.get("color")
|
|
|
+ , o = e.getItemStyle(["color", "borderColor"]);
|
|
|
+ t.useStyle(o),
|
|
|
+ t.style.fill = null,
|
|
|
+ t.style.stroke = n,
|
|
|
+ t.style.lineWidth = i.getLayout("barWidth")
|
|
|
+ }(c, l, n),
|
|
|
+ e.add(c)
|
|
|
+ }
|
|
|
+ var d = new Hv({
|
|
|
+ shape: {
|
|
|
+ points: n.getLayout("largePoints")
|
|
|
+ },
|
|
|
+ incremental: !!i,
|
|
|
+ __startPoint: o,
|
|
|
+ __baseDimIdx: a,
|
|
|
+ __largeDataIndices: r,
|
|
|
+ __barWidth: s
|
|
|
+ });
|
|
|
+ e.add(d),
|
|
|
+ function(t, e, i) {
|
|
|
+ var n = i.getVisual("borderColor") || i.getVisual("color")
|
|
|
+ , o = e.getModel("itemStyle").getItemStyle(["color", "borderColor"]);
|
|
|
+ t.useStyle(o),
|
|
|
+ t.style.fill = null,
|
|
|
+ t.style.stroke = n,
|
|
|
+ t.style.lineWidth = i.getLayout("barWidth")
|
|
|
+ }(d, t, n),
|
|
|
+ d.seriesIndex = t.seriesIndex,
|
|
|
+ t.get("silent") || (d.on("mousedown", Uv),
|
|
|
+ d.on("mousemove", Uv))
|
|
|
+ }
|
|
|
+ var Uv = Lc(function(t) {
|
|
|
+ var e = function(t, e, i) {
|
|
|
+ var n = t.__baseDimIdx
|
|
|
+ , o = 1 - n
|
|
|
+ , a = t.shape.points
|
|
|
+ , r = t.__largeDataIndices
|
|
|
+ , s = Math.abs(t.__barWidth / 2)
|
|
|
+ , l = t.__startPoint[o];
|
|
|
+ Nv[0] = e,
|
|
|
+ Nv[1] = i;
|
|
|
+ for (var u = Nv[n], h = Nv[1 - n], c = u - s, d = u + s, f = 0, p = a.length / 2; f < p; f++) {
|
|
|
+ var g = 2 * f
|
|
|
+ , m = a[g + n]
|
|
|
+ , v = a[g + o];
|
|
|
+ if (c <= m && m <= d && (l <= v ? l <= h && h <= v : v <= h && h <= l))
|
|
|
+ return r[f]
|
|
|
+ }
|
|
|
+ return -1
|
|
|
+ }(this, t.offsetX, t.offsetY);
|
|
|
+ this.dataIndex = 0 <= e ? e : null
|
|
|
+ }, 30, !1);
|
|
|
+ function Xv(t, e, i) {
|
|
|
+ var n, o = "polar" === i.type;
|
|
|
+ return n = o ? i.getArea() : i.grid.getRect(),
|
|
|
+ o ? {
|
|
|
+ cx: n.cx,
|
|
|
+ cy: n.cy,
|
|
|
+ r0: t ? n.r0 : e.r0,
|
|
|
+ r: t ? n.r : e.r,
|
|
|
+ startAngle: t ? e.startAngle : 0,
|
|
|
+ endAngle: t ? e.endAngle : 2 * Math.PI
|
|
|
+ } : {
|
|
|
+ x: t ? e.x : n.x,
|
|
|
+ y: t ? n.y : e.y,
|
|
|
+ width: t ? e.width : n.width,
|
|
|
+ height: t ? n.height : e.height
|
|
|
+ }
|
|
|
+ }
|
|
|
+ bf(Ld.VISUAL.LAYOUT, T(zp, "bar")),
|
|
|
+ bf(Ld.VISUAL.PROGRESSIVE_LAYOUT, Bp),
|
|
|
+ Sf({
|
|
|
+ seriesType: "bar",
|
|
|
+ reset: function(t) {
|
|
|
+ t.getData().setVisual("legendSymbol", "roundRect")
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function Yv(t, e, i) {
|
|
|
+ e = L(e) && {
|
|
|
+ coordDimensions: e
|
|
|
+ } || P({}, e);
|
|
|
+ var n = t.getSource()
|
|
|
+ , o = lp(n, e)
|
|
|
+ , a = new Yf(o,t);
|
|
|
+ return a.initData(n, i),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ var jv = {
|
|
|
+ updateSelectedMap: function(t) {
|
|
|
+ this._targetList = L(t) ? t.slice() : [],
|
|
|
+ this._selectTargetMap = S(t || [], function(t, e) {
|
|
|
+ return t.set(e.name, e),
|
|
|
+ t
|
|
|
+ }, Q())
|
|
|
+ },
|
|
|
+ select: function(t, e) {
|
|
|
+ var i = null != e ? this._targetList[e] : this._selectTargetMap.get(t);
|
|
|
+ "single" === this.get("selectedMode") && this._selectTargetMap.each(function(t) {
|
|
|
+ t.selected = !1
|
|
|
+ }),
|
|
|
+ i && (i.selected = !0)
|
|
|
+ },
|
|
|
+ unSelect: function(t, e) {
|
|
|
+ var i = null != e ? this._targetList[e] : this._selectTargetMap.get(t);
|
|
|
+ i && (i.selected = !1)
|
|
|
+ },
|
|
|
+ toggleSelected: function(t, e) {
|
|
|
+ var i = null != e ? this._targetList[e] : this._selectTargetMap.get(t);
|
|
|
+ if (null != i)
|
|
|
+ return this[i.selected ? "unSelect" : "select"](t, e),
|
|
|
+ i.selected
|
|
|
+ },
|
|
|
+ isSelected: function(t, e) {
|
|
|
+ var i = null != e ? this._targetList[e] : this._selectTargetMap.get(t);
|
|
|
+ return i && i.selected
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function qv(i, e) {
|
|
|
+ this.getAllNames = function() {
|
|
|
+ var t = e();
|
|
|
+ return t.mapArray(t.getName)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.containName = function(t) {
|
|
|
+ return 0 <= e().indexOfName(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.indexOfName = function(t) {
|
|
|
+ return i().indexOfName(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.getItemVisual = function(t, e) {
|
|
|
+ return i().getItemVisual(t, e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Kv = Df({
|
|
|
+ type: "series.pie",
|
|
|
+ init: function(t) {
|
|
|
+ Kv.superApply(this, "init", arguments),
|
|
|
+ this.legendVisualProvider = new qv(A(this.getData, this),A(this.getRawData, this)),
|
|
|
+ this.updateSelectedMap(this._createSelectableList()),
|
|
|
+ this._defaultLabelLine(t)
|
|
|
+ },
|
|
|
+ mergeOption: function(t) {
|
|
|
+ Kv.superCall(this, "mergeOption", t),
|
|
|
+ this.updateSelectedMap(this._createSelectableList())
|
|
|
+ },
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return Yv(this, {
|
|
|
+ coordDimensions: ["value"],
|
|
|
+ encodeDefaulter: T(Ju, this)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _createSelectableList: function() {
|
|
|
+ for (var t = this.getRawData(), e = t.mapDimension("value"), i = [], n = 0, o = t.count(); n < o; n++)
|
|
|
+ i.push({
|
|
|
+ name: t.getName(n),
|
|
|
+ value: t.get(e, n),
|
|
|
+ selected: Zh(t, n, "selected")
|
|
|
+ });
|
|
|
+ return i
|
|
|
+ },
|
|
|
+ getDataParams: function(t) {
|
|
|
+ var e = this.getData()
|
|
|
+ , i = Kv.superCall(this, "getDataParams", t)
|
|
|
+ , n = [];
|
|
|
+ return e.each(e.mapDimension("value"), function(t) {
|
|
|
+ n.push(t)
|
|
|
+ }),
|
|
|
+ i.percent = Wl(n, t, e.hostModel.get("percentPrecision")),
|
|
|
+ i.$vars.push("percent"),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ _defaultLabelLine: function(t) {
|
|
|
+ Go(t, "labelLine", ["show"]);
|
|
|
+ var e = t.labelLine
|
|
|
+ , i = t.emphasis.labelLine;
|
|
|
+ e.show = e.show && t.label.show,
|
|
|
+ i.show = i.show && t.emphasis.label.show
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ legendHoverLink: !0,
|
|
|
+ hoverAnimation: !0,
|
|
|
+ center: ["50%", "50%"],
|
|
|
+ radius: [0, "75%"],
|
|
|
+ clockwise: !0,
|
|
|
+ startAngle: 90,
|
|
|
+ minAngle: 0,
|
|
|
+ minShowLabelAngle: 0,
|
|
|
+ selectedOffset: 10,
|
|
|
+ hoverOffset: 10,
|
|
|
+ avoidLabelOverlap: !0,
|
|
|
+ percentPrecision: 2,
|
|
|
+ stillShowZeroSum: !0,
|
|
|
+ left: 0,
|
|
|
+ top: 0,
|
|
|
+ right: 0,
|
|
|
+ bottom: 0,
|
|
|
+ width: null,
|
|
|
+ height: null,
|
|
|
+ label: {
|
|
|
+ rotate: !1,
|
|
|
+ show: !0,
|
|
|
+ position: "outer",
|
|
|
+ alignTo: "none",
|
|
|
+ margin: "25%",
|
|
|
+ bleedMargin: 10,
|
|
|
+ distanceToLabelLine: 5
|
|
|
+ },
|
|
|
+ labelLine: {
|
|
|
+ show: !0,
|
|
|
+ length: 15,
|
|
|
+ length2: 15,
|
|
|
+ smooth: !1,
|
|
|
+ lineStyle: {
|
|
|
+ width: 1,
|
|
|
+ type: "solid"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: 1
|
|
|
+ },
|
|
|
+ animationType: "expansion",
|
|
|
+ animationTypeUpdate: "transition",
|
|
|
+ animationEasing: "cubicOut"
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function $v(t, e, i, n) {
|
|
|
+ var o = e.getData()
|
|
|
+ , a = this.dataIndex
|
|
|
+ , r = o.getName(a)
|
|
|
+ , s = e.get("selectedOffset");
|
|
|
+ n.dispatchAction({
|
|
|
+ type: "pieToggleSelect",
|
|
|
+ from: t,
|
|
|
+ name: r,
|
|
|
+ seriesId: e.id
|
|
|
+ }),
|
|
|
+ o.each(function(t) {
|
|
|
+ Jv(o.getItemGraphicEl(t), o.getItemLayout(t), e.isSelected(o.getName(t)), s, i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Jv(t, e, i, n, o) {
|
|
|
+ var a = (e.startAngle + e.endAngle) / 2
|
|
|
+ , r = i ? n : 0
|
|
|
+ , s = [Math.cos(a) * r, Math.sin(a) * r];
|
|
|
+ o ? t.animate().when(200, {
|
|
|
+ position: s
|
|
|
+ }).start("bounceOut") : t.attr("position", s)
|
|
|
+ }
|
|
|
+ function Qv(t, e) {
|
|
|
+ Ci.call(this);
|
|
|
+ var i = new qr({
|
|
|
+ z2: 2
|
|
|
+ })
|
|
|
+ , n = new ts
|
|
|
+ , o = new Ur;
|
|
|
+ this.add(i),
|
|
|
+ this.add(n),
|
|
|
+ this.add(o),
|
|
|
+ this.updateData(t, e, !0)
|
|
|
+ }
|
|
|
+ b(Kv, jv);
|
|
|
+ var ty = Qv.prototype;
|
|
|
+ ty.updateData = function(t, e, i) {
|
|
|
+ var n = this.childAt(0)
|
|
|
+ , o = this.childAt(1)
|
|
|
+ , a = this.childAt(2)
|
|
|
+ , r = t.hostModel
|
|
|
+ , s = t.getItemModel(e)
|
|
|
+ , l = t.getItemLayout(e)
|
|
|
+ , u = P({}, l);
|
|
|
+ u.label = null;
|
|
|
+ var h = r.getShallow("animationTypeUpdate");
|
|
|
+ i ? (n.setShape(u),
|
|
|
+ "scale" === r.getShallow("animationType") ? (n.shape.r = l.r0,
|
|
|
+ dl(n, {
|
|
|
+ shape: {
|
|
|
+ r: l.r
|
|
|
+ }
|
|
|
+ }, r, e)) : (n.shape.endAngle = l.startAngle,
|
|
|
+ cl(n, {
|
|
|
+ shape: {
|
|
|
+ endAngle: l.endAngle
|
|
|
+ }
|
|
|
+ }, r, e))) : "expansion" === h ? n.setShape(u) : cl(n, {
|
|
|
+ shape: u
|
|
|
+ }, r, e);
|
|
|
+ var c = t.getItemVisual(e, "color");
|
|
|
+ n.useStyle(D({
|
|
|
+ lineJoin: "bevel",
|
|
|
+ fill: c
|
|
|
+ }, s.getModel("itemStyle").getItemStyle())),
|
|
|
+ n.hoverStyle = s.getModel("emphasis.itemStyle").getItemStyle();
|
|
|
+ var d = s.getShallow("cursor");
|
|
|
+ d && n.attr("cursor", d),
|
|
|
+ Jv(this, t.getItemLayout(e), r.isSelected(t.getName(e)), r.get("selectedOffset"), r.get("animation"));
|
|
|
+ var f = !i && "transition" === h;
|
|
|
+ this._updateLabel(t, e, f),
|
|
|
+ this.highDownOnUpdate = r.get("silent") ? null : function(t, e) {
|
|
|
+ var i = r.isAnimationEnabled() && s.get("hoverAnimation");
|
|
|
+ "emphasis" === e ? (o.ignore = o.hoverIgnore,
|
|
|
+ a.ignore = a.hoverIgnore,
|
|
|
+ i && (n.stopAnimation(!0),
|
|
|
+ n.animateTo({
|
|
|
+ shape: {
|
|
|
+ r: l.r + r.get("hoverOffset")
|
|
|
+ }
|
|
|
+ }, 300, "elasticOut"))) : (o.ignore = o.normalIgnore,
|
|
|
+ a.ignore = a.normalIgnore,
|
|
|
+ i && (n.stopAnimation(!0),
|
|
|
+ n.animateTo({
|
|
|
+ shape: {
|
|
|
+ r: l.r
|
|
|
+ }
|
|
|
+ }, 300, "elasticOut")))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ $s(this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ ty._updateLabel = function(t, e, i) {
|
|
|
+ var n = this.childAt(1)
|
|
|
+ , o = this.childAt(2)
|
|
|
+ , a = t.hostModel
|
|
|
+ , r = t.getItemModel(e)
|
|
|
+ , s = t.getItemLayout(e).label
|
|
|
+ , l = t.getItemVisual(e, "color");
|
|
|
+ if (!s || isNaN(s.x) || isNaN(s.y))
|
|
|
+ o.ignore = o.normalIgnore = o.hoverIgnore = n.ignore = n.normalIgnore = n.hoverIgnore = !0;
|
|
|
+ else {
|
|
|
+ var u = {
|
|
|
+ points: s.linePoints || [[s.x, s.y], [s.x, s.y], [s.x, s.y]]
|
|
|
+ }
|
|
|
+ , h = {
|
|
|
+ x: s.x,
|
|
|
+ y: s.y
|
|
|
+ };
|
|
|
+ i ? (cl(n, {
|
|
|
+ shape: u
|
|
|
+ }, a, e),
|
|
|
+ cl(o, {
|
|
|
+ style: h
|
|
|
+ }, a, e)) : (n.attr({
|
|
|
+ shape: u
|
|
|
+ }),
|
|
|
+ o.attr({
|
|
|
+ style: h
|
|
|
+ })),
|
|
|
+ o.attr({
|
|
|
+ rotation: s.rotation,
|
|
|
+ origin: [s.x, s.y],
|
|
|
+ z2: 10
|
|
|
+ });
|
|
|
+ var c = r.getModel("label")
|
|
|
+ , d = r.getModel("emphasis.label")
|
|
|
+ , f = r.getModel("labelLine")
|
|
|
+ , p = r.getModel("emphasis.labelLine");
|
|
|
+ l = t.getItemVisual(e, "color");
|
|
|
+ el(o.style, o.hoverStyle = {}, c, d, {
|
|
|
+ labelFetcher: t.hostModel,
|
|
|
+ labelDataIndex: e,
|
|
|
+ defaultText: s.text,
|
|
|
+ autoColor: l,
|
|
|
+ useInsideStyle: !!s.inside
|
|
|
+ }, {
|
|
|
+ textAlign: s.textAlign,
|
|
|
+ textVerticalAlign: s.verticalAlign,
|
|
|
+ opacity: t.getItemVisual(e, "opacity")
|
|
|
+ }),
|
|
|
+ o.ignore = o.normalIgnore = !c.get("show"),
|
|
|
+ o.hoverIgnore = !d.get("show"),
|
|
|
+ n.ignore = n.normalIgnore = !f.get("show"),
|
|
|
+ n.hoverIgnore = !p.get("show"),
|
|
|
+ n.setStyle({
|
|
|
+ stroke: l,
|
|
|
+ opacity: t.getItemVisual(e, "opacity")
|
|
|
+ }),
|
|
|
+ n.setStyle(f.getModel("lineStyle").getLineStyle()),
|
|
|
+ n.hoverStyle = p.getModel("lineStyle").getLineStyle();
|
|
|
+ var g = f.get("smooth");
|
|
|
+ g && !0 === g && (g = .4),
|
|
|
+ n.setShape({
|
|
|
+ smooth: g
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(Qv, Ci);
|
|
|
+ function ey(i, t) {
|
|
|
+ E(t, function(a) {
|
|
|
+ a.update = "updateView",
|
|
|
+ _f(a, function(t, e) {
|
|
|
+ var o = {};
|
|
|
+ return e.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: i,
|
|
|
+ query: t
|
|
|
+ }, function(i) {
|
|
|
+ i[a.method] && i[a.method](t.name, t.dataIndex);
|
|
|
+ var n = i.getData();
|
|
|
+ n.each(function(t) {
|
|
|
+ var e = n.getName(t);
|
|
|
+ o[e] = i.isSelected(e) || !1
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ name: t.name,
|
|
|
+ selected: o,
|
|
|
+ seriesId: t.seriesId
|
|
|
+ }
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function iy(n) {
|
|
|
+ return {
|
|
|
+ getTargetSeries: function(t) {
|
|
|
+ var e = {}
|
|
|
+ , i = Q();
|
|
|
+ return t.eachSeriesByType(n, function(t) {
|
|
|
+ t.__paletteScope = e,
|
|
|
+ i.set(t.uid, t)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ reset: function(s, t) {
|
|
|
+ var l = s.getRawData()
|
|
|
+ , u = {}
|
|
|
+ , h = s.getData();
|
|
|
+ h.each(function(t) {
|
|
|
+ var e = h.getRawIndex(t);
|
|
|
+ u[e] = t
|
|
|
+ }),
|
|
|
+ l.each(function(t) {
|
|
|
+ var e, i = u[t], n = null != i && h.getItemVisual(i, "color", !0), o = null != i && h.getItemVisual(i, "borderColor", !0);
|
|
|
+ if (n && o || (e = l.getItemModel(t)),
|
|
|
+ !n) {
|
|
|
+ var a = e.get("itemStyle.color") || s.getColorFromPalette(l.getName(t) || t + "", s.__paletteScope, l.count());
|
|
|
+ null != i && h.setItemVisual(i, "color", a)
|
|
|
+ }
|
|
|
+ if (!o) {
|
|
|
+ var r = e.get("itemStyle.borderColor");
|
|
|
+ null != i && h.setItemVisual(i, "borderColor", r)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _c.extend({
|
|
|
+ type: "pie",
|
|
|
+ init: function() {
|
|
|
+ var t = new Ci;
|
|
|
+ this._sectorGroup = t
|
|
|
+ },
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ if (!n || n.from !== this.uid) {
|
|
|
+ var o = t.getData()
|
|
|
+ , a = this._data
|
|
|
+ , r = this.group
|
|
|
+ , s = e.get("animation")
|
|
|
+ , l = !a
|
|
|
+ , u = t.get("animationType")
|
|
|
+ , h = t.get("animationTypeUpdate")
|
|
|
+ , c = T($v, this.uid, t, s, i)
|
|
|
+ , d = t.get("selectedMode");
|
|
|
+ if (o.diff(a).add(function(t) {
|
|
|
+ var e = new Qv(o,t);
|
|
|
+ l && "scale" !== u && e.eachChild(function(t) {
|
|
|
+ t.stopAnimation(!0)
|
|
|
+ }),
|
|
|
+ d && e.on("click", c),
|
|
|
+ o.setItemGraphicEl(t, e),
|
|
|
+ r.add(e)
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = a.getItemGraphicEl(e);
|
|
|
+ l || "transition" === h || i.eachChild(function(t) {
|
|
|
+ t.stopAnimation(!0)
|
|
|
+ }),
|
|
|
+ i.updateData(o, t),
|
|
|
+ i.off("click"),
|
|
|
+ d && i.on("click", c),
|
|
|
+ r.add(i),
|
|
|
+ o.setItemGraphicEl(t, i)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = a.getItemGraphicEl(t);
|
|
|
+ r.remove(e)
|
|
|
+ }).execute(),
|
|
|
+ s && 0 < o.count() && (l ? "scale" !== u : "transition" !== h)) {
|
|
|
+ for (var f = o.getItemLayout(0), p = 1; isNaN(f.startAngle) && p < o.count(); ++p)
|
|
|
+ f = o.getItemLayout(p);
|
|
|
+ var g = Math.max(i.getWidth(), i.getHeight()) / 2
|
|
|
+ , m = A(r.removeClipPath, r);
|
|
|
+ r.setClipPath(this._createClipPath(f.cx, f.cy, g, f.startAngle, f.clockwise, m, t, l))
|
|
|
+ } else
|
|
|
+ r.removeClipPath();
|
|
|
+ this._data = o
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dispose: function() {},
|
|
|
+ _createClipPath: function(t, e, i, n, o, a, r, s) {
|
|
|
+ var l = new qr({
|
|
|
+ shape: {
|
|
|
+ cx: t,
|
|
|
+ cy: e,
|
|
|
+ r0: 0,
|
|
|
+ r: i,
|
|
|
+ startAngle: n,
|
|
|
+ endAngle: n,
|
|
|
+ clockwise: o
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return (s ? dl : cl)(l, {
|
|
|
+ shape: {
|
|
|
+ endAngle: n + (o ? 1 : -1) * Math.PI * 2
|
|
|
+ }
|
|
|
+ }, r, a),
|
|
|
+ l
|
|
|
+ },
|
|
|
+ containPoint: function(t, e) {
|
|
|
+ var i = e.getData().getItemLayout(0);
|
|
|
+ if (i) {
|
|
|
+ var n = t[0] - i.cx
|
|
|
+ , o = t[1] - i.cy
|
|
|
+ , a = Math.sqrt(n * n + o * o);
|
|
|
+ return a <= i.r && a >= i.r0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var ny = Math.PI / 180;
|
|
|
+ function oy(o, t, e, i, n, a, r, s, l, u) {
|
|
|
+ function h(t, e, i) {
|
|
|
+ for (var n = t; n < e && !(o[n].y + i > l + r); n++)
|
|
|
+ if (o[n].y += i,
|
|
|
+ t < n && n + 1 < e && o[n + 1].y > o[n].y + o[n].height)
|
|
|
+ return void c(n, i / 2);
|
|
|
+ c(e - 1, i / 2)
|
|
|
+ }
|
|
|
+ function c(t, e) {
|
|
|
+ for (var i = t; 0 <= i && !(o[i].y - e < l) && (o[i].y -= e,
|
|
|
+ !(0 < i && o[i].y > o[i - 1].y + o[i - 1].height)); i--)
|
|
|
+ ;
|
|
|
+ }
|
|
|
+ function d(t, e, i, n, o, a) {
|
|
|
+ for (var r = e ? Number.MAX_VALUE : 0, s = 0, l = t.length; s < l; s++)
|
|
|
+ if ("none" === t[s].labelAlignTo) {
|
|
|
+ var u = Math.abs(t[s].y - n)
|
|
|
+ , h = t[s].len
|
|
|
+ , c = t[s].len2
|
|
|
+ , d = u < o + h ? Math.sqrt((o + h + c) * (o + h + c) - u * u) : Math.abs(t[s].x - i);
|
|
|
+ e && r <= d && (d = r - 10),
|
|
|
+ !e && d <= r && (d = r + 10),
|
|
|
+ t[s].x = i + d * a,
|
|
|
+ r = d
|
|
|
+ }
|
|
|
+ }
|
|
|
+ o.sort(function(t, e) {
|
|
|
+ return t.y - e.y
|
|
|
+ });
|
|
|
+ for (var f, p = 0, g = o.length, m = [], v = [], y = 0; y < g; y++) {
|
|
|
+ if ("outer" === o[y].position && "labelLine" === o[y].labelAlignTo) {
|
|
|
+ var x = o[y].x - u;
|
|
|
+ o[y].linePoints[1][0] += x,
|
|
|
+ o[y].x = u
|
|
|
+ }
|
|
|
+ (f = o[y].y - p) < 0 && h(y, g, -f),
|
|
|
+ p = o[y].y + o[y].height
|
|
|
+ }
|
|
|
+ r - p < 0 && c(g - 1, p - r);
|
|
|
+ for (y = 0; y < g; y++)
|
|
|
+ o[y].y >= e ? v.push(o[y]) : m.push(o[y]);
|
|
|
+ d(m, !1, t, e, i, n),
|
|
|
+ d(v, !0, t, e, i, n)
|
|
|
+ }
|
|
|
+ function ay(t) {
|
|
|
+ return "center" === t.position
|
|
|
+ }
|
|
|
+ function ry(L, k, P, t, N, e) {
|
|
|
+ var O, E, R = L.getData(), z = [], B = !1, V = (L.get("minShowLabelAngle") || 0) * ny;
|
|
|
+ R.each(function(t) {
|
|
|
+ var e = R.getItemLayout(t)
|
|
|
+ , i = R.getItemModel(t)
|
|
|
+ , n = i.getModel("label")
|
|
|
+ , o = n.get("position") || i.get("emphasis.label.position")
|
|
|
+ , a = n.get("distanceToLabelLine")
|
|
|
+ , r = n.get("alignTo")
|
|
|
+ , s = Rl(n.get("margin"), P)
|
|
|
+ , l = n.get("bleedMargin")
|
|
|
+ , u = n.getFont()
|
|
|
+ , h = i.getModel("labelLine")
|
|
|
+ , c = h.get("length");
|
|
|
+ c = Rl(c, P);
|
|
|
+ var d = h.get("length2");
|
|
|
+ if (d = Rl(d, P),
|
|
|
+ !(e.angle < V)) {
|
|
|
+ var f, p, g, m, v = (e.startAngle + e.endAngle) / 2, y = Math.cos(v), x = Math.sin(v);
|
|
|
+ O = e.cx,
|
|
|
+ E = e.cy;
|
|
|
+ var _, w = L.getFormattedLabel(t, "normal") || R.getName(t), b = gn(w, u, m, "top"), S = "inside" === o || "inner" === o;
|
|
|
+ if ("center" === o)
|
|
|
+ f = e.cx,
|
|
|
+ p = e.cy,
|
|
|
+ m = "center";
|
|
|
+ else {
|
|
|
+ var M = (S ? (e.r + e.r0) / 2 * y : e.r * y) + O
|
|
|
+ , I = (S ? (e.r + e.r0) / 2 * x : e.r * x) + E;
|
|
|
+ if (f = M + 3 * y,
|
|
|
+ p = I + 3 * x,
|
|
|
+ !S) {
|
|
|
+ var T = M + y * (c + k - e.r)
|
|
|
+ , A = I + x * (c + k - e.r)
|
|
|
+ , D = T + (y < 0 ? -1 : 1) * d;
|
|
|
+ f = "edge" === r ? y < 0 ? N + s : N + P - s : D + (y < 0 ? -a : a),
|
|
|
+ g = [[M, I], [T, A], [D, p = A]]
|
|
|
+ }
|
|
|
+ m = S ? "center" : "edge" === r ? 0 < y ? "right" : "left" : 0 < y ? "left" : "right"
|
|
|
+ }
|
|
|
+ var C = n.get("rotate");
|
|
|
+ _ = "number" == typeof C ? C * (Math.PI / 180) : C ? y < 0 ? -v + Math.PI : -v : 0,
|
|
|
+ B = !!_,
|
|
|
+ e.label = {
|
|
|
+ x: f,
|
|
|
+ y: p,
|
|
|
+ position: o,
|
|
|
+ height: b.height,
|
|
|
+ len: c,
|
|
|
+ len2: d,
|
|
|
+ linePoints: g,
|
|
|
+ textAlign: m,
|
|
|
+ verticalAlign: "middle",
|
|
|
+ rotation: _,
|
|
|
+ inside: S,
|
|
|
+ labelDistance: a,
|
|
|
+ labelAlignTo: r,
|
|
|
+ labelMargin: s,
|
|
|
+ bleedMargin: l,
|
|
|
+ textRect: b,
|
|
|
+ text: w,
|
|
|
+ font: u
|
|
|
+ },
|
|
|
+ S || z.push(e.label)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ !B && L.get("avoidLabelOverlap") && function(t, e, i, n, o, a, r, s) {
|
|
|
+ for (var l = [], u = [], h = Number.MAX_VALUE, c = -Number.MAX_VALUE, d = 0; d < t.length; d++)
|
|
|
+ ay(t[d]) || (t[d].x < e ? (h = Math.min(h, t[d].x),
|
|
|
+ l.push(t[d])) : (c = Math.max(c, t[d].x),
|
|
|
+ u.push(t[d])));
|
|
|
+ for (oy(u, e, i, n, 1, 0, a, 0, s, c),
|
|
|
+ oy(l, e, i, n, -1, 0, a, 0, s, h),
|
|
|
+ d = 0; d < t.length; d++) {
|
|
|
+ var f = t[d];
|
|
|
+ if (!ay(f)) {
|
|
|
+ var p = f.linePoints;
|
|
|
+ if (p) {
|
|
|
+ var g, m = "edge" === f.labelAlignTo, v = f.textRect.width;
|
|
|
+ (g = m ? f.x < e ? p[2][0] - f.labelDistance - r - f.labelMargin : r + o - f.labelMargin - p[2][0] - f.labelDistance : f.x < e ? f.x - r - f.bleedMargin : r + o - f.x - f.bleedMargin) < f.textRect.width && (f.text = xn(f.text, g, f.font),
|
|
|
+ "edge" === f.labelAlignTo && (v = pn(f.text, f.font)));
|
|
|
+ var y = p[1][0] - p[2][0];
|
|
|
+ m ? f.x < e ? p[2][0] = r + f.labelMargin + v + f.labelDistance : p[2][0] = r + o - f.labelMargin - v - f.labelDistance : (f.x < e ? p[2][0] = f.x + f.labelDistance : p[2][0] = f.x - f.labelDistance,
|
|
|
+ p[1][0] = p[2][0] + y),
|
|
|
+ p[1][1] = p[2][1] = f.y
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }(z, O, E, k, P, t, N, e)
|
|
|
+ }
|
|
|
+ var sy = 2 * Math.PI
|
|
|
+ , ly = Math.PI / 180;
|
|
|
+ function uy(t) {
|
|
|
+ return {
|
|
|
+ seriesType: t,
|
|
|
+ reset: function(t, e) {
|
|
|
+ var n = e.findComponents({
|
|
|
+ mainType: "legend"
|
|
|
+ });
|
|
|
+ if (n && n.length) {
|
|
|
+ var o = t.getData();
|
|
|
+ o.filterSelf(function(t) {
|
|
|
+ for (var e = o.getName(t), i = 0; i < n.length; i++)
|
|
|
+ if (!n[i].isSelected(e))
|
|
|
+ return !1;
|
|
|
+ return !0
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ey("pie", [{
|
|
|
+ type: "pieToggleSelect",
|
|
|
+ event: "pieselectchanged",
|
|
|
+ method: "toggleSelected"
|
|
|
+ }, {
|
|
|
+ type: "pieSelect",
|
|
|
+ event: "pieselected",
|
|
|
+ method: "select"
|
|
|
+ }, {
|
|
|
+ type: "pieUnSelect",
|
|
|
+ event: "pieunselected",
|
|
|
+ method: "unSelect"
|
|
|
+ }]),
|
|
|
+ Sf(iy("pie")),
|
|
|
+ bf(T(function(t, e, A, i) {
|
|
|
+ e.eachSeriesByType(t, function(t) {
|
|
|
+ var o = t.getData()
|
|
|
+ , e = o.mapDimension("value")
|
|
|
+ , a = function(t, e) {
|
|
|
+ return bu(t.getBoxLayoutParams(), {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ })
|
|
|
+ }(t, A)
|
|
|
+ , i = t.get("center")
|
|
|
+ , n = t.get("radius");
|
|
|
+ L(n) || (n = [0, n]),
|
|
|
+ L(i) || (i = [i, i]);
|
|
|
+ var r = Rl(a.width, A.getWidth())
|
|
|
+ , s = Rl(a.height, A.getHeight())
|
|
|
+ , l = Math.min(r, s)
|
|
|
+ , u = Rl(i[0], r) + a.x
|
|
|
+ , h = Rl(i[1], s) + a.y
|
|
|
+ , c = Rl(n[0], l / 2)
|
|
|
+ , d = Rl(n[1], l / 2)
|
|
|
+ , f = -t.get("startAngle") * ly
|
|
|
+ , p = t.get("minAngle") * ly
|
|
|
+ , g = 0;
|
|
|
+ o.each(e, function(t) {
|
|
|
+ isNaN(t) || g++
|
|
|
+ });
|
|
|
+ var m = o.getSum(e)
|
|
|
+ , v = Math.PI / (m || g) * 2
|
|
|
+ , y = t.get("clockwise")
|
|
|
+ , x = t.get("roseType")
|
|
|
+ , _ = t.get("stillShowZeroSum")
|
|
|
+ , w = o.getDataExtent(e);
|
|
|
+ w[0] = 0;
|
|
|
+ var b = sy
|
|
|
+ , S = 0
|
|
|
+ , M = f
|
|
|
+ , I = y ? 1 : -1;
|
|
|
+ if (o.each(e, function(t, e) {
|
|
|
+ var i;
|
|
|
+ if (isNaN(t))
|
|
|
+ o.setItemLayout(e, {
|
|
|
+ angle: NaN,
|
|
|
+ startAngle: NaN,
|
|
|
+ endAngle: NaN,
|
|
|
+ clockwise: y,
|
|
|
+ cx: u,
|
|
|
+ cy: h,
|
|
|
+ r0: c,
|
|
|
+ r: x ? NaN : d,
|
|
|
+ viewRect: a
|
|
|
+ });
|
|
|
+ else {
|
|
|
+ (i = "area" !== x ? 0 === m && _ ? v : t * v : sy / g) < p ? b -= i = p : S += t;
|
|
|
+ var n = M + I * i;
|
|
|
+ o.setItemLayout(e, {
|
|
|
+ angle: i,
|
|
|
+ startAngle: M,
|
|
|
+ endAngle: n,
|
|
|
+ clockwise: y,
|
|
|
+ cx: u,
|
|
|
+ cy: h,
|
|
|
+ r0: c,
|
|
|
+ r: x ? El(t, w, [c, d]) : d,
|
|
|
+ viewRect: a
|
|
|
+ }),
|
|
|
+ M = n
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ b < sy && g)
|
|
|
+ if (b <= .001) {
|
|
|
+ var T = sy / g;
|
|
|
+ o.each(e, function(t, e) {
|
|
|
+ if (!isNaN(t)) {
|
|
|
+ var i = o.getItemLayout(e);
|
|
|
+ i.angle = T,
|
|
|
+ i.startAngle = f + I * e * T,
|
|
|
+ i.endAngle = f + I * (e + 1) * T
|
|
|
+ }
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ v = b / S,
|
|
|
+ M = f,
|
|
|
+ o.each(e, function(t, e) {
|
|
|
+ if (!isNaN(t)) {
|
|
|
+ var i = o.getItemLayout(e)
|
|
|
+ , n = i.angle === p ? p : t * v;
|
|
|
+ i.startAngle = M,
|
|
|
+ i.endAngle = M + I * n,
|
|
|
+ M += I * n
|
|
|
+ }
|
|
|
+ });
|
|
|
+ ry(t, d, a.width, a.height, a.x, a.y)
|
|
|
+ })
|
|
|
+ }, "pie")),
|
|
|
+ xf(uy("pie")),
|
|
|
+ sc.extend({
|
|
|
+ type: "series.scatter",
|
|
|
+ dependencies: ["grid", "polar", "geo", "singleAxis", "calendar"],
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return gp(this.getSource(), this, {
|
|
|
+ useEncodeDefaulter: !0
|
|
|
+ })
|
|
|
+ },
|
|
|
+ brushSelector: "point",
|
|
|
+ getProgressive: function() {
|
|
|
+ var t = this.option.progressive;
|
|
|
+ return null == t ? this.option.large ? 5e3 : this.get("progressive") : t
|
|
|
+ },
|
|
|
+ getProgressiveThreshold: function() {
|
|
|
+ var t = this.option.progressiveThreshold;
|
|
|
+ return null == t ? this.option.large ? 1e4 : this.get("progressiveThreshold") : t
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ coordinateSystem: "cartesian2d",
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ legendHoverLink: !0,
|
|
|
+ hoverAnimation: !0,
|
|
|
+ symbolSize: 10,
|
|
|
+ large: !1,
|
|
|
+ largeThreshold: 2e3,
|
|
|
+ itemStyle: {
|
|
|
+ opacity: .8
|
|
|
+ },
|
|
|
+ clip: !0
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var hy = Cs({
|
|
|
+ shape: {
|
|
|
+ points: null
|
|
|
+ },
|
|
|
+ symbolProxy: null,
|
|
|
+ softClipShape: null,
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.points
|
|
|
+ , n = e.size
|
|
|
+ , o = this.symbolProxy
|
|
|
+ , a = o.shape;
|
|
|
+ if (!((t.getContext ? t.getContext() : t) && n[0] < 4))
|
|
|
+ for (var r = 0; r < i.length; ) {
|
|
|
+ var s = i[r++]
|
|
|
+ , l = i[r++];
|
|
|
+ isNaN(s) || isNaN(l) || this.softClipShape && !this.softClipShape.contain(s, l) || (a.x = s - n[0] / 2,
|
|
|
+ a.y = l - n[1] / 2,
|
|
|
+ a.width = n[0],
|
|
|
+ a.height = n[1],
|
|
|
+ o.buildPath(t, a, !0))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ afterBrush: function(t) {
|
|
|
+ var e = this.shape
|
|
|
+ , i = e.points
|
|
|
+ , n = e.size;
|
|
|
+ if (n[0] < 4) {
|
|
|
+ this.setTransform(t);
|
|
|
+ for (var o = 0; o < i.length; ) {
|
|
|
+ var a = i[o++]
|
|
|
+ , r = i[o++];
|
|
|
+ isNaN(a) || isNaN(r) || this.softClipShape && !this.softClipShape.contain(a, r) || t.fillRect(a - n[0] / 2, r - n[1] / 2, n[0], n[1])
|
|
|
+ }
|
|
|
+ this.restoreTransform(t)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ findDataIndex: function(t, e) {
|
|
|
+ for (var i = this.shape, n = i.points, o = i.size, a = Math.max(o[0], 4), r = Math.max(o[1], 4), s = n.length / 2 - 1; 0 <= s; s--) {
|
|
|
+ var l = 2 * s
|
|
|
+ , u = n[l] - a / 2
|
|
|
+ , h = n[1 + l] - r / 2;
|
|
|
+ if (u <= t && h <= e && t <= u + a && e <= h + r)
|
|
|
+ return s
|
|
|
+ }
|
|
|
+ return -1
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function cy() {
|
|
|
+ this.group = new Ci
|
|
|
+ }
|
|
|
+ var dy = cy.prototype;
|
|
|
+ function fy(t, e, i) {
|
|
|
+ Gg.call(this, t, e, i),
|
|
|
+ this.type = "value",
|
|
|
+ this.angle = 0,
|
|
|
+ this.name = "",
|
|
|
+ this.model
|
|
|
+ }
|
|
|
+ function py(t, e, i) {
|
|
|
+ this._model = t,
|
|
|
+ this.dimensions = [],
|
|
|
+ this._indicatorAxes = O(t.getIndicatorModels(), function(t, e) {
|
|
|
+ var i = "indicator_" + e
|
|
|
+ , n = new fy(i,"log" === t.get("axisType") ? new ng : new Dp);
|
|
|
+ return n.name = t.get("name"),
|
|
|
+ (n.model = t).axis = n,
|
|
|
+ this.dimensions.push(i),
|
|
|
+ n
|
|
|
+ }, this),
|
|
|
+ this.resize(t, i),
|
|
|
+ this.cx,
|
|
|
+ this.cy,
|
|
|
+ this.r,
|
|
|
+ this.r0,
|
|
|
+ this.startAngle
|
|
|
+ }
|
|
|
+ dy.isPersistent = function() {
|
|
|
+ return !this._incremental
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dy.updateData = function(t, e) {
|
|
|
+ this.group.removeAll();
|
|
|
+ var i = new hy({
|
|
|
+ rectHover: !0,
|
|
|
+ cursor: "default"
|
|
|
+ });
|
|
|
+ i.setShape({
|
|
|
+ points: t.getLayout("symbolPoints")
|
|
|
+ }),
|
|
|
+ this._setCommon(i, t, !1, e),
|
|
|
+ this.group.add(i),
|
|
|
+ this._incremental = null
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dy.updateLayout = function(t) {
|
|
|
+ if (!this._incremental) {
|
|
|
+ var n = t.getLayout("symbolPoints");
|
|
|
+ this.group.eachChild(function(t) {
|
|
|
+ if (null != t.startIndex) {
|
|
|
+ var e = 2 * (t.endIndex - t.startIndex)
|
|
|
+ , i = 4 * t.startIndex * 2;
|
|
|
+ n = new Float32Array(n.buffer,i,e)
|
|
|
+ }
|
|
|
+ t.setShape("points", n)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dy.incrementalPrepareUpdate = function(t) {
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._clearIncremental(),
|
|
|
+ 2e6 < t.count() ? (this._incremental || (this._incremental = new vs({
|
|
|
+ silent: !0
|
|
|
+ })),
|
|
|
+ this.group.add(this._incremental)) : this._incremental = null
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dy.incrementalUpdate = function(t, e, i) {
|
|
|
+ var n;
|
|
|
+ this._incremental ? (n = new hy,
|
|
|
+ this._incremental.addDisplayable(n, !0)) : ((n = new hy({
|
|
|
+ rectHover: !0,
|
|
|
+ cursor: "default",
|
|
|
+ startIndex: t.start,
|
|
|
+ endIndex: t.end
|
|
|
+ })).incremental = !0,
|
|
|
+ this.group.add(n)),
|
|
|
+ n.setShape({
|
|
|
+ points: e.getLayout("symbolPoints")
|
|
|
+ }),
|
|
|
+ this._setCommon(n, e, !!this._incremental, i)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dy._setCommon = function(i, t, e, n) {
|
|
|
+ var o = t.hostModel;
|
|
|
+ n = n || {};
|
|
|
+ var a = t.getVisual("symbolSize");
|
|
|
+ i.setShape("size", a instanceof Array ? a : [a, a]),
|
|
|
+ i.softClipShape = n.clipShape || null,
|
|
|
+ i.symbolProxy = wg(t.getVisual("symbol"), 0, 0, 0, 0),
|
|
|
+ i.setColor = i.symbolProxy.setColor;
|
|
|
+ var r = i.shape.size[0] < 4;
|
|
|
+ i.useStyle(o.getModel("itemStyle").getItemStyle(r ? ["color", "shadowBlur", "shadowColor"] : ["color"]));
|
|
|
+ var s = t.getVisual("color");
|
|
|
+ s && i.setColor(s),
|
|
|
+ e || (i.seriesIndex = o.seriesIndex,
|
|
|
+ i.on("mousemove", function(t) {
|
|
|
+ i.dataIndex = null;
|
|
|
+ var e = i.findDataIndex(t.offsetX, t.offsetY);
|
|
|
+ 0 <= e && (i.dataIndex = e + (i.startIndex || 0))
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dy.remove = function() {
|
|
|
+ this._clearIncremental(),
|
|
|
+ this._incremental = null,
|
|
|
+ this.group.removeAll()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dy._clearIncremental = function() {
|
|
|
+ var t = this._incremental;
|
|
|
+ t && t.clearDisplaybles()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Cf({
|
|
|
+ type: "scatter",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var n = t.getData();
|
|
|
+ this._updateSymbolDraw(n, t).updateData(n, {
|
|
|
+ clipShape: this._getClipShape(t)
|
|
|
+ }),
|
|
|
+ this._finished = !0
|
|
|
+ },
|
|
|
+ incrementalPrepareRender: function(t, e, i) {
|
|
|
+ var n = t.getData();
|
|
|
+ this._updateSymbolDraw(n, t).incrementalPrepareUpdate(n),
|
|
|
+ this._finished = !1
|
|
|
+ },
|
|
|
+ incrementalRender: function(t, e, i) {
|
|
|
+ this._symbolDraw.incrementalUpdate(t, e.getData(), {
|
|
|
+ clipShape: this._getClipShape(e)
|
|
|
+ }),
|
|
|
+ this._finished = t.end === e.getData().count()
|
|
|
+ },
|
|
|
+ updateTransform: function(t, e, i) {
|
|
|
+ var n = t.getData();
|
|
|
+ if (this.group.dirty(),
|
|
|
+ !this._finished || 1e4 < n.count() || !this._symbolDraw.isPersistent())
|
|
|
+ return {
|
|
|
+ update: !0
|
|
|
+ };
|
|
|
+ var o = km().reset(t);
|
|
|
+ o.progress && o.progress({
|
|
|
+ start: 0,
|
|
|
+ end: n.count()
|
|
|
+ }, n),
|
|
|
+ this._symbolDraw.updateLayout(n)
|
|
|
+ },
|
|
|
+ _getClipShape: function(t) {
|
|
|
+ var e = t.coordinateSystem
|
|
|
+ , i = e && e.getArea && e.getArea();
|
|
|
+ return t.get("clip", !0) ? i : null
|
|
|
+ },
|
|
|
+ _updateSymbolDraw: function(t, e) {
|
|
|
+ var i = this._symbolDraw
|
|
|
+ , n = e.pipelineContext.large;
|
|
|
+ return i && n === this._isLargeDraw || (i && i.remove(),
|
|
|
+ i = this._symbolDraw = n ? new cy : new im,
|
|
|
+ this._isLargeDraw = n,
|
|
|
+ this.group.removeAll()),
|
|
|
+ this.group.add(i.group),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ remove: function(t, e) {
|
|
|
+ this._symbolDraw && this._symbolDraw.remove(!0),
|
|
|
+ this._symbolDraw = null
|
|
|
+ },
|
|
|
+ dispose: function() {}
|
|
|
+ }),
|
|
|
+ Sf(Lm("scatter", "circle")),
|
|
|
+ bf(km("scatter")),
|
|
|
+ w(fy, Gg),
|
|
|
+ py.prototype.getIndicatorAxes = function() {
|
|
|
+ return this._indicatorAxes
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ py.prototype.dataToPoint = function(t, e) {
|
|
|
+ var i = this._indicatorAxes[e];
|
|
|
+ return this.coordToPoint(i.dataToCoord(t), e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ py.prototype.coordToPoint = function(t, e) {
|
|
|
+ var i = this._indicatorAxes[e].angle;
|
|
|
+ return [this.cx + t * Math.cos(i), this.cy - t * Math.sin(i)]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ py.prototype.pointToData = function(t) {
|
|
|
+ var e = t[0] - this.cx
|
|
|
+ , i = t[1] - this.cy
|
|
|
+ , n = Math.sqrt(e * e + i * i);
|
|
|
+ e /= n,
|
|
|
+ i /= n;
|
|
|
+ for (var o, a = Math.atan2(-i, e), r = 1 / 0, s = -1, l = 0; l < this._indicatorAxes.length; l++) {
|
|
|
+ var u = this._indicatorAxes[l]
|
|
|
+ , h = Math.abs(a - u.angle);
|
|
|
+ h < r && (o = u,
|
|
|
+ s = l,
|
|
|
+ r = h)
|
|
|
+ }
|
|
|
+ return [s, +(o && o.coordToData(n))]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ py.prototype.resize = function(t, e) {
|
|
|
+ var i = t.get("center")
|
|
|
+ , n = e.getWidth()
|
|
|
+ , o = e.getHeight()
|
|
|
+ , a = Math.min(n, o) / 2;
|
|
|
+ this.cx = Rl(i[0], n),
|
|
|
+ this.cy = Rl(i[1], o),
|
|
|
+ this.startAngle = t.get("startAngle") * Math.PI / 180;
|
|
|
+ var r = t.get("radius");
|
|
|
+ "string" != typeof r && "number" != typeof r || (r = [0, r]),
|
|
|
+ this.r0 = Rl(r[0], a),
|
|
|
+ this.r = Rl(r[1], a),
|
|
|
+ E(this._indicatorAxes, function(t, e) {
|
|
|
+ t.setExtent(this.r0, this.r);
|
|
|
+ var i = this.startAngle + e * Math.PI * 2 / this._indicatorAxes.length;
|
|
|
+ i = Math.atan2(Math.sin(i), Math.cos(i)),
|
|
|
+ t.angle = i
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ py.prototype.update = function(n, t) {
|
|
|
+ var o = this._indicatorAxes
|
|
|
+ , a = this._model;
|
|
|
+ E(o, function(t) {
|
|
|
+ t.scale.setExtent(1 / 0, -1 / 0)
|
|
|
+ }),
|
|
|
+ n.eachSeriesByType("radar", function(t, e) {
|
|
|
+ if ("radar" === t.get("coordinateSystem") && n.getComponent("radar", t.get("radarIndex")) === a) {
|
|
|
+ var i = t.getData();
|
|
|
+ E(o, function(t) {
|
|
|
+ t.scale.unionExtentFromData(i, i.mapDimension(t.dim))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }, this);
|
|
|
+ var c = a.get("splitNumber");
|
|
|
+ function d(t) {
|
|
|
+ var e = Math.pow(10, Math.floor(Math.log(t) / Math.LN10))
|
|
|
+ , i = t / e;
|
|
|
+ return 2 === i ? i = 5 : i *= 2,
|
|
|
+ i * e
|
|
|
+ }
|
|
|
+ E(o, function(t, e) {
|
|
|
+ var i = ag(t.scale, t.model).extent;
|
|
|
+ rg(t.scale, t.model);
|
|
|
+ var n = t.model
|
|
|
+ , o = t.scale
|
|
|
+ , a = n.getMin()
|
|
|
+ , r = n.getMax()
|
|
|
+ , s = o.getInterval();
|
|
|
+ if (null != a && null != r)
|
|
|
+ o.setExtent(+a, +r),
|
|
|
+ o.setInterval((r - a) / c);
|
|
|
+ else if (null != a)
|
|
|
+ for (; u = a + s * c,
|
|
|
+ o.setExtent(+a, u),
|
|
|
+ o.setInterval(s),
|
|
|
+ s = d(s),
|
|
|
+ u < i[1] && isFinite(u) && isFinite(i[1]); )
|
|
|
+ ;
|
|
|
+ else if (null != r)
|
|
|
+ for (; h = r - s * c,
|
|
|
+ o.setExtent(h, +r),
|
|
|
+ o.setInterval(s),
|
|
|
+ s = d(s),
|
|
|
+ h > i[0] && isFinite(h) && isFinite(i[0]); )
|
|
|
+ ;
|
|
|
+ else {
|
|
|
+ var l = o.getTicks().length - 1;
|
|
|
+ c < l && (s = d(s));
|
|
|
+ var u, h = zl((u = Math.ceil(i[1] / s) * s) - s * c);
|
|
|
+ o.setExtent(h, u),
|
|
|
+ o.setInterval(s)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ py.dimensions = [],
|
|
|
+ py.create = function(i, n) {
|
|
|
+ var o = [];
|
|
|
+ return i.eachComponent("radar", function(t) {
|
|
|
+ var e = new py(t,i,n);
|
|
|
+ o.push(e),
|
|
|
+ t.coordinateSystem = e
|
|
|
+ }),
|
|
|
+ i.eachSeriesByType("radar", function(t) {
|
|
|
+ "radar" === t.get("coordinateSystem") && (t.coordinateSystem = o[t.get("radarIndex") || 0])
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lh.register("radar", py);
|
|
|
+ var gy = Vm.valueAxis;
|
|
|
+ function my(t, e) {
|
|
|
+ return D({
|
|
|
+ show: e
|
|
|
+ }, t)
|
|
|
+ }
|
|
|
+ Tf({
|
|
|
+ type: "radar",
|
|
|
+ optionUpdated: function() {
|
|
|
+ var o = this.get("boundaryGap")
|
|
|
+ , a = this.get("splitNumber")
|
|
|
+ , r = this.get("scale")
|
|
|
+ , s = this.get("axisLine")
|
|
|
+ , l = this.get("axisTick")
|
|
|
+ , u = this.get("axisType")
|
|
|
+ , h = this.get("axisLabel")
|
|
|
+ , c = this.get("name")
|
|
|
+ , d = this.get("name.show")
|
|
|
+ , f = this.get("name.formatter")
|
|
|
+ , p = this.get("nameGap")
|
|
|
+ , g = this.get("triggerEvent")
|
|
|
+ , t = O(this.get("indicator") || [], function(t) {
|
|
|
+ null != t.max && 0 < t.max && !t.min ? t.min = 0 : null != t.min && t.min < 0 && !t.max && (t.max = 0);
|
|
|
+ var e = c;
|
|
|
+ if (null != t.color && (e = D({
|
|
|
+ color: t.color
|
|
|
+ }, c)),
|
|
|
+ t = m(k(t), {
|
|
|
+ boundaryGap: o,
|
|
|
+ splitNumber: a,
|
|
|
+ scale: r,
|
|
|
+ axisLine: s,
|
|
|
+ axisTick: l,
|
|
|
+ axisType: u,
|
|
|
+ axisLabel: h,
|
|
|
+ name: t.text,
|
|
|
+ nameLocation: "end",
|
|
|
+ nameGap: p,
|
|
|
+ nameTextStyle: e,
|
|
|
+ triggerEvent: g
|
|
|
+ }, !1),
|
|
|
+ d || (t.name = ""),
|
|
|
+ "string" == typeof f) {
|
|
|
+ var i = t.name;
|
|
|
+ t.name = f.replace("{value}", null != i ? i : "")
|
|
|
+ } else
|
|
|
+ "function" == typeof f && (t.name = f(t.name, t));
|
|
|
+ var n = P(new Cl(t,null,this.ecModel), dg);
|
|
|
+ return n.mainType = "radar",
|
|
|
+ n.componentIndex = this.componentIndex,
|
|
|
+ n
|
|
|
+ }, this);
|
|
|
+ this.getIndicatorModels = function() {
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 0,
|
|
|
+ center: ["50%", "50%"],
|
|
|
+ radius: "75%",
|
|
|
+ startAngle: 90,
|
|
|
+ name: {
|
|
|
+ show: !0
|
|
|
+ },
|
|
|
+ boundaryGap: [0, 0],
|
|
|
+ splitNumber: 5,
|
|
|
+ nameGap: 15,
|
|
|
+ scale: !1,
|
|
|
+ shape: "polygon",
|
|
|
+ axisLine: m({
|
|
|
+ lineStyle: {
|
|
|
+ color: "#bbb"
|
|
|
+ }
|
|
|
+ }, gy.axisLine),
|
|
|
+ axisLabel: my(gy.axisLabel, !1),
|
|
|
+ axisTick: my(gy.axisTick, !1),
|
|
|
+ axisType: "interval",
|
|
|
+ splitLine: my(gy.splitLine, !0),
|
|
|
+ splitArea: my(gy.splitArea, !0),
|
|
|
+ indicator: []
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var vy = ["axisLine", "axisTickLabel", "axisName"];
|
|
|
+ Af({
|
|
|
+ type: "radar",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._buildAxes(t),
|
|
|
+ this._buildSplitLineAndArea(t)
|
|
|
+ },
|
|
|
+ _buildAxes: function(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ E(O(e.getIndicatorAxes(), function(t) {
|
|
|
+ return new Qm(t.model,{
|
|
|
+ position: [e.cx, e.cy],
|
|
|
+ rotation: t.angle,
|
|
|
+ labelDirection: -1,
|
|
|
+ tickDirection: -1,
|
|
|
+ nameDirection: 1
|
|
|
+ })
|
|
|
+ }), function(t) {
|
|
|
+ E(vy, t.add, t),
|
|
|
+ this.group.add(t.getGroup())
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _buildSplitLineAndArea: function(t) {
|
|
|
+ var n = t.coordinateSystem
|
|
|
+ , e = n.getIndicatorAxes();
|
|
|
+ if (e.length) {
|
|
|
+ var i = t.get("shape")
|
|
|
+ , o = t.getModel("splitLine")
|
|
|
+ , a = t.getModel("splitArea")
|
|
|
+ , r = o.getModel("lineStyle")
|
|
|
+ , s = a.getModel("areaStyle")
|
|
|
+ , l = o.get("show")
|
|
|
+ , u = a.get("show")
|
|
|
+ , h = r.get("color")
|
|
|
+ , c = s.get("color");
|
|
|
+ h = L(h) ? h : [h],
|
|
|
+ c = L(c) ? c : [c];
|
|
|
+ var d = []
|
|
|
+ , f = [];
|
|
|
+ if ("circle" === i)
|
|
|
+ for (var p = e[0].getTicksCoords(), g = n.cx, m = n.cy, v = 0; v < p.length; v++) {
|
|
|
+ if (l)
|
|
|
+ d[I(d, h, v)].push(new Yr({
|
|
|
+ shape: {
|
|
|
+ cx: g,
|
|
|
+ cy: m,
|
|
|
+ r: p[v].coord
|
|
|
+ }
|
|
|
+ }));
|
|
|
+ if (u && v < p.length - 1)
|
|
|
+ f[I(f, c, v)].push(new Kr({
|
|
|
+ shape: {
|
|
|
+ cx: g,
|
|
|
+ cy: m,
|
|
|
+ r0: p[v].coord,
|
|
|
+ r: p[v + 1].coord
|
|
|
+ }
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ var y, x = O(e, function(t, e) {
|
|
|
+ var i = t.getTicksCoords();
|
|
|
+ return y = null == y ? i.length - 1 : Math.min(i.length - 1, y),
|
|
|
+ O(i, function(t) {
|
|
|
+ return n.coordToPoint(t.coord, e)
|
|
|
+ })
|
|
|
+ }), _ = [];
|
|
|
+ for (v = 0; v <= y; v++) {
|
|
|
+ for (var w = [], b = 0; b < e.length; b++)
|
|
|
+ w.push(x[b][v]);
|
|
|
+ if (w[0] && w.push(w[0].slice()),
|
|
|
+ l)
|
|
|
+ d[I(d, h, v)].push(new ts({
|
|
|
+ shape: {
|
|
|
+ points: w
|
|
|
+ }
|
|
|
+ }));
|
|
|
+ if (u && _)
|
|
|
+ f[I(f, c, v - 1)].push(new Qr({
|
|
|
+ shape: {
|
|
|
+ points: w.concat(_)
|
|
|
+ }
|
|
|
+ }));
|
|
|
+ _ = w.slice().reverse()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var S = r.getLineStyle()
|
|
|
+ , M = s.getAreaStyle();
|
|
|
+ E(f, function(t, e) {
|
|
|
+ this.group.add(Es(t, {
|
|
|
+ style: D({
|
|
|
+ stroke: "none",
|
|
|
+ fill: c[e % c.length]
|
|
|
+ }, M),
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }, this),
|
|
|
+ E(d, function(t, e) {
|
|
|
+ this.group.add(Es(t, {
|
|
|
+ style: D({
|
|
|
+ fill: "none",
|
|
|
+ stroke: h[e % h.length]
|
|
|
+ }, S),
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ function I(t, e, i) {
|
|
|
+ var n = i % e.length;
|
|
|
+ return t[n] = t[n] || [],
|
|
|
+ n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var yy = sc.extend({
|
|
|
+ type: "series.radar",
|
|
|
+ dependencies: ["radar"],
|
|
|
+ init: function(t) {
|
|
|
+ yy.superApply(this, "init", arguments),
|
|
|
+ this.legendVisualProvider = new qv(A(this.getData, this),A(this.getRawData, this))
|
|
|
+ },
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return Yv(this, {
|
|
|
+ generateCoord: "indicator_",
|
|
|
+ generateCoordCount: 1 / 0
|
|
|
+ })
|
|
|
+ },
|
|
|
+ formatTooltip: function(n) {
|
|
|
+ var o = this.getData()
|
|
|
+ , t = this.coordinateSystem.getIndicatorAxes()
|
|
|
+ , e = this.getData().getName(n);
|
|
|
+ return au("" === e ? this.name : e) + "<br/>" + O(t, function(t, e) {
|
|
|
+ var i = o.get(o.mapDimension(t.dim), n);
|
|
|
+ return au(t.name + " : " + i)
|
|
|
+ }).join("<br />")
|
|
|
+ },
|
|
|
+ getTooltipPosition: function(t) {
|
|
|
+ if (null != t)
|
|
|
+ for (var e = this.getData(), i = this.coordinateSystem, n = e.getValues(O(i.dimensions, function(t) {
|
|
|
+ return e.mapDimension(t)
|
|
|
+ }), t, !0), o = 0, a = n.length; o < a; o++)
|
|
|
+ if (!isNaN(n[o])) {
|
|
|
+ var r = i.getIndicatorAxes();
|
|
|
+ return i.coordToPoint(r[o].dataToCoord(n[o]), o)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "radar",
|
|
|
+ legendHoverLink: !0,
|
|
|
+ radarIndex: 0,
|
|
|
+ lineStyle: {
|
|
|
+ width: 2,
|
|
|
+ type: "solid"
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ position: "top"
|
|
|
+ },
|
|
|
+ symbol: "emptyCircle",
|
|
|
+ symbolSize: 4
|
|
|
+ }
|
|
|
+ });
|
|
|
+ Cf({
|
|
|
+ type: "radar",
|
|
|
+ render: function(l, t, e) {
|
|
|
+ var i = l.coordinateSystem
|
|
|
+ , g = this.group
|
|
|
+ , m = l.getData()
|
|
|
+ , s = this._data;
|
|
|
+ function u(t, e) {
|
|
|
+ var i = t.getItemVisual(e, "symbol") || "circle"
|
|
|
+ , n = t.getItemVisual(e, "color");
|
|
|
+ if ("none" !== i) {
|
|
|
+ var o = function(t) {
|
|
|
+ return L(t) || (t = [+t, +t]),
|
|
|
+ t
|
|
|
+ }(t.getItemVisual(e, "symbolSize"))
|
|
|
+ , a = wg(i, -1, -1, 2, 2, n);
|
|
|
+ return a.attr({
|
|
|
+ style: {
|
|
|
+ strokeNoScale: !0
|
|
|
+ },
|
|
|
+ z2: 100,
|
|
|
+ scale: [o[0] / 2, o[1] / 2]
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function h(t, e, i, n, o, a) {
|
|
|
+ i.removeAll();
|
|
|
+ for (var r = 0; r < e.length - 1; r++) {
|
|
|
+ var s = u(n, o);
|
|
|
+ s && (t[s.__dimIdx = r] ? (s.attr("position", t[r]),
|
|
|
+ bl[a ? "initProps" : "updateProps"](s, {
|
|
|
+ position: e[r]
|
|
|
+ }, l, o)) : s.attr("position", e[r]),
|
|
|
+ i.add(s))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function c(t) {
|
|
|
+ return O(t, function(t) {
|
|
|
+ return [i.cx, i.cy]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ m.diff(s).add(function(t) {
|
|
|
+ var e = m.getItemLayout(t);
|
|
|
+ if (e) {
|
|
|
+ var i = new Qr
|
|
|
+ , n = new ts
|
|
|
+ , o = {
|
|
|
+ shape: {
|
|
|
+ points: e
|
|
|
+ }
|
|
|
+ };
|
|
|
+ i.shape.points = c(e),
|
|
|
+ n.shape.points = c(e),
|
|
|
+ dl(i, o, l, t),
|
|
|
+ dl(n, o, l, t);
|
|
|
+ var a = new Ci
|
|
|
+ , r = new Ci;
|
|
|
+ a.add(n),
|
|
|
+ a.add(i),
|
|
|
+ a.add(r),
|
|
|
+ h(n.shape.points, e, r, m, t, !0),
|
|
|
+ m.setItemGraphicEl(t, a)
|
|
|
+ }
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = s.getItemGraphicEl(e)
|
|
|
+ , n = i.childAt(0)
|
|
|
+ , o = i.childAt(1)
|
|
|
+ , a = i.childAt(2)
|
|
|
+ , r = {
|
|
|
+ shape: {
|
|
|
+ points: m.getItemLayout(t)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ r.shape.points && (h(n.shape.points, r.shape.points, a, m, t, !1),
|
|
|
+ cl(n, r, l),
|
|
|
+ cl(o, r, l),
|
|
|
+ m.setItemGraphicEl(t, i))
|
|
|
+ }).remove(function(t) {
|
|
|
+ g.remove(s.getItemGraphicEl(t))
|
|
|
+ }).execute(),
|
|
|
+ m.eachItemGraphicEl(function(t, i) {
|
|
|
+ var e = m.getItemModel(i)
|
|
|
+ , n = t.childAt(0)
|
|
|
+ , o = t.childAt(1)
|
|
|
+ , a = t.childAt(2)
|
|
|
+ , r = m.getItemVisual(i, "color");
|
|
|
+ g.add(t),
|
|
|
+ n.useStyle(D(e.getModel("lineStyle").getLineStyle(), {
|
|
|
+ fill: "none",
|
|
|
+ stroke: r
|
|
|
+ })),
|
|
|
+ n.hoverStyle = e.getModel("emphasis.lineStyle").getLineStyle();
|
|
|
+ var s = e.getModel("areaStyle")
|
|
|
+ , l = e.getModel("emphasis.areaStyle")
|
|
|
+ , u = s.isEmpty() && s.parentModel.isEmpty()
|
|
|
+ , h = l.isEmpty() && l.parentModel.isEmpty();
|
|
|
+ h = h && u,
|
|
|
+ o.ignore = u,
|
|
|
+ o.useStyle(D(s.getAreaStyle(), {
|
|
|
+ fill: r,
|
|
|
+ opacity: .7
|
|
|
+ })),
|
|
|
+ o.hoverStyle = l.getAreaStyle();
|
|
|
+ var c = e.getModel("itemStyle").getItemStyle(["color"])
|
|
|
+ , d = e.getModel("emphasis.itemStyle").getItemStyle()
|
|
|
+ , f = e.getModel("label")
|
|
|
+ , p = e.getModel("emphasis.label");
|
|
|
+ a.eachChild(function(t) {
|
|
|
+ t.setStyle(c),
|
|
|
+ t.hoverStyle = k(d);
|
|
|
+ var e = m.get(m.dimensions[t.__dimIdx], i);
|
|
|
+ null != e && !isNaN(e) || (e = ""),
|
|
|
+ el(t.style, t.hoverStyle, f, p, {
|
|
|
+ labelFetcher: m.hostModel,
|
|
|
+ labelDataIndex: i,
|
|
|
+ labelDimIndex: t.__dimIdx,
|
|
|
+ defaultText: e,
|
|
|
+ autoColor: r,
|
|
|
+ isRectText: !0
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ t.highDownOnUpdate = function(t, e) {
|
|
|
+ o.attr("ignore", "emphasis" === e ? h : u)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ $s(t)
|
|
|
+ }),
|
|
|
+ this._data = m
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._data = null
|
|
|
+ },
|
|
|
+ dispose: function() {}
|
|
|
+ });
|
|
|
+ function xy(t) {
|
|
|
+ return !isNaN(t[0]) && !isNaN(t[1])
|
|
|
+ }
|
|
|
+ function _y(t) {
|
|
|
+ return [t.cx, t.cy]
|
|
|
+ }
|
|
|
+ Sf(iy("radar")),
|
|
|
+ Sf(Lm("radar", "circle")),
|
|
|
+ bf(function(t) {
|
|
|
+ t.eachSeriesByType("radar", function(t) {
|
|
|
+ var i = t.getData()
|
|
|
+ , o = []
|
|
|
+ , a = t.coordinateSystem;
|
|
|
+ if (a) {
|
|
|
+ var e = a.getIndicatorAxes();
|
|
|
+ E(e, function(t, n) {
|
|
|
+ i.each(i.mapDimension(e[n].dim), function(t, e) {
|
|
|
+ o[e] = o[e] || [];
|
|
|
+ var i = a.dataToPoint(t, n);
|
|
|
+ o[e][n] = xy(i) ? i : _y(a)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ i.each(function(t) {
|
|
|
+ var e = I(o[t], function(t) {
|
|
|
+ return xy(t)
|
|
|
+ }) || _y(a);
|
|
|
+ o[t].push(e.slice()),
|
|
|
+ i.setItemLayout(t, o[t])
|
|
|
+ })
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ xf(uy("radar")),
|
|
|
+ yf(function(i) {
|
|
|
+ var t = i.polar;
|
|
|
+ if (t) {
|
|
|
+ L(t) || (t = [t]);
|
|
|
+ var n = [];
|
|
|
+ E(t, function(t, e) {
|
|
|
+ t.indicator ? (t.type && !t.shape && (t.shape = t.type),
|
|
|
+ i.radar = i.radar || [],
|
|
|
+ L(i.radar) || (i.radar = [i.radar]),
|
|
|
+ i.radar.push(t)) : n.push(t)
|
|
|
+ }),
|
|
|
+ i.polar = n
|
|
|
+ }
|
|
|
+ E(i.series, function(t) {
|
|
|
+ t && "radar" === t.type && t.polarIndex && (t.radarIndex = t.polarIndex)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ for (var wy = [126, 25], by = [[[0, 3.5], [7, 11.2], [15, 11.9], [30, 7], [42, .7], [52, .7], [56, 7.7], [59, .7], [64, .7], [64, 0], [5, 0], [0, 3.5]], [[13, 16.1], [19, 14.7], [16, 21.7], [11, 23.1], [13, 16.1]], [[12, 32.2], [14, 38.5], [15, 38.5], [13, 32.2], [12, 32.2]], [[16, 47.6], [12, 53.2], [13, 53.2], [18, 47.6], [16, 47.6]], [[6, 64.4], [8, 70], [9, 70], [8, 64.4], [6, 64.4]], [[23, 82.6], [29, 79.8], [30, 79.8], [25, 82.6], [23, 82.6]], [[37, 70.7], [43, 62.3], [44, 62.3], [39, 70.7], [37, 70.7]], [[48, 51.1], [51, 45.5], [53, 45.5], [50, 51.1], [48, 51.1]], [[51, 35], [51, 28.7], [53, 28.7], [53, 35], [51, 35]], [[52, 22.4], [55, 17.5], [56, 17.5], [53, 22.4], [52, 22.4]], [[58, 12.6], [62, 7], [63, 7], [60, 12.6], [58, 12.6]], [[0, 3.5], [0, 93.1], [64, 93.1], [64, 0], [63, 0], [63, 92.4], [1, 92.4], [1, 3.5], [0, 3.5]]], Sy = 0; Sy < by.length; Sy++)
|
|
|
+ for (var My = 0; My < by[Sy].length; My++)
|
|
|
+ by[Sy][My][0] /= 10.5,
|
|
|
+ by[Sy][My][1] /= -14,
|
|
|
+ by[Sy][My][0] += wy[0],
|
|
|
+ by[Sy][My][1] += wy[1];
|
|
|
+ var Iy = {
|
|
|
+ "南海诸岛": [32, 80],
|
|
|
+ "广东": [0, -10],
|
|
|
+ "香港": [10, 5],
|
|
|
+ "澳门": [-10, 10],
|
|
|
+ "天津": [5, 5]
|
|
|
+ }
|
|
|
+ , Ty = {
|
|
|
+ Russia: [100, 60],
|
|
|
+ "United States": [-99, 38],
|
|
|
+ "United States of America": [-99, 38]
|
|
|
+ }
|
|
|
+ , Ay = [[[123.45165252685547, 25.73527164402261], [123.49731445312499, 25.73527164402261], [123.49731445312499, 25.750734064600884], [123.45165252685547, 25.750734064600884], [123.45165252685547, 25.73527164402261]]]
|
|
|
+ , Dy = jo()
|
|
|
+ , Cy = {
|
|
|
+ load: function(n, t, e) {
|
|
|
+ var i = Dy(t).parsed;
|
|
|
+ if (i)
|
|
|
+ return i;
|
|
|
+ var o, a = t.specialAreas || {}, r = t.geoJSON;
|
|
|
+ try {
|
|
|
+ o = r ? Cg(r, e) : []
|
|
|
+ } catch (t) {
|
|
|
+ throw new Error("Invalid geoJson format\n" + t.message)
|
|
|
+ }
|
|
|
+ return function(t, e) {
|
|
|
+ "china" === t && e.push(new Ag("南海诸岛",O(by, function(t) {
|
|
|
+ return {
|
|
|
+ type: "polygon",
|
|
|
+ exterior: t
|
|
|
+ }
|
|
|
+ }),wy))
|
|
|
+ }(n, o),
|
|
|
+ E(o, function(t) {
|
|
|
+ var e = t.name;
|
|
|
+ !function(t, e) {
|
|
|
+ if ("china" === t) {
|
|
|
+ var i = Iy[e.name];
|
|
|
+ if (i) {
|
|
|
+ var n = e.center;
|
|
|
+ n[0] += i[0] / 10.5,
|
|
|
+ n[1] += -i[1] / 14
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }(n, t),
|
|
|
+ function(t, e) {
|
|
|
+ if ("world" === t) {
|
|
|
+ var i = Ty[e.name];
|
|
|
+ if (i) {
|
|
|
+ var n = e.center;
|
|
|
+ n[0] = i[0],
|
|
|
+ n[1] = i[1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }(n, t),
|
|
|
+ function(t, e) {
|
|
|
+ "china" === t && "台湾" === e.name && e.geometries.push({
|
|
|
+ type: "polygon",
|
|
|
+ exterior: Ay[0]
|
|
|
+ })
|
|
|
+ }(n, t);
|
|
|
+ var i = a[e];
|
|
|
+ i && t.transformTo(i.left, i.top, i.width, i.height)
|
|
|
+ }),
|
|
|
+ Dy(t).parsed = {
|
|
|
+ regions: o,
|
|
|
+ boundingRect: function(t) {
|
|
|
+ for (var e, i = 0; i < t.length; i++) {
|
|
|
+ var n = t[i].getBoundingRect();
|
|
|
+ (e = e || n.clone()).union(n)
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }(o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var Ly = jo();
|
|
|
+ function ky(t, e) {
|
|
|
+ var i, n, o = t.svgXML;
|
|
|
+ try {
|
|
|
+ Y(null != (n = (i = o && function(t, e) {
|
|
|
+ return (new hd).parse(t, e)
|
|
|
+ }(o, {
|
|
|
+ ignoreViewBox: !0,
|
|
|
+ ignoreRootClip: !0
|
|
|
+ }) || {}).root))
|
|
|
+ } catch (t) {
|
|
|
+ throw new Error("Invalid svg format\n" + t.message)
|
|
|
+ }
|
|
|
+ var a = i.width
|
|
|
+ , r = i.height
|
|
|
+ , s = i.viewBoxRect;
|
|
|
+ if (e || (e = null == a || null == r ? n.getBoundingRect() : new Di(0,0,0,0),
|
|
|
+ null != a && (e.width = a),
|
|
|
+ null != r && (e.height = r)),
|
|
|
+ s) {
|
|
|
+ var l = wd(s, e.width, e.height)
|
|
|
+ , u = n;
|
|
|
+ (n = new Ci).add(u),
|
|
|
+ u.scale = l.scale,
|
|
|
+ u.position = l.position
|
|
|
+ }
|
|
|
+ return n.setClipPath(new rs({
|
|
|
+ shape: e.plain()
|
|
|
+ })),
|
|
|
+ {
|
|
|
+ root: n,
|
|
|
+ boundingRect: e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Py = {
|
|
|
+ geoJSON: Cy,
|
|
|
+ svg: {
|
|
|
+ load: function(t, e) {
|
|
|
+ var i = Ly(e).originRoot;
|
|
|
+ if (i)
|
|
|
+ return {
|
|
|
+ root: i,
|
|
|
+ boundingRect: Ly(e).boundingRect
|
|
|
+ };
|
|
|
+ var n = ky(e);
|
|
|
+ return Ly(e).originRoot = n.root,
|
|
|
+ Ly(e).boundingRect = n.boundingRect,
|
|
|
+ n
|
|
|
+ },
|
|
|
+ makeGraphic: function(t, e, i) {
|
|
|
+ var n = Ly(e)
|
|
|
+ , o = n.rootMap || (n.rootMap = Q())
|
|
|
+ , a = o.get(i);
|
|
|
+ if (a)
|
|
|
+ return a;
|
|
|
+ var r = n.originRoot
|
|
|
+ , s = n.boundingRect;
|
|
|
+ return a = n.originRootHostKey ? ky(e, s).root : (n.originRootHostKey = i,
|
|
|
+ r),
|
|
|
+ o.set(i, a)
|
|
|
+ },
|
|
|
+ removeGraphic: function(t, e, i) {
|
|
|
+ var n = Ly(e)
|
|
|
+ , o = n.rootMap;
|
|
|
+ o && o.removeKey(i),
|
|
|
+ i === n.originRootHostKey && (n.originRootHostKey = null)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Ny = {
|
|
|
+ load: function(n, o, a) {
|
|
|
+ var r, s = [], l = Q(), u = Q();
|
|
|
+ return E(Ey(n), function(t) {
|
|
|
+ var e = Py[t.type].load(n, t, a);
|
|
|
+ E(e.regions, function(t) {
|
|
|
+ var e = t.name;
|
|
|
+ o && o.hasOwnProperty(e) && (t = t.cloneShallow(e = o[e])),
|
|
|
+ s.push(t),
|
|
|
+ l.set(e, t),
|
|
|
+ u.set(e, t.center)
|
|
|
+ });
|
|
|
+ var i = e.boundingRect;
|
|
|
+ i && (r ? r.union(i) : r = i.clone())
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ regions: s,
|
|
|
+ regionsMap: l,
|
|
|
+ nameCoordMap: u,
|
|
|
+ boundingRect: r || new Di(0,0,0,0)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ makeGraphic: Oy("makeGraphic"),
|
|
|
+ removeGraphic: Oy("removeGraphic")
|
|
|
+ };
|
|
|
+ function Oy(a) {
|
|
|
+ return function(i, n) {
|
|
|
+ var t = Ey(i)
|
|
|
+ , o = [];
|
|
|
+ return E(t, function(t) {
|
|
|
+ var e = Py[t.type][a];
|
|
|
+ e && o.push(e(i, t, n))
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ey(t) {
|
|
|
+ return Sd.retrieveMap(t) || []
|
|
|
+ }
|
|
|
+ b(sc.extend({
|
|
|
+ type: "series.map",
|
|
|
+ dependencies: ["geo"],
|
|
|
+ layoutMode: "box",
|
|
|
+ needsDrawMap: !1,
|
|
|
+ seriesGroup: [],
|
|
|
+ getInitialData: function(t) {
|
|
|
+ for (var e = Yv(this, {
|
|
|
+ coordDimensions: ["value"],
|
|
|
+ encodeDefaulter: T(Ju, this)
|
|
|
+ }), i = e.mapDimension("value"), n = Q(), o = [], a = [], r = 0, s = e.count(); r < s; r++) {
|
|
|
+ var l = e.getName(r);
|
|
|
+ n.set(l, !0),
|
|
|
+ o.push({
|
|
|
+ name: l,
|
|
|
+ value: e.get(i, r),
|
|
|
+ selected: Zh(e, r, "selected")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return E(Ny.load(this.getMapType(), this.option.nameMap, this.option.nameProperty).regions, function(t) {
|
|
|
+ var e = t.name;
|
|
|
+ n.get(e) || (o.push({
|
|
|
+ name: e
|
|
|
+ }),
|
|
|
+ a.push(e))
|
|
|
+ }),
|
|
|
+ this.updateSelectedMap(o),
|
|
|
+ e.appendValues([], a),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ getHostGeoModel: function() {
|
|
|
+ var t = this.option.geoIndex;
|
|
|
+ return null != t ? this.dependentModels.geo[t] : null
|
|
|
+ },
|
|
|
+ getMapType: function() {
|
|
|
+ return (this.getHostGeoModel() || this).option.map
|
|
|
+ },
|
|
|
+ getRawValue: function(t) {
|
|
|
+ var e = this.getData();
|
|
|
+ return e.get(e.mapDimension("value"), t)
|
|
|
+ },
|
|
|
+ getRegionModel: function(t) {
|
|
|
+ var e = this.getData();
|
|
|
+ return e.getItemModel(e.indexOfName(t))
|
|
|
+ },
|
|
|
+ formatTooltip: function(t) {
|
|
|
+ for (var e = this.getData(), i = tu(this.getRawValue(t)), n = e.getName(t), o = this.seriesGroup, a = [], r = 0; r < o.length; r++) {
|
|
|
+ var s = o[r].originalData.indexOfName(n)
|
|
|
+ , l = e.mapDimension("value");
|
|
|
+ isNaN(o[r].originalData.get(l, s)) || a.push(au(o[r].name))
|
|
|
+ }
|
|
|
+ return a.join(", ") + "<br />" + au(n + " : " + i)
|
|
|
+ },
|
|
|
+ getTooltipPosition: function(t) {
|
|
|
+ if (null != t) {
|
|
|
+ var e = this.getData().getName(t)
|
|
|
+ , i = this.coordinateSystem
|
|
|
+ , n = i.getRegion(e);
|
|
|
+ return n && i.dataToPoint(n.center)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ setZoom: function(t) {
|
|
|
+ this.option.zoom = t
|
|
|
+ },
|
|
|
+ setCenter: function(t) {
|
|
|
+ this.option.center = t
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "geo",
|
|
|
+ map: "",
|
|
|
+ left: "center",
|
|
|
+ top: "center",
|
|
|
+ aspectScale: .75,
|
|
|
+ showLegendSymbol: !0,
|
|
|
+ dataRangeHoverLink: !0,
|
|
|
+ boundingCoords: null,
|
|
|
+ center: null,
|
|
|
+ zoom: 1,
|
|
|
+ scaleLimit: null,
|
|
|
+ label: {
|
|
|
+ show: !1,
|
|
|
+ color: "#000"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: .5,
|
|
|
+ borderColor: "#444",
|
|
|
+ areaColor: "#eee"
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ color: "rgb(100,0,0)"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ areaColor: "rgba(255,215,0,0.8)"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ nameProperty: "name"
|
|
|
+ }
|
|
|
+ }), jv);
|
|
|
+ var Ry = "\0_ec_interaction_mutex";
|
|
|
+ function zy(t, e) {
|
|
|
+ return !!By(t)[e]
|
|
|
+ }
|
|
|
+ function By(t) {
|
|
|
+ return t[Ry] || (t[Ry] = {})
|
|
|
+ }
|
|
|
+ function Vy(i) {
|
|
|
+ this.pointerChecker,
|
|
|
+ this._zr = i,
|
|
|
+ this._opt = {};
|
|
|
+ var t = A
|
|
|
+ , n = t(Gy, this)
|
|
|
+ , o = t(Fy, this)
|
|
|
+ , a = t(Wy, this)
|
|
|
+ , r = t(Hy, this)
|
|
|
+ , s = t(Zy, this);
|
|
|
+ Ct.call(this),
|
|
|
+ this.setPointerChecker = function(t) {
|
|
|
+ this.pointerChecker = t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.enable = function(t, e) {
|
|
|
+ this.disable(),
|
|
|
+ this._opt = D(k(e) || {}, {
|
|
|
+ zoomOnMouseWheel: !0,
|
|
|
+ moveOnMouseMove: !0,
|
|
|
+ moveOnMouseWheel: !1,
|
|
|
+ preventDefaultMouseMove: !0
|
|
|
+ }),
|
|
|
+ null == t && (t = !0),
|
|
|
+ !0 !== t && "move" !== t && "pan" !== t || (i.on("mousedown", n),
|
|
|
+ i.on("mousemove", o),
|
|
|
+ i.on("mouseup", a)),
|
|
|
+ !0 !== t && "scale" !== t && "zoom" !== t || (i.on("mousewheel", r),
|
|
|
+ i.on("pinch", s))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.disable = function() {
|
|
|
+ i.off("mousedown", n),
|
|
|
+ i.off("mousemove", o),
|
|
|
+ i.off("mouseup", a),
|
|
|
+ i.off("mousewheel", r),
|
|
|
+ i.off("pinch", s)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.dispose = this.disable,
|
|
|
+ this.isDragging = function() {
|
|
|
+ return this._dragging
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.isPinching = function() {
|
|
|
+ return this._pinching
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Gy(t) {
|
|
|
+ if (!(Yt(t) || t.target && t.target.draggable)) {
|
|
|
+ var e = t.offsetX
|
|
|
+ , i = t.offsetY;
|
|
|
+ this.pointerChecker && this.pointerChecker(t, e, i) && (this._x = e,
|
|
|
+ this._y = i,
|
|
|
+ this._dragging = !0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Fy(t) {
|
|
|
+ if (this._dragging && Yy("moveOnMouseMove", t, this._opt) && "pinch" !== t.gestureEvent && !zy(this._zr, "globalPan")) {
|
|
|
+ var e = t.offsetX
|
|
|
+ , i = t.offsetY
|
|
|
+ , n = this._x
|
|
|
+ , o = this._y
|
|
|
+ , a = e - n
|
|
|
+ , r = i - o;
|
|
|
+ this._x = e,
|
|
|
+ this._y = i,
|
|
|
+ this._opt.preventDefaultMouseMove && Xt(t.event),
|
|
|
+ Xy(this, "pan", "moveOnMouseMove", t, {
|
|
|
+ dx: a,
|
|
|
+ dy: r,
|
|
|
+ oldX: n,
|
|
|
+ oldY: o,
|
|
|
+ newX: e,
|
|
|
+ newY: i
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Wy(t) {
|
|
|
+ Yt(t) || (this._dragging = !1)
|
|
|
+ }
|
|
|
+ function Hy(t) {
|
|
|
+ var e = Yy("zoomOnMouseWheel", t, this._opt)
|
|
|
+ , i = Yy("moveOnMouseWheel", t, this._opt)
|
|
|
+ , n = t.wheelDelta
|
|
|
+ , o = Math.abs(n)
|
|
|
+ , a = t.offsetX
|
|
|
+ , r = t.offsetY;
|
|
|
+ if (0 !== n && (e || i)) {
|
|
|
+ if (e) {
|
|
|
+ var s = 3 < o ? 1.4 : 1 < o ? 1.2 : 1.1;
|
|
|
+ Uy(this, "zoom", "zoomOnMouseWheel", t, {
|
|
|
+ scale: 0 < n ? s : 1 / s,
|
|
|
+ originX: a,
|
|
|
+ originY: r
|
|
|
+ })
|
|
|
+ }
|
|
|
+ if (i) {
|
|
|
+ var l = Math.abs(n);
|
|
|
+ Uy(this, "scrollMove", "moveOnMouseWheel", t, {
|
|
|
+ scrollDelta: (0 < n ? 1 : -1) * (3 < l ? .4 : 1 < l ? .15 : .05),
|
|
|
+ originX: a,
|
|
|
+ originY: r
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Zy(t) {
|
|
|
+ zy(this._zr, "globalPan") || Uy(this, "zoom", null, t, {
|
|
|
+ scale: 1 < t.pinchScale ? 1.1 : 1 / 1.1,
|
|
|
+ originX: t.pinchX,
|
|
|
+ originY: t.pinchY
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Uy(t, e, i, n, o) {
|
|
|
+ t.pointerChecker && t.pointerChecker(n, o.originX, o.originY) && (Xt(n.event),
|
|
|
+ Xy(t, e, i, n, o))
|
|
|
+ }
|
|
|
+ function Xy(t, e, i, n, o) {
|
|
|
+ o.isAvailableBehavior = A(Yy, null, i, n),
|
|
|
+ t.trigger(e, o)
|
|
|
+ }
|
|
|
+ function Yy(t, e, i) {
|
|
|
+ var n = i[t];
|
|
|
+ return !t || n && (!R(n) || e.event[n + "Key"])
|
|
|
+ }
|
|
|
+ function jy(t, e, i) {
|
|
|
+ var n = t.target
|
|
|
+ , o = n.position;
|
|
|
+ o[0] += e,
|
|
|
+ o[1] += i,
|
|
|
+ n.dirty()
|
|
|
+ }
|
|
|
+ function qy(t, e, i, n) {
|
|
|
+ var o = t.target
|
|
|
+ , a = t.zoomLimit
|
|
|
+ , r = o.position
|
|
|
+ , s = o.scale
|
|
|
+ , l = t.zoom = t.zoom || 1;
|
|
|
+ if (l *= e,
|
|
|
+ a) {
|
|
|
+ var u = a.min || 0
|
|
|
+ , h = a.max || 1 / 0;
|
|
|
+ l = Math.max(Math.min(h, l), u)
|
|
|
+ }
|
|
|
+ var c = l / t.zoom;
|
|
|
+ t.zoom = l,
|
|
|
+ r[0] -= (i - r[0]) * (c - 1),
|
|
|
+ r[1] -= (n - r[1]) * (c - 1),
|
|
|
+ s[0] *= c,
|
|
|
+ s[1] *= c,
|
|
|
+ o.dirty()
|
|
|
+ }
|
|
|
+ _f({
|
|
|
+ type: "takeGlobalCursor",
|
|
|
+ event: "globalCursorTaken",
|
|
|
+ update: "update"
|
|
|
+ }, function() {}),
|
|
|
+ b(Vy, Ct);
|
|
|
+ var Ky = {
|
|
|
+ axisPointer: 1,
|
|
|
+ tooltip: 1,
|
|
|
+ brush: 1
|
|
|
+ };
|
|
|
+ function $y(t, e, i) {
|
|
|
+ var n = e.getComponentByElement(t.topTarget)
|
|
|
+ , o = n && n.coordinateSystem;
|
|
|
+ return n && n !== i && !Ky[n.mainType] && o && o.model !== i
|
|
|
+ }
|
|
|
+ function Jy(t) {
|
|
|
+ var e = t.getItemStyle()
|
|
|
+ , i = t.get("areaColor");
|
|
|
+ return null != i && (e.fill = i),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function Qy(i, t) {
|
|
|
+ t.eachChild(function(e) {
|
|
|
+ E(e.__regions, function(t) {
|
|
|
+ e.trigger(i.isSelected(t.name) ? "emphasis" : "normal")
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function tx(t, e) {
|
|
|
+ var i = new Ci;
|
|
|
+ this.uid = Nl("ec_map_draw"),
|
|
|
+ this._controller = new Vy(t.getZr()),
|
|
|
+ this._controllerHost = {
|
|
|
+ target: e ? i : null
|
|
|
+ },
|
|
|
+ this.group = i,
|
|
|
+ this._updateGroup = e,
|
|
|
+ this._mouseDownFlag,
|
|
|
+ this._mapName,
|
|
|
+ this._initialized,
|
|
|
+ i.add(this._regionsGroup = new Ci),
|
|
|
+ i.add(this._backgroundGroup = new Ci)
|
|
|
+ }
|
|
|
+ tx.prototype = {
|
|
|
+ constructor: tx,
|
|
|
+ draw: function(_, t, e, i, n) {
|
|
|
+ var w = "geo" === _.mainType
|
|
|
+ , b = _.getData && _.getData();
|
|
|
+ w && t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "map"
|
|
|
+ }, function(t) {
|
|
|
+ b || t.getHostGeoModel() !== _ || (b = t.getData())
|
|
|
+ });
|
|
|
+ var o = _.coordinateSystem;
|
|
|
+ this._updateBackground(o);
|
|
|
+ var S, M = this._regionsGroup, I = this.group, a = o.getTransformInfo(), T = !M.childAt(0) || n;
|
|
|
+ if (T)
|
|
|
+ I.transform = a.roamTransform,
|
|
|
+ I.decomposeTransform(),
|
|
|
+ I.dirty();
|
|
|
+ else {
|
|
|
+ var r = new ve;
|
|
|
+ r.transform = a.roamTransform,
|
|
|
+ r.decomposeTransform();
|
|
|
+ var s = {
|
|
|
+ scale: r.scale,
|
|
|
+ position: r.position
|
|
|
+ };
|
|
|
+ S = r.scale,
|
|
|
+ cl(I, s, _)
|
|
|
+ }
|
|
|
+ var A = a.rawScale
|
|
|
+ , D = a.rawPosition;
|
|
|
+ M.removeAll();
|
|
|
+ var C = ["itemStyle"]
|
|
|
+ , L = ["emphasis", "itemStyle"]
|
|
|
+ , k = ["label"]
|
|
|
+ , P = ["emphasis", "label"]
|
|
|
+ , N = Q();
|
|
|
+ E(o.regions, function(t) {
|
|
|
+ var e = N.get(t.name) || N.set(t.name, new Ci)
|
|
|
+ , a = new ps({
|
|
|
+ segmentIgnoreThreshold: 1,
|
|
|
+ shape: {
|
|
|
+ paths: []
|
|
|
+ }
|
|
|
+ });
|
|
|
+ e.add(a);
|
|
|
+ var i, n = (x = _.getRegionModel(t.name) || _).getModel(C), o = x.getModel(L), r = Jy(n), s = Jy(o), l = x.getModel(k), u = x.getModel(P);
|
|
|
+ if (b) {
|
|
|
+ i = b.indexOfName(t.name);
|
|
|
+ var h = b.getItemVisual(i, "color", !0);
|
|
|
+ h && (r.fill = h)
|
|
|
+ }
|
|
|
+ function c(t) {
|
|
|
+ return [t[0] * A[0] + D[0], t[1] * A[1] + D[1]]
|
|
|
+ }
|
|
|
+ E(t.geometries, function(t) {
|
|
|
+ if ("polygon" === t.type) {
|
|
|
+ for (var e = [], i = 0; i < t.exterior.length; ++i)
|
|
|
+ e.push(c(t.exterior[i]));
|
|
|
+ a.shape.paths.push(new Qr({
|
|
|
+ segmentIgnoreThreshold: 1,
|
|
|
+ shape: {
|
|
|
+ points: e
|
|
|
+ }
|
|
|
+ }));
|
|
|
+ for (i = 0; i < (t.interiors ? t.interiors.length : 0); ++i) {
|
|
|
+ for (var n = t.interiors[i], o = (e = [],
|
|
|
+ 0); o < n.length; ++o)
|
|
|
+ e.push(c(n[o]));
|
|
|
+ a.shape.paths.push(new Qr({
|
|
|
+ segmentIgnoreThreshold: 1,
|
|
|
+ shape: {
|
|
|
+ points: e
|
|
|
+ }
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a.setStyle(r),
|
|
|
+ a.style.strokeNoScale = !0,
|
|
|
+ a.culling = !0;
|
|
|
+ var d = l.get("show")
|
|
|
+ , f = u.get("show")
|
|
|
+ , p = b && isNaN(b.get(b.mapDimension("value"), i))
|
|
|
+ , g = b && b.getItemLayout(i);
|
|
|
+ if (w || p && (d || f) || g && g.showLabel) {
|
|
|
+ var m, v = w ? t.name : i;
|
|
|
+ (!b || 0 <= i) && (m = _);
|
|
|
+ var y = new Ur({
|
|
|
+ position: c(t.center.slice()),
|
|
|
+ scale: [1 / I.scale[0], 1 / I.scale[1]],
|
|
|
+ z2: 10,
|
|
|
+ silent: !0
|
|
|
+ });
|
|
|
+ if (el(y.style, y.hoverStyle = {}, l, u, {
|
|
|
+ labelFetcher: m,
|
|
|
+ labelDataIndex: v,
|
|
|
+ defaultText: t.name,
|
|
|
+ useInsideStyle: !1
|
|
|
+ }, {
|
|
|
+ textAlign: "center",
|
|
|
+ textVerticalAlign: "middle"
|
|
|
+ }),
|
|
|
+ !T)
|
|
|
+ cl(y, {
|
|
|
+ scale: [1 / S[0], 1 / S[1]]
|
|
|
+ }, _);
|
|
|
+ e.add(y)
|
|
|
+ }
|
|
|
+ if (b)
|
|
|
+ b.setItemGraphicEl(i, e);
|
|
|
+ else {
|
|
|
+ var x = _.getRegionModel(t.name);
|
|
|
+ a.eventData = {
|
|
|
+ componentType: "geo",
|
|
|
+ componentIndex: _.componentIndex,
|
|
|
+ geoIndex: _.componentIndex,
|
|
|
+ name: t.name,
|
|
|
+ region: x && x.option || {}
|
|
|
+ }
|
|
|
+ }
|
|
|
+ (e.__regions || (e.__regions = [])).push(t),
|
|
|
+ e.highDownSilentOnTouch = !!_.get("selectedMode"),
|
|
|
+ $s(e, s),
|
|
|
+ M.add(e)
|
|
|
+ }),
|
|
|
+ this._updateController(_, t, e),
|
|
|
+ function(n, o, a, r, s) {
|
|
|
+ a.off("click"),
|
|
|
+ a.off("mousedown"),
|
|
|
+ o.get("selectedMode") && (a.on("mousedown", function() {
|
|
|
+ n._mouseDownFlag = !0
|
|
|
+ }),
|
|
|
+ a.on("click", function(t) {
|
|
|
+ if (n._mouseDownFlag) {
|
|
|
+ n._mouseDownFlag = !1;
|
|
|
+ for (var e = t.target; !e.__regions; )
|
|
|
+ e = e.parent;
|
|
|
+ if (e) {
|
|
|
+ var i = {
|
|
|
+ type: ("geo" === o.mainType ? "geo" : "map") + "ToggleSelect",
|
|
|
+ batch: O(e.__regions, function(t) {
|
|
|
+ return {
|
|
|
+ name: t.name,
|
|
|
+ from: s.uid
|
|
|
+ }
|
|
|
+ })
|
|
|
+ };
|
|
|
+ i[o.mainType + "Id"] = o.id,
|
|
|
+ r.dispatchAction(i),
|
|
|
+ Qy(o, a)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }))
|
|
|
+ }(this, _, M, e, i),
|
|
|
+ Qy(_, M)
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this._regionsGroup.removeAll(),
|
|
|
+ this._backgroundGroup.removeAll(),
|
|
|
+ this._controller.dispose(),
|
|
|
+ this._mapName && Ny.removeGraphic(this._mapName, this.uid),
|
|
|
+ this._mapName = null,
|
|
|
+ this._controllerHost = {}
|
|
|
+ },
|
|
|
+ _updateBackground: function(t) {
|
|
|
+ var e = t.map;
|
|
|
+ this._mapName !== e && E(Ny.makeGraphic(e, this.uid), function(t) {
|
|
|
+ this._backgroundGroup.add(t)
|
|
|
+ }, this),
|
|
|
+ this._mapName = e
|
|
|
+ },
|
|
|
+ _updateController: function(n, t, o) {
|
|
|
+ var a = n.coordinateSystem
|
|
|
+ , e = this._controller
|
|
|
+ , i = this._controllerHost;
|
|
|
+ i.zoomLimit = n.get("scaleLimit"),
|
|
|
+ i.zoom = a.getZoom(),
|
|
|
+ e.enable(n.get("roam") || !1);
|
|
|
+ var r = n.mainType;
|
|
|
+ function s() {
|
|
|
+ var t = {
|
|
|
+ type: "geoRoam",
|
|
|
+ componentType: r
|
|
|
+ };
|
|
|
+ return t[r + "Id"] = n.id,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ e.off("pan").on("pan", function(t) {
|
|
|
+ this._mouseDownFlag = !1,
|
|
|
+ jy(i, t.dx, t.dy),
|
|
|
+ o.dispatchAction(P(s(), {
|
|
|
+ dx: t.dx,
|
|
|
+ dy: t.dy
|
|
|
+ }))
|
|
|
+ }, this),
|
|
|
+ e.off("zoom").on("zoom", function(t) {
|
|
|
+ if (this._mouseDownFlag = !1,
|
|
|
+ qy(i, t.scale, t.originX, t.originY),
|
|
|
+ o.dispatchAction(P(s(), {
|
|
|
+ zoom: t.scale,
|
|
|
+ originX: t.originX,
|
|
|
+ originY: t.originY
|
|
|
+ })),
|
|
|
+ this._updateGroup) {
|
|
|
+ var e = this.group.scale;
|
|
|
+ this._regionsGroup.traverse(function(t) {
|
|
|
+ "text" === t.type && t.attr("scale", [1 / e[0], 1 / e[1]])
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }, this),
|
|
|
+ e.setPointerChecker(function(t, e, i) {
|
|
|
+ return a.getViewRectAfterRoam().contain(e, i) && !$y(t, o, n)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var ex = "__seriesMapHighDown"
|
|
|
+ , ix = "__seriesMapCallKey";
|
|
|
+ function nx(t) {
|
|
|
+ var e = this[ex];
|
|
|
+ e && e.recordVersion === this[ix] && ox(e, t)
|
|
|
+ }
|
|
|
+ function ox(t, e) {
|
|
|
+ var i = t.circle
|
|
|
+ , n = t.labelModel
|
|
|
+ , o = t.hoverLabelModel
|
|
|
+ , a = t.emphasisText
|
|
|
+ , r = t.normalText;
|
|
|
+ e ? (i.style.extendFrom(nl({}, o, {
|
|
|
+ text: o.get("show") ? a : null
|
|
|
+ }, {
|
|
|
+ isRectText: !0,
|
|
|
+ useInsideStyle: !1
|
|
|
+ }, !0)),
|
|
|
+ i.__mapOriginalZ2 = i.z2,
|
|
|
+ i.z2 += bs) : (nl(i.style, n, {
|
|
|
+ text: n.get("show") ? r : null,
|
|
|
+ textPosition: n.getShallow("position") || "bottom"
|
|
|
+ }, {
|
|
|
+ isRectText: !0,
|
|
|
+ useInsideStyle: !1
|
|
|
+ }),
|
|
|
+ i.dirty(!1),
|
|
|
+ null != i.__mapOriginalZ2 && (i.z2 = i.__mapOriginalZ2,
|
|
|
+ i.__mapOriginalZ2 = null))
|
|
|
+ }
|
|
|
+ function ax(t, e, i) {
|
|
|
+ var n = t.getZoom()
|
|
|
+ , o = t.getCenter()
|
|
|
+ , a = e.zoom
|
|
|
+ , r = t.dataToPoint(o);
|
|
|
+ if (null != e.dx && null != e.dy) {
|
|
|
+ r[0] -= e.dx,
|
|
|
+ r[1] -= e.dy;
|
|
|
+ o = t.pointToData(r);
|
|
|
+ t.setCenter(o)
|
|
|
+ }
|
|
|
+ if (null != a) {
|
|
|
+ if (i) {
|
|
|
+ var s = i.min || 0
|
|
|
+ , l = i.max || 1 / 0;
|
|
|
+ a = Math.max(Math.min(n * a, l), s) / n
|
|
|
+ }
|
|
|
+ t.scale[0] *= a,
|
|
|
+ t.scale[1] *= a;
|
|
|
+ var u = t.position
|
|
|
+ , h = (e.originX - u[0]) * (a - 1)
|
|
|
+ , c = (e.originY - u[1]) * (a - 1);
|
|
|
+ u[0] -= h,
|
|
|
+ u[1] -= c,
|
|
|
+ t.updateTransform();
|
|
|
+ o = t.pointToData(r);
|
|
|
+ t.setCenter(o),
|
|
|
+ t.setZoom(a * n)
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ center: t.getCenter(),
|
|
|
+ zoom: t.getZoom()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Cf({
|
|
|
+ type: "map",
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ if (!n || "mapToggleSelect" !== n.type || n.from !== this.uid) {
|
|
|
+ var o = this.group;
|
|
|
+ if (o.removeAll(),
|
|
|
+ !t.getHostGeoModel()) {
|
|
|
+ if (n && "geoRoam" === n.type && "series" === n.componentType && n.seriesId === t.id)
|
|
|
+ (a = this._mapDraw) && o.add(a.group);
|
|
|
+ else if (t.needsDrawMap) {
|
|
|
+ var a = this._mapDraw || new tx(i,!0);
|
|
|
+ o.add(a.group),
|
|
|
+ a.draw(t, e, i, this, n),
|
|
|
+ this._mapDraw = a
|
|
|
+ } else
|
|
|
+ this._mapDraw && this._mapDraw.remove(),
|
|
|
+ this._mapDraw = null;
|
|
|
+ t.get("showLegendSymbol") && e.getComponent("legend") && this._renderSymbols(t, e, i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this._mapDraw && this._mapDraw.remove(),
|
|
|
+ this._mapDraw = null,
|
|
|
+ this.group.removeAll()
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._mapDraw && this._mapDraw.remove(),
|
|
|
+ this._mapDraw = null
|
|
|
+ },
|
|
|
+ _renderSymbols: function(x, t, e) {
|
|
|
+ var _ = x.originalData
|
|
|
+ , w = this.group;
|
|
|
+ _.each(_.mapDimension("value"), function(t, e) {
|
|
|
+ if (!isNaN(t)) {
|
|
|
+ var i = _.getItemLayout(e);
|
|
|
+ if (i && i.point) {
|
|
|
+ var n = i.point
|
|
|
+ , o = i.offset
|
|
|
+ , a = new Yr({
|
|
|
+ style: {
|
|
|
+ fill: x.getData().getVisual("color")
|
|
|
+ },
|
|
|
+ shape: {
|
|
|
+ cx: n[0] + 9 * o,
|
|
|
+ cy: n[1],
|
|
|
+ r: 3
|
|
|
+ },
|
|
|
+ silent: !0,
|
|
|
+ z2: 8 + (o ? 0 : bs + 1)
|
|
|
+ });
|
|
|
+ if (!o) {
|
|
|
+ var r = x.mainSeries.getData()
|
|
|
+ , s = _.getName(e)
|
|
|
+ , l = r.indexOfName(s)
|
|
|
+ , u = _.getItemModel(e)
|
|
|
+ , h = u.getModel("label")
|
|
|
+ , c = u.getModel("emphasis.label")
|
|
|
+ , d = r.getItemGraphicEl(l)
|
|
|
+ , f = H(x.getFormattedLabel(l, "normal"), s)
|
|
|
+ , p = H(x.getFormattedLabel(l, "emphasis"), f)
|
|
|
+ , g = d[ex]
|
|
|
+ , m = Math.random();
|
|
|
+ if (!g) {
|
|
|
+ g = d[ex] = {};
|
|
|
+ var v = T(nx, !0)
|
|
|
+ , y = T(nx, !1);
|
|
|
+ d.on("mouseover", v).on("mouseout", y).on("emphasis", v).on("normal", y)
|
|
|
+ }
|
|
|
+ P(g, {
|
|
|
+ recordVersion: d[ix] = m,
|
|
|
+ circle: a,
|
|
|
+ labelModel: h,
|
|
|
+ hoverLabelModel: c,
|
|
|
+ emphasisText: p,
|
|
|
+ normalText: f
|
|
|
+ }),
|
|
|
+ ox(g, !1)
|
|
|
+ }
|
|
|
+ w.add(a)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "geoRoam",
|
|
|
+ event: "geoRoam",
|
|
|
+ update: "updateTransform"
|
|
|
+ }, function(n, t) {
|
|
|
+ var o = n.componentType || "series";
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: o,
|
|
|
+ query: n
|
|
|
+ }, function(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ if ("geo" === e.type) {
|
|
|
+ var i = ax(e, n, t.get("scaleLimit"));
|
|
|
+ t.setCenter && t.setCenter(i.center),
|
|
|
+ t.setZoom && t.setZoom(i.zoom),
|
|
|
+ "series" === o && E(t.seriesGroup, function(t) {
|
|
|
+ t.setCenter(i.center),
|
|
|
+ t.setZoom(i.zoom)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var rx = bt;
|
|
|
+ function sx() {
|
|
|
+ ve.call(this)
|
|
|
+ }
|
|
|
+ function lx(t) {
|
|
|
+ this.name = t,
|
|
|
+ this.zoomLimit,
|
|
|
+ ve.call(this),
|
|
|
+ this._roamTransformable = new sx,
|
|
|
+ this._rawTransformable = new sx,
|
|
|
+ this._center,
|
|
|
+ this._zoom
|
|
|
+ }
|
|
|
+ function ux(t, e, i, n) {
|
|
|
+ var o = i.seriesModel
|
|
|
+ , a = o ? o.coordinateSystem : null;
|
|
|
+ return a === this ? a[t](n) : null
|
|
|
+ }
|
|
|
+ function hx(t, e, i, n) {
|
|
|
+ lx.call(this, t),
|
|
|
+ this.map = e;
|
|
|
+ var o = Ny.load(e, i);
|
|
|
+ this._nameCoordMap = o.nameCoordMap,
|
|
|
+ this._regionsMap = o.regionsMap,
|
|
|
+ this._invertLongitute = null == n || n,
|
|
|
+ this.regions = o.regions,
|
|
|
+ this._rect = o.boundingRect
|
|
|
+ }
|
|
|
+ function cx(t, e, i, n) {
|
|
|
+ var o = i.geoModel
|
|
|
+ , a = i.seriesModel
|
|
|
+ , r = o ? o.coordinateSystem : a ? a.coordinateSystem || (a.getReferringComponents("geo")[0] || {}).coordinateSystem : null;
|
|
|
+ return r === this ? r[t](n) : null
|
|
|
+ }
|
|
|
+ function dx(t, e) {
|
|
|
+ var i = t.get("boundingCoords");
|
|
|
+ if (null != i) {
|
|
|
+ var n = i[0]
|
|
|
+ , o = i[1];
|
|
|
+ isNaN(n[0]) || isNaN(n[1]) || isNaN(o[0]) || isNaN(o[1]) || this.setBoundingRect(n[0], n[1], o[0] - n[0], o[1] - n[1])
|
|
|
+ }
|
|
|
+ var a, r = this.getBoundingRect(), s = t.get("layoutCenter"), l = t.get("layoutSize"), u = e.getWidth(), h = e.getHeight(), c = r.width / r.height * this.aspectScale, d = !1;
|
|
|
+ if (s && l && (s = [Rl(s[0], u), Rl(s[1], h)],
|
|
|
+ l = Rl(l, Math.min(u, h)),
|
|
|
+ isNaN(s[0]) || isNaN(s[1]) || isNaN(l) || (d = !0)),
|
|
|
+ d) {
|
|
|
+ var f = {};
|
|
|
+ 1 < c ? (f.width = l,
|
|
|
+ f.height = l / c) : (f.height = l,
|
|
|
+ f.width = l * c),
|
|
|
+ f.y = s[1] - f.height / 2,
|
|
|
+ f.x = s[0] - f.width / 2
|
|
|
+ } else
|
|
|
+ (a = t.getBoxLayoutParams()).aspect = c,
|
|
|
+ f = bu(a, {
|
|
|
+ width: u,
|
|
|
+ height: h
|
|
|
+ });
|
|
|
+ this.setViewRect(f.x, f.y, f.width, f.height),
|
|
|
+ this.setCenter(t.get("center")),
|
|
|
+ this.setZoom(t.get("zoom"))
|
|
|
+ }
|
|
|
+ function fx(i, t) {
|
|
|
+ E(t.get("geoCoord"), function(t, e) {
|
|
|
+ i.addGeoCoord(e, t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ b(sx, ve),
|
|
|
+ lx.prototype = {
|
|
|
+ constructor: lx,
|
|
|
+ type: "view",
|
|
|
+ dimensions: ["x", "y"],
|
|
|
+ setBoundingRect: function(t, e, i, n) {
|
|
|
+ return this._rect = new Di(t,e,i,n),
|
|
|
+ this._rect
|
|
|
+ },
|
|
|
+ getBoundingRect: function() {
|
|
|
+ return this._rect
|
|
|
+ },
|
|
|
+ setViewRect: function(t, e, i, n) {
|
|
|
+ this.transformTo(t, e, i, n),
|
|
|
+ this._viewRect = new Di(t,e,i,n)
|
|
|
+ },
|
|
|
+ transformTo: function(t, e, i, n) {
|
|
|
+ var o = this.getBoundingRect()
|
|
|
+ , a = this._rawTransformable;
|
|
|
+ a.transform = o.calculateTransform(new Di(t,e,i,n)),
|
|
|
+ a.decomposeTransform(),
|
|
|
+ this._updateTransform()
|
|
|
+ },
|
|
|
+ setCenter: function(t) {
|
|
|
+ t && (this._center = t,
|
|
|
+ this._updateCenterAndZoom())
|
|
|
+ },
|
|
|
+ setZoom: function(t) {
|
|
|
+ t = t || 1;
|
|
|
+ var e = this.zoomLimit;
|
|
|
+ e && (null != e.max && (t = Math.min(e.max, t)),
|
|
|
+ null != e.min && (t = Math.max(e.min, t))),
|
|
|
+ this._zoom = t,
|
|
|
+ this._updateCenterAndZoom()
|
|
|
+ },
|
|
|
+ getDefaultCenter: function() {
|
|
|
+ var t = this.getBoundingRect();
|
|
|
+ return [t.x + t.width / 2, t.y + t.height / 2]
|
|
|
+ },
|
|
|
+ getCenter: function() {
|
|
|
+ return this._center || this.getDefaultCenter()
|
|
|
+ },
|
|
|
+ getZoom: function() {
|
|
|
+ return this._zoom || 1
|
|
|
+ },
|
|
|
+ getRoamTransform: function() {
|
|
|
+ return this._roamTransformable.getLocalTransform()
|
|
|
+ },
|
|
|
+ _updateCenterAndZoom: function() {
|
|
|
+ var t = this._rawTransformable.getLocalTransform()
|
|
|
+ , e = this._roamTransformable
|
|
|
+ , i = this.getDefaultCenter()
|
|
|
+ , n = this.getCenter()
|
|
|
+ , o = this.getZoom();
|
|
|
+ n = bt([], n, t),
|
|
|
+ i = bt([], i, t),
|
|
|
+ e.origin = n,
|
|
|
+ e.position = [i[0] - n[0], i[1] - n[1]],
|
|
|
+ e.scale = [o, o],
|
|
|
+ this._updateTransform()
|
|
|
+ },
|
|
|
+ _updateTransform: function() {
|
|
|
+ var t = this._roamTransformable
|
|
|
+ , e = this._rawTransformable;
|
|
|
+ (e.parent = t).updateTransform(),
|
|
|
+ e.updateTransform(),
|
|
|
+ se(this.transform || (this.transform = []), e.transform || ae()),
|
|
|
+ this._rawTransform = e.getLocalTransform(),
|
|
|
+ this.invTransform = this.invTransform || [],
|
|
|
+ de(this.invTransform, this.transform),
|
|
|
+ this.decomposeTransform()
|
|
|
+ },
|
|
|
+ getTransformInfo: function() {
|
|
|
+ var t = this._roamTransformable.transform
|
|
|
+ , e = this._rawTransformable;
|
|
|
+ return {
|
|
|
+ roamTransform: t ? U(t) : ae(),
|
|
|
+ rawScale: U(e.scale),
|
|
|
+ rawPosition: U(e.position)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getViewRect: function() {
|
|
|
+ return this._viewRect
|
|
|
+ },
|
|
|
+ getViewRectAfterRoam: function() {
|
|
|
+ var t = this.getBoundingRect().clone();
|
|
|
+ return t.applyTransform(this.transform),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ dataToPoint: function(t, e, i) {
|
|
|
+ var n = e ? this._rawTransform : this.transform;
|
|
|
+ return i = i || [],
|
|
|
+ n ? rx(i, t, n) : at(i, t)
|
|
|
+ },
|
|
|
+ pointToData: function(t) {
|
|
|
+ var e = this.invTransform;
|
|
|
+ return e ? rx([], t, e) : [t[0], t[1]]
|
|
|
+ },
|
|
|
+ convertToPixel: T(ux, "dataToPoint"),
|
|
|
+ convertFromPixel: T(ux, "pointToData"),
|
|
|
+ containPoint: function(t) {
|
|
|
+ return this.getViewRectAfterRoam().contain(t[0], t[1])
|
|
|
+ }
|
|
|
+ },
|
|
|
+ b(lx, ve),
|
|
|
+ hx.prototype = {
|
|
|
+ constructor: hx,
|
|
|
+ type: "geo",
|
|
|
+ dimensions: ["lng", "lat"],
|
|
|
+ containCoord: function(t) {
|
|
|
+ for (var e = this.regions, i = 0; i < e.length; i++)
|
|
|
+ if (e[i].contain(t))
|
|
|
+ return !0;
|
|
|
+ return !1
|
|
|
+ },
|
|
|
+ transformTo: function(t, e, i, n) {
|
|
|
+ var o = this.getBoundingRect()
|
|
|
+ , a = this._invertLongitute;
|
|
|
+ o = o.clone(),
|
|
|
+ a && (o.y = -o.y - o.height);
|
|
|
+ var r = this._rawTransformable;
|
|
|
+ if (r.transform = o.calculateTransform(new Di(t,e,i,n)),
|
|
|
+ r.decomposeTransform(),
|
|
|
+ a) {
|
|
|
+ var s = r.scale;
|
|
|
+ s[1] = -s[1]
|
|
|
+ }
|
|
|
+ r.updateTransform(),
|
|
|
+ this._updateTransform()
|
|
|
+ },
|
|
|
+ getRegion: function(t) {
|
|
|
+ return this._regionsMap.get(t)
|
|
|
+ },
|
|
|
+ getRegionByCoord: function(t) {
|
|
|
+ for (var e = this.regions, i = 0; i < e.length; i++)
|
|
|
+ if (e[i].contain(t))
|
|
|
+ return e[i]
|
|
|
+ },
|
|
|
+ addGeoCoord: function(t, e) {
|
|
|
+ this._nameCoordMap.set(t, e)
|
|
|
+ },
|
|
|
+ getGeoCoord: function(t) {
|
|
|
+ return this._nameCoordMap.get(t)
|
|
|
+ },
|
|
|
+ getBoundingRect: function() {
|
|
|
+ return this._rect
|
|
|
+ },
|
|
|
+ dataToPoint: function(t, e, i) {
|
|
|
+ if ("string" == typeof t && (t = this.getGeoCoord(t)),
|
|
|
+ t)
|
|
|
+ return lx.prototype.dataToPoint.call(this, t, e, i)
|
|
|
+ },
|
|
|
+ convertToPixel: T(cx, "dataToPoint"),
|
|
|
+ convertFromPixel: T(cx, "pointToData")
|
|
|
+ },
|
|
|
+ b(hx, lx);
|
|
|
+ var px = {
|
|
|
+ dimensions: hx.prototype.dimensions,
|
|
|
+ create: function(t, s) {
|
|
|
+ var l = [];
|
|
|
+ t.eachComponent("geo", function(t, e) {
|
|
|
+ var i = t.get("map")
|
|
|
+ , n = t.get("aspectScale")
|
|
|
+ , o = !0
|
|
|
+ , a = Sd.retrieveMap(i);
|
|
|
+ a && a[0] && "svg" === a[0].type ? (null == n && (n = 1),
|
|
|
+ o = !1) : null == n && (n = .75);
|
|
|
+ var r = new hx(i + e,i,t.get("nameMap"),o);
|
|
|
+ r.aspectScale = n,
|
|
|
+ r.zoomLimit = t.get("scaleLimit"),
|
|
|
+ l.push(r),
|
|
|
+ fx(r, t),
|
|
|
+ (t.coordinateSystem = r).model = t,
|
|
|
+ r.resize = dx,
|
|
|
+ r.resize(t, s)
|
|
|
+ }),
|
|
|
+ t.eachSeries(function(t) {
|
|
|
+ if ("geo" === t.get("coordinateSystem")) {
|
|
|
+ var e = t.get("geoIndex") || 0;
|
|
|
+ t.coordinateSystem = l[e]
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var i = {};
|
|
|
+ return t.eachSeriesByType("map", function(t) {
|
|
|
+ if (!t.getHostGeoModel()) {
|
|
|
+ var e = t.getMapType();
|
|
|
+ i[e] = i[e] || [],
|
|
|
+ i[e].push(t)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ E(i, function(t, e) {
|
|
|
+ var i = new hx(e,e,p(O(t, function(t) {
|
|
|
+ return t.get("nameMap")
|
|
|
+ })));
|
|
|
+ i.zoomLimit = W.apply(null, O(t, function(t) {
|
|
|
+ return t.get("scaleLimit")
|
|
|
+ })),
|
|
|
+ l.push(i),
|
|
|
+ i.resize = dx,
|
|
|
+ i.aspectScale = t[0].get("aspectScale"),
|
|
|
+ i.resize(t[0], s),
|
|
|
+ E(t, function(t) {
|
|
|
+ fx(t.coordinateSystem = i, t)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ l
|
|
|
+ },
|
|
|
+ getFilledRegions: function(t, e, i) {
|
|
|
+ for (var n = (t || []).slice(), o = Q(), a = 0; a < n.length; a++)
|
|
|
+ o.set(n[a].name, n[a]);
|
|
|
+ return E(Ny.load(e, i).regions, function(t) {
|
|
|
+ var e = t.name;
|
|
|
+ o.get(e) || n.push({
|
|
|
+ name: e
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ };
|
|
|
+ wf("geo", px);
|
|
|
+ bf(function(i) {
|
|
|
+ var o = {};
|
|
|
+ i.eachSeriesByType("map", function(t) {
|
|
|
+ var e = t.getMapType();
|
|
|
+ if (!t.getHostGeoModel() && !o[e]) {
|
|
|
+ var l = {};
|
|
|
+ E(t.seriesGroup, function(t) {
|
|
|
+ var r = t.coordinateSystem
|
|
|
+ , s = t.originalData;
|
|
|
+ t.get("showLegendSymbol") && i.getComponent("legend") && s.each(s.mapDimension("value"), function(t, e) {
|
|
|
+ var i = s.getName(e)
|
|
|
+ , n = r.getRegion(i);
|
|
|
+ if (n && !isNaN(t)) {
|
|
|
+ var o = l[i] || 0
|
|
|
+ , a = r.dataToPoint(n.center);
|
|
|
+ l[i] = o + 1,
|
|
|
+ s.setItemLayout(e, {
|
|
|
+ point: a,
|
|
|
+ offset: o
|
|
|
+ })
|
|
|
+ }
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var n = t.getData();
|
|
|
+ n.each(function(t) {
|
|
|
+ var e = n.getName(t)
|
|
|
+ , i = n.getItemLayout(t) || {};
|
|
|
+ i.showLabel = !l[e],
|
|
|
+ n.setItemLayout(t, i)
|
|
|
+ }),
|
|
|
+ o[e] = !0
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ Sf(function(t) {
|
|
|
+ t.eachSeriesByType("map", function(t) {
|
|
|
+ var e = t.get("color")
|
|
|
+ , i = t.getModel("itemStyle")
|
|
|
+ , n = i.get("areaColor")
|
|
|
+ , o = i.get("color") || e[t.seriesIndex % e.length];
|
|
|
+ t.getData().setVisual({
|
|
|
+ areaColor: n,
|
|
|
+ color: o
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ xf(Ld.PROCESSOR.STATISTIC, function(t) {
|
|
|
+ var n = {};
|
|
|
+ t.eachSeriesByType("map", function(t) {
|
|
|
+ var e = t.getHostGeoModel()
|
|
|
+ , i = e ? "o" + e.id : "i" + t.getMapType();
|
|
|
+ (n[i] = n[i] || []).push(t)
|
|
|
+ }),
|
|
|
+ E(n, function(t, e) {
|
|
|
+ for (var i = function(u, h) {
|
|
|
+ var c = {};
|
|
|
+ return E(u, function(n) {
|
|
|
+ n.each(n.mapDimension("value"), function(t, e) {
|
|
|
+ var i = "ec-" + n.getName(e);
|
|
|
+ c[i] = c[i] || [],
|
|
|
+ isNaN(t) || c[i].push(t)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ u[0].map(u[0].mapDimension("value"), function(t, e) {
|
|
|
+ for (var i, n = "ec-" + u[0].getName(e), o = 0, a = 1 / 0, r = -1 / 0, s = c[n].length, l = 0; l < s; l++)
|
|
|
+ a = Math.min(a, c[n][l]),
|
|
|
+ r = Math.max(r, c[n][l]),
|
|
|
+ o += c[n][l];
|
|
|
+ return i = "min" === h ? a : "max" === h ? r : "average" === h ? o / s : o,
|
|
|
+ 0 === s ? NaN : i
|
|
|
+ })
|
|
|
+ }(O(t, function(t) {
|
|
|
+ return t.getData()
|
|
|
+ }), t[0].get("mapValueCalculation")), n = 0; n < t.length; n++)
|
|
|
+ t[n].originalData = t[n].getData();
|
|
|
+ for (n = 0; n < t.length; n++)
|
|
|
+ (t[n].seriesGroup = t)[n].needsDrawMap = 0 === n && !t[n].getHostGeoModel(),
|
|
|
+ t[n].setData(i.cloneShallow()),
|
|
|
+ t[n].mainSeries = t[0]
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ yf(function(t) {
|
|
|
+ var e = [];
|
|
|
+ E(t.series, function(t) {
|
|
|
+ t && "map" === t.type && (e.push(t),
|
|
|
+ t.map = t.map || t.mapType,
|
|
|
+ D(t, t.mapLocation))
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ ey("map", [{
|
|
|
+ type: "mapToggleSelect",
|
|
|
+ event: "mapselectchanged",
|
|
|
+ method: "toggleSelected"
|
|
|
+ }, {
|
|
|
+ type: "mapSelect",
|
|
|
+ event: "mapselected",
|
|
|
+ method: "select"
|
|
|
+ }, {
|
|
|
+ type: "mapUnSelect",
|
|
|
+ event: "mapunselected",
|
|
|
+ method: "unSelect"
|
|
|
+ }]);
|
|
|
+ var gx = E
|
|
|
+ , mx = "\0__link_datas"
|
|
|
+ , vx = "\0__link_mainData";
|
|
|
+ function yx(i) {
|
|
|
+ var n = i.mainData
|
|
|
+ , t = i.datas;
|
|
|
+ t || (t = {
|
|
|
+ main: n
|
|
|
+ },
|
|
|
+ i.datasAttr = {
|
|
|
+ main: "data"
|
|
|
+ }),
|
|
|
+ i.datas = i.mainData = null,
|
|
|
+ Mx(n, t, i),
|
|
|
+ gx(t, function(e) {
|
|
|
+ gx(n.TRANSFERABLE_METHODS, function(t) {
|
|
|
+ e.wrapMethod(t, T(xx, i))
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ n.wrapMethod("cloneShallow", T(bx, i)),
|
|
|
+ gx(n.CHANGABLE_METHODS, function(t) {
|
|
|
+ n.wrapMethod(t, T(_x, i))
|
|
|
+ }),
|
|
|
+ Y(t[n.dataType] === n)
|
|
|
+ }
|
|
|
+ function xx(t, e) {
|
|
|
+ if (function(t) {
|
|
|
+ return t[vx] === t
|
|
|
+ }(this)) {
|
|
|
+ var i = P({}, this[mx]);
|
|
|
+ Mx(i[this.dataType] = e, i, t)
|
|
|
+ } else
|
|
|
+ Ix(e, this.dataType, this[vx], t);
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ function _x(t, e) {
|
|
|
+ return t.struct && t.struct.update(this),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function bx(i, n) {
|
|
|
+ return gx(n[mx], function(t, e) {
|
|
|
+ t !== n && Ix(t.cloneShallow(), e, n, i)
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ function Sx(t) {
|
|
|
+ var e = this[vx];
|
|
|
+ return null == t || null == e ? e : e[mx][t]
|
|
|
+ }
|
|
|
+ function Mx(i, t, n) {
|
|
|
+ i[mx] = {},
|
|
|
+ gx(t, function(t, e) {
|
|
|
+ Ix(t, e, i, n)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Ix(t, e, i, n) {
|
|
|
+ (i[mx][e] = t)[vx] = i,
|
|
|
+ t.dataType = e,
|
|
|
+ n.struct && (t[n.structAttr] = n.struct,
|
|
|
+ n.struct[n.datasAttr[e]] = t),
|
|
|
+ t.getLinkedData = Sx
|
|
|
+ }
|
|
|
+ function Tx(t, e) {
|
|
|
+ this.name = t || "",
|
|
|
+ this.depth = 0,
|
|
|
+ this.height = 0,
|
|
|
+ this.parentNode = null,
|
|
|
+ this.dataIndex = -1,
|
|
|
+ this.children = [],
|
|
|
+ this.viewChildren = [],
|
|
|
+ this.hostTree = e
|
|
|
+ }
|
|
|
+ function Ax(e, t) {
|
|
|
+ this.root,
|
|
|
+ this.data,
|
|
|
+ this._nodes = [],
|
|
|
+ this.hostModel = e,
|
|
|
+ this.levelModels = O(t || [], function(t) {
|
|
|
+ return new Cl(t,e,e.ecModel)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Dx(t, e) {
|
|
|
+ var i = e.children;
|
|
|
+ t.parentNode !== e && (i.push(t),
|
|
|
+ t.parentNode = e)
|
|
|
+ }
|
|
|
+ function Cx(t, e) {
|
|
|
+ var i = t.isExpand ? t.children : []
|
|
|
+ , n = t.parentNode.children
|
|
|
+ , o = t.hierNode.i ? n[t.hierNode.i - 1] : null;
|
|
|
+ if (i.length) {
|
|
|
+ !function(t) {
|
|
|
+ var e = t.children
|
|
|
+ , i = e.length
|
|
|
+ , n = 0
|
|
|
+ , o = 0;
|
|
|
+ for (; 0 <= --i; ) {
|
|
|
+ var a = e[i];
|
|
|
+ a.hierNode.prelim += n,
|
|
|
+ a.hierNode.modifier += n,
|
|
|
+ o += a.hierNode.change,
|
|
|
+ n += a.hierNode.shift + o
|
|
|
+ }
|
|
|
+ }(t);
|
|
|
+ var a = (i[0].hierNode.prelim + i[i.length - 1].hierNode.prelim) / 2;
|
|
|
+ o ? (t.hierNode.prelim = o.hierNode.prelim + e(t, o),
|
|
|
+ t.hierNode.modifier = t.hierNode.prelim - a) : t.hierNode.prelim = a
|
|
|
+ } else
|
|
|
+ o && (t.hierNode.prelim = o.hierNode.prelim + e(t, o));
|
|
|
+ t.parentNode.hierNode.defaultAncestor = function(t, e, i, n) {
|
|
|
+ if (e) {
|
|
|
+ for (var o = t, a = t, r = a.parentNode.children[0], s = e, l = o.hierNode.modifier, u = a.hierNode.modifier, h = r.hierNode.modifier, c = s.hierNode.modifier; s = Nx(s),
|
|
|
+ a = Ox(a),
|
|
|
+ s && a; ) {
|
|
|
+ o = Nx(o),
|
|
|
+ r = Ox(r),
|
|
|
+ o.hierNode.ancestor = t;
|
|
|
+ var d = s.hierNode.prelim + c - a.hierNode.prelim - u + n(s, a);
|
|
|
+ 0 < d && (Ex((p = t,
|
|
|
+ g = i,
|
|
|
+ (f = s).hierNode.ancestor.parentNode === p.parentNode ? f.hierNode.ancestor : g), t, d),
|
|
|
+ u += d,
|
|
|
+ l += d),
|
|
|
+ c += s.hierNode.modifier,
|
|
|
+ u += a.hierNode.modifier,
|
|
|
+ l += o.hierNode.modifier,
|
|
|
+ h += r.hierNode.modifier
|
|
|
+ }
|
|
|
+ s && !Nx(o) && (o.hierNode.thread = s,
|
|
|
+ o.hierNode.modifier += c - l),
|
|
|
+ a && !Ox(r) && (r.hierNode.thread = a,
|
|
|
+ r.hierNode.modifier += u - h,
|
|
|
+ i = t)
|
|
|
+ }
|
|
|
+ var f, p, g;
|
|
|
+ return i
|
|
|
+ }(t, o, t.parentNode.hierNode.defaultAncestor || n[0], e)
|
|
|
+ }
|
|
|
+ function Lx(t) {
|
|
|
+ var e = t.hierNode.prelim + t.parentNode.hierNode.modifier;
|
|
|
+ t.setLayout({
|
|
|
+ x: e
|
|
|
+ }, !0),
|
|
|
+ t.hierNode.modifier += t.parentNode.hierNode.modifier
|
|
|
+ }
|
|
|
+ function kx(t) {
|
|
|
+ return arguments.length ? t : Rx
|
|
|
+ }
|
|
|
+ function Px(t, e) {
|
|
|
+ var i = {};
|
|
|
+ return t -= Math.PI / 2,
|
|
|
+ i.x = e * Math.cos(t),
|
|
|
+ i.y = e * Math.sin(t),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function Nx(t) {
|
|
|
+ var e = t.children;
|
|
|
+ return e.length && t.isExpand ? e[e.length - 1] : t.hierNode.thread
|
|
|
+ }
|
|
|
+ function Ox(t) {
|
|
|
+ var e = t.children;
|
|
|
+ return e.length && t.isExpand ? e[0] : t.hierNode.thread
|
|
|
+ }
|
|
|
+ function Ex(t, e, i) {
|
|
|
+ var n = i / (e.hierNode.i - t.hierNode.i);
|
|
|
+ e.hierNode.change -= n,
|
|
|
+ e.hierNode.shift += i,
|
|
|
+ e.hierNode.modifier += i,
|
|
|
+ e.hierNode.prelim += i,
|
|
|
+ t.hierNode.change += n
|
|
|
+ }
|
|
|
+ function Rx(t, e) {
|
|
|
+ return t.parentNode === e.parentNode ? 1 : 2
|
|
|
+ }
|
|
|
+ Tx.prototype = {
|
|
|
+ constructor: Tx,
|
|
|
+ isRemoved: function() {
|
|
|
+ return this.dataIndex < 0
|
|
|
+ },
|
|
|
+ eachNode: function(t, e, i) {
|
|
|
+ "function" == typeof t && (i = e,
|
|
|
+ e = t,
|
|
|
+ t = null),
|
|
|
+ R(t = t || {}) && (t = {
|
|
|
+ order: t
|
|
|
+ });
|
|
|
+ var n, o = t.order || "preorder", a = this[t.attr || "children"];
|
|
|
+ "preorder" === o && (n = e.call(i, this));
|
|
|
+ for (var r = 0; !n && r < a.length; r++)
|
|
|
+ a[r].eachNode(t, e, i);
|
|
|
+ "postorder" === o && e.call(i, this)
|
|
|
+ },
|
|
|
+ updateDepthAndHeight: function(t) {
|
|
|
+ var e = 0;
|
|
|
+ this.depth = t;
|
|
|
+ for (var i = 0; i < this.children.length; i++) {
|
|
|
+ var n = this.children[i];
|
|
|
+ n.updateDepthAndHeight(t + 1),
|
|
|
+ n.height > e && (e = n.height)
|
|
|
+ }
|
|
|
+ this.height = e + 1
|
|
|
+ },
|
|
|
+ getNodeById: function(t) {
|
|
|
+ if (this.getId() === t)
|
|
|
+ return this;
|
|
|
+ for (var e = 0, i = this.children, n = i.length; e < n; e++) {
|
|
|
+ var o = i[e].getNodeById(t);
|
|
|
+ if (o)
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ },
|
|
|
+ contains: function(t) {
|
|
|
+ if (t === this)
|
|
|
+ return !0;
|
|
|
+ for (var e = 0, i = this.children, n = i.length; e < n; e++) {
|
|
|
+ var o = i[e].contains(t);
|
|
|
+ if (o)
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getAncestors: function(t) {
|
|
|
+ for (var e = [], i = t ? this : this.parentNode; i; )
|
|
|
+ e.push(i),
|
|
|
+ i = i.parentNode;
|
|
|
+ return e.reverse(),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ getValue: function(t) {
|
|
|
+ var e = this.hostTree.data;
|
|
|
+ return e.get(e.getDimension(t || "value"), this.dataIndex)
|
|
|
+ },
|
|
|
+ setLayout: function(t, e) {
|
|
|
+ 0 <= this.dataIndex && this.hostTree.data.setItemLayout(this.dataIndex, t, e)
|
|
|
+ },
|
|
|
+ getLayout: function() {
|
|
|
+ return this.hostTree.data.getItemLayout(this.dataIndex)
|
|
|
+ },
|
|
|
+ getModel: function(t) {
|
|
|
+ if (!(this.dataIndex < 0)) {
|
|
|
+ var e = this.hostTree.data.getItemModel(this.dataIndex)
|
|
|
+ , i = this.getLevelModel();
|
|
|
+ return i ? e.getModel(t, i.getModel(t)) : e.getModel(t)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getLevelModel: function() {
|
|
|
+ return (this.hostTree.levelModels || [])[this.depth]
|
|
|
+ },
|
|
|
+ setVisual: function(t, e) {
|
|
|
+ 0 <= this.dataIndex && this.hostTree.data.setItemVisual(this.dataIndex, t, e)
|
|
|
+ },
|
|
|
+ getVisual: function(t, e) {
|
|
|
+ return this.hostTree.data.getItemVisual(this.dataIndex, t, e)
|
|
|
+ },
|
|
|
+ getRawIndex: function() {
|
|
|
+ return this.hostTree.data.getRawIndex(this.dataIndex)
|
|
|
+ },
|
|
|
+ getId: function() {
|
|
|
+ return this.hostTree.data.getId(this.dataIndex)
|
|
|
+ },
|
|
|
+ isAncestorOf: function(t) {
|
|
|
+ for (var e = t.parentNode; e; ) {
|
|
|
+ if (e === this)
|
|
|
+ return !0;
|
|
|
+ e = e.parentNode
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ },
|
|
|
+ isDescendantOf: function(t) {
|
|
|
+ return t !== this && t.isAncestorOf(this)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Ax.prototype = {
|
|
|
+ constructor: Ax,
|
|
|
+ type: "tree",
|
|
|
+ eachNode: function(t, e, i) {
|
|
|
+ this.root.eachNode(t, e, i)
|
|
|
+ },
|
|
|
+ getNodeByDataIndex: function(t) {
|
|
|
+ var e = this.data.getRawIndex(t);
|
|
|
+ return this._nodes[e]
|
|
|
+ },
|
|
|
+ getNodeByName: function(t) {
|
|
|
+ return this.root.getNodeByName(t)
|
|
|
+ },
|
|
|
+ update: function() {
|
|
|
+ for (var t = this.data, e = this._nodes, i = 0, n = e.length; i < n; i++)
|
|
|
+ e[i].dataIndex = -1;
|
|
|
+ for (i = 0,
|
|
|
+ n = t.count(); i < n; i++)
|
|
|
+ e[t.getRawIndex(i)].dataIndex = i
|
|
|
+ },
|
|
|
+ clearLayouts: function() {
|
|
|
+ this.data.clearItemLayouts()
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Ax.createTree = function(t, e, i, n) {
|
|
|
+ var s = new Ax(e,i && i.levels)
|
|
|
+ , l = []
|
|
|
+ , u = 1;
|
|
|
+ !function t(e, i) {
|
|
|
+ var n = e.value;
|
|
|
+ u = Math.max(u, L(n) ? n.length : 1);
|
|
|
+ l.push(e);
|
|
|
+ var o = new Tx(e.name,s);
|
|
|
+ i ? Dx(o, i) : s.root = o;
|
|
|
+ s._nodes.push(o);
|
|
|
+ var a = e.children;
|
|
|
+ if (a)
|
|
|
+ for (var r = 0; r < a.length; r++)
|
|
|
+ t(a[r], o)
|
|
|
+ }(t),
|
|
|
+ s.root.updateDepthAndHeight(0);
|
|
|
+ var o = lp(l, {
|
|
|
+ coordDimensions: ["value"],
|
|
|
+ dimensionsCount: u
|
|
|
+ })
|
|
|
+ , a = new Yf(o,e);
|
|
|
+ return a.initData(l),
|
|
|
+ n && n(a),
|
|
|
+ yx({
|
|
|
+ mainData: a,
|
|
|
+ struct: s,
|
|
|
+ structAttr: "tree"
|
|
|
+ }),
|
|
|
+ s.update(),
|
|
|
+ s
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ sc.extend({
|
|
|
+ type: "series.tree",
|
|
|
+ layoutInfo: null,
|
|
|
+ layoutMode: "box",
|
|
|
+ getInitialData: function(t) {
|
|
|
+ var e = {
|
|
|
+ name: t.name,
|
|
|
+ children: t.data
|
|
|
+ }
|
|
|
+ , n = new Cl(t.leaves || {},this,this.ecModel)
|
|
|
+ , o = Ax.createTree(e, this, {}, function(t) {
|
|
|
+ t.wrapMethod("getItemModel", function(t, e) {
|
|
|
+ var i = o.getNodeByDataIndex(e);
|
|
|
+ return i.children.length && i.isExpand || (t.parentModel = n),
|
|
|
+ t
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var i = 0;
|
|
|
+ o.eachNode("preorder", function(t) {
|
|
|
+ t.depth > i && (i = t.depth)
|
|
|
+ });
|
|
|
+ var a = t.expandAndCollapse && 0 <= t.initialTreeDepth ? t.initialTreeDepth : i;
|
|
|
+ return o.root.eachNode("preorder", function(t) {
|
|
|
+ var e = t.hostTree.data.getRawDataItem(t.dataIndex);
|
|
|
+ t.isExpand = e && null != e.collapsed ? !e.collapsed : t.depth <= a
|
|
|
+ }),
|
|
|
+ o.data
|
|
|
+ },
|
|
|
+ getOrient: function() {
|
|
|
+ var t = this.get("orient");
|
|
|
+ return "horizontal" === t ? t = "LR" : "vertical" === t && (t = "TB"),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ setZoom: function(t) {
|
|
|
+ this.option.zoom = t
|
|
|
+ },
|
|
|
+ setCenter: function(t) {
|
|
|
+ this.option.center = t
|
|
|
+ },
|
|
|
+ formatTooltip: function(t) {
|
|
|
+ for (var e = this.getData().tree, i = e.root.children[0], n = e.getNodeByDataIndex(t), o = n.getValue(), a = n.name; n && n !== i; )
|
|
|
+ a = n.parentNode.name + "." + a,
|
|
|
+ n = n.parentNode;
|
|
|
+ return au(a + (isNaN(o) || null == o ? "" : " : " + o))
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "view",
|
|
|
+ left: "12%",
|
|
|
+ top: "12%",
|
|
|
+ right: "12%",
|
|
|
+ bottom: "12%",
|
|
|
+ layout: "orthogonal",
|
|
|
+ edgeShape: "curve",
|
|
|
+ edgeForkPosition: "50%",
|
|
|
+ roam: !1,
|
|
|
+ nodeScaleRatio: .4,
|
|
|
+ center: null,
|
|
|
+ zoom: 1,
|
|
|
+ orient: "LR",
|
|
|
+ symbol: "emptyCircle",
|
|
|
+ symbolSize: 7,
|
|
|
+ expandAndCollapse: !0,
|
|
|
+ initialTreeDepth: 2,
|
|
|
+ lineStyle: {
|
|
|
+ color: "#ccc",
|
|
|
+ width: 1.5,
|
|
|
+ curveness: .5
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ color: "lightsteelblue",
|
|
|
+ borderColor: "#c23531",
|
|
|
+ borderWidth: 1.5
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ color: "#555"
|
|
|
+ },
|
|
|
+ leaves: {
|
|
|
+ label: {
|
|
|
+ show: !0
|
|
|
+ }
|
|
|
+ },
|
|
|
+ animationEasing: "linear",
|
|
|
+ animationDuration: 700,
|
|
|
+ animationDurationUpdate: 1e3
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var zx = Cs({
|
|
|
+ shape: {
|
|
|
+ parentPoint: [],
|
|
|
+ childPoints: [],
|
|
|
+ orient: "",
|
|
|
+ forkPosition: ""
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ stroke: "#000",
|
|
|
+ fill: null
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.childPoints
|
|
|
+ , n = i.length
|
|
|
+ , o = e.parentPoint
|
|
|
+ , a = i[0]
|
|
|
+ , r = i[n - 1];
|
|
|
+ if (1 === n)
|
|
|
+ return t.moveTo(o[0], o[1]),
|
|
|
+ void t.lineTo(a[0], a[1]);
|
|
|
+ var s = e.orient
|
|
|
+ , l = "TB" === s || "BT" === s ? 0 : 1
|
|
|
+ , u = 1 - l
|
|
|
+ , h = Rl(e.forkPosition, 1)
|
|
|
+ , c = [];
|
|
|
+ c[l] = o[l],
|
|
|
+ c[u] = o[u] + (r[u] - o[u]) * h,
|
|
|
+ t.moveTo(o[0], o[1]),
|
|
|
+ t.lineTo(c[0], c[1]),
|
|
|
+ t.moveTo(a[0], a[1]),
|
|
|
+ c[l] = a[l],
|
|
|
+ t.lineTo(c[0], c[1]),
|
|
|
+ c[l] = r[l],
|
|
|
+ t.lineTo(c[0], c[1]),
|
|
|
+ t.lineTo(r[0], r[1]);
|
|
|
+ for (var d = 1; d < n - 1; d++) {
|
|
|
+ var f = i[d];
|
|
|
+ t.moveTo(f[0], f[1]),
|
|
|
+ c[l] = f[l],
|
|
|
+ t.lineTo(c[0], c[1])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function Bx(t, e) {
|
|
|
+ var i = t.getItemLayout(e);
|
|
|
+ return i && !isNaN(i.x) && !isNaN(i.y) && "none" !== t.getItemVisual(e, "symbol")
|
|
|
+ }
|
|
|
+ function Vx(t, e, i) {
|
|
|
+ return i.itemModel = e,
|
|
|
+ i.itemStyle = e.getModel("itemStyle").getItemStyle(),
|
|
|
+ i.hoverItemStyle = e.getModel("emphasis.itemStyle").getItemStyle(),
|
|
|
+ i.lineStyle = e.getModel("lineStyle").getLineStyle(),
|
|
|
+ i.labelModel = e.getModel("label"),
|
|
|
+ i.hoverLabelModel = e.getModel("emphasis.label"),
|
|
|
+ !1 === t.isExpand && 0 !== t.children.length ? i.symbolInnerColor = i.itemStyle.fill : i.symbolInnerColor = "#fff",
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function Gx(t, e, i, n, o, a) {
|
|
|
+ var r = !i
|
|
|
+ , s = t.tree.getNodeByDataIndex(e)
|
|
|
+ , l = s.getModel()
|
|
|
+ , u = (a = Vx(s, l, a),
|
|
|
+ t.tree.root)
|
|
|
+ , h = s.parentNode === u ? s : s.parentNode || s
|
|
|
+ , c = t.getItemGraphicEl(h.dataIndex)
|
|
|
+ , d = h.getLayout()
|
|
|
+ , f = c ? {
|
|
|
+ x: c.position[0],
|
|
|
+ y: c.position[1],
|
|
|
+ rawX: c.__radialOldRawX,
|
|
|
+ rawY: c.__radialOldRawY
|
|
|
+ } : d
|
|
|
+ , p = s.getLayout();
|
|
|
+ r ? (i = new Xg(t,e,a)).attr("position", [f.x, f.y]) : i.updateData(t, e, a),
|
|
|
+ i.__radialOldRawX = i.__radialRawX,
|
|
|
+ i.__radialOldRawY = i.__radialRawY,
|
|
|
+ i.__radialRawX = p.rawX,
|
|
|
+ i.__radialRawY = p.rawY,
|
|
|
+ n.add(i),
|
|
|
+ t.setItemGraphicEl(e, i),
|
|
|
+ cl(i, {
|
|
|
+ position: [p.x, p.y]
|
|
|
+ }, o);
|
|
|
+ var g = i.getSymbolPath();
|
|
|
+ if ("radial" === a.layout) {
|
|
|
+ var m, v, y = u.children[0], x = y.getLayout(), _ = y.children.length;
|
|
|
+ if (p.x === x.x && !0 === s.isExpand) {
|
|
|
+ var w = {};
|
|
|
+ w.x = (y.children[0].getLayout().x + y.children[_ - 1].getLayout().x) / 2,
|
|
|
+ w.y = (y.children[0].getLayout().y + y.children[_ - 1].getLayout().y) / 2,
|
|
|
+ (m = Math.atan2(w.y - x.y, w.x - x.x)) < 0 && (m = 2 * Math.PI + m),
|
|
|
+ (v = w.x < x.x) && (m -= Math.PI)
|
|
|
+ } else
|
|
|
+ (m = Math.atan2(p.y - x.y, p.x - x.x)) < 0 && (m = 2 * Math.PI + m),
|
|
|
+ 0 === s.children.length || 0 !== s.children.length && !1 === s.isExpand ? (v = p.x < x.x) && (m -= Math.PI) : (v = p.x > x.x) || (m -= Math.PI);
|
|
|
+ var b = v ? "left" : "right"
|
|
|
+ , S = a.labelModel.get("rotate")
|
|
|
+ , M = S * (Math.PI / 180);
|
|
|
+ g.setStyle({
|
|
|
+ textPosition: a.labelModel.get("position") || b,
|
|
|
+ textRotation: null == S ? -m : M,
|
|
|
+ textOrigin: "center",
|
|
|
+ verticalAlign: "middle"
|
|
|
+ })
|
|
|
+ }
|
|
|
+ !function(t, e, i, n, o, a, r, s, l) {
|
|
|
+ var u = l.edgeShape
|
|
|
+ , h = n.__edge;
|
|
|
+ if ("curve" === u)
|
|
|
+ e.parentNode && e.parentNode !== i && cl(h = h || (n.__edge = new ds({
|
|
|
+ shape: Wx(l, o, o),
|
|
|
+ style: D({
|
|
|
+ opacity: 0,
|
|
|
+ strokeNoScale: !0
|
|
|
+ }, l.lineStyle)
|
|
|
+ })), {
|
|
|
+ shape: Wx(l, a, r),
|
|
|
+ style: {
|
|
|
+ opacity: 1
|
|
|
+ }
|
|
|
+ }, t);
|
|
|
+ else if ("polyline" === u && "orthogonal" === l.layout && e !== i && e.children && 0 !== e.children.length && !0 === e.isExpand) {
|
|
|
+ for (var c = e.children, d = [], f = 0; f < c.length; f++) {
|
|
|
+ var p = c[f].getLayout();
|
|
|
+ d.push([p.x, p.y])
|
|
|
+ }
|
|
|
+ cl(h = h || (n.__edge = new zx({
|
|
|
+ shape: {
|
|
|
+ parentPoint: [r.x, r.y],
|
|
|
+ childPoints: [[r.x, r.y]],
|
|
|
+ orient: l.orient,
|
|
|
+ forkPosition: l.edgeForkPosition
|
|
|
+ },
|
|
|
+ style: D({
|
|
|
+ opacity: 0,
|
|
|
+ strokeNoScale: !0
|
|
|
+ }, l.lineStyle)
|
|
|
+ })), {
|
|
|
+ shape: {
|
|
|
+ parentPoint: [r.x, r.y],
|
|
|
+ childPoints: d
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ opacity: 1
|
|
|
+ }
|
|
|
+ }, t)
|
|
|
+ }
|
|
|
+ s.add(h)
|
|
|
+ }(o, s, u, i, f, d, p, n, a)
|
|
|
+ }
|
|
|
+ function Fx(t, e, i, n, o, a) {
|
|
|
+ for (var r, s = t.tree.getNodeByDataIndex(e), l = t.tree.root, u = s.getModel(), h = (a = Vx(s, u, a),
|
|
|
+ s.parentNode === l ? s : s.parentNode || s), c = a.edgeShape; null == (r = h.getLayout()); )
|
|
|
+ h = h.parentNode === l ? h : h.parentNode || h;
|
|
|
+ cl(i, {
|
|
|
+ position: [r.x + 1, r.y + 1]
|
|
|
+ }, o, function() {
|
|
|
+ n.remove(i),
|
|
|
+ t.setItemGraphicEl(e, null)
|
|
|
+ }),
|
|
|
+ i.fadeOut(null, {
|
|
|
+ keepLabel: !0
|
|
|
+ });
|
|
|
+ var d = t.getItemGraphicEl(h.dataIndex).__edge
|
|
|
+ , f = i.__edge || (!1 === h.isExpand || 1 === h.children.length ? d : void 0);
|
|
|
+ c = a.edgeShape;
|
|
|
+ f && ("curve" === c ? cl(f, {
|
|
|
+ shape: Wx(a, r, r),
|
|
|
+ style: {
|
|
|
+ opacity: 0
|
|
|
+ }
|
|
|
+ }, o, function() {
|
|
|
+ n.remove(f)
|
|
|
+ }) : "polyline" === c && "orthogonal" === a.layout && cl(f, {
|
|
|
+ shape: {
|
|
|
+ parentPoint: [r.x, r.y],
|
|
|
+ childPoints: [[r.x, r.y]]
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ opacity: 0
|
|
|
+ }
|
|
|
+ }, o, function() {
|
|
|
+ n.remove(f)
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ function Wx(t, e, i) {
|
|
|
+ var n, o, a, r, s, l, u, h, c = t.orient;
|
|
|
+ if ("radial" !== t.layout)
|
|
|
+ return s = e.x,
|
|
|
+ u = e.y,
|
|
|
+ l = i.x,
|
|
|
+ h = i.y,
|
|
|
+ "LR" !== c && "RL" !== c || (n = s + (l - s) * t.curvature,
|
|
|
+ o = u,
|
|
|
+ a = l + (s - l) * t.curvature,
|
|
|
+ r = h),
|
|
|
+ "TB" !== c && "BT" !== c || (n = s,
|
|
|
+ o = u + (h - u) * t.curvature,
|
|
|
+ a = l,
|
|
|
+ r = h + (u - h) * t.curvature),
|
|
|
+ {
|
|
|
+ x1: s,
|
|
|
+ y1: u,
|
|
|
+ x2: l,
|
|
|
+ y2: h,
|
|
|
+ cpx1: n,
|
|
|
+ cpy1: o,
|
|
|
+ cpx2: a,
|
|
|
+ cpy2: r
|
|
|
+ };
|
|
|
+ s = e.rawX,
|
|
|
+ u = e.rawY,
|
|
|
+ l = i.rawX,
|
|
|
+ h = i.rawY;
|
|
|
+ var d = Px(s, u)
|
|
|
+ , f = Px(s, u + (h - u) * t.curvature)
|
|
|
+ , p = Px(l, h + (u - h) * t.curvature)
|
|
|
+ , g = Px(l, h);
|
|
|
+ return {
|
|
|
+ x1: d.x,
|
|
|
+ y1: d.y,
|
|
|
+ x2: g.x,
|
|
|
+ y2: g.y,
|
|
|
+ cpx1: f.x,
|
|
|
+ cpy1: f.y,
|
|
|
+ cpx2: p.x,
|
|
|
+ cpy2: p.y
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Hx(t, e) {
|
|
|
+ for (var i, n = [t]; i = n.pop(); )
|
|
|
+ if (e(i),
|
|
|
+ i.isExpand) {
|
|
|
+ var o = i.children;
|
|
|
+ if (o.length)
|
|
|
+ for (var a = o.length - 1; 0 <= a; a--)
|
|
|
+ n.push(o[a])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Cf({
|
|
|
+ type: "tree",
|
|
|
+ init: function(t, e) {
|
|
|
+ this._oldTree,
|
|
|
+ this._mainGroup = new Ci,
|
|
|
+ this._controller = new Vy(e.getZr()),
|
|
|
+ this._controllerHost = {
|
|
|
+ target: this.group
|
|
|
+ },
|
|
|
+ this.group.add(this._mainGroup)
|
|
|
+ },
|
|
|
+ render: function(n, t, i, e) {
|
|
|
+ var o = n.getData()
|
|
|
+ , a = n.layoutInfo
|
|
|
+ , r = this._mainGroup
|
|
|
+ , s = n.get("layout");
|
|
|
+ "radial" === s ? r.attr("position", [a.x + a.width / 2, a.y + a.height / 2]) : r.attr("position", [a.x, a.y]),
|
|
|
+ this._updateViewCoordSys(n, a, s),
|
|
|
+ this._updateController(n, t, i);
|
|
|
+ var l = this._data
|
|
|
+ , u = {
|
|
|
+ expandAndCollapse: n.get("expandAndCollapse"),
|
|
|
+ layout: s,
|
|
|
+ edgeShape: n.get("edgeShape"),
|
|
|
+ edgeForkPosition: n.get("edgeForkPosition"),
|
|
|
+ orient: n.getOrient(),
|
|
|
+ curvature: n.get("lineStyle.curveness"),
|
|
|
+ symbolRotate: n.get("symbolRotate"),
|
|
|
+ symbolOffset: n.get("symbolOffset"),
|
|
|
+ hoverAnimation: n.get("hoverAnimation"),
|
|
|
+ useNameLabel: !0,
|
|
|
+ fadeIn: !0
|
|
|
+ };
|
|
|
+ o.diff(l).add(function(t) {
|
|
|
+ Bx(o, t) && Gx(o, t, null, r, n, u)
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = l.getItemGraphicEl(e);
|
|
|
+ Bx(o, t) ? Gx(o, t, i, r, n, u) : i && Fx(l, e, i, r, n, u)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = l.getItemGraphicEl(t);
|
|
|
+ e && Fx(l, t, e, r, n, u)
|
|
|
+ }).execute(),
|
|
|
+ this._nodeScaleRatio = n.get("nodeScaleRatio"),
|
|
|
+ this._updateNodeAndLinkScale(n),
|
|
|
+ !0 === u.expandAndCollapse && o.eachItemGraphicEl(function(t, e) {
|
|
|
+ t.off("click").on("click", function() {
|
|
|
+ i.dispatchAction({
|
|
|
+ type: "treeExpandAndCollapse",
|
|
|
+ seriesId: n.id,
|
|
|
+ dataIndex: e
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ this._data = o
|
|
|
+ },
|
|
|
+ _updateViewCoordSys: function(t) {
|
|
|
+ var i = t.getData()
|
|
|
+ , n = [];
|
|
|
+ i.each(function(t) {
|
|
|
+ var e = i.getItemLayout(t);
|
|
|
+ !e || isNaN(e.x) || isNaN(e.y) || n.push([+e.x, +e.y])
|
|
|
+ });
|
|
|
+ var e = []
|
|
|
+ , o = [];
|
|
|
+ Wa(n, e, o);
|
|
|
+ var a = this._min
|
|
|
+ , r = this._max;
|
|
|
+ o[0] - e[0] == 0 && (e[0] = a ? a[0] : e[0] - 1,
|
|
|
+ o[0] = r ? r[0] : o[0] + 1),
|
|
|
+ o[1] - e[1] == 0 && (e[1] = a ? a[1] : e[1] - 1,
|
|
|
+ o[1] = r ? r[1] : o[1] + 1);
|
|
|
+ var s = t.coordinateSystem = new lx;
|
|
|
+ s.zoomLimit = t.get("scaleLimit"),
|
|
|
+ s.setBoundingRect(e[0], e[1], o[0] - e[0], o[1] - e[1]),
|
|
|
+ s.setCenter(t.get("center")),
|
|
|
+ s.setZoom(t.get("zoom")),
|
|
|
+ this.group.attr({
|
|
|
+ position: s.position,
|
|
|
+ scale: s.scale
|
|
|
+ }),
|
|
|
+ this._viewCoordSys = s,
|
|
|
+ this._min = e,
|
|
|
+ this._max = o
|
|
|
+ },
|
|
|
+ _updateController: function(o, t, a) {
|
|
|
+ var e = this._controller
|
|
|
+ , i = this._controllerHost
|
|
|
+ , r = this.group;
|
|
|
+ e.setPointerChecker(function(t, e, i) {
|
|
|
+ var n = r.getBoundingRect();
|
|
|
+ return n.applyTransform(r.transform),
|
|
|
+ n.contain(e, i) && !$y(t, a, o)
|
|
|
+ }),
|
|
|
+ e.enable(o.get("roam")),
|
|
|
+ i.zoomLimit = o.get("scaleLimit"),
|
|
|
+ i.zoom = o.coordinateSystem.getZoom(),
|
|
|
+ e.off("pan").off("zoom").on("pan", function(t) {
|
|
|
+ jy(i, t.dx, t.dy),
|
|
|
+ a.dispatchAction({
|
|
|
+ seriesId: o.id,
|
|
|
+ type: "treeRoam",
|
|
|
+ dx: t.dx,
|
|
|
+ dy: t.dy
|
|
|
+ })
|
|
|
+ }, this).on("zoom", function(t) {
|
|
|
+ qy(i, t.scale, t.originX, t.originY),
|
|
|
+ a.dispatchAction({
|
|
|
+ seriesId: o.id,
|
|
|
+ type: "treeRoam",
|
|
|
+ zoom: t.scale,
|
|
|
+ originX: t.originX,
|
|
|
+ originY: t.originY
|
|
|
+ }),
|
|
|
+ this._updateNodeAndLinkScale(o)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _updateNodeAndLinkScale: function(t) {
|
|
|
+ var e = t.getData()
|
|
|
+ , i = this._getNodeGlobalScale(t)
|
|
|
+ , n = [i, i];
|
|
|
+ e.eachItemGraphicEl(function(t, e) {
|
|
|
+ t.attr("scale", n)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _getNodeGlobalScale: function(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ if ("view" !== e.type)
|
|
|
+ return 1;
|
|
|
+ var i = this._nodeScaleRatio
|
|
|
+ , n = e.scale
|
|
|
+ , o = n && n[0] || 1;
|
|
|
+ return ((e.getZoom() - 1) * i + 1) / o
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._controller && this._controller.dispose(),
|
|
|
+ this._controllerHost = {}
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this._mainGroup.removeAll(),
|
|
|
+ this._data = null
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "treeExpandAndCollapse",
|
|
|
+ event: "treeExpandAndCollapse",
|
|
|
+ update: "update"
|
|
|
+ }, function(n, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "tree",
|
|
|
+ query: n
|
|
|
+ }, function(t) {
|
|
|
+ var e = n.dataIndex
|
|
|
+ , i = t.getData().tree.getNodeByDataIndex(e);
|
|
|
+ i.isExpand = !i.isExpand
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "treeRoam",
|
|
|
+ event: "treeRoam",
|
|
|
+ update: "none"
|
|
|
+ }, function(i, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "tree",
|
|
|
+ query: i
|
|
|
+ }, function(t) {
|
|
|
+ var e = ax(t.coordinateSystem, i);
|
|
|
+ t.setCenter && t.setCenter(e.center),
|
|
|
+ t.setZoom && t.setZoom(e.zoom)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ function Zx(t, e, i) {
|
|
|
+ if (t && 0 <= _(e, t.type)) {
|
|
|
+ var n = i.getData().tree.root
|
|
|
+ , o = t.targetNode;
|
|
|
+ if ("string" == typeof o && (o = n.getNodeById(o)),
|
|
|
+ o && n.contains(o))
|
|
|
+ return {
|
|
|
+ node: o
|
|
|
+ };
|
|
|
+ var a = t.targetNodeId;
|
|
|
+ if (null != a && (o = n.getNodeById(a)))
|
|
|
+ return {
|
|
|
+ node: o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ux(t) {
|
|
|
+ for (var e = []; t; )
|
|
|
+ (t = t.parentNode) && e.push(t);
|
|
|
+ return e.reverse()
|
|
|
+ }
|
|
|
+ function Xx(t, e) {
|
|
|
+ return 0 <= _(Ux(t), e)
|
|
|
+ }
|
|
|
+ function Yx(t, e) {
|
|
|
+ for (var i = []; t; ) {
|
|
|
+ var n = t.dataIndex;
|
|
|
+ i.push({
|
|
|
+ name: t.name,
|
|
|
+ dataIndex: n,
|
|
|
+ value: e.getRawValue(n)
|
|
|
+ }),
|
|
|
+ t = t.parentNode
|
|
|
+ }
|
|
|
+ return i.reverse(),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ Sf(Lm("tree", "circle")),
|
|
|
+ bf(function(t, e) {
|
|
|
+ t.eachSeriesByType("tree", function(t) {
|
|
|
+ !function(t, e) {
|
|
|
+ var i = function(t, e) {
|
|
|
+ return bu(t.getBoxLayoutParams(), {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ })
|
|
|
+ }(t, e);
|
|
|
+ t.layoutInfo = i;
|
|
|
+ var n = t.get("layout")
|
|
|
+ , o = 0
|
|
|
+ , a = 0
|
|
|
+ , r = null;
|
|
|
+ r = "radial" === n ? (o = 2 * Math.PI,
|
|
|
+ a = Math.min(i.height, i.width) / 2,
|
|
|
+ kx(function(t, e) {
|
|
|
+ return (t.parentNode === e.parentNode ? 1 : 2) / t.depth
|
|
|
+ })) : (o = i.width,
|
|
|
+ a = i.height,
|
|
|
+ kx());
|
|
|
+ var s = t.getData().tree.root
|
|
|
+ , l = s.children[0];
|
|
|
+ if (l) {
|
|
|
+ !function(t) {
|
|
|
+ t.hierNode = {
|
|
|
+ defaultAncestor: null,
|
|
|
+ ancestor: t,
|
|
|
+ prelim: 0,
|
|
|
+ modifier: 0,
|
|
|
+ change: 0,
|
|
|
+ shift: 0,
|
|
|
+ i: 0,
|
|
|
+ thread: null
|
|
|
+ };
|
|
|
+ for (var e, i, n = [t]; e = n.pop(); )
|
|
|
+ if (i = e.children,
|
|
|
+ e.isExpand && i.length)
|
|
|
+ for (var o = i.length - 1; 0 <= o; o--) {
|
|
|
+ var a = i[o];
|
|
|
+ a.hierNode = {
|
|
|
+ defaultAncestor: null,
|
|
|
+ ancestor: a,
|
|
|
+ prelim: 0,
|
|
|
+ modifier: 0,
|
|
|
+ change: 0,
|
|
|
+ shift: 0,
|
|
|
+ i: o,
|
|
|
+ thread: null
|
|
|
+ },
|
|
|
+ n.push(a)
|
|
|
+ }
|
|
|
+ }(s),
|
|
|
+ function(t, e, i) {
|
|
|
+ for (var n, o = [t], a = []; n = o.pop(); )
|
|
|
+ if (a.push(n),
|
|
|
+ n.isExpand) {
|
|
|
+ var r = n.children;
|
|
|
+ if (r.length)
|
|
|
+ for (var s = 0; s < r.length; s++)
|
|
|
+ o.push(r[s])
|
|
|
+ }
|
|
|
+ for (; n = a.pop(); )
|
|
|
+ e(n, i)
|
|
|
+ }(l, Cx, r),
|
|
|
+ s.hierNode.modifier = -l.hierNode.prelim,
|
|
|
+ Hx(l, Lx);
|
|
|
+ var u = l
|
|
|
+ , h = l
|
|
|
+ , c = l;
|
|
|
+ Hx(l, function(t) {
|
|
|
+ var e = t.getLayout().x;
|
|
|
+ e < u.getLayout().x && (u = t),
|
|
|
+ e > h.getLayout().x && (h = t),
|
|
|
+ t.depth > c.depth && (c = t)
|
|
|
+ });
|
|
|
+ var d = u === h ? 1 : r(u, h) / 2
|
|
|
+ , f = d - u.getLayout().x
|
|
|
+ , p = 0
|
|
|
+ , g = 0
|
|
|
+ , m = 0
|
|
|
+ , v = 0;
|
|
|
+ if ("radial" === n)
|
|
|
+ p = o / (h.getLayout().x + d + f),
|
|
|
+ g = a / (c.depth - 1 || 1),
|
|
|
+ Hx(l, function(t) {
|
|
|
+ m = (t.getLayout().x + f) * p,
|
|
|
+ v = (t.depth - 1) * g;
|
|
|
+ var e = Px(m, v);
|
|
|
+ t.setLayout({
|
|
|
+ x: e.x,
|
|
|
+ y: e.y,
|
|
|
+ rawX: m,
|
|
|
+ rawY: v
|
|
|
+ }, !0)
|
|
|
+ });
|
|
|
+ else {
|
|
|
+ var y = t.getOrient();
|
|
|
+ "RL" === y || "LR" === y ? (g = a / (h.getLayout().x + d + f),
|
|
|
+ p = o / (c.depth - 1 || 1),
|
|
|
+ Hx(l, function(t) {
|
|
|
+ v = (t.getLayout().x + f) * g,
|
|
|
+ m = "LR" === y ? (t.depth - 1) * p : o - (t.depth - 1) * p,
|
|
|
+ t.setLayout({
|
|
|
+ x: m,
|
|
|
+ y: v
|
|
|
+ }, !0)
|
|
|
+ })) : "TB" !== y && "BT" !== y || (p = o / (h.getLayout().x + d + f),
|
|
|
+ g = a / (c.depth - 1 || 1),
|
|
|
+ Hx(l, function(t) {
|
|
|
+ m = (t.getLayout().x + f) * p,
|
|
|
+ v = "TB" === y ? (t.depth - 1) * g : a - (t.depth - 1) * g,
|
|
|
+ t.setLayout({
|
|
|
+ x: m,
|
|
|
+ y: v
|
|
|
+ }, !0)
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }(t, e)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ sc.extend({
|
|
|
+ type: "series.treemap",
|
|
|
+ layoutMode: "box",
|
|
|
+ dependencies: ["grid", "polar"],
|
|
|
+ preventUsingHoverLayer: !0,
|
|
|
+ _viewRoot: null,
|
|
|
+ defaultOption: {
|
|
|
+ progressive: 0,
|
|
|
+ left: "center",
|
|
|
+ top: "middle",
|
|
|
+ right: null,
|
|
|
+ bottom: null,
|
|
|
+ width: "80%",
|
|
|
+ height: "80%",
|
|
|
+ sort: !0,
|
|
|
+ clipWindow: "origin",
|
|
|
+ squareRatio: .5 * (1 + Math.sqrt(5)),
|
|
|
+ leafDepth: null,
|
|
|
+ drillDownIcon: "▶",
|
|
|
+ zoomToNodeRatio: .1024,
|
|
|
+ roam: !0,
|
|
|
+ nodeClick: "zoomToNode",
|
|
|
+ animation: !0,
|
|
|
+ animationDurationUpdate: 900,
|
|
|
+ animationEasing: "quinticInOut",
|
|
|
+ breadcrumb: {
|
|
|
+ show: !0,
|
|
|
+ height: 22,
|
|
|
+ left: "center",
|
|
|
+ top: "bottom",
|
|
|
+ emptyItemWidth: 25,
|
|
|
+ itemStyle: {
|
|
|
+ color: "rgba(0,0,0,0.7)",
|
|
|
+ borderColor: "rgba(255,255,255,0.7)",
|
|
|
+ borderWidth: 1,
|
|
|
+ shadowColor: "rgba(150,150,150,1)",
|
|
|
+ shadowBlur: 3,
|
|
|
+ shadowOffsetX: 0,
|
|
|
+ shadowOffsetY: 0,
|
|
|
+ textStyle: {
|
|
|
+ color: "#fff"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ textStyle: {}
|
|
|
+ }
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ distance: 0,
|
|
|
+ padding: 5,
|
|
|
+ position: "inside",
|
|
|
+ color: "#fff",
|
|
|
+ ellipsis: !0
|
|
|
+ },
|
|
|
+ upperLabel: {
|
|
|
+ show: !1,
|
|
|
+ position: [0, "50%"],
|
|
|
+ height: 20,
|
|
|
+ color: "#fff",
|
|
|
+ ellipsis: !0,
|
|
|
+ verticalAlign: "middle"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ color: null,
|
|
|
+ colorAlpha: null,
|
|
|
+ colorSaturation: null,
|
|
|
+ borderWidth: 0,
|
|
|
+ gapWidth: 0,
|
|
|
+ borderColor: "#fff",
|
|
|
+ borderColorSaturation: null
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ upperLabel: {
|
|
|
+ show: !0,
|
|
|
+ position: [0, "50%"],
|
|
|
+ color: "#fff",
|
|
|
+ ellipsis: !0,
|
|
|
+ verticalAlign: "middle"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ visualDimension: 0,
|
|
|
+ visualMin: null,
|
|
|
+ visualMax: null,
|
|
|
+ color: [],
|
|
|
+ colorAlpha: null,
|
|
|
+ colorSaturation: null,
|
|
|
+ colorMappingBy: "index",
|
|
|
+ visibleMin: 10,
|
|
|
+ childrenVisibleMin: null,
|
|
|
+ levels: []
|
|
|
+ },
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ var i = {
|
|
|
+ name: t.name,
|
|
|
+ children: t.data
|
|
|
+ };
|
|
|
+ !function i(t) {
|
|
|
+ var n = 0;
|
|
|
+ E(t.children, function(t) {
|
|
|
+ i(t);
|
|
|
+ var e = t.value;
|
|
|
+ L(e) && (e = e[0]),
|
|
|
+ n += e
|
|
|
+ });
|
|
|
+ var e = t.value;
|
|
|
+ L(e) && (e = e[0]);
|
|
|
+ null != e && !isNaN(e) || (e = n);
|
|
|
+ e < 0 && (e = 0);
|
|
|
+ L(t.value) ? t.value[0] = e : t.value = e
|
|
|
+ }(i);
|
|
|
+ var n = t.levels || []
|
|
|
+ , o = O((n = t.levels = function(t, e) {
|
|
|
+ var n, i = e.get("color");
|
|
|
+ if (!i)
|
|
|
+ return;
|
|
|
+ if (E(t = t || [], function(t) {
|
|
|
+ var e = new Cl(t)
|
|
|
+ , i = e.get("color");
|
|
|
+ (e.get("itemStyle.color") || i && "none" !== i) && (n = !0)
|
|
|
+ }),
|
|
|
+ !n) {
|
|
|
+ (t[0] || (t[0] = {})).color = i.slice()
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }(n, e)) || [], function(t) {
|
|
|
+ return new Cl(t,this,e)
|
|
|
+ }, this)
|
|
|
+ , a = Ax.createTree(i, this, null, function(t) {
|
|
|
+ t.wrapMethod("getItemModel", function(t, e) {
|
|
|
+ var i = a.getNodeByDataIndex(e)
|
|
|
+ , n = o[i.depth];
|
|
|
+ return n && (t.parentModel = n),
|
|
|
+ t
|
|
|
+ })
|
|
|
+ });
|
|
|
+ return a.data
|
|
|
+ },
|
|
|
+ optionUpdated: function() {
|
|
|
+ this.resetViewRoot()
|
|
|
+ },
|
|
|
+ formatTooltip: function(t) {
|
|
|
+ var e = this.getData()
|
|
|
+ , i = this.getRawValue(t)
|
|
|
+ , n = L(i) ? tu(i[0]) : tu(i);
|
|
|
+ return au(e.getName(t) + ": " + n)
|
|
|
+ },
|
|
|
+ getDataParams: function(t) {
|
|
|
+ var e = sc.prototype.getDataParams.apply(this, arguments)
|
|
|
+ , i = this.getData().tree.getNodeByDataIndex(t);
|
|
|
+ return e.treePathInfo = Yx(i, this),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ setLayoutInfo: function(t) {
|
|
|
+ this.layoutInfo = this.layoutInfo || {},
|
|
|
+ P(this.layoutInfo, t)
|
|
|
+ },
|
|
|
+ mapIdToIndex: function(t) {
|
|
|
+ var e = this._idIndexMap;
|
|
|
+ e || (e = this._idIndexMap = Q(),
|
|
|
+ this._idIndexMapCount = 0);
|
|
|
+ var i = e.get(t);
|
|
|
+ return null == i && e.set(t, i = this._idIndexMapCount++),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ getViewRoot: function() {
|
|
|
+ return this._viewRoot
|
|
|
+ },
|
|
|
+ resetViewRoot: function(t) {
|
|
|
+ t ? this._viewRoot = t : t = this._viewRoot;
|
|
|
+ var e = this.getRawData().tree.root;
|
|
|
+ t && (t === e || e.contains(t)) || (this._viewRoot = e)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var jx = 5;
|
|
|
+ function qx(t) {
|
|
|
+ this.group = new Ci,
|
|
|
+ t.add(this.group)
|
|
|
+ }
|
|
|
+ function Kx(t, e, i, n, o, a) {
|
|
|
+ var r = [[o ? t : t - jx, e], [t + i, e], [t + i, e + n], [o ? t : t - jx, e + n]];
|
|
|
+ return a || r.splice(2, 0, [t + i + jx, e + n / 2]),
|
|
|
+ o || r.push([t, e + n / 2]),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ qx.prototype = {
|
|
|
+ constructor: qx,
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ var o = t.getModel("breadcrumb")
|
|
|
+ , a = this.group;
|
|
|
+ if (a.removeAll(),
|
|
|
+ o.get("show") && i) {
|
|
|
+ var r = o.getModel("itemStyle")
|
|
|
+ , s = r.getModel("textStyle")
|
|
|
+ , l = {
|
|
|
+ pos: {
|
|
|
+ left: o.get("left"),
|
|
|
+ right: o.get("right"),
|
|
|
+ top: o.get("top"),
|
|
|
+ bottom: o.get("bottom")
|
|
|
+ },
|
|
|
+ box: {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ },
|
|
|
+ emptyItemWidth: o.get("emptyItemWidth"),
|
|
|
+ totalWidth: 0,
|
|
|
+ renderList: []
|
|
|
+ };
|
|
|
+ this._prepare(i, l, s),
|
|
|
+ this._renderContent(t, l, r, s, n),
|
|
|
+ Su(a, l.pos, l.box)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _prepare: function(t, e, i) {
|
|
|
+ for (var n = t; n; n = n.parentNode) {
|
|
|
+ var o = n.getModel().get("name")
|
|
|
+ , a = i.getTextRect(o)
|
|
|
+ , r = Math.max(a.width + 16, e.emptyItemWidth);
|
|
|
+ e.totalWidth += r + 8,
|
|
|
+ e.renderList.push({
|
|
|
+ node: n,
|
|
|
+ text: o,
|
|
|
+ width: r
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderContent: function(t, e, i, n, o) {
|
|
|
+ for (var a, r, s = 0, l = e.emptyItemWidth, u = t.get("breadcrumb.height"), h = function(t, e, i) {
|
|
|
+ var n = e.width
|
|
|
+ , o = e.height
|
|
|
+ , a = Rl(t.x, n)
|
|
|
+ , r = Rl(t.y, o)
|
|
|
+ , s = Rl(t.x2, n)
|
|
|
+ , l = Rl(t.y2, o);
|
|
|
+ return (isNaN(a) || isNaN(parseFloat(t.x))) && (a = 0),
|
|
|
+ (isNaN(s) || isNaN(parseFloat(t.x2))) && (s = n),
|
|
|
+ (isNaN(r) || isNaN(parseFloat(t.y))) && (r = 0),
|
|
|
+ (isNaN(l) || isNaN(parseFloat(t.y2))) && (l = o),
|
|
|
+ i = iu(i || 0),
|
|
|
+ {
|
|
|
+ width: Math.max(s - a - i[1] - i[3], 0),
|
|
|
+ height: Math.max(l - r - i[0] - i[2], 0)
|
|
|
+ }
|
|
|
+ }(e.pos, e.box), c = e.totalWidth, d = e.renderList, f = d.length - 1; 0 <= f; f--) {
|
|
|
+ var p = d[f]
|
|
|
+ , g = p.node
|
|
|
+ , m = p.width
|
|
|
+ , v = p.text;
|
|
|
+ c > h.width && (c -= m - l,
|
|
|
+ m = l,
|
|
|
+ v = null);
|
|
|
+ var y = new Qr({
|
|
|
+ shape: {
|
|
|
+ points: Kx(s, 0, m, u, f === d.length - 1, 0 === f)
|
|
|
+ },
|
|
|
+ style: D(i.getItemStyle(), {
|
|
|
+ lineJoin: "bevel",
|
|
|
+ text: v,
|
|
|
+ textFill: n.getTextColor(),
|
|
|
+ textFont: n.getFont()
|
|
|
+ }),
|
|
|
+ z: 10,
|
|
|
+ onclick: T(o, g)
|
|
|
+ });
|
|
|
+ this.group.add(y),
|
|
|
+ a = t,
|
|
|
+ r = g,
|
|
|
+ y.eventData = {
|
|
|
+ componentType: "series",
|
|
|
+ componentSubType: "treemap",
|
|
|
+ componentIndex: a.componentIndex,
|
|
|
+ seriesIndex: a.componentIndex,
|
|
|
+ seriesName: a.name,
|
|
|
+ seriesType: "treemap",
|
|
|
+ selfType: "breadcrumb",
|
|
|
+ nodeData: {
|
|
|
+ dataIndex: r && r.dataIndex,
|
|
|
+ name: r && r.name
|
|
|
+ },
|
|
|
+ treePathInfo: r && Yx(r, a)
|
|
|
+ },
|
|
|
+ s += m + 8
|
|
|
+ }
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this.group.removeAll()
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function $x(t) {
|
|
|
+ var e = s_(t);
|
|
|
+ return e.stroke = e.fill = e.lineWidth = null,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ var Jx = A
|
|
|
+ , Qx = Ci
|
|
|
+ , t_ = rs
|
|
|
+ , e_ = E
|
|
|
+ , i_ = ["label"]
|
|
|
+ , n_ = ["emphasis", "label"]
|
|
|
+ , o_ = ["upperLabel"]
|
|
|
+ , a_ = ["emphasis", "upperLabel"]
|
|
|
+ , r_ = 10
|
|
|
+ , s_ = ha([["fill", "color"], ["stroke", "strokeColor"], ["lineWidth", "strokeWidth"], ["shadowBlur"], ["shadowOffsetX"], ["shadowOffsetY"], ["shadowColor"]]);
|
|
|
+ function l_(h, r, s, l, u, e, c, t, i, n) {
|
|
|
+ if (c) {
|
|
|
+ var d = c.getLayout()
|
|
|
+ , o = h.getData();
|
|
|
+ if (o.setItemGraphicEl(c.dataIndex, null),
|
|
|
+ d && d.isInView) {
|
|
|
+ var f = d.width
|
|
|
+ , p = d.height
|
|
|
+ , g = d.borderWidth
|
|
|
+ , m = d.invisible
|
|
|
+ , v = c.getRawIndex()
|
|
|
+ , y = t && t.getRawIndex()
|
|
|
+ , a = c.viewChildren
|
|
|
+ , x = d.upperHeight
|
|
|
+ , _ = a && a.length
|
|
|
+ , w = c.getModel("itemStyle")
|
|
|
+ , b = c.getModel("emphasis.itemStyle")
|
|
|
+ , S = L("nodeGroup", Qx);
|
|
|
+ if (S) {
|
|
|
+ if (i.add(S),
|
|
|
+ S.attr("position", [d.x || 0, d.y || 0]),
|
|
|
+ S.__tmNodeWidth = f,
|
|
|
+ S.__tmNodeHeight = p,
|
|
|
+ d.isAboveViewRoot)
|
|
|
+ return S;
|
|
|
+ var M = c.getModel()
|
|
|
+ , I = L("background", t_, n, 1);
|
|
|
+ if (I && function(t, e, i) {
|
|
|
+ if (e.dataIndex = c.dataIndex,
|
|
|
+ e.seriesIndex = h.seriesIndex,
|
|
|
+ e.setShape({
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: f,
|
|
|
+ height: p
|
|
|
+ }),
|
|
|
+ m)
|
|
|
+ A(e);
|
|
|
+ else {
|
|
|
+ e.invisible = !1;
|
|
|
+ var n = c.getVisual("borderColor", !0)
|
|
|
+ , o = b.get("borderColor")
|
|
|
+ , a = $x(w);
|
|
|
+ a.fill = n;
|
|
|
+ var r = s_(b);
|
|
|
+ if (r.fill = o,
|
|
|
+ i) {
|
|
|
+ var s = f - 2 * g;
|
|
|
+ D(a, r, n, s, x, {
|
|
|
+ x: g,
|
|
|
+ y: 0,
|
|
|
+ width: s,
|
|
|
+ height: x
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ a.text = r.text = null;
|
|
|
+ e.setStyle(a),
|
|
|
+ Us(e, r)
|
|
|
+ }
|
|
|
+ t.add(e)
|
|
|
+ }(S, I, _ && d.upperLabelHeight),
|
|
|
+ _)
|
|
|
+ Qs(S) && Js(S, !1),
|
|
|
+ I && (Js(I, !0),
|
|
|
+ o.setItemGraphicEl(c.dataIndex, I));
|
|
|
+ else {
|
|
|
+ var T = L("content", t_, n, 2);
|
|
|
+ T && function(t, e) {
|
|
|
+ e.dataIndex = c.dataIndex,
|
|
|
+ e.seriesIndex = h.seriesIndex;
|
|
|
+ var i = Math.max(f - 2 * g, 0)
|
|
|
+ , n = Math.max(p - 2 * g, 0);
|
|
|
+ if (e.culling = !0,
|
|
|
+ e.setShape({
|
|
|
+ x: g,
|
|
|
+ y: g,
|
|
|
+ width: i,
|
|
|
+ height: n
|
|
|
+ }),
|
|
|
+ m)
|
|
|
+ A(e);
|
|
|
+ else {
|
|
|
+ e.invisible = !1;
|
|
|
+ var o = c.getVisual("color", !0)
|
|
|
+ , a = $x(w);
|
|
|
+ a.fill = o;
|
|
|
+ var r = s_(b);
|
|
|
+ D(a, r, o, i, n),
|
|
|
+ e.setStyle(a),
|
|
|
+ Us(e, r)
|
|
|
+ }
|
|
|
+ t.add(e)
|
|
|
+ }(S, T),
|
|
|
+ I && Qs(I) && Js(I, !1),
|
|
|
+ Js(S, !0),
|
|
|
+ o.setItemGraphicEl(c.dataIndex, S)
|
|
|
+ }
|
|
|
+ return S
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function A(t) {
|
|
|
+ t.invisible || e.push(t)
|
|
|
+ }
|
|
|
+ function D(t, e, i, n, o, a) {
|
|
|
+ var r = M.get("name")
|
|
|
+ , s = M.getModel(a ? o_ : i_)
|
|
|
+ , l = M.getModel(a ? a_ : n_)
|
|
|
+ , u = s.getShallow("show");
|
|
|
+ el(t, e, s, l, {
|
|
|
+ defaultText: u ? r : null,
|
|
|
+ autoColor: i,
|
|
|
+ isRectText: !0,
|
|
|
+ labelFetcher: h,
|
|
|
+ labelDataIndex: c.dataIndex,
|
|
|
+ labelProp: a ? "upperLabel" : "label"
|
|
|
+ }),
|
|
|
+ C(t, a, d),
|
|
|
+ C(e, a, d),
|
|
|
+ a && (t.textRect = k(a)),
|
|
|
+ t.truncate = u && s.get("ellipsis") ? {
|
|
|
+ outerWidth: n,
|
|
|
+ outerHeight: o,
|
|
|
+ minChar: 2
|
|
|
+ } : null
|
|
|
+ }
|
|
|
+ function C(t, e, i) {
|
|
|
+ var n = t.text;
|
|
|
+ if (!e && i.isLeafRoot && null != n) {
|
|
|
+ var o = h.get("drillDownIcon", !0);
|
|
|
+ t.text = o ? o + " " + n : n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function L(t, e, i, n) {
|
|
|
+ var o = null != y && s[t][y]
|
|
|
+ , a = u[t];
|
|
|
+ return o ? (s[t][y] = null,
|
|
|
+ function(t, e, i) {
|
|
|
+ (t[v] = {}).old = "nodeGroup" === i ? e.position.slice() : P({}, e.shape)
|
|
|
+ }(a, o, t)) : m || ((o = new e({
|
|
|
+ z: function(t, e) {
|
|
|
+ var i = t * r_ + e;
|
|
|
+ return (i - 1) / i
|
|
|
+ }(i, n)
|
|
|
+ })).__tmDepth = i,
|
|
|
+ function(t, e, i) {
|
|
|
+ var n = t[v] = {}
|
|
|
+ , o = c.parentNode;
|
|
|
+ if (o && (!l || "drillDown" === l.direction)) {
|
|
|
+ var a = 0
|
|
|
+ , r = 0
|
|
|
+ , s = u.background[o.getRawIndex()];
|
|
|
+ !l && s && s.old && (a = s.old.width,
|
|
|
+ r = s.old.height),
|
|
|
+ n.old = "nodeGroup" === i ? [0, r] : {
|
|
|
+ x: a,
|
|
|
+ y: r,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ n.fadein = "nodeGroup" !== i
|
|
|
+ }(a, 0, o.__tmStorageName = t)),
|
|
|
+ r[t][v] = o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Cf({
|
|
|
+ type: "treemap",
|
|
|
+ init: function(t, e) {
|
|
|
+ this._containerGroup,
|
|
|
+ this._storage = {
|
|
|
+ nodeGroup: [],
|
|
|
+ background: [],
|
|
|
+ content: []
|
|
|
+ },
|
|
|
+ this._oldTree,
|
|
|
+ this._breadcrumb,
|
|
|
+ this._controller,
|
|
|
+ this._state = "ready"
|
|
|
+ },
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ if (!(_(e.findComponents({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "treemap",
|
|
|
+ query: n
|
|
|
+ }), t) < 0)) {
|
|
|
+ this.seriesModel = t,
|
|
|
+ this.api = i,
|
|
|
+ this.ecModel = e;
|
|
|
+ var o = Zx(n, ["treemapZoomToNode", "treemapRootToNode"], t)
|
|
|
+ , a = n && n.type
|
|
|
+ , r = t.layoutInfo
|
|
|
+ , s = !this._oldTree
|
|
|
+ , l = this._storage
|
|
|
+ , u = "treemapRootToNode" === a && o && l ? {
|
|
|
+ rootNodeGroup: l.nodeGroup[o.node.getRawIndex()],
|
|
|
+ direction: n.direction
|
|
|
+ } : null
|
|
|
+ , h = this._giveContainerGroup(r)
|
|
|
+ , c = this._doRender(h, t, u);
|
|
|
+ s || a && "treemapZoomToNode" !== a && "treemapRootToNode" !== a ? c.renderFinally() : this._doAnimation(h, c, t, u),
|
|
|
+ this._resetController(i),
|
|
|
+ this._renderBreadcrumb(t, i, o)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _giveContainerGroup: function(t) {
|
|
|
+ var e = this._containerGroup;
|
|
|
+ return e || (e = this._containerGroup = new Qx,
|
|
|
+ this._initEvents(e),
|
|
|
+ this.group.add(e)),
|
|
|
+ e.attr("position", [t.x, t.y]),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ _doRender: function(t, e, i) {
|
|
|
+ var n = e.getData().tree
|
|
|
+ , o = this._oldTree
|
|
|
+ , a = {
|
|
|
+ nodeGroup: [],
|
|
|
+ background: [],
|
|
|
+ content: []
|
|
|
+ }
|
|
|
+ , r = {
|
|
|
+ nodeGroup: [],
|
|
|
+ background: [],
|
|
|
+ content: []
|
|
|
+ }
|
|
|
+ , s = this._storage
|
|
|
+ , l = []
|
|
|
+ , c = T(l_, e, r, s, i, a, l);
|
|
|
+ !function a(r, s, l, u, h) {
|
|
|
+ u ? e_(s = r, function(t, e) {
|
|
|
+ t.isRemoved() || i(e, e)
|
|
|
+ }) : new kf(s,r,t,t).add(i).update(i).remove(T(i, null)).execute();
|
|
|
+ function t(t) {
|
|
|
+ return t.getId()
|
|
|
+ }
|
|
|
+ function i(t, e) {
|
|
|
+ var i = null != t ? r[t] : null
|
|
|
+ , n = null != e ? s[e] : null
|
|
|
+ , o = c(i, n, l, h);
|
|
|
+ o && a(i && i.viewChildren || [], n && n.viewChildren || [], o, u, h + 1)
|
|
|
+ }
|
|
|
+ }(n.root ? [n.root] : [], o && o.root ? [o.root] : [], t, n === o || !o, 0);
|
|
|
+ var u, h, d = (h = {
|
|
|
+ nodeGroup: [],
|
|
|
+ background: [],
|
|
|
+ content: []
|
|
|
+ },
|
|
|
+ (u = s) && e_(u, function(t, e) {
|
|
|
+ var i = h[e];
|
|
|
+ e_(t, function(t) {
|
|
|
+ t && (i.push(t),
|
|
|
+ t.__tmWillDelete = 1)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ h);
|
|
|
+ return this._oldTree = n,
|
|
|
+ this._storage = r,
|
|
|
+ {
|
|
|
+ lastsForAnimation: a,
|
|
|
+ willDeleteEls: d,
|
|
|
+ renderFinally: function() {
|
|
|
+ e_(d, function(t) {
|
|
|
+ e_(t, function(t) {
|
|
|
+ t.parent && t.parent.remove(t)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ e_(l, function(t) {
|
|
|
+ t.invisible = !0,
|
|
|
+ t.dirty()
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _doAnimation: function(t, a, e, s) {
|
|
|
+ if (e.get("animation")) {
|
|
|
+ var l = e.get("animationDurationUpdate")
|
|
|
+ , u = e.get("animationEasing")
|
|
|
+ , h = function() {
|
|
|
+ var a, r = [], s = {};
|
|
|
+ return {
|
|
|
+ add: function(t, e, i, n, o) {
|
|
|
+ return R(n) && (o = n,
|
|
|
+ n = 0),
|
|
|
+ !s[t.id] && (s[t.id] = 1,
|
|
|
+ r.push({
|
|
|
+ el: t,
|
|
|
+ target: e,
|
|
|
+ time: i,
|
|
|
+ delay: n,
|
|
|
+ easing: o
|
|
|
+ }),
|
|
|
+ !0)
|
|
|
+ },
|
|
|
+ done: function(t) {
|
|
|
+ return a = t,
|
|
|
+ this
|
|
|
+ },
|
|
|
+ start: function() {
|
|
|
+ for (var t = r.length, e = 0, i = r.length; e < i; e++) {
|
|
|
+ var n = r[e];
|
|
|
+ n.el.animateTo(n.target, n.time, n.delay, n.easing, o)
|
|
|
+ }
|
|
|
+ return this;
|
|
|
+ function o() {
|
|
|
+ --t || (r.length = 0,
|
|
|
+ s = {},
|
|
|
+ a && a())
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }();
|
|
|
+ e_(a.willDeleteEls, function(t, r) {
|
|
|
+ e_(t, function(t, e) {
|
|
|
+ if (!t.invisible) {
|
|
|
+ var i, n = t.parent;
|
|
|
+ if (s && "drillDown" === s.direction)
|
|
|
+ i = n === s.rootNodeGroup ? {
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: n.__tmNodeWidth,
|
|
|
+ height: n.__tmNodeHeight
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ opacity: 0
|
|
|
+ }
|
|
|
+ } : {
|
|
|
+ style: {
|
|
|
+ opacity: 0
|
|
|
+ }
|
|
|
+ };
|
|
|
+ else {
|
|
|
+ var o = 0
|
|
|
+ , a = 0;
|
|
|
+ n.__tmWillDelete || (o = n.__tmNodeWidth / 2,
|
|
|
+ a = n.__tmNodeHeight / 2),
|
|
|
+ i = "nodeGroup" === r ? {
|
|
|
+ position: [o, a],
|
|
|
+ style: {
|
|
|
+ opacity: 0
|
|
|
+ }
|
|
|
+ } : {
|
|
|
+ shape: {
|
|
|
+ x: o,
|
|
|
+ y: a,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ opacity: 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ i && h.add(t, i, l, u)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ e_(this._storage, function(t, o) {
|
|
|
+ e_(t, function(t, e) {
|
|
|
+ var i = a.lastsForAnimation[o][e]
|
|
|
+ , n = {};
|
|
|
+ i && ("nodeGroup" === o ? i.old && (n.position = t.position.slice(),
|
|
|
+ t.attr("position", i.old)) : (i.old && (n.shape = P({}, t.shape),
|
|
|
+ t.setShape(i.old)),
|
|
|
+ i.fadein ? (t.setStyle("opacity", 0),
|
|
|
+ n.style = {
|
|
|
+ opacity: 1
|
|
|
+ }) : 1 !== t.style.opacity && (n.style = {
|
|
|
+ opacity: 1
|
|
|
+ })),
|
|
|
+ h.add(t, n, l, u))
|
|
|
+ })
|
|
|
+ }, this),
|
|
|
+ this._state = "animating",
|
|
|
+ h.done(Jx(function() {
|
|
|
+ this._state = "ready",
|
|
|
+ a.renderFinally()
|
|
|
+ }, this)).start()
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _resetController: function(t) {
|
|
|
+ var e = this._controller;
|
|
|
+ e || ((e = this._controller = new Vy(t.getZr())).enable(this.seriesModel.get("roam")),
|
|
|
+ e.on("pan", Jx(this._onPan, this)),
|
|
|
+ e.on("zoom", Jx(this._onZoom, this)));
|
|
|
+ var n = new Di(0,0,t.getWidth(),t.getHeight());
|
|
|
+ e.setPointerChecker(function(t, e, i) {
|
|
|
+ return n.contain(e, i)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _clearController: function() {
|
|
|
+ var t = this._controller;
|
|
|
+ t && (t.dispose(),
|
|
|
+ t = null)
|
|
|
+ },
|
|
|
+ _onPan: function(t) {
|
|
|
+ if ("animating" !== this._state && (3 < Math.abs(t.dx) || 3 < Math.abs(t.dy))) {
|
|
|
+ var e = this.seriesModel.getData().tree.root;
|
|
|
+ if (!e)
|
|
|
+ return;
|
|
|
+ var i = e.getLayout();
|
|
|
+ if (!i)
|
|
|
+ return;
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "treemapMove",
|
|
|
+ from: this.uid,
|
|
|
+ seriesId: this.seriesModel.id,
|
|
|
+ rootRect: {
|
|
|
+ x: i.x + t.dx,
|
|
|
+ y: i.y + t.dy,
|
|
|
+ width: i.width,
|
|
|
+ height: i.height
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _onZoom: function(t) {
|
|
|
+ var e = t.originX
|
|
|
+ , i = t.originY;
|
|
|
+ if ("animating" !== this._state) {
|
|
|
+ var n = this.seriesModel.getData().tree.root;
|
|
|
+ if (!n)
|
|
|
+ return;
|
|
|
+ var o = n.getLayout();
|
|
|
+ if (!o)
|
|
|
+ return;
|
|
|
+ var a = new Di(o.x,o.y,o.width,o.height)
|
|
|
+ , r = this.seriesModel.layoutInfo;
|
|
|
+ e -= r.x,
|
|
|
+ i -= r.y;
|
|
|
+ var s = ae();
|
|
|
+ ue(s, s, [-e, -i]),
|
|
|
+ ce(s, s, [t.scale, t.scale]),
|
|
|
+ ue(s, s, [e, i]),
|
|
|
+ a.applyTransform(s),
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "treemapRender",
|
|
|
+ from: this.uid,
|
|
|
+ seriesId: this.seriesModel.id,
|
|
|
+ rootRect: {
|
|
|
+ x: a.x,
|
|
|
+ y: a.y,
|
|
|
+ width: a.width,
|
|
|
+ height: a.height
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _initEvents: function(t) {
|
|
|
+ t.on("click", function(t) {
|
|
|
+ if ("ready" === this._state) {
|
|
|
+ var e = this.seriesModel.get("nodeClick", !0);
|
|
|
+ if (e) {
|
|
|
+ var i = this.findTarget(t.offsetX, t.offsetY);
|
|
|
+ if (i) {
|
|
|
+ var n = i.node;
|
|
|
+ if (n.getLayout().isLeafRoot)
|
|
|
+ this._rootToNode(i);
|
|
|
+ else if ("zoomToNode" === e)
|
|
|
+ this._zoomToNode(i);
|
|
|
+ else if ("link" === e) {
|
|
|
+ var o = n.hostTree.data.getItemModel(n.dataIndex)
|
|
|
+ , a = o.get("link", !0)
|
|
|
+ , r = o.get("target", !0) || "blank";
|
|
|
+ a && gu(a, r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _renderBreadcrumb: function(e, t, i) {
|
|
|
+ i = i || ((i = null != e.get("leafDepth", !0) ? {
|
|
|
+ node: e.getViewRoot()
|
|
|
+ } : this.findTarget(t.getWidth() / 2, t.getHeight() / 2)) || {
|
|
|
+ node: e.getData().tree.root
|
|
|
+ }),
|
|
|
+ (this._breadcrumb || (this._breadcrumb = new qx(this.group))).render(e, t, i.node, Jx(function(t) {
|
|
|
+ "animating" !== this._state && (Xx(e.getViewRoot(), t) ? this._rootToNode({
|
|
|
+ node: t
|
|
|
+ }) : this._zoomToNode({
|
|
|
+ node: t
|
|
|
+ }))
|
|
|
+ }, this))
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this._clearController(),
|
|
|
+ this._containerGroup && this._containerGroup.removeAll(),
|
|
|
+ this._storage = {
|
|
|
+ nodeGroup: [],
|
|
|
+ background: [],
|
|
|
+ content: []
|
|
|
+ },
|
|
|
+ this._state = "ready",
|
|
|
+ this._breadcrumb && this._breadcrumb.remove()
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._clearController()
|
|
|
+ },
|
|
|
+ _zoomToNode: function(t) {
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "treemapZoomToNode",
|
|
|
+ from: this.uid,
|
|
|
+ seriesId: this.seriesModel.id,
|
|
|
+ targetNode: t.node
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _rootToNode: function(t) {
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "treemapRootToNode",
|
|
|
+ from: this.uid,
|
|
|
+ seriesId: this.seriesModel.id,
|
|
|
+ targetNode: t.node
|
|
|
+ })
|
|
|
+ },
|
|
|
+ findTarget: function(o, a) {
|
|
|
+ var r;
|
|
|
+ return this.seriesModel.getViewRoot().eachNode({
|
|
|
+ attr: "viewChildren",
|
|
|
+ order: "preorder"
|
|
|
+ }, function(t) {
|
|
|
+ var e = this._storage.background[t.getRawIndex()];
|
|
|
+ if (e) {
|
|
|
+ var i = e.transformCoordToLocal(o, a)
|
|
|
+ , n = e.shape;
|
|
|
+ if (!(n.x <= i[0] && i[0] <= n.x + n.width && n.y <= i[1] && i[1] <= n.y + n.height))
|
|
|
+ return !1;
|
|
|
+ r = {
|
|
|
+ node: t,
|
|
|
+ offsetX: i[0],
|
|
|
+ offsetY: i[1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, this),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ });
|
|
|
+ for (var u_ = function() {}, h_ = ["treemapZoomToNode", "treemapRender", "treemapMove"], c_ = 0; c_ < h_.length; c_++)
|
|
|
+ _f({
|
|
|
+ type: h_[c_],
|
|
|
+ update: "updateView"
|
|
|
+ }, u_);
|
|
|
+ _f({
|
|
|
+ type: "treemapRootToNode",
|
|
|
+ update: "updateView"
|
|
|
+ }, function(o, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "treemap",
|
|
|
+ query: o
|
|
|
+ }, function(t, e) {
|
|
|
+ var i = Zx(o, ["treemapZoomToNode", "treemapRootToNode"], t);
|
|
|
+ if (i) {
|
|
|
+ var n = t.getViewRoot();
|
|
|
+ n && (o.direction = Xx(n, i.node) ? "rollUp" : "drillDown"),
|
|
|
+ t.resetViewRoot(i.node)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var d_ = E
|
|
|
+ , f_ = z
|
|
|
+ , p_ = -1
|
|
|
+ , g_ = function(t) {
|
|
|
+ var e = t.mappingMethod
|
|
|
+ , i = t.type
|
|
|
+ , n = this.option = k(t);
|
|
|
+ this.type = i,
|
|
|
+ this.mappingMethod = e,
|
|
|
+ this._normalizeData = T_[e];
|
|
|
+ var o = m_[i];
|
|
|
+ this.applyVisual = o.applyVisual,
|
|
|
+ this.getColorMapper = o.getColorMapper,
|
|
|
+ this._doMap = o._doMap[e],
|
|
|
+ "piecewise" === e ? (v_(n),
|
|
|
+ function(i) {
|
|
|
+ var t = i.pieceList;
|
|
|
+ i.hasSpecialVisual = !1,
|
|
|
+ E(t, function(t, e) {
|
|
|
+ t.originIndex = e,
|
|
|
+ null != t.visual && (i.hasSpecialVisual = !0)
|
|
|
+ })
|
|
|
+ }(n)) : "category" === e ? n.categories ? function(t) {
|
|
|
+ var e = t.categories
|
|
|
+ , i = t.visual
|
|
|
+ , n = t.categoryMap = {};
|
|
|
+ if (d_(e, function(t, e) {
|
|
|
+ n[t] = e
|
|
|
+ }),
|
|
|
+ !L(i)) {
|
|
|
+ var o = [];
|
|
|
+ z(i) ? d_(i, function(t, e) {
|
|
|
+ var i = n[e];
|
|
|
+ o[null != i ? i : p_] = t
|
|
|
+ }) : o[p_] = i,
|
|
|
+ i = I_(t, o)
|
|
|
+ }
|
|
|
+ for (var a = e.length - 1; 0 <= a; a--)
|
|
|
+ null == i[a] && (delete n[e[a]],
|
|
|
+ e.pop())
|
|
|
+ }(n) : v_(n, !0) : (Y("linear" !== e || n.dataExtent),
|
|
|
+ v_(n))
|
|
|
+ };
|
|
|
+ g_.prototype = {
|
|
|
+ constructor: g_,
|
|
|
+ mapValueToVisual: function(t) {
|
|
|
+ var e = this._normalizeData(t);
|
|
|
+ return this._doMap(e, t)
|
|
|
+ },
|
|
|
+ getNormalizer: function() {
|
|
|
+ return A(this._normalizeData, this)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var m_ = g_.visualHandlers = {
|
|
|
+ color: {
|
|
|
+ applyVisual: __("color"),
|
|
|
+ getColorMapper: function() {
|
|
|
+ var o = this.option;
|
|
|
+ return A("category" === o.mappingMethod ? function(t, e) {
|
|
|
+ return e || (t = this._normalizeData(t)),
|
|
|
+ w_.call(this, t)
|
|
|
+ }
|
|
|
+ : function(t, e, i) {
|
|
|
+ var n = !!i;
|
|
|
+ return e || (t = this._normalizeData(t)),
|
|
|
+ i = Ue(t, o.parsedVisual, i),
|
|
|
+ n ? i : $e(i, "rgba")
|
|
|
+ }
|
|
|
+ , this)
|
|
|
+ },
|
|
|
+ _doMap: {
|
|
|
+ linear: function(t) {
|
|
|
+ return $e(Ue(t, this.option.parsedVisual), "rgba")
|
|
|
+ },
|
|
|
+ category: w_,
|
|
|
+ piecewise: function(t, e) {
|
|
|
+ var i = M_.call(this, e);
|
|
|
+ return null == i && (i = $e(Ue(t, this.option.parsedVisual), "rgba")),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ fixed: b_
|
|
|
+ }
|
|
|
+ },
|
|
|
+ colorHue: y_(function(t, e) {
|
|
|
+ return qe(t, e)
|
|
|
+ }),
|
|
|
+ colorSaturation: y_(function(t, e) {
|
|
|
+ return qe(t, null, e)
|
|
|
+ }),
|
|
|
+ colorLightness: y_(function(t, e) {
|
|
|
+ return qe(t, null, null, e)
|
|
|
+ }),
|
|
|
+ colorAlpha: y_(function(t, e) {
|
|
|
+ return Ke(t, e)
|
|
|
+ }),
|
|
|
+ opacity: {
|
|
|
+ applyVisual: __("opacity"),
|
|
|
+ _doMap: S_([0, 1])
|
|
|
+ },
|
|
|
+ liftZ: {
|
|
|
+ applyVisual: __("liftZ"),
|
|
|
+ _doMap: {
|
|
|
+ linear: b_,
|
|
|
+ category: b_,
|
|
|
+ piecewise: b_,
|
|
|
+ fixed: b_
|
|
|
+ }
|
|
|
+ },
|
|
|
+ symbol: {
|
|
|
+ applyVisual: function(t, e, i) {
|
|
|
+ var n = this.mapValueToVisual(t);
|
|
|
+ if (R(n))
|
|
|
+ i("symbol", n);
|
|
|
+ else if (f_(n))
|
|
|
+ for (var o in n)
|
|
|
+ n.hasOwnProperty(o) && i(o, n[o])
|
|
|
+ },
|
|
|
+ _doMap: {
|
|
|
+ linear: x_,
|
|
|
+ category: w_,
|
|
|
+ piecewise: function(t, e) {
|
|
|
+ var i = M_.call(this, e);
|
|
|
+ return null == i && (i = x_.call(this, t)),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ fixed: b_
|
|
|
+ }
|
|
|
+ },
|
|
|
+ symbolSize: {
|
|
|
+ applyVisual: __("symbolSize"),
|
|
|
+ _doMap: S_([0, 1])
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function v_(t, e) {
|
|
|
+ var i = t.visual
|
|
|
+ , n = [];
|
|
|
+ z(i) ? d_(i, function(t) {
|
|
|
+ n.push(t)
|
|
|
+ }) : null != i && n.push(i);
|
|
|
+ e || 1 !== n.length || {
|
|
|
+ color: 1,
|
|
|
+ symbol: 1
|
|
|
+ }.hasOwnProperty(t.type) || (n[1] = n[0]),
|
|
|
+ I_(t, n)
|
|
|
+ }
|
|
|
+ function y_(n) {
|
|
|
+ return {
|
|
|
+ applyVisual: function(t, e, i) {
|
|
|
+ t = this.mapValueToVisual(t),
|
|
|
+ i("color", n(e("color"), t))
|
|
|
+ },
|
|
|
+ _doMap: S_([0, 1])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function x_(t) {
|
|
|
+ var e = this.option.visual;
|
|
|
+ return e[Math.round(El(t, [0, 1], [0, e.length - 1], !0))] || {}
|
|
|
+ }
|
|
|
+ function __(n) {
|
|
|
+ return function(t, e, i) {
|
|
|
+ i(n, this.mapValueToVisual(t))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function w_(t) {
|
|
|
+ var e = this.option.visual;
|
|
|
+ return e[this.option.loop && t !== p_ ? t % e.length : t]
|
|
|
+ }
|
|
|
+ function b_() {
|
|
|
+ return this.option.visual[0]
|
|
|
+ }
|
|
|
+ function S_(n) {
|
|
|
+ return {
|
|
|
+ linear: function(t) {
|
|
|
+ return El(t, n, this.option.visual, !0)
|
|
|
+ },
|
|
|
+ category: w_,
|
|
|
+ piecewise: function(t, e) {
|
|
|
+ var i = M_.call(this, e);
|
|
|
+ return null == i && (i = El(t, n, this.option.visual, !0)),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ fixed: b_
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function M_(t) {
|
|
|
+ var e = this.option
|
|
|
+ , i = e.pieceList;
|
|
|
+ if (e.hasSpecialVisual) {
|
|
|
+ var n = i[g_.findPieceIndex(t, i)];
|
|
|
+ if (n && n.visual)
|
|
|
+ return n.visual[this.type]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function I_(t, e) {
|
|
|
+ return t.visual = e,
|
|
|
+ "color" === t.type && (t.parsedVisual = O(e, function(t) {
|
|
|
+ return Fe(t)
|
|
|
+ })),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ var T_ = {
|
|
|
+ linear: function(t) {
|
|
|
+ return El(t, this.option.dataExtent, [0, 1], !0)
|
|
|
+ },
|
|
|
+ piecewise: function(t) {
|
|
|
+ var e = this.option.pieceList
|
|
|
+ , i = g_.findPieceIndex(t, e, !0);
|
|
|
+ if (null != i)
|
|
|
+ return El(i, [0, e.length - 1], [0, 1], !0)
|
|
|
+ },
|
|
|
+ category: function(t) {
|
|
|
+ var e = this.option.categories ? this.option.categoryMap[t] : t;
|
|
|
+ return null == e ? p_ : e
|
|
|
+ },
|
|
|
+ fixed: et
|
|
|
+ };
|
|
|
+ function A_(t, e, i) {
|
|
|
+ return t ? e <= i : e < i
|
|
|
+ }
|
|
|
+ g_.listVisualTypes = function() {
|
|
|
+ var i = [];
|
|
|
+ return E(m_, function(t, e) {
|
|
|
+ i.push(e)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ g_.addVisualHandler = function(t, e) {
|
|
|
+ m_[t] = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ g_.isValidType = function(t) {
|
|
|
+ return m_.hasOwnProperty(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ g_.eachVisual = function(t, e, i) {
|
|
|
+ z(t) ? E(t, e, i) : e.call(i, t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ g_.mapVisual = function(t, n, o) {
|
|
|
+ var a, r = L(t) ? [] : z(t) ? {} : (a = !0,
|
|
|
+ null);
|
|
|
+ return g_.eachVisual(t, function(t, e) {
|
|
|
+ var i = n.call(o, t, e);
|
|
|
+ a ? r = i : r[e] = i
|
|
|
+ }),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ g_.retrieveVisuals = function(i) {
|
|
|
+ var n, o = {};
|
|
|
+ return i && d_(m_, function(t, e) {
|
|
|
+ i.hasOwnProperty(e) && (o[e] = i[e],
|
|
|
+ n = !0)
|
|
|
+ }),
|
|
|
+ n ? o : null
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ g_.prepareVisualTypes = function(t) {
|
|
|
+ if (f_(t)) {
|
|
|
+ var i = [];
|
|
|
+ d_(t, function(t, e) {
|
|
|
+ i.push(e)
|
|
|
+ }),
|
|
|
+ t = i
|
|
|
+ } else {
|
|
|
+ if (!L(t))
|
|
|
+ return [];
|
|
|
+ t = t.slice()
|
|
|
+ }
|
|
|
+ return t.sort(function(t, e) {
|
|
|
+ return "color" === e && "color" !== t && 0 === t.indexOf("color") ? 1 : -1
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ g_.dependsOn = function(t, e) {
|
|
|
+ return "color" === e ? !(!t || 0 !== t.indexOf(e)) : t === e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ g_.findPieceIndex = function(n, t, e) {
|
|
|
+ for (var o, a = 1 / 0, i = 0, r = t.length; i < r; i++) {
|
|
|
+ var s = t[i].value;
|
|
|
+ if (null != s) {
|
|
|
+ if (s === n || "string" == typeof s && s === n + "")
|
|
|
+ return i;
|
|
|
+ e && c(s, i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (i = 0,
|
|
|
+ r = t.length; i < r; i++) {
|
|
|
+ var l = t[i]
|
|
|
+ , u = l.interval
|
|
|
+ , h = l.close;
|
|
|
+ if (u) {
|
|
|
+ if (u[0] === -1 / 0) {
|
|
|
+ if (A_(h[1], n, u[1]))
|
|
|
+ return i
|
|
|
+ } else if (u[1] === 1 / 0) {
|
|
|
+ if (A_(h[0], u[0], n))
|
|
|
+ return i
|
|
|
+ } else if (A_(h[0], u[0], n) && A_(h[1], n, u[1]))
|
|
|
+ return i;
|
|
|
+ e && c(u[0], i),
|
|
|
+ e && c(u[1], i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (e)
|
|
|
+ return n === 1 / 0 ? t.length - 1 : n === -1 / 0 ? 0 : o;
|
|
|
+ function c(t, e) {
|
|
|
+ var i = Math.abs(t - n);
|
|
|
+ i < a && (a = i,
|
|
|
+ o = e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var D_ = L
|
|
|
+ , C_ = "itemStyle"
|
|
|
+ , L_ = {
|
|
|
+ seriesType: "treemap",
|
|
|
+ reset: function(t, e, i, n) {
|
|
|
+ var o = t.getData().tree
|
|
|
+ , a = o.root
|
|
|
+ , r = t.getModel(C_);
|
|
|
+ a.isRemoved() || !function n(t, e, o, a, r, s) {
|
|
|
+ var l = t.getModel();
|
|
|
+ var i = t.getLayout();
|
|
|
+ if (!i || i.invisible || !i.isInView)
|
|
|
+ return;
|
|
|
+ var u = t.getModel(C_);
|
|
|
+ var h = o[t.depth];
|
|
|
+ var c = k_(u, e, h, a);
|
|
|
+ var d = u.get("borderColor");
|
|
|
+ var f = u.get("borderColorSaturation");
|
|
|
+ var p;
|
|
|
+ null != f && (p = P_(c),
|
|
|
+ g = f,
|
|
|
+ d = null != (m = p) ? qe(m, null, null, g) : null);
|
|
|
+ var g, m;
|
|
|
+ t.setVisual("borderColor", d);
|
|
|
+ var v = t.viewChildren;
|
|
|
+ if (v && v.length) {
|
|
|
+ var y = O_(t, l, i, u, c, v);
|
|
|
+ E(v, function(t, e) {
|
|
|
+ if (t.depth >= r.length || t === r[t.depth]) {
|
|
|
+ var i = R_(l, c, t, e, y, s);
|
|
|
+ n(t, i, o, a, r, s)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ p = P_(c),
|
|
|
+ t.setVisual("color", p)
|
|
|
+ }(a, {}, O(o.levelModels, function(t) {
|
|
|
+ return t ? t.get(C_) : null
|
|
|
+ }), r, t.getViewRoot().getAncestors(), t)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function k_(i, n, o, a) {
|
|
|
+ var r = P({}, n);
|
|
|
+ return E(["color", "colorAlpha", "colorSaturation"], function(t) {
|
|
|
+ var e = i.get(t, !0);
|
|
|
+ null == e && o && (e = o[t]),
|
|
|
+ null == e && (e = n[t]),
|
|
|
+ null == e && (e = a.get(t)),
|
|
|
+ null != e && (r[t] = e)
|
|
|
+ }),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ function P_(t) {
|
|
|
+ var e = N_(t, "color");
|
|
|
+ if (e) {
|
|
|
+ var i = N_(t, "colorAlpha")
|
|
|
+ , n = N_(t, "colorSaturation");
|
|
|
+ return n && (e = qe(e, null, null, n)),
|
|
|
+ i && (e = Ke(e, i)),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function N_(t, e) {
|
|
|
+ var i = t[e];
|
|
|
+ if (null != i && "none" !== i)
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ function O_(t, e, i, n, o, a) {
|
|
|
+ if (a && a.length) {
|
|
|
+ var r = E_(e, "color") || null != o.color && "none" !== o.color && (E_(e, "colorAlpha") || E_(e, "colorSaturation"));
|
|
|
+ if (r) {
|
|
|
+ var s = e.get("visualMin")
|
|
|
+ , l = e.get("visualMax")
|
|
|
+ , u = i.dataExtent.slice();
|
|
|
+ null != s && s < u[0] && (u[0] = s),
|
|
|
+ null != l && l > u[1] && (u[1] = l);
|
|
|
+ var h = e.get("colorMappingBy")
|
|
|
+ , c = {
|
|
|
+ type: r.name,
|
|
|
+ dataExtent: u,
|
|
|
+ visual: r.range
|
|
|
+ };
|
|
|
+ "color" !== c.type || "index" !== h && "id" !== h ? c.mappingMethod = "linear" : (c.mappingMethod = "category",
|
|
|
+ c.loop = !0);
|
|
|
+ var d = new g_(c);
|
|
|
+ return d.__drColorMappingBy = h,
|
|
|
+ d
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function E_(t, e) {
|
|
|
+ var i = t.get(e);
|
|
|
+ return D_(i) && i.length ? {
|
|
|
+ name: e,
|
|
|
+ range: i
|
|
|
+ } : null
|
|
|
+ }
|
|
|
+ function R_(t, e, i, n, o, a) {
|
|
|
+ var r = P({}, e);
|
|
|
+ if (o) {
|
|
|
+ var s = o.type
|
|
|
+ , l = "color" === s && o.__drColorMappingBy
|
|
|
+ , u = "index" === l ? n : "id" === l ? a.mapIdToIndex(i.getId()) : i.getValue(t.get("visualDimension"));
|
|
|
+ r[s] = o.mapValueToVisual(u)
|
|
|
+ }
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ var z_ = Math.max
|
|
|
+ , B_ = Math.min
|
|
|
+ , V_ = W
|
|
|
+ , G_ = E
|
|
|
+ , F_ = ["itemStyle", "borderWidth"]
|
|
|
+ , W_ = ["itemStyle", "gapWidth"]
|
|
|
+ , H_ = ["upperLabel", "show"]
|
|
|
+ , Z_ = ["upperLabel", "height"]
|
|
|
+ , U_ = {
|
|
|
+ seriesType: "treemap",
|
|
|
+ reset: function(t, e, i, n) {
|
|
|
+ var o = i.getWidth()
|
|
|
+ , a = i.getHeight()
|
|
|
+ , r = t.option
|
|
|
+ , s = bu(t.getBoxLayoutParams(), {
|
|
|
+ width: i.getWidth(),
|
|
|
+ height: i.getHeight()
|
|
|
+ })
|
|
|
+ , l = r.size || []
|
|
|
+ , u = Rl(V_(s.width, l[0]), o)
|
|
|
+ , h = Rl(V_(s.height, l[1]), a)
|
|
|
+ , c = n && n.type
|
|
|
+ , d = Zx(n, ["treemapZoomToNode", "treemapRootToNode"], t)
|
|
|
+ , f = "treemapRender" === c || "treemapMove" === c ? n.rootRect : null
|
|
|
+ , p = t.getViewRoot()
|
|
|
+ , g = Ux(p);
|
|
|
+ if ("treemapMove" !== c) {
|
|
|
+ var m = "treemapZoomToNode" === c ? function(t, e, i, n, o) {
|
|
|
+ var a, r = (e || {}).node, s = [n, o];
|
|
|
+ if (!r || r === i)
|
|
|
+ return s;
|
|
|
+ var l = n * o
|
|
|
+ , u = l * t.option.zoomToNodeRatio;
|
|
|
+ for (; a = r.parentNode; ) {
|
|
|
+ for (var h = 0, c = a.children, d = 0, f = c.length; d < f; d++)
|
|
|
+ h += c[d].getValue();
|
|
|
+ var p = r.getValue();
|
|
|
+ if (0 === p)
|
|
|
+ return s;
|
|
|
+ u *= h / p;
|
|
|
+ var g = a.getModel()
|
|
|
+ , m = g.get(F_)
|
|
|
+ , v = Math.max(m, q_(g));
|
|
|
+ u += 4 * m * m + (3 * m + v) * Math.pow(u, .5),
|
|
|
+ Hl < u && (u = Hl),
|
|
|
+ r = a
|
|
|
+ }
|
|
|
+ u < l && (u = l);
|
|
|
+ var y = Math.pow(u / l, .5);
|
|
|
+ return [n * y, o * y]
|
|
|
+ }(t, d, p, u, h) : f ? [f.width, f.height] : [u, h]
|
|
|
+ , v = r.sort;
|
|
|
+ v && "asc" !== v && "desc" !== v && (v = "desc");
|
|
|
+ var y = {
|
|
|
+ squareRatio: r.squareRatio,
|
|
|
+ sort: v,
|
|
|
+ leafDepth: r.leafDepth
|
|
|
+ };
|
|
|
+ p.hostTree.clearLayouts();
|
|
|
+ var x = {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: m[0],
|
|
|
+ height: m[1],
|
|
|
+ area: m[0] * m[1]
|
|
|
+ };
|
|
|
+ p.setLayout(x),
|
|
|
+ function t(e, i, n, o) {
|
|
|
+ var a;
|
|
|
+ var r;
|
|
|
+ if (e.isRemoved())
|
|
|
+ return;
|
|
|
+ var s = e.getLayout();
|
|
|
+ a = s.width;
|
|
|
+ r = s.height;
|
|
|
+ var l = e.getModel();
|
|
|
+ var u = l.get(F_);
|
|
|
+ var h = l.get(W_) / 2;
|
|
|
+ var c = q_(l);
|
|
|
+ var d = Math.max(u, c);
|
|
|
+ var f = u - h;
|
|
|
+ var p = d - h;
|
|
|
+ var l = e.getModel();
|
|
|
+ e.setLayout({
|
|
|
+ borderWidth: u,
|
|
|
+ upperHeight: d,
|
|
|
+ upperLabelHeight: c
|
|
|
+ }, !0);
|
|
|
+ a = z_(a - 2 * f, 0);
|
|
|
+ r = z_(r - f - p, 0);
|
|
|
+ var g = a * r;
|
|
|
+ var m = X_(e, l, g, i, n, o);
|
|
|
+ if (!m.length)
|
|
|
+ return;
|
|
|
+ var v = {
|
|
|
+ x: f,
|
|
|
+ y: p,
|
|
|
+ width: a,
|
|
|
+ height: r
|
|
|
+ };
|
|
|
+ var y = B_(a, r);
|
|
|
+ var x = 1 / 0;
|
|
|
+ var _ = [];
|
|
|
+ _.area = 0;
|
|
|
+ for (var w = 0, b = m.length; w < b; ) {
|
|
|
+ var S = m[w];
|
|
|
+ _.push(S),
|
|
|
+ _.area += S.getLayout().area;
|
|
|
+ var M = Y_(_, y, i.squareRatio);
|
|
|
+ x = M <= x ? (w++,
|
|
|
+ M) : (_.area -= _.pop().getLayout().area,
|
|
|
+ j_(_, y, v, h, !1),
|
|
|
+ y = B_(v.width, v.height),
|
|
|
+ _.length = _.area = 0,
|
|
|
+ 1 / 0)
|
|
|
+ }
|
|
|
+ _.length && j_(_, y, v, h, !0);
|
|
|
+ if (!n) {
|
|
|
+ var I = l.get("childrenVisibleMin");
|
|
|
+ null != I && g < I && (n = !0)
|
|
|
+ }
|
|
|
+ for (var w = 0, b = m.length; w < b; w++)
|
|
|
+ t(m[w], i, n, o + 1)
|
|
|
+ }(p, y, !1, 0);
|
|
|
+ x = p.getLayout();
|
|
|
+ G_(g, function(t, e) {
|
|
|
+ var i = (g[e + 1] || p).getValue();
|
|
|
+ t.setLayout(P({
|
|
|
+ dataExtent: [i, i],
|
|
|
+ borderWidth: 0,
|
|
|
+ upperHeight: 0
|
|
|
+ }, x))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var _ = t.getData().tree.root;
|
|
|
+ _.setLayout(function(t, e, i) {
|
|
|
+ if (e)
|
|
|
+ return {
|
|
|
+ x: e.x,
|
|
|
+ y: e.y
|
|
|
+ };
|
|
|
+ var n = {
|
|
|
+ x: 0,
|
|
|
+ y: 0
|
|
|
+ };
|
|
|
+ if (!i)
|
|
|
+ return n;
|
|
|
+ var o = i.node
|
|
|
+ , a = o.getLayout();
|
|
|
+ if (!a)
|
|
|
+ return n;
|
|
|
+ var r = [a.width / 2, a.height / 2]
|
|
|
+ , s = o;
|
|
|
+ for (; s; ) {
|
|
|
+ var l = s.getLayout();
|
|
|
+ r[0] += l.x,
|
|
|
+ r[1] += l.y,
|
|
|
+ s = s.parentNode
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ x: t.width / 2 - r[0],
|
|
|
+ y: t.height / 2 - r[1]
|
|
|
+ }
|
|
|
+ }(s, f, d), !0),
|
|
|
+ t.setLayoutInfo(s),
|
|
|
+ function e(t, i, n, o, a) {
|
|
|
+ var r = t.getLayout();
|
|
|
+ var s = n[a];
|
|
|
+ var l = s && s === t;
|
|
|
+ if (s && !l || a === n.length && t !== o)
|
|
|
+ return;
|
|
|
+ t.setLayout({
|
|
|
+ isInView: !0,
|
|
|
+ invisible: !l && !i.intersect(r),
|
|
|
+ isAboveViewRoot: l
|
|
|
+ }, !0);
|
|
|
+ var u = new Di(i.x - r.x,i.y - r.y,i.width,i.height);
|
|
|
+ G_(t.viewChildren || [], function(t) {
|
|
|
+ e(t, u, n, o, a + 1)
|
|
|
+ })
|
|
|
+ }(_, new Di(-s.x,-s.y,o,a), g, p, 0)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function X_(t, e, i, n, o, a) {
|
|
|
+ var r = t.children || []
|
|
|
+ , s = n.sort;
|
|
|
+ "asc" !== s && "desc" !== s && (s = null);
|
|
|
+ var l = null != n.leafDepth && n.leafDepth <= a;
|
|
|
+ if (o && !l)
|
|
|
+ return t.viewChildren = [];
|
|
|
+ !function(t, n) {
|
|
|
+ n && t.sort(function(t, e) {
|
|
|
+ var i = "asc" === n ? t.getValue() - e.getValue() : e.getValue() - t.getValue();
|
|
|
+ return 0 == i ? "asc" === n ? t.dataIndex - e.dataIndex : e.dataIndex - t.dataIndex : i
|
|
|
+ })
|
|
|
+ }(r = M(r, function(t) {
|
|
|
+ return !t.isRemoved()
|
|
|
+ }), s);
|
|
|
+ var u = function(t, e, i) {
|
|
|
+ for (var n = 0, o = 0, a = e.length; o < a; o++)
|
|
|
+ n += e[o].getValue();
|
|
|
+ var r = t.get("visualDimension");
|
|
|
+ if (e && e.length)
|
|
|
+ if ("value" === r && i)
|
|
|
+ s = [e[e.length - 1].getValue(), e[0].getValue()],
|
|
|
+ "asc" === i && s.reverse();
|
|
|
+ else {
|
|
|
+ var s = [1 / 0, -1 / 0];
|
|
|
+ G_(e, function(t) {
|
|
|
+ var e = t.getValue(r);
|
|
|
+ e < s[0] && (s[0] = e),
|
|
|
+ e > s[1] && (s[1] = e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ else
|
|
|
+ s = [NaN, NaN];
|
|
|
+ return {
|
|
|
+ sum: n,
|
|
|
+ dataExtent: s
|
|
|
+ }
|
|
|
+ }(e, r, s);
|
|
|
+ if (0 === u.sum)
|
|
|
+ return t.viewChildren = [];
|
|
|
+ if (u.sum = function(t, e, i, n, o) {
|
|
|
+ if (!n)
|
|
|
+ return i;
|
|
|
+ for (var a = t.get("visibleMin"), r = o.length, s = r, l = r - 1; 0 <= l; l--) {
|
|
|
+ var u = o["asc" === n ? r - l - 1 : l].getValue();
|
|
|
+ u / i * e < a && (s = l,
|
|
|
+ i -= u)
|
|
|
+ }
|
|
|
+ return "asc" === n ? o.splice(0, r - s) : o.splice(s, r - s),
|
|
|
+ i
|
|
|
+ }(e, i, u.sum, s, r),
|
|
|
+ 0 === u.sum)
|
|
|
+ return t.viewChildren = [];
|
|
|
+ for (var h = 0, c = r.length; h < c; h++) {
|
|
|
+ var d = r[h].getValue() / u.sum * i;
|
|
|
+ r[h].setLayout({
|
|
|
+ area: d
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return l && (r.length && t.setLayout({
|
|
|
+ isLeafRoot: !0
|
|
|
+ }, !0),
|
|
|
+ r.length = 0),
|
|
|
+ t.viewChildren = r,
|
|
|
+ t.setLayout({
|
|
|
+ dataExtent: u.dataExtent
|
|
|
+ }, !0),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ function Y_(t, e, i) {
|
|
|
+ for (var n, o = 0, a = 1 / 0, r = 0, s = t.length; r < s; r++)
|
|
|
+ (n = t[r].getLayout().area) && (n < a && (a = n),
|
|
|
+ o < n && (o = n));
|
|
|
+ var l = t.area * t.area
|
|
|
+ , u = e * e * i;
|
|
|
+ return l ? z_(u * o / l, l / (u * a)) : 1 / 0
|
|
|
+ }
|
|
|
+ function j_(t, e, i, n, o) {
|
|
|
+ var a = e === i.width ? 0 : 1
|
|
|
+ , r = 1 - a
|
|
|
+ , s = ["x", "y"]
|
|
|
+ , l = ["width", "height"]
|
|
|
+ , u = i[s[a]]
|
|
|
+ , h = e ? t.area / e : 0;
|
|
|
+ (o || h > i[l[r]]) && (h = i[l[r]]);
|
|
|
+ for (var c = 0, d = t.length; c < d; c++) {
|
|
|
+ var f = t[c]
|
|
|
+ , p = {}
|
|
|
+ , g = h ? f.getLayout().area / h : 0
|
|
|
+ , m = p[l[r]] = z_(h - 2 * n, 0)
|
|
|
+ , v = i[s[a]] + i[l[a]] - u
|
|
|
+ , y = c === d - 1 || v < g ? v : g
|
|
|
+ , x = p[l[a]] = z_(y - 2 * n, 0);
|
|
|
+ p[s[r]] = i[s[r]] + B_(n, m / 2),
|
|
|
+ p[s[a]] = u + B_(n, x / 2),
|
|
|
+ u += y,
|
|
|
+ f.setLayout(p, !0)
|
|
|
+ }
|
|
|
+ i[s[r]] += h,
|
|
|
+ i[l[r]] -= h
|
|
|
+ }
|
|
|
+ function q_(t) {
|
|
|
+ return t.get(H_) ? t.get(Z_) : 0
|
|
|
+ }
|
|
|
+ function K_(t) {
|
|
|
+ return "_EC_" + t
|
|
|
+ }
|
|
|
+ Sf(L_),
|
|
|
+ bf(U_);
|
|
|
+ function $_(t) {
|
|
|
+ this._directed = t || !1,
|
|
|
+ this.nodes = [],
|
|
|
+ this.edges = [],
|
|
|
+ this._nodesMap = {},
|
|
|
+ this._edgesMap = {},
|
|
|
+ this.data,
|
|
|
+ this.edgeData
|
|
|
+ }
|
|
|
+ var J_ = $_.prototype;
|
|
|
+ function Q_(t, e) {
|
|
|
+ this.id = null == t ? "" : t,
|
|
|
+ this.inEdges = [],
|
|
|
+ this.outEdges = [],
|
|
|
+ this.edges = [],
|
|
|
+ this.hostGraph,
|
|
|
+ this.dataIndex = null == e ? -1 : e
|
|
|
+ }
|
|
|
+ function tw(t, e, i) {
|
|
|
+ this.node1 = t,
|
|
|
+ this.node2 = e,
|
|
|
+ this.dataIndex = null == i ? -1 : i
|
|
|
+ }
|
|
|
+ J_.type = "graph",
|
|
|
+ J_.isDirected = function() {
|
|
|
+ return this._directed
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.addNode = function(t, e) {
|
|
|
+ t = null == t ? "" + e : "" + t;
|
|
|
+ var i = this._nodesMap;
|
|
|
+ if (!i[K_(t)]) {
|
|
|
+ var n = new Q_(t,e);
|
|
|
+ return (n.hostGraph = this).nodes.push(n),
|
|
|
+ i[K_(t)] = n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.getNodeByIndex = function(t) {
|
|
|
+ var e = this.data.getRawIndex(t);
|
|
|
+ return this.nodes[e]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.getNodeById = function(t) {
|
|
|
+ return this._nodesMap[K_(t)]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.addEdge = function(t, e, i) {
|
|
|
+ var n = this._nodesMap
|
|
|
+ , o = this._edgesMap;
|
|
|
+ if ("number" == typeof t && (t = this.nodes[t]),
|
|
|
+ "number" == typeof e && (e = this.nodes[e]),
|
|
|
+ Q_.isInstance(t) || (t = n[K_(t)]),
|
|
|
+ Q_.isInstance(e) || (e = n[K_(e)]),
|
|
|
+ t && e) {
|
|
|
+ var a = t.id + "-" + e.id;
|
|
|
+ if (!o[a]) {
|
|
|
+ var r = new tw(t,e,i);
|
|
|
+ return (r.hostGraph = this)._directed && (t.outEdges.push(r),
|
|
|
+ e.inEdges.push(r)),
|
|
|
+ t.edges.push(r),
|
|
|
+ t !== e && e.edges.push(r),
|
|
|
+ this.edges.push(r),
|
|
|
+ o[a] = r
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.getEdgeByIndex = function(t) {
|
|
|
+ var e = this.edgeData.getRawIndex(t);
|
|
|
+ return this.edges[e]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.getEdge = function(t, e) {
|
|
|
+ Q_.isInstance(t) && (t = t.id),
|
|
|
+ Q_.isInstance(e) && (e = e.id);
|
|
|
+ var i = this._edgesMap;
|
|
|
+ return this._directed ? i[t + "-" + e] : i[t + "-" + e] || i[e + "-" + t]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.eachNode = function(t, e) {
|
|
|
+ for (var i = this.nodes, n = i.length, o = 0; o < n; o++)
|
|
|
+ 0 <= i[o].dataIndex && t.call(e, i[o], o)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.eachEdge = function(t, e) {
|
|
|
+ for (var i = this.edges, n = i.length, o = 0; o < n; o++)
|
|
|
+ 0 <= i[o].dataIndex && 0 <= i[o].node1.dataIndex && 0 <= i[o].node2.dataIndex && t.call(e, i[o], o)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.breadthFirstTraverse = function(t, e, i, n) {
|
|
|
+ if (Q_.isInstance(e) || (e = this._nodesMap[K_(e)]),
|
|
|
+ e) {
|
|
|
+ for (var o = "out" === i ? "outEdges" : "in" === i ? "inEdges" : "edges", a = 0; a < this.nodes.length; a++)
|
|
|
+ this.nodes[a].__visited = !1;
|
|
|
+ if (!t.call(n, e, null))
|
|
|
+ for (var r = [e]; r.length; ) {
|
|
|
+ var s = r.shift()
|
|
|
+ , l = s[o];
|
|
|
+ for (a = 0; a < l.length; a++) {
|
|
|
+ var u = l[a]
|
|
|
+ , h = u.node1 === s ? u.node2 : u.node1;
|
|
|
+ if (!h.__visited) {
|
|
|
+ if (t.call(n, h, s))
|
|
|
+ return;
|
|
|
+ r.push(h),
|
|
|
+ h.__visited = !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.update = function() {
|
|
|
+ for (var t = this.data, i = this.edgeData, e = this.nodes, n = this.edges, o = 0, a = e.length; o < a; o++)
|
|
|
+ e[o].dataIndex = -1;
|
|
|
+ for (o = 0,
|
|
|
+ a = t.count(); o < a; o++)
|
|
|
+ e[t.getRawIndex(o)].dataIndex = o;
|
|
|
+ i.filterSelf(function(t) {
|
|
|
+ var e = n[i.getRawIndex(t)];
|
|
|
+ return 0 <= e.node1.dataIndex && 0 <= e.node2.dataIndex
|
|
|
+ });
|
|
|
+ for (o = 0,
|
|
|
+ a = n.length; o < a; o++)
|
|
|
+ n[o].dataIndex = -1;
|
|
|
+ for (o = 0,
|
|
|
+ a = i.count(); o < a; o++)
|
|
|
+ n[i.getRawIndex(o)].dataIndex = o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ J_.clone = function() {
|
|
|
+ for (var t = new $_(this._directed), e = this.nodes, i = this.edges, n = 0; n < e.length; n++)
|
|
|
+ t.addNode(e[n].id, e[n].dataIndex);
|
|
|
+ for (n = 0; n < i.length; n++) {
|
|
|
+ var o = i[n];
|
|
|
+ t.addEdge(o.node1.id, o.node2.id, o.dataIndex)
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Q_.prototype = {
|
|
|
+ constructor: Q_,
|
|
|
+ degree: function() {
|
|
|
+ return this.edges.length
|
|
|
+ },
|
|
|
+ inDegree: function() {
|
|
|
+ return this.inEdges.length
|
|
|
+ },
|
|
|
+ outDegree: function() {
|
|
|
+ return this.outEdges.length
|
|
|
+ },
|
|
|
+ getModel: function(t) {
|
|
|
+ if (!(this.dataIndex < 0))
|
|
|
+ return this.hostGraph.data.getItemModel(this.dataIndex).getModel(t)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ tw.prototype.getModel = function(t) {
|
|
|
+ if (!(this.dataIndex < 0))
|
|
|
+ return this.hostGraph.edgeData.getItemModel(this.dataIndex).getModel(t)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function ew(i, n) {
|
|
|
+ return {
|
|
|
+ getValue: function(t) {
|
|
|
+ var e = this[i][n];
|
|
|
+ return e.get(e.getDimension(t || "value"), this.dataIndex)
|
|
|
+ },
|
|
|
+ setVisual: function(t, e) {
|
|
|
+ 0 <= this.dataIndex && this[i][n].setItemVisual(this.dataIndex, t, e)
|
|
|
+ },
|
|
|
+ getVisual: function(t, e) {
|
|
|
+ return this[i][n].getItemVisual(this.dataIndex, t, e)
|
|
|
+ },
|
|
|
+ setLayout: function(t, e) {
|
|
|
+ 0 <= this.dataIndex && this[i][n].setItemLayout(this.dataIndex, t, e)
|
|
|
+ },
|
|
|
+ getLayout: function() {
|
|
|
+ return this[i][n].getItemLayout(this.dataIndex)
|
|
|
+ },
|
|
|
+ getGraphicEl: function() {
|
|
|
+ return this[i][n].getItemGraphicEl(this.dataIndex)
|
|
|
+ },
|
|
|
+ getRawIndex: function() {
|
|
|
+ return this[i][n].getRawIndex(this.dataIndex)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ b(Q_, ew("hostGraph", "data")),
|
|
|
+ b(tw, ew("hostGraph", "edgeData")),
|
|
|
+ $_.Node = Q_,
|
|
|
+ $_.Edge = tw,
|
|
|
+ ra(Q_),
|
|
|
+ ra(tw);
|
|
|
+ function iw(t, e, i, n, o) {
|
|
|
+ for (var a = new $_(n), r = 0; r < t.length; r++)
|
|
|
+ a.addNode(W(t[r].id, t[r].name, r), r);
|
|
|
+ var s = []
|
|
|
+ , l = []
|
|
|
+ , u = 0;
|
|
|
+ for (r = 0; r < e.length; r++) {
|
|
|
+ var h = e[r]
|
|
|
+ , c = h.source
|
|
|
+ , d = h.target;
|
|
|
+ a.addEdge(c, d, u) && (l.push(h),
|
|
|
+ s.push(W(h.id, c + " > " + d)),
|
|
|
+ u++)
|
|
|
+ }
|
|
|
+ var f, p = i.get("coordinateSystem");
|
|
|
+ if ("cartesian2d" === p || "polar" === p)
|
|
|
+ f = gp(t, i);
|
|
|
+ else {
|
|
|
+ var g = lh.get(p)
|
|
|
+ , m = g && "view" !== g.type && g.dimensions || [];
|
|
|
+ _(m, "value") < 0 && m.concat(["value"]);
|
|
|
+ var v = lp(t, {
|
|
|
+ coordDimensions: m
|
|
|
+ });
|
|
|
+ (f = new Yf(v,i)).initData(t)
|
|
|
+ }
|
|
|
+ var y = new Yf(["value"],i);
|
|
|
+ return y.initData(l, s),
|
|
|
+ o && o(f, y),
|
|
|
+ yx({
|
|
|
+ mainData: f,
|
|
|
+ struct: a,
|
|
|
+ structAttr: "graph",
|
|
|
+ datas: {
|
|
|
+ node: f,
|
|
|
+ edge: y
|
|
|
+ },
|
|
|
+ datasAttr: {
|
|
|
+ node: "data",
|
|
|
+ edge: "edgeData"
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a.update(),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ var nw = Df({
|
|
|
+ type: "series.graph",
|
|
|
+ init: function(t) {
|
|
|
+ nw.superApply(this, "init", arguments);
|
|
|
+ var e = this;
|
|
|
+ function i() {
|
|
|
+ return e._categoriesData
|
|
|
+ }
|
|
|
+ this.legendVisualProvider = new qv(i,i),
|
|
|
+ this.fillDataTextStyle(t.edges || t.links),
|
|
|
+ this._updateCategoriesData()
|
|
|
+ },
|
|
|
+ mergeOption: function(t) {
|
|
|
+ nw.superApply(this, "mergeOption", arguments),
|
|
|
+ this.fillDataTextStyle(t.edges || t.links),
|
|
|
+ this._updateCategoriesData()
|
|
|
+ },
|
|
|
+ mergeDefaultAndTheme: function(t) {
|
|
|
+ nw.superApply(this, "mergeDefaultAndTheme", arguments),
|
|
|
+ Go(t, ["edgeLabel"], ["show"])
|
|
|
+ },
|
|
|
+ getInitialData: function(t, s) {
|
|
|
+ var e = t.edges || t.links || []
|
|
|
+ , i = t.data || t.nodes || []
|
|
|
+ , l = this;
|
|
|
+ if (i && e)
|
|
|
+ return iw(i, e, this, !0, function(t, e) {
|
|
|
+ t.wrapMethod("getItemModel", function(t) {
|
|
|
+ var e = l._categoriesModels[t.getShallow("category")];
|
|
|
+ return e && (e.parentModel = t.parentModel,
|
|
|
+ t.parentModel = e),
|
|
|
+ t
|
|
|
+ });
|
|
|
+ var i = l.getModel("edgeLabel")
|
|
|
+ , n = new Cl({
|
|
|
+ label: i.option
|
|
|
+ },i.parentModel,s)
|
|
|
+ , o = l.getModel("emphasis.edgeLabel")
|
|
|
+ , a = new Cl({
|
|
|
+ emphasis: {
|
|
|
+ label: o.option
|
|
|
+ }
|
|
|
+ },o.parentModel,s);
|
|
|
+ function r(t) {
|
|
|
+ return (t = this.parsePath(t)) && "label" === t[0] ? n : t && "emphasis" === t[0] && "label" === t[1] ? a : this.parentModel
|
|
|
+ }
|
|
|
+ e.wrapMethod("getItemModel", function(t) {
|
|
|
+ return t.customizeGetParent(r),
|
|
|
+ t
|
|
|
+ })
|
|
|
+ }).data
|
|
|
+ },
|
|
|
+ getGraph: function() {
|
|
|
+ return this.getData().graph
|
|
|
+ },
|
|
|
+ getEdgeData: function() {
|
|
|
+ return this.getGraph().edgeData
|
|
|
+ },
|
|
|
+ getCategoriesData: function() {
|
|
|
+ return this._categoriesData
|
|
|
+ },
|
|
|
+ formatTooltip: function(t, e, i) {
|
|
|
+ if ("edge" !== i)
|
|
|
+ return nw.superApply(this, "formatTooltip", arguments);
|
|
|
+ var n = this.getData()
|
|
|
+ , o = this.getDataParams(t, i)
|
|
|
+ , a = n.graph.getEdgeByIndex(t)
|
|
|
+ , r = n.getName(a.node1.dataIndex)
|
|
|
+ , s = n.getName(a.node2.dataIndex)
|
|
|
+ , l = [];
|
|
|
+ return null != r && l.push(r),
|
|
|
+ null != s && l.push(s),
|
|
|
+ l = au(l.join(" > ")),
|
|
|
+ o.value && (l += " : " + au(o.value)),
|
|
|
+ l
|
|
|
+ },
|
|
|
+ _updateCategoriesData: function() {
|
|
|
+ var t = O(this.option.categories || [], function(t) {
|
|
|
+ return null != t.value ? t : P({
|
|
|
+ value: 0
|
|
|
+ }, t)
|
|
|
+ })
|
|
|
+ , e = new Yf(["value"],this);
|
|
|
+ e.initData(t),
|
|
|
+ this._categoriesData = e,
|
|
|
+ this._categoriesModels = e.mapArray(function(t) {
|
|
|
+ return e.getItemModel(t, !0)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ setZoom: function(t) {
|
|
|
+ this.option.zoom = t
|
|
|
+ },
|
|
|
+ setCenter: function(t) {
|
|
|
+ this.option.center = t
|
|
|
+ },
|
|
|
+ isAnimationEnabled: function() {
|
|
|
+ return nw.superCall(this, "isAnimationEnabled") && !("force" === this.get("layout") && this.get("force.layoutAnimation"))
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "view",
|
|
|
+ legendHoverLink: !0,
|
|
|
+ hoverAnimation: !0,
|
|
|
+ layout: null,
|
|
|
+ focusNodeAdjacency: !1,
|
|
|
+ circular: {
|
|
|
+ rotateLabel: !1
|
|
|
+ },
|
|
|
+ force: {
|
|
|
+ initLayout: null,
|
|
|
+ repulsion: [0, 50],
|
|
|
+ gravity: .1,
|
|
|
+ friction: .6,
|
|
|
+ edgeLength: 30,
|
|
|
+ layoutAnimation: !0
|
|
|
+ },
|
|
|
+ left: "center",
|
|
|
+ top: "center",
|
|
|
+ symbol: "circle",
|
|
|
+ symbolSize: 10,
|
|
|
+ edgeSymbol: ["none", "none"],
|
|
|
+ edgeSymbolSize: 10,
|
|
|
+ edgeLabel: {
|
|
|
+ position: "middle",
|
|
|
+ distance: 5
|
|
|
+ },
|
|
|
+ draggable: !1,
|
|
|
+ roam: !1,
|
|
|
+ center: null,
|
|
|
+ zoom: 1,
|
|
|
+ nodeScaleRatio: .6,
|
|
|
+ label: {
|
|
|
+ show: !1,
|
|
|
+ formatter: "{b}"
|
|
|
+ },
|
|
|
+ itemStyle: {},
|
|
|
+ lineStyle: {
|
|
|
+ color: "#aaa",
|
|
|
+ width: 1,
|
|
|
+ curveness: 0,
|
|
|
+ opacity: .5
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , ow = ls.prototype
|
|
|
+ , aw = ds.prototype;
|
|
|
+ function rw(t) {
|
|
|
+ return isNaN(+t.cpx1) || isNaN(+t.cpy1)
|
|
|
+ }
|
|
|
+ var sw = Cs({
|
|
|
+ type: "ec-line",
|
|
|
+ style: {
|
|
|
+ stroke: "#000",
|
|
|
+ fill: null
|
|
|
+ },
|
|
|
+ shape: {
|
|
|
+ x1: 0,
|
|
|
+ y1: 0,
|
|
|
+ x2: 0,
|
|
|
+ y2: 0,
|
|
|
+ percent: 1,
|
|
|
+ cpx1: null,
|
|
|
+ cpy1: null
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ this[rw(e) ? "_buildPathLine" : "_buildPathCurve"](t, e)
|
|
|
+ },
|
|
|
+ _buildPathLine: ow.buildPath,
|
|
|
+ _buildPathCurve: aw.buildPath,
|
|
|
+ pointAt: function(t) {
|
|
|
+ return this[rw(this.shape) ? "_pointAtLine" : "_pointAtCurve"](t)
|
|
|
+ },
|
|
|
+ _pointAtLine: ow.pointAt,
|
|
|
+ _pointAtCurve: aw.pointAt,
|
|
|
+ tangentAt: function(t) {
|
|
|
+ var e = this.shape
|
|
|
+ , i = rw(e) ? [e.x2 - e.x1, e.y2 - e.y1] : this._tangentAtCurve(t);
|
|
|
+ return mt(i, i)
|
|
|
+ },
|
|
|
+ _tangentAtCurve: aw.tangentAt
|
|
|
+ })
|
|
|
+ , lw = ["fromSymbol", "toSymbol"];
|
|
|
+ function uw(t) {
|
|
|
+ return "_" + t + "Type"
|
|
|
+ }
|
|
|
+ function hw(t, e, i) {
|
|
|
+ var n = e.getItemVisual(i, "color")
|
|
|
+ , o = e.getItemVisual(i, t)
|
|
|
+ , a = e.getItemVisual(i, t + "Size");
|
|
|
+ if (o && "none" !== o) {
|
|
|
+ L(a) || (a = [a, a]);
|
|
|
+ var r = wg(o, -a[0] / 2, -a[1] / 2, a[0], a[1], n);
|
|
|
+ return r.name = t,
|
|
|
+ r
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function cw(t, e) {
|
|
|
+ t.x1 = e[0][0],
|
|
|
+ t.y1 = e[0][1],
|
|
|
+ t.x2 = e[1][0],
|
|
|
+ t.y2 = e[1][1],
|
|
|
+ t.percent = 1;
|
|
|
+ var i = e[2];
|
|
|
+ i ? (t.cpx1 = i[0],
|
|
|
+ t.cpy1 = i[1]) : (t.cpx1 = NaN,
|
|
|
+ t.cpy1 = NaN)
|
|
|
+ }
|
|
|
+ function dw(t, e, i) {
|
|
|
+ Ci.call(this),
|
|
|
+ this._createLine(t, e, i)
|
|
|
+ }
|
|
|
+ var fw = dw.prototype;
|
|
|
+ function pw(t) {
|
|
|
+ this._ctor = t || dw,
|
|
|
+ this.group = new Ci
|
|
|
+ }
|
|
|
+ fw.beforeUpdate = function() {
|
|
|
+ var t = this.childOfName("fromSymbol")
|
|
|
+ , e = this.childOfName("toSymbol")
|
|
|
+ , i = this.childOfName("label");
|
|
|
+ if (t || e || !i.ignore) {
|
|
|
+ for (var n = 1, o = this.parent; o; )
|
|
|
+ o.scale && (n /= o.scale[0]),
|
|
|
+ o = o.parent;
|
|
|
+ var a = this.childOfName("line");
|
|
|
+ if (this.__dirty || a.__dirty) {
|
|
|
+ var r = a.shape.percent
|
|
|
+ , s = a.pointAt(0)
|
|
|
+ , l = a.pointAt(r)
|
|
|
+ , u = ht([], l, s);
|
|
|
+ if (mt(u, u),
|
|
|
+ t) {
|
|
|
+ t.attr("position", s);
|
|
|
+ var h = a.tangentAt(0);
|
|
|
+ t.attr("rotation", Math.PI / 2 - Math.atan2(h[1], h[0])),
|
|
|
+ t.attr("scale", [n * r, n * r])
|
|
|
+ }
|
|
|
+ if (e) {
|
|
|
+ e.attr("position", l);
|
|
|
+ h = a.tangentAt(1);
|
|
|
+ e.attr("rotation", -Math.PI / 2 - Math.atan2(h[1], h[0])),
|
|
|
+ e.attr("scale", [n * r, n * r])
|
|
|
+ }
|
|
|
+ if (!i.ignore) {
|
|
|
+ var c, d, f, p;
|
|
|
+ i.attr("position", l);
|
|
|
+ var g = i.__labelDistance
|
|
|
+ , m = g[0] * n
|
|
|
+ , v = g[1] * n
|
|
|
+ , y = r / 2
|
|
|
+ , x = [(h = a.tangentAt(y))[1], -h[0]]
|
|
|
+ , _ = a.pointAt(y);
|
|
|
+ 0 < x[1] && (x[0] = -x[0],
|
|
|
+ x[1] = -x[1]);
|
|
|
+ var w, b = h[0] < 0 ? -1 : 1;
|
|
|
+ if ("start" !== i.__position && "end" !== i.__position) {
|
|
|
+ var S = -Math.atan2(h[1], h[0]);
|
|
|
+ l[0] < s[0] && (S = Math.PI + S),
|
|
|
+ i.attr("rotation", S)
|
|
|
+ }
|
|
|
+ switch (i.__position) {
|
|
|
+ case "insideStartTop":
|
|
|
+ case "insideMiddleTop":
|
|
|
+ case "insideEndTop":
|
|
|
+ case "middle":
|
|
|
+ w = -v,
|
|
|
+ f = "bottom";
|
|
|
+ break;
|
|
|
+ case "insideStartBottom":
|
|
|
+ case "insideMiddleBottom":
|
|
|
+ case "insideEndBottom":
|
|
|
+ w = v,
|
|
|
+ f = "top";
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ w = 0,
|
|
|
+ f = "middle"
|
|
|
+ }
|
|
|
+ switch (i.__position) {
|
|
|
+ case "end":
|
|
|
+ c = [u[0] * m + l[0], u[1] * v + l[1]],
|
|
|
+ d = .8 < u[0] ? "left" : u[0] < -.8 ? "right" : "center",
|
|
|
+ f = .8 < u[1] ? "top" : u[1] < -.8 ? "bottom" : "middle";
|
|
|
+ break;
|
|
|
+ case "start":
|
|
|
+ c = [-u[0] * m + s[0], -u[1] * v + s[1]],
|
|
|
+ d = .8 < u[0] ? "right" : u[0] < -.8 ? "left" : "center",
|
|
|
+ f = .8 < u[1] ? "bottom" : u[1] < -.8 ? "top" : "middle";
|
|
|
+ break;
|
|
|
+ case "insideStartTop":
|
|
|
+ case "insideStart":
|
|
|
+ case "insideStartBottom":
|
|
|
+ c = [m * b + s[0], s[1] + w],
|
|
|
+ d = h[0] < 0 ? "right" : "left",
|
|
|
+ p = [-m * b, -w];
|
|
|
+ break;
|
|
|
+ case "insideMiddleTop":
|
|
|
+ case "insideMiddle":
|
|
|
+ case "insideMiddleBottom":
|
|
|
+ case "middle":
|
|
|
+ c = [_[0], _[1] + w],
|
|
|
+ d = "center",
|
|
|
+ p = [0, -w];
|
|
|
+ break;
|
|
|
+ case "insideEndTop":
|
|
|
+ case "insideEnd":
|
|
|
+ case "insideEndBottom":
|
|
|
+ c = [-m * b + l[0], l[1] + w],
|
|
|
+ d = 0 <= h[0] ? "right" : "left",
|
|
|
+ p = [m * b, -w]
|
|
|
+ }
|
|
|
+ i.attr({
|
|
|
+ style: {
|
|
|
+ textVerticalAlign: i.__verticalAlign || f,
|
|
|
+ textAlign: i.__textAlign || d
|
|
|
+ },
|
|
|
+ position: c,
|
|
|
+ scale: [n, n],
|
|
|
+ origin: p
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fw._createLine = function(i, n, t) {
|
|
|
+ var e = i.hostModel
|
|
|
+ , o = function(t) {
|
|
|
+ var e = new sw({
|
|
|
+ name: "line",
|
|
|
+ subPixelOptimize: !0
|
|
|
+ });
|
|
|
+ return cw(e.shape, t),
|
|
|
+ e
|
|
|
+ }(i.getItemLayout(n));
|
|
|
+ o.shape.percent = 0,
|
|
|
+ dl(o, {
|
|
|
+ shape: {
|
|
|
+ percent: 1
|
|
|
+ }
|
|
|
+ }, e, n),
|
|
|
+ this.add(o);
|
|
|
+ var a = new Ur({
|
|
|
+ name: "label",
|
|
|
+ lineLabelOriginalOpacity: 1
|
|
|
+ });
|
|
|
+ this.add(a),
|
|
|
+ E(lw, function(t) {
|
|
|
+ var e = hw(t, i, n);
|
|
|
+ this.add(e),
|
|
|
+ this[uw(t)] = i.getItemVisual(n, t)
|
|
|
+ }, this),
|
|
|
+ this._updateCommonStl(i, n, t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fw.updateData = function(o, a, t) {
|
|
|
+ var e = o.hostModel
|
|
|
+ , i = this.childOfName("line")
|
|
|
+ , n = o.getItemLayout(a)
|
|
|
+ , r = {
|
|
|
+ shape: {}
|
|
|
+ };
|
|
|
+ cw(r.shape, n),
|
|
|
+ cl(i, r, e, a),
|
|
|
+ E(lw, function(t) {
|
|
|
+ var e = o.getItemVisual(a, t)
|
|
|
+ , i = uw(t);
|
|
|
+ if (this[i] !== e) {
|
|
|
+ this.remove(this.childOfName(t));
|
|
|
+ var n = hw(t, o, a);
|
|
|
+ this.add(n)
|
|
|
+ }
|
|
|
+ this[i] = e
|
|
|
+ }, this),
|
|
|
+ this._updateCommonStl(o, a, t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fw._updateCommonStl = function(t, e, i) {
|
|
|
+ var n = t.hostModel
|
|
|
+ , o = this.childOfName("line")
|
|
|
+ , a = i && i.lineStyle
|
|
|
+ , r = i && i.hoverLineStyle
|
|
|
+ , s = i && i.labelModel
|
|
|
+ , l = i && i.hoverLabelModel;
|
|
|
+ if (!i || t.hasItemOption) {
|
|
|
+ var u = t.getItemModel(e);
|
|
|
+ a = u.getModel("lineStyle").getLineStyle(),
|
|
|
+ r = u.getModel("emphasis.lineStyle").getLineStyle(),
|
|
|
+ s = u.getModel("label"),
|
|
|
+ l = u.getModel("emphasis.label")
|
|
|
+ }
|
|
|
+ var h = t.getItemVisual(e, "color")
|
|
|
+ , c = Z(t.getItemVisual(e, "opacity"), a.opacity, 1);
|
|
|
+ o.useStyle(D({
|
|
|
+ strokeNoScale: !0,
|
|
|
+ fill: "none",
|
|
|
+ stroke: h,
|
|
|
+ opacity: c
|
|
|
+ }, a)),
|
|
|
+ o.hoverStyle = r,
|
|
|
+ E(lw, function(t) {
|
|
|
+ var e = this.childOfName(t);
|
|
|
+ e && (e.setColor(h),
|
|
|
+ e.setStyle({
|
|
|
+ opacity: c
|
|
|
+ }))
|
|
|
+ }, this);
|
|
|
+ var d, f, p = s.getShallow("show"), g = l.getShallow("show"), m = this.childOfName("label");
|
|
|
+ if ((p || g) && (d = h || "#000",
|
|
|
+ null == (f = n.getFormattedLabel(e, "normal", t.dataType)))) {
|
|
|
+ var v = n.getRawValue(e);
|
|
|
+ f = null == v ? t.getName(e) : isFinite(v) ? zl(v) : v
|
|
|
+ }
|
|
|
+ var y = p ? f : null
|
|
|
+ , x = g ? H(n.getFormattedLabel(e, "emphasis", t.dataType), f) : null
|
|
|
+ , _ = m.style;
|
|
|
+ if (null != y || null != x) {
|
|
|
+ nl(m.style, s, {
|
|
|
+ text: y
|
|
|
+ }, {
|
|
|
+ autoColor: d
|
|
|
+ }),
|
|
|
+ m.__textAlign = _.textAlign,
|
|
|
+ m.__verticalAlign = _.textVerticalAlign,
|
|
|
+ m.__position = s.get("position") || "middle";
|
|
|
+ var w = s.get("distance");
|
|
|
+ L(w) || (w = [w, w]),
|
|
|
+ m.__labelDistance = w
|
|
|
+ }
|
|
|
+ m.hoverStyle = null != x ? {
|
|
|
+ text: x,
|
|
|
+ textFill: l.getTextColor(!0),
|
|
|
+ fontStyle: l.getShallow("fontStyle"),
|
|
|
+ fontWeight: l.getShallow("fontWeight"),
|
|
|
+ fontSize: l.getShallow("fontSize"),
|
|
|
+ fontFamily: l.getShallow("fontFamily")
|
|
|
+ } : {
|
|
|
+ text: null
|
|
|
+ },
|
|
|
+ m.ignore = !p && !g,
|
|
|
+ $s(this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fw.highlight = function() {
|
|
|
+ this.trigger("emphasis")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fw.downplay = function() {
|
|
|
+ this.trigger("normal")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fw.updateLayout = function(t, e) {
|
|
|
+ this.setLinePoints(t.getItemLayout(e))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fw.setLinePoints = function(t) {
|
|
|
+ var e = this.childOfName("line");
|
|
|
+ cw(e.shape, t),
|
|
|
+ e.dirty()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(dw, Ci);
|
|
|
+ var gw = pw.prototype;
|
|
|
+ function mw(t) {
|
|
|
+ var e = t.hostModel;
|
|
|
+ return {
|
|
|
+ lineStyle: e.getModel("lineStyle").getLineStyle(),
|
|
|
+ hoverLineStyle: e.getModel("emphasis.lineStyle").getLineStyle(),
|
|
|
+ labelModel: e.getModel("label"),
|
|
|
+ hoverLabelModel: e.getModel("emphasis.label")
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function vw(t) {
|
|
|
+ return isNaN(t[0]) || isNaN(t[1])
|
|
|
+ }
|
|
|
+ function yw(t) {
|
|
|
+ return !vw(t[0]) && !vw(t[1])
|
|
|
+ }
|
|
|
+ function xw(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ if ("view" !== e.type)
|
|
|
+ return 1;
|
|
|
+ var i = t.option.nodeScaleRatio
|
|
|
+ , n = e.scale
|
|
|
+ , o = n && n[0] || 1;
|
|
|
+ return ((e.getZoom() - 1) * i + 1) / o
|
|
|
+ }
|
|
|
+ function _w(t) {
|
|
|
+ var e = t.getVisual("symbolSize");
|
|
|
+ return e instanceof Array && (e = (e[0] + e[1]) / 2),
|
|
|
+ +e
|
|
|
+ }
|
|
|
+ gw.isPersistent = function() {
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gw.updateData = function(i) {
|
|
|
+ var n = this
|
|
|
+ , e = n.group
|
|
|
+ , o = n._lineData;
|
|
|
+ n._lineData = i,
|
|
|
+ o || e.removeAll();
|
|
|
+ var a = mw(i);
|
|
|
+ i.diff(o).add(function(t) {
|
|
|
+ !function(t, e, i, n) {
|
|
|
+ if (!yw(e.getItemLayout(i)))
|
|
|
+ return;
|
|
|
+ var o = new t._ctor(e,i,n);
|
|
|
+ e.setItemGraphicEl(i, o),
|
|
|
+ t.group.add(o)
|
|
|
+ }(n, i, t, a)
|
|
|
+ }).update(function(t, e) {
|
|
|
+ !function(t, e, i, n, o, a) {
|
|
|
+ var r = e.getItemGraphicEl(n);
|
|
|
+ if (!yw(i.getItemLayout(o)))
|
|
|
+ return t.group.remove(r);
|
|
|
+ r ? r.updateData(i, o, a) : r = new t._ctor(i,o,a);
|
|
|
+ i.setItemGraphicEl(o, r),
|
|
|
+ t.group.add(r)
|
|
|
+ }(n, o, i, e, t, a)
|
|
|
+ }).remove(function(t) {
|
|
|
+ e.remove(o.getItemGraphicEl(t))
|
|
|
+ }).execute()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gw.updateLayout = function() {
|
|
|
+ var i = this._lineData;
|
|
|
+ i && i.eachItemGraphicEl(function(t, e) {
|
|
|
+ t.updateLayout(i, e)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gw.incrementalPrepareUpdate = function(t) {
|
|
|
+ this._seriesScope = mw(t),
|
|
|
+ this._lineData = null,
|
|
|
+ this.group.removeAll()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gw.incrementalUpdate = function(t, e) {
|
|
|
+ function i(t) {
|
|
|
+ t.isGroup || function(t) {
|
|
|
+ return t.animators && 0 < t.animators.length
|
|
|
+ }(t) || (t.incremental = t.useHoverLayer = !0)
|
|
|
+ }
|
|
|
+ for (var n = t.start; n < t.end; n++) {
|
|
|
+ if (yw(e.getItemLayout(n))) {
|
|
|
+ var o = new this._ctor(e,n,this._seriesScope);
|
|
|
+ o.traverse(i),
|
|
|
+ this.group.add(o),
|
|
|
+ e.setItemGraphicEl(n, o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gw.remove = function() {
|
|
|
+ this._clearIncremental(),
|
|
|
+ this._incremental = null,
|
|
|
+ this.group.removeAll()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gw._clearIncremental = function() {
|
|
|
+ var t = this._incremental;
|
|
|
+ t && t.clearDisplaybles()
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var ww = []
|
|
|
+ , bw = []
|
|
|
+ , Sw = []
|
|
|
+ , Mw = La
|
|
|
+ , Iw = _t
|
|
|
+ , Tw = Math.abs;
|
|
|
+ function Aw(t, e, i) {
|
|
|
+ for (var n, o = t[0], a = t[1], r = t[2], s = 1 / 0, l = i * i, u = .1, h = .1; h <= .9; h += .1) {
|
|
|
+ ww[0] = Mw(o[0], a[0], r[0], h),
|
|
|
+ ww[1] = Mw(o[1], a[1], r[1], h),
|
|
|
+ (f = Tw(Iw(ww, e) - l)) < s && (s = f,
|
|
|
+ n = h)
|
|
|
+ }
|
|
|
+ for (var c = 0; c < 32; c++) {
|
|
|
+ var d = n + u;
|
|
|
+ bw[0] = Mw(o[0], a[0], r[0], n),
|
|
|
+ bw[1] = Mw(o[1], a[1], r[1], n),
|
|
|
+ Sw[0] = Mw(o[0], a[0], r[0], d),
|
|
|
+ Sw[1] = Mw(o[1], a[1], r[1], d);
|
|
|
+ var f = Iw(bw, e) - l;
|
|
|
+ if (Tw(f) < .01)
|
|
|
+ break;
|
|
|
+ var p = Iw(Sw, e) - l;
|
|
|
+ u /= 2,
|
|
|
+ f < 0 ? 0 <= p ? n += u : n -= u : 0 <= p ? n -= u : n += u
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function Dw(t, l) {
|
|
|
+ var u = []
|
|
|
+ , h = Na
|
|
|
+ , c = [[], [], []]
|
|
|
+ , d = [[], []]
|
|
|
+ , f = [];
|
|
|
+ l /= 2,
|
|
|
+ t.eachEdge(function(t, e) {
|
|
|
+ var i = t.getLayout()
|
|
|
+ , n = t.getVisual("fromSymbol")
|
|
|
+ , o = t.getVisual("toSymbol");
|
|
|
+ i.__original || (i.__original = [rt(i[0]), rt(i[1])],
|
|
|
+ i[2] && i.__original.push(rt(i[2])));
|
|
|
+ var a = i.__original;
|
|
|
+ if (null != i[2]) {
|
|
|
+ if (at(c[0], a[0]),
|
|
|
+ at(c[1], a[2]),
|
|
|
+ at(c[2], a[1]),
|
|
|
+ n && "none" !== n) {
|
|
|
+ var r = _w(t.node1)
|
|
|
+ , s = Aw(c, a[0], r * l);
|
|
|
+ h(c[0][0], c[1][0], c[2][0], s, u),
|
|
|
+ c[0][0] = u[3],
|
|
|
+ c[1][0] = u[4],
|
|
|
+ h(c[0][1], c[1][1], c[2][1], s, u),
|
|
|
+ c[0][1] = u[3],
|
|
|
+ c[1][1] = u[4]
|
|
|
+ }
|
|
|
+ if (o && "none" !== o) {
|
|
|
+ r = _w(t.node2),
|
|
|
+ s = Aw(c, a[1], r * l);
|
|
|
+ h(c[0][0], c[1][0], c[2][0], s, u),
|
|
|
+ c[1][0] = u[1],
|
|
|
+ c[2][0] = u[2],
|
|
|
+ h(c[0][1], c[1][1], c[2][1], s, u),
|
|
|
+ c[1][1] = u[1],
|
|
|
+ c[2][1] = u[2]
|
|
|
+ }
|
|
|
+ at(i[0], c[0]),
|
|
|
+ at(i[1], c[2]),
|
|
|
+ at(i[2], c[1])
|
|
|
+ } else {
|
|
|
+ if (at(d[0], a[0]),
|
|
|
+ at(d[1], a[1]),
|
|
|
+ ht(f, d[1], d[0]),
|
|
|
+ mt(f, f),
|
|
|
+ n && "none" !== n) {
|
|
|
+ r = _w(t.node1);
|
|
|
+ ut(d[0], d[0], f, r * l)
|
|
|
+ }
|
|
|
+ if (o && "none" !== o) {
|
|
|
+ r = _w(t.node2);
|
|
|
+ ut(d[1], d[1], f, -r * l)
|
|
|
+ }
|
|
|
+ at(i[0], d[0]),
|
|
|
+ at(i[1], d[1])
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var Cw = "__focusNodeAdjacency"
|
|
|
+ , Lw = "__unfocusNodeAdjacency"
|
|
|
+ , kw = ["itemStyle", "opacity"]
|
|
|
+ , Pw = ["lineStyle", "opacity"];
|
|
|
+ function Nw(t, e) {
|
|
|
+ var i = t.getVisual("opacity");
|
|
|
+ return null != i ? i : t.getModel().get(e)
|
|
|
+ }
|
|
|
+ function Ow(t, e, i) {
|
|
|
+ var n = t.getGraphicEl()
|
|
|
+ , o = Nw(t, e);
|
|
|
+ null != i && (null == o && (o = 1),
|
|
|
+ o *= i),
|
|
|
+ n.downplay && n.downplay(),
|
|
|
+ n.traverse(function(t) {
|
|
|
+ if (!t.isGroup) {
|
|
|
+ var e = t.lineLabelOriginalOpacity;
|
|
|
+ null != e && null == i || (e = o),
|
|
|
+ t.setStyle("opacity", e)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Ew(t, e) {
|
|
|
+ var i = Nw(t, e)
|
|
|
+ , n = t.getGraphicEl();
|
|
|
+ n.traverse(function(t) {
|
|
|
+ t.isGroup || t.setStyle("opacity", i)
|
|
|
+ }),
|
|
|
+ n.highlight && n.highlight()
|
|
|
+ }
|
|
|
+ Cf({
|
|
|
+ type: "graph",
|
|
|
+ init: function(t, e) {
|
|
|
+ var i = new im
|
|
|
+ , n = new pw
|
|
|
+ , o = this.group;
|
|
|
+ this._controller = new Vy(e.getZr()),
|
|
|
+ this._controllerHost = {
|
|
|
+ target: o
|
|
|
+ },
|
|
|
+ o.add(i.group),
|
|
|
+ o.add(n.group),
|
|
|
+ this._symbolDraw = i,
|
|
|
+ this._lineDraw = n,
|
|
|
+ this._firstRender = !0
|
|
|
+ },
|
|
|
+ render: function(o, t, a) {
|
|
|
+ var r = this
|
|
|
+ , e = o.coordinateSystem;
|
|
|
+ this._model = o;
|
|
|
+ var i = this._symbolDraw
|
|
|
+ , n = this._lineDraw
|
|
|
+ , s = this.group;
|
|
|
+ if ("view" === e.type) {
|
|
|
+ var l = {
|
|
|
+ position: e.position,
|
|
|
+ scale: e.scale
|
|
|
+ };
|
|
|
+ this._firstRender ? s.attr(l) : cl(s, l, o)
|
|
|
+ }
|
|
|
+ Dw(o.getGraph(), xw(o));
|
|
|
+ var u = o.getData();
|
|
|
+ i.updateData(u);
|
|
|
+ var h = o.getEdgeData();
|
|
|
+ n.updateData(h),
|
|
|
+ this._updateNodeAndLinkScale(),
|
|
|
+ this._updateController(o, t, a),
|
|
|
+ clearTimeout(this._layoutTimeout);
|
|
|
+ var c = o.forceLayout
|
|
|
+ , d = o.get("force.layoutAnimation");
|
|
|
+ c && this._startForceLayoutIteration(c, d),
|
|
|
+ u.eachItemGraphicEl(function(t, e) {
|
|
|
+ var i = u.getItemModel(e);
|
|
|
+ t.off("drag").off("dragend");
|
|
|
+ var n = i.get("draggable");
|
|
|
+ n && t.on("drag", function() {
|
|
|
+ c && (c.warmUp(),
|
|
|
+ this._layouting || this._startForceLayoutIteration(c, d),
|
|
|
+ c.setFixed(e),
|
|
|
+ u.setItemLayout(e, t.position))
|
|
|
+ }, this).on("dragend", function() {
|
|
|
+ c && c.setUnfixed(e)
|
|
|
+ }, this),
|
|
|
+ t.setDraggable(n && c),
|
|
|
+ t[Cw] && t.off("mouseover", t[Cw]),
|
|
|
+ t[Lw] && t.off("mouseout", t[Lw]),
|
|
|
+ i.get("focusNodeAdjacency") && (t.on("mouseover", t[Cw] = function() {
|
|
|
+ r._clearTimer(),
|
|
|
+ a.dispatchAction({
|
|
|
+ type: "focusNodeAdjacency",
|
|
|
+ seriesId: o.id,
|
|
|
+ dataIndex: t.dataIndex
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ t.on("mouseout", t[Lw] = function() {
|
|
|
+ r._dispatchUnfocus(a)
|
|
|
+ }
|
|
|
+ ))
|
|
|
+ }, this),
|
|
|
+ u.graph.eachEdge(function(t) {
|
|
|
+ var e = t.getGraphicEl();
|
|
|
+ e[Cw] && e.off("mouseover", e[Cw]),
|
|
|
+ e[Lw] && e.off("mouseout", e[Lw]),
|
|
|
+ t.getModel().get("focusNodeAdjacency") && (e.on("mouseover", e[Cw] = function() {
|
|
|
+ r._clearTimer(),
|
|
|
+ a.dispatchAction({
|
|
|
+ type: "focusNodeAdjacency",
|
|
|
+ seriesId: o.id,
|
|
|
+ edgeDataIndex: t.dataIndex
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ e.on("mouseout", e[Lw] = function() {
|
|
|
+ r._dispatchUnfocus(a)
|
|
|
+ }
|
|
|
+ ))
|
|
|
+ });
|
|
|
+ var f = "circular" === o.get("layout") && o.get("circular.rotateLabel")
|
|
|
+ , p = u.getLayout("cx")
|
|
|
+ , g = u.getLayout("cy");
|
|
|
+ u.eachItemGraphicEl(function(t, e) {
|
|
|
+ var i = u.getItemModel(e).get("label.rotate") || 0
|
|
|
+ , n = t.getSymbolPath();
|
|
|
+ if (f) {
|
|
|
+ var o = u.getItemLayout(e)
|
|
|
+ , a = Math.atan2(o[1] - g, o[0] - p);
|
|
|
+ a < 0 && (a = 2 * Math.PI + a);
|
|
|
+ var r = o[0] < p;
|
|
|
+ r && (a -= Math.PI);
|
|
|
+ var s = r ? "left" : "right";
|
|
|
+ il(n, {
|
|
|
+ textRotation: -a,
|
|
|
+ textPosition: s,
|
|
|
+ textOrigin: "center"
|
|
|
+ }, {
|
|
|
+ textPosition: s
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ il(n, {
|
|
|
+ textRotation: i *= Math.PI / 180
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ this._firstRender = !1
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._controller && this._controller.dispose(),
|
|
|
+ this._controllerHost = {},
|
|
|
+ this._clearTimer()
|
|
|
+ },
|
|
|
+ _dispatchUnfocus: function(t, e) {
|
|
|
+ var i = this;
|
|
|
+ this._clearTimer(),
|
|
|
+ this._unfocusDelayTimer = setTimeout(function() {
|
|
|
+ i._unfocusDelayTimer = null,
|
|
|
+ t.dispatchAction({
|
|
|
+ type: "unfocusNodeAdjacency",
|
|
|
+ seriesId: i._model.id
|
|
|
+ })
|
|
|
+ }, 500)
|
|
|
+ },
|
|
|
+ _clearTimer: function() {
|
|
|
+ this._unfocusDelayTimer && (clearTimeout(this._unfocusDelayTimer),
|
|
|
+ this._unfocusDelayTimer = null)
|
|
|
+ },
|
|
|
+ focusNodeAdjacency: function(t, e, i, n) {
|
|
|
+ var o = t.getData().graph
|
|
|
+ , a = n.dataIndex
|
|
|
+ , r = n.edgeDataIndex
|
|
|
+ , s = o.getNodeByIndex(a)
|
|
|
+ , l = o.getEdgeByIndex(r);
|
|
|
+ (s || l) && (o.eachNode(function(t) {
|
|
|
+ Ow(t, kw, .1)
|
|
|
+ }),
|
|
|
+ o.eachEdge(function(t) {
|
|
|
+ Ow(t, Pw, .1)
|
|
|
+ }),
|
|
|
+ s && (Ew(s, kw),
|
|
|
+ E(s.edges, function(t) {
|
|
|
+ t.dataIndex < 0 || (Ew(t, Pw),
|
|
|
+ Ew(t.node1, kw),
|
|
|
+ Ew(t.node2, kw))
|
|
|
+ })),
|
|
|
+ l && (Ew(l, Pw),
|
|
|
+ Ew(l.node1, kw),
|
|
|
+ Ew(l.node2, kw)))
|
|
|
+ },
|
|
|
+ unfocusNodeAdjacency: function(t, e, i, n) {
|
|
|
+ var o = t.getData().graph;
|
|
|
+ o.eachNode(function(t) {
|
|
|
+ Ow(t, kw)
|
|
|
+ }),
|
|
|
+ o.eachEdge(function(t) {
|
|
|
+ Ow(t, Pw)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _startForceLayoutIteration: function(t, i) {
|
|
|
+ var n = this;
|
|
|
+ !function e() {
|
|
|
+ t.step(function(t) {
|
|
|
+ n.updateLayout(n._model),
|
|
|
+ (n._layouting = !t) && (i ? n._layoutTimeout = setTimeout(e, 16) : e())
|
|
|
+ })
|
|
|
+ }()
|
|
|
+ },
|
|
|
+ _updateController: function(o, t, a) {
|
|
|
+ var e = this._controller
|
|
|
+ , i = this._controllerHost
|
|
|
+ , r = this.group;
|
|
|
+ e.setPointerChecker(function(t, e, i) {
|
|
|
+ var n = r.getBoundingRect();
|
|
|
+ return n.applyTransform(r.transform),
|
|
|
+ n.contain(e, i) && !$y(t, a, o)
|
|
|
+ }),
|
|
|
+ "view" === o.coordinateSystem.type ? (e.enable(o.get("roam")),
|
|
|
+ i.zoomLimit = o.get("scaleLimit"),
|
|
|
+ i.zoom = o.coordinateSystem.getZoom(),
|
|
|
+ e.off("pan").off("zoom").on("pan", function(t) {
|
|
|
+ jy(i, t.dx, t.dy),
|
|
|
+ a.dispatchAction({
|
|
|
+ seriesId: o.id,
|
|
|
+ type: "graphRoam",
|
|
|
+ dx: t.dx,
|
|
|
+ dy: t.dy
|
|
|
+ })
|
|
|
+ }).on("zoom", function(t) {
|
|
|
+ qy(i, t.scale, t.originX, t.originY),
|
|
|
+ a.dispatchAction({
|
|
|
+ seriesId: o.id,
|
|
|
+ type: "graphRoam",
|
|
|
+ zoom: t.scale,
|
|
|
+ originX: t.originX,
|
|
|
+ originY: t.originY
|
|
|
+ }),
|
|
|
+ this._updateNodeAndLinkScale(),
|
|
|
+ Dw(o.getGraph(), xw(o)),
|
|
|
+ this._lineDraw.updateLayout()
|
|
|
+ }, this)) : e.disable()
|
|
|
+ },
|
|
|
+ _updateNodeAndLinkScale: function() {
|
|
|
+ var t = this._model
|
|
|
+ , e = t.getData()
|
|
|
+ , i = xw(t)
|
|
|
+ , n = [i, i];
|
|
|
+ e.eachItemGraphicEl(function(t, e) {
|
|
|
+ t.attr("scale", n)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ updateLayout: function(t) {
|
|
|
+ Dw(t.getGraph(), xw(t)),
|
|
|
+ this._symbolDraw.updateLayout(),
|
|
|
+ this._lineDraw.updateLayout()
|
|
|
+ },
|
|
|
+ remove: function(t, e) {
|
|
|
+ this._symbolDraw && this._symbolDraw.remove(),
|
|
|
+ this._lineDraw && this._lineDraw.remove()
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "focusNodeAdjacency",
|
|
|
+ event: "focusNodeAdjacency",
|
|
|
+ update: "series:focusNodeAdjacency"
|
|
|
+ }, function() {}),
|
|
|
+ _f({
|
|
|
+ type: "unfocusNodeAdjacency",
|
|
|
+ event: "unfocusNodeAdjacency",
|
|
|
+ update: "series:unfocusNodeAdjacency"
|
|
|
+ }, function() {});
|
|
|
+ _f({
|
|
|
+ type: "graphRoam",
|
|
|
+ event: "graphRoam",
|
|
|
+ update: "none"
|
|
|
+ }, function(i, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ query: i
|
|
|
+ }, function(t) {
|
|
|
+ var e = ax(t.coordinateSystem, i);
|
|
|
+ t.setCenter && t.setCenter(e.center),
|
|
|
+ t.setZoom && t.setZoom(e.zoom)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ function Rw(t) {
|
|
|
+ return t instanceof Array || (t = [t, t]),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function zw(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ if (!e || "view" === e.type) {
|
|
|
+ var i = t.getGraph();
|
|
|
+ i.eachNode(function(t) {
|
|
|
+ var e = t.getModel();
|
|
|
+ t.setLayout([+e.get("x"), +e.get("y")])
|
|
|
+ }),
|
|
|
+ Bw(i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Bw(t) {
|
|
|
+ t.eachEdge(function(t) {
|
|
|
+ var e = t.getModel().get("lineStyle.curveness") || 0
|
|
|
+ , i = rt(t.node1.getLayout())
|
|
|
+ , n = rt(t.node2.getLayout())
|
|
|
+ , o = [i, n];
|
|
|
+ +e && o.push([(i[0] + n[0]) / 2 - (i[1] - n[1]) * e, (i[1] + n[1]) / 2 - (n[0] - i[0]) * e]),
|
|
|
+ t.setLayout(o)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var Vw = Math.PI
|
|
|
+ , Gw = [];
|
|
|
+ function Fw(t, e) {
|
|
|
+ var i = t.coordinateSystem;
|
|
|
+ if (!i || "view" === i.type) {
|
|
|
+ var n = i.getBoundingRect()
|
|
|
+ , o = t.getData()
|
|
|
+ , a = o.graph
|
|
|
+ , s = n.width / 2 + n.x
|
|
|
+ , l = n.height / 2 + n.y
|
|
|
+ , r = Math.min(n.width, n.height) / 2
|
|
|
+ , u = o.count();
|
|
|
+ o.setLayout({
|
|
|
+ cx: s,
|
|
|
+ cy: l
|
|
|
+ }),
|
|
|
+ u && (Ww[e](t, i, a, o, r, s, l, u),
|
|
|
+ a.eachEdge(function(t) {
|
|
|
+ var e, i = t.getModel().get("lineStyle.curveness") || 0, n = rt(t.node1.getLayout()), o = rt(t.node2.getLayout()), a = (n[0] + o[0]) / 2, r = (n[1] + o[1]) / 2;
|
|
|
+ +i && (e = [s * (i *= 3) + a * (1 - i), l * i + r * (1 - i)]),
|
|
|
+ t.setLayout([n, o, e])
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Ww = {
|
|
|
+ value: function(t, e, i, n, o, a, r, s) {
|
|
|
+ var l = 0
|
|
|
+ , u = n.getSum("value")
|
|
|
+ , h = 2 * Math.PI / (u || s);
|
|
|
+ i.eachNode(function(t) {
|
|
|
+ var e = t.getValue("value")
|
|
|
+ , i = h * (u ? e : 1) / 2;
|
|
|
+ l += i,
|
|
|
+ t.setLayout([o * Math.cos(l) + a, o * Math.sin(l) + r]),
|
|
|
+ l += i
|
|
|
+ })
|
|
|
+ },
|
|
|
+ symbolSize: function(t, e, i, n, o, a, r, s) {
|
|
|
+ var l = 0;
|
|
|
+ Gw.length = s;
|
|
|
+ var u = xw(t);
|
|
|
+ i.eachNode(function(t) {
|
|
|
+ var e = _w(t);
|
|
|
+ isNaN(e) && (e = 2),
|
|
|
+ e < 0 && (e = 0),
|
|
|
+ e *= u;
|
|
|
+ var i = Math.asin(e / 2 / o);
|
|
|
+ isNaN(i) && (i = Vw / 2),
|
|
|
+ Gw[t.dataIndex] = i,
|
|
|
+ l += 2 * i
|
|
|
+ });
|
|
|
+ var h = (2 * Vw - l) / s / 2
|
|
|
+ , c = 0;
|
|
|
+ i.eachNode(function(t) {
|
|
|
+ var e = h + Gw[t.dataIndex];
|
|
|
+ c += e,
|
|
|
+ t.setLayout([o * Math.cos(c) + a, o * Math.sin(c) + r]),
|
|
|
+ c += e
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , Hw = ut;
|
|
|
+ xf(function(t) {
|
|
|
+ var a = t.findComponents({
|
|
|
+ mainType: "legend"
|
|
|
+ });
|
|
|
+ a && a.length && t.eachSeriesByType("graph", function(t) {
|
|
|
+ var e = t.getCategoriesData()
|
|
|
+ , n = t.getGraph().data
|
|
|
+ , o = e.mapArray(e.getName);
|
|
|
+ n.filterSelf(function(t) {
|
|
|
+ var e = n.getItemModel(t).getShallow("category");
|
|
|
+ if (null != e) {
|
|
|
+ "number" == typeof e && (e = o[e]);
|
|
|
+ for (var i = 0; i < a.length; i++)
|
|
|
+ if (!a[i].isSelected(e))
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ return !0
|
|
|
+ })
|
|
|
+ }, this)
|
|
|
+ }),
|
|
|
+ Sf(Lm("graph", "circle", null)),
|
|
|
+ Sf(function(t) {
|
|
|
+ var h = {};
|
|
|
+ t.eachSeriesByType("graph", function(s) {
|
|
|
+ var l = s.getCategoriesData()
|
|
|
+ , o = s.getData()
|
|
|
+ , u = {};
|
|
|
+ l.each(function(t) {
|
|
|
+ var e = l.getName(t);
|
|
|
+ u["ec-" + e] = t;
|
|
|
+ var i = l.getItemModel(t)
|
|
|
+ , n = i.get("itemStyle.color") || s.getColorFromPalette(e, h);
|
|
|
+ l.setItemVisual(t, "color", n);
|
|
|
+ for (var o = ["opacity", "symbol", "symbolSize", "symbolKeepAspect"], a = 0; a < o.length; a++) {
|
|
|
+ var r = i.getShallow(o[a], !0);
|
|
|
+ null != r && l.setItemVisual(t, o[a], r)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ l.count() && o.each(function(t) {
|
|
|
+ var e = o.getItemModel(t).getShallow("category");
|
|
|
+ if (null != e) {
|
|
|
+ "string" == typeof e && (e = u["ec-" + e]);
|
|
|
+ for (var i = ["color", "opacity", "symbol", "symbolSize", "symbolKeepAspect"], n = 0; n < i.length; n++)
|
|
|
+ null == o.getItemVisual(t, i[n], !0) && o.setItemVisual(t, i[n], l.getItemVisual(e, i[n]))
|
|
|
+ }
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ Sf(function(t) {
|
|
|
+ t.eachSeriesByType("graph", function(t) {
|
|
|
+ var s = t.getGraph()
|
|
|
+ , l = t.getEdgeData()
|
|
|
+ , e = Rw(t.get("edgeSymbol"))
|
|
|
+ , i = Rw(t.get("edgeSymbolSize"))
|
|
|
+ , u = "lineStyle.color".split(".")
|
|
|
+ , h = "lineStyle.opacity".split(".");
|
|
|
+ l.setVisual("fromSymbol", e && e[0]),
|
|
|
+ l.setVisual("toSymbol", e && e[1]),
|
|
|
+ l.setVisual("fromSymbolSize", i && i[0]),
|
|
|
+ l.setVisual("toSymbolSize", i && i[1]),
|
|
|
+ l.setVisual("color", t.get(u)),
|
|
|
+ l.setVisual("opacity", t.get(h)),
|
|
|
+ l.each(function(t) {
|
|
|
+ var e = l.getItemModel(t)
|
|
|
+ , i = s.getEdgeByIndex(t)
|
|
|
+ , n = Rw(e.getShallow("symbol", !0))
|
|
|
+ , o = Rw(e.getShallow("symbolSize", !0))
|
|
|
+ , a = e.get(u)
|
|
|
+ , r = e.get(h);
|
|
|
+ switch (a) {
|
|
|
+ case "source":
|
|
|
+ a = i.node1.getVisual("color");
|
|
|
+ break;
|
|
|
+ case "target":
|
|
|
+ a = i.node2.getVisual("color")
|
|
|
+ }
|
|
|
+ n[0] && i.setVisual("fromSymbol", n[0]),
|
|
|
+ n[1] && i.setVisual("toSymbol", n[1]),
|
|
|
+ o[0] && i.setVisual("fromSymbolSize", o[0]),
|
|
|
+ o[1] && i.setVisual("toSymbolSize", o[1]),
|
|
|
+ i.setVisual("color", a),
|
|
|
+ i.setVisual("opacity", r)
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ bf(function(t, e) {
|
|
|
+ t.eachSeriesByType("graph", function(t) {
|
|
|
+ var e = t.get("layout")
|
|
|
+ , i = t.coordinateSystem;
|
|
|
+ if (i && "view" !== i.type) {
|
|
|
+ var n = t.getData()
|
|
|
+ , o = [];
|
|
|
+ E(i.dimensions, function(t) {
|
|
|
+ o = o.concat(n.mapDimension(t, !0))
|
|
|
+ });
|
|
|
+ for (var a = 0; a < n.count(); a++) {
|
|
|
+ for (var r = [], s = !1, l = 0; l < o.length; l++) {
|
|
|
+ var u = n.get(o[l], a);
|
|
|
+ isNaN(u) || (s = !0),
|
|
|
+ r.push(u)
|
|
|
+ }
|
|
|
+ s ? n.setItemLayout(a, i.dataToPoint(r)) : n.setItemLayout(a, [NaN, NaN])
|
|
|
+ }
|
|
|
+ Bw(n.graph)
|
|
|
+ } else
|
|
|
+ e && "none" !== e || zw(t)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ bf(Ld.VISUAL.POST_CHART_LAYOUT, function(t) {
|
|
|
+ t.eachSeriesByType("graph", function(t) {
|
|
|
+ "circular" === t.get("layout") && Fw(t, "symbolSize")
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ bf(function(t) {
|
|
|
+ t.eachSeriesByType("graph", function(t) {
|
|
|
+ if (!(l = t.coordinateSystem) || "view" === l.type)
|
|
|
+ if ("force" === t.get("layout")) {
|
|
|
+ var c = t.preservedPoints || {}
|
|
|
+ , d = t.getGraph()
|
|
|
+ , f = d.data
|
|
|
+ , e = d.edgeData
|
|
|
+ , i = t.getModel("force")
|
|
|
+ , n = i.get("initLayout");
|
|
|
+ t.preservedPoints ? f.each(function(t) {
|
|
|
+ var e = f.getId(t);
|
|
|
+ f.setItemLayout(t, c[e] || [NaN, NaN])
|
|
|
+ }) : n && "none" !== n ? "circular" === n && Fw(t, "value") : zw(t);
|
|
|
+ var o = f.getDataExtent("value")
|
|
|
+ , a = e.getDataExtent("value")
|
|
|
+ , r = i.get("repulsion")
|
|
|
+ , s = i.get("edgeLength");
|
|
|
+ L(r) || (r = [r, r]),
|
|
|
+ L(s) || (s = [s, s]),
|
|
|
+ s = [s[1], s[0]];
|
|
|
+ var l, u = f.mapArray("value", function(t, e) {
|
|
|
+ var i = f.getItemLayout(e)
|
|
|
+ , n = El(t, o, r);
|
|
|
+ return isNaN(n) && (n = (r[0] + r[1]) / 2),
|
|
|
+ {
|
|
|
+ w: n,
|
|
|
+ rep: n,
|
|
|
+ fixed: f.getItemModel(e).get("fixed"),
|
|
|
+ p: !i || isNaN(i[0]) || isNaN(i[1]) ? null : i
|
|
|
+ }
|
|
|
+ }), h = e.mapArray("value", function(t, e) {
|
|
|
+ var i = d.getEdgeByIndex(e)
|
|
|
+ , n = El(t, a, s);
|
|
|
+ isNaN(n) && (n = (s[0] + s[1]) / 2);
|
|
|
+ var o = i.getModel();
|
|
|
+ return {
|
|
|
+ n1: u[i.node1.dataIndex],
|
|
|
+ n2: u[i.node2.dataIndex],
|
|
|
+ d: n,
|
|
|
+ curveness: o.get("lineStyle.curveness") || 0,
|
|
|
+ ignoreForceLayout: o.get("ignoreForceLayout")
|
|
|
+ }
|
|
|
+ }), p = (l = t.coordinateSystem).getBoundingRect(), g = function(f, p, t) {
|
|
|
+ for (var e = t.rect, i = e.width, n = e.height, g = [e.x + i / 2, e.y + n / 2], m = null == t.gravity ? .1 : t.gravity, o = 0; o < f.length; o++) {
|
|
|
+ var a = f[o];
|
|
|
+ a.p || (a.p = ot(i * (Math.random() - .5) + g[0], n * (Math.random() - .5) + g[1])),
|
|
|
+ a.pp = rt(a.p),
|
|
|
+ a.edges = null
|
|
|
+ }
|
|
|
+ var r = null == t.friction ? .6 : t.friction
|
|
|
+ , v = r;
|
|
|
+ return {
|
|
|
+ warmUp: function() {
|
|
|
+ v = .8 * r
|
|
|
+ },
|
|
|
+ setFixed: function(t) {
|
|
|
+ f[t].fixed = !0
|
|
|
+ },
|
|
|
+ setUnfixed: function(t) {
|
|
|
+ f[t].fixed = !1
|
|
|
+ },
|
|
|
+ step: function(t) {
|
|
|
+ for (var e = [], i = f.length, n = 0; n < p.length; n++) {
|
|
|
+ var o = p[n];
|
|
|
+ if (!o.ignoreForceLayout) {
|
|
|
+ var a = o.n1;
|
|
|
+ ht(e, (u = o.n2).p, a.p);
|
|
|
+ var r = ct(e) - o.d
|
|
|
+ , s = u.w / (a.w + u.w);
|
|
|
+ isNaN(s) && (s = 0),
|
|
|
+ mt(e, e),
|
|
|
+ a.fixed || Hw(a.p, a.p, e, s * r * v),
|
|
|
+ u.fixed || Hw(u.p, u.p, e, -(1 - s) * r * v)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (n = 0; n < i; n++) {
|
|
|
+ (d = f[n]).fixed || (ht(e, g, d.p),
|
|
|
+ Hw(d.p, d.p, e, m * v))
|
|
|
+ }
|
|
|
+ for (n = 0; n < i; n++) {
|
|
|
+ a = f[n];
|
|
|
+ for (var l = n + 1; l < i; l++) {
|
|
|
+ var u;
|
|
|
+ ht(e, (u = f[l]).p, a.p),
|
|
|
+ 0 === (r = ct(e)) && (st(e, Math.random() - .5, Math.random() - .5),
|
|
|
+ r = 1);
|
|
|
+ var h = (a.rep + u.rep) / r / r;
|
|
|
+ a.fixed || Hw(a.pp, a.pp, e, h),
|
|
|
+ u.fixed || Hw(u.pp, u.pp, e, -h)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var c = [];
|
|
|
+ for (n = 0; n < i; n++) {
|
|
|
+ var d;
|
|
|
+ (d = f[n]).fixed || (ht(c, d.p, d.pp),
|
|
|
+ Hw(d.p, d.p, c, v),
|
|
|
+ at(d.pp, d.p))
|
|
|
+ }
|
|
|
+ v *= .992,
|
|
|
+ t && t(f, p, v < .01)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }(u, h, {
|
|
|
+ rect: p,
|
|
|
+ gravity: i.get("gravity"),
|
|
|
+ friction: i.get("friction")
|
|
|
+ }), m = g.step;
|
|
|
+ g.step = function(h) {
|
|
|
+ for (var t = 0, e = u.length; t < e; t++)
|
|
|
+ u[t].fixed && at(u[t].p, d.getNodeByIndex(t).getLayout());
|
|
|
+ m(function(t, e, i) {
|
|
|
+ for (var n = 0, o = t.length; n < o; n++)
|
|
|
+ t[n].fixed || d.getNodeByIndex(n).setLayout(t[n].p),
|
|
|
+ c[f.getId(n)] = t[n].p;
|
|
|
+ for (n = 0,
|
|
|
+ o = e.length; n < o; n++) {
|
|
|
+ var a = e[n]
|
|
|
+ , r = d.getEdgeByIndex(n)
|
|
|
+ , s = a.n1.p
|
|
|
+ , l = a.n2.p
|
|
|
+ , u = r.getLayout();
|
|
|
+ (u = u ? u.slice() : [])[0] = u[0] || [],
|
|
|
+ u[1] = u[1] || [],
|
|
|
+ at(u[0], s),
|
|
|
+ at(u[1], l),
|
|
|
+ +a.curveness && (u[2] = [(s[0] + l[0]) / 2 - (s[1] - l[1]) * a.curveness, (s[1] + l[1]) / 2 - (l[0] - s[0]) * a.curveness]),
|
|
|
+ r.setLayout(u)
|
|
|
+ }
|
|
|
+ h && h(i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.forceLayout = g,
|
|
|
+ t.preservedPoints = c,
|
|
|
+ g.step()
|
|
|
+ } else
|
|
|
+ t.forceLayout = null
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ wf("graphView", {
|
|
|
+ create: function(t, d) {
|
|
|
+ var f = [];
|
|
|
+ return t.eachSeriesByType("graph", function(t) {
|
|
|
+ var e = t.get("coordinateSystem");
|
|
|
+ if (!e || "view" === e) {
|
|
|
+ var i = t.getData()
|
|
|
+ , n = []
|
|
|
+ , o = [];
|
|
|
+ Wa(i.mapArray(function(t) {
|
|
|
+ var e = i.getItemModel(t);
|
|
|
+ return [+e.get("x"), +e.get("y")]
|
|
|
+ }), n, o),
|
|
|
+ o[0] - n[0] == 0 && (o[0] += 1,
|
|
|
+ n[0] -= 1),
|
|
|
+ o[1] - n[1] == 0 && (o[1] += 1,
|
|
|
+ n[1] -= 1);
|
|
|
+ var a = (o[0] - n[0]) / (o[1] - n[1])
|
|
|
+ , r = function(t, e, i) {
|
|
|
+ var n = t.getBoxLayoutParams();
|
|
|
+ return n.aspect = i,
|
|
|
+ bu(n, {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ })
|
|
|
+ }(t, d, a);
|
|
|
+ isNaN(a) && (n = [r.x, r.y],
|
|
|
+ o = [r.x + r.width, r.y + r.height]);
|
|
|
+ var s = o[0] - n[0]
|
|
|
+ , l = o[1] - n[1]
|
|
|
+ , u = r.width
|
|
|
+ , h = r.height
|
|
|
+ , c = t.coordinateSystem = new lx;
|
|
|
+ c.zoomLimit = t.get("scaleLimit"),
|
|
|
+ c.setBoundingRect(n[0], n[1], s, l),
|
|
|
+ c.setViewRect(r.x, r.y, u, h),
|
|
|
+ c.setCenter(t.get("center")),
|
|
|
+ c.setZoom(t.get("zoom")),
|
|
|
+ f.push(c)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ f
|
|
|
+ }
|
|
|
+ });
|
|
|
+ sc.extend({
|
|
|
+ type: "series.gauge",
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return Yv(this, ["value"])
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ center: ["50%", "50%"],
|
|
|
+ legendHoverLink: !0,
|
|
|
+ radius: "75%",
|
|
|
+ startAngle: 225,
|
|
|
+ endAngle: -45,
|
|
|
+ clockwise: !0,
|
|
|
+ min: 0,
|
|
|
+ max: 100,
|
|
|
+ splitNumber: 10,
|
|
|
+ axisLine: {
|
|
|
+ show: !0,
|
|
|
+ lineStyle: {
|
|
|
+ color: [[.2, "#91c7ae"], [.8, "#63869e"], [1, "#c23531"]],
|
|
|
+ width: 30
|
|
|
+ }
|
|
|
+ },
|
|
|
+ splitLine: {
|
|
|
+ show: !0,
|
|
|
+ length: 30,
|
|
|
+ lineStyle: {
|
|
|
+ color: "#eee",
|
|
|
+ width: 2,
|
|
|
+ type: "solid"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ axisTick: {
|
|
|
+ show: !0,
|
|
|
+ splitNumber: 5,
|
|
|
+ length: 8,
|
|
|
+ lineStyle: {
|
|
|
+ color: "#eee",
|
|
|
+ width: 1,
|
|
|
+ type: "solid"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ axisLabel: {
|
|
|
+ show: !0,
|
|
|
+ distance: 5,
|
|
|
+ color: "auto"
|
|
|
+ },
|
|
|
+ pointer: {
|
|
|
+ show: !0,
|
|
|
+ length: "80%",
|
|
|
+ width: 8
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ color: "auto"
|
|
|
+ },
|
|
|
+ title: {
|
|
|
+ show: !0,
|
|
|
+ offsetCenter: [0, "-40%"],
|
|
|
+ color: "#333",
|
|
|
+ fontSize: 15
|
|
|
+ },
|
|
|
+ detail: {
|
|
|
+ show: !0,
|
|
|
+ backgroundColor: "rgba(0,0,0,0)",
|
|
|
+ borderWidth: 0,
|
|
|
+ borderColor: "#ccc",
|
|
|
+ width: 100,
|
|
|
+ height: null,
|
|
|
+ padding: [5, 10],
|
|
|
+ offsetCenter: [0, "40%"],
|
|
|
+ color: "auto",
|
|
|
+ fontSize: 30
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var Zw = Ar.extend({
|
|
|
+ type: "echartsGaugePointer",
|
|
|
+ shape: {
|
|
|
+ angle: 0,
|
|
|
+ width: 10,
|
|
|
+ r: 10,
|
|
|
+ x: 0,
|
|
|
+ y: 0
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = Math.cos
|
|
|
+ , n = Math.sin
|
|
|
+ , o = e.r
|
|
|
+ , a = e.width
|
|
|
+ , r = e.angle
|
|
|
+ , s = e.x - i(r) * a * (o / 3 <= a ? 1 : 2)
|
|
|
+ , l = e.y - n(r) * a * (o / 3 <= a ? 1 : 2);
|
|
|
+ r = e.angle - Math.PI / 2,
|
|
|
+ t.moveTo(s, l),
|
|
|
+ t.lineTo(e.x + i(r) * a, e.y + n(r) * a),
|
|
|
+ t.lineTo(e.x + i(e.angle) * o, e.y + n(e.angle) * o),
|
|
|
+ t.lineTo(e.x - i(r) * a, e.y - n(r) * a),
|
|
|
+ t.lineTo(s, l)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function Uw(t, e) {
|
|
|
+ return e && ("string" == typeof e ? t = e.replace("{value}", null != t ? t : "") : "function" == typeof e && (t = e(t))),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ var Xw = 2 * Math.PI
|
|
|
+ , Yw = (_c.extend({
|
|
|
+ type: "gauge",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ this.group.removeAll();
|
|
|
+ var n = t.get("axisLine.lineStyle.color")
|
|
|
+ , o = function(t, e) {
|
|
|
+ var i = t.get("center")
|
|
|
+ , n = e.getWidth()
|
|
|
+ , o = e.getHeight()
|
|
|
+ , a = Math.min(n, o);
|
|
|
+ return {
|
|
|
+ cx: Rl(i[0], e.getWidth()),
|
|
|
+ cy: Rl(i[1], e.getHeight()),
|
|
|
+ r: Rl(t.get("radius"), a / 2)
|
|
|
+ }
|
|
|
+ }(t, i);
|
|
|
+ this._renderMain(t, e, i, n, o)
|
|
|
+ },
|
|
|
+ dispose: function() {},
|
|
|
+ _renderMain: function(t, e, i, n, o) {
|
|
|
+ for (var a = this.group, r = t.getModel("axisLine"), s = r.getModel("lineStyle"), l = t.get("clockwise"), u = -t.get("startAngle") / 180 * Math.PI, h = ((g = -t.get("endAngle") / 180 * Math.PI) - u) % Xw, c = u, d = s.get("width"), f = r.get("show"), p = 0; f && p < n.length; p++) {
|
|
|
+ var g, m = Math.min(Math.max(n[p][0], 0), 1), v = new qr({
|
|
|
+ shape: {
|
|
|
+ startAngle: c,
|
|
|
+ endAngle: g = u + h * m,
|
|
|
+ cx: o.cx,
|
|
|
+ cy: o.cy,
|
|
|
+ clockwise: l,
|
|
|
+ r0: o.r - d,
|
|
|
+ r: o.r
|
|
|
+ },
|
|
|
+ silent: !0
|
|
|
+ });
|
|
|
+ v.setStyle({
|
|
|
+ fill: n[p][1]
|
|
|
+ }),
|
|
|
+ v.setStyle(s.getLineStyle(["color", "borderWidth", "borderColor"])),
|
|
|
+ a.add(v),
|
|
|
+ c = g
|
|
|
+ }
|
|
|
+ function y(t) {
|
|
|
+ if (t <= 0)
|
|
|
+ return n[0][1];
|
|
|
+ for (var e = 0; e < n.length; e++)
|
|
|
+ if (n[e][0] >= t && (0 === e ? 0 : n[e - 1][0]) < t)
|
|
|
+ return n[e][1];
|
|
|
+ return n[e - 1][1]
|
|
|
+ }
|
|
|
+ if (!l) {
|
|
|
+ var x = u;
|
|
|
+ u = g,
|
|
|
+ g = x
|
|
|
+ }
|
|
|
+ this._renderTicks(t, e, i, y, o, u, g, l),
|
|
|
+ this._renderPointer(t, e, i, y, o, u, g, l),
|
|
|
+ this._renderTitle(t, e, i, y, o),
|
|
|
+ this._renderDetail(t, e, i, y, o)
|
|
|
+ },
|
|
|
+ _renderTicks: function(t, e, i, n, o, a, r, s) {
|
|
|
+ for (var l = this.group, u = o.cx, h = o.cy, c = o.r, d = +t.get("min"), f = +t.get("max"), p = t.getModel("splitLine"), g = t.getModel("axisTick"), m = t.getModel("axisLabel"), v = t.get("splitNumber"), y = g.get("splitNumber"), x = Rl(p.get("length"), c), _ = Rl(g.get("length"), c), w = a, b = (r - a) / v, S = b / y, M = p.getModel("lineStyle").getLineStyle(), I = g.getModel("lineStyle").getLineStyle(), T = 0; T <= v; T++) {
|
|
|
+ var A = Math.cos(w)
|
|
|
+ , D = Math.sin(w);
|
|
|
+ if (p.get("show")) {
|
|
|
+ var C = new ls({
|
|
|
+ shape: {
|
|
|
+ x1: A * c + u,
|
|
|
+ y1: D * c + h,
|
|
|
+ x2: A * (c - x) + u,
|
|
|
+ y2: D * (c - x) + h
|
|
|
+ },
|
|
|
+ style: M,
|
|
|
+ silent: !0
|
|
|
+ });
|
|
|
+ "auto" === M.stroke && C.setStyle({
|
|
|
+ stroke: n(T / v)
|
|
|
+ }),
|
|
|
+ l.add(C)
|
|
|
+ }
|
|
|
+ if (m.get("show")) {
|
|
|
+ var L = Uw(zl(T / v * (f - d) + d), m.get("formatter"))
|
|
|
+ , k = m.get("distance")
|
|
|
+ , P = n(T / v);
|
|
|
+ l.add(new Ur({
|
|
|
+ style: nl({}, m, {
|
|
|
+ text: L,
|
|
|
+ x: A * (c - x - k) + u,
|
|
|
+ y: D * (c - x - k) + h,
|
|
|
+ textVerticalAlign: D < -.4 ? "top" : .4 < D ? "bottom" : "middle",
|
|
|
+ textAlign: A < -.4 ? "left" : .4 < A ? "right" : "center"
|
|
|
+ }, {
|
|
|
+ autoColor: P
|
|
|
+ }),
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ if (g.get("show") && T !== v) {
|
|
|
+ for (var N = 0; N <= y; N++) {
|
|
|
+ A = Math.cos(w),
|
|
|
+ D = Math.sin(w);
|
|
|
+ var O = new ls({
|
|
|
+ shape: {
|
|
|
+ x1: A * c + u,
|
|
|
+ y1: D * c + h,
|
|
|
+ x2: A * (c - _) + u,
|
|
|
+ y2: D * (c - _) + h
|
|
|
+ },
|
|
|
+ silent: !0,
|
|
|
+ style: I
|
|
|
+ });
|
|
|
+ "auto" === I.stroke && O.setStyle({
|
|
|
+ stroke: n((T + N / y) / v)
|
|
|
+ }),
|
|
|
+ l.add(O),
|
|
|
+ w += S
|
|
|
+ }
|
|
|
+ w -= S
|
|
|
+ } else
|
|
|
+ w += b
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderPointer: function(n, t, e, o, a, i, r, s) {
|
|
|
+ var l = this.group
|
|
|
+ , u = this._data;
|
|
|
+ if (n.get("pointer.show")) {
|
|
|
+ var h = [+n.get("min"), +n.get("max")]
|
|
|
+ , c = [i, r]
|
|
|
+ , d = n.getData()
|
|
|
+ , f = d.mapDimension("value");
|
|
|
+ d.diff(u).add(function(t) {
|
|
|
+ var e = new Zw({
|
|
|
+ shape: {
|
|
|
+ angle: i
|
|
|
+ }
|
|
|
+ });
|
|
|
+ dl(e, {
|
|
|
+ shape: {
|
|
|
+ angle: El(d.get(f, t), h, c, !0)
|
|
|
+ }
|
|
|
+ }, n),
|
|
|
+ l.add(e),
|
|
|
+ d.setItemGraphicEl(t, e)
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = u.getItemGraphicEl(e);
|
|
|
+ cl(i, {
|
|
|
+ shape: {
|
|
|
+ angle: El(d.get(f, t), h, c, !0)
|
|
|
+ }
|
|
|
+ }, n),
|
|
|
+ l.add(i),
|
|
|
+ d.setItemGraphicEl(t, i)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = u.getItemGraphicEl(t);
|
|
|
+ l.remove(e)
|
|
|
+ }).execute(),
|
|
|
+ d.eachItemGraphicEl(function(t, e) {
|
|
|
+ var i = d.getItemModel(e)
|
|
|
+ , n = i.getModel("pointer");
|
|
|
+ t.setShape({
|
|
|
+ x: a.cx,
|
|
|
+ y: a.cy,
|
|
|
+ width: Rl(n.get("width"), a.r),
|
|
|
+ r: Rl(n.get("length"), a.r)
|
|
|
+ }),
|
|
|
+ t.useStyle(i.getModel("itemStyle").getItemStyle()),
|
|
|
+ "auto" === t.style.fill && t.setStyle("fill", o(El(d.get(f, e), h, [0, 1], !0))),
|
|
|
+ $s(t, i.getModel("emphasis.itemStyle").getItemStyle())
|
|
|
+ }),
|
|
|
+ this._data = d
|
|
|
+ } else
|
|
|
+ u && u.eachItemGraphicEl(function(t) {
|
|
|
+ l.remove(t)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _renderTitle: function(t, e, i, n, o) {
|
|
|
+ var a = t.getData()
|
|
|
+ , r = a.mapDimension("value")
|
|
|
+ , s = t.getModel("title");
|
|
|
+ if (s.get("show")) {
|
|
|
+ var l = s.get("offsetCenter")
|
|
|
+ , u = o.cx + Rl(l[0], o.r)
|
|
|
+ , h = o.cy + Rl(l[1], o.r)
|
|
|
+ , c = +t.get("min")
|
|
|
+ , d = +t.get("max")
|
|
|
+ , f = n(El(t.getData().get(r, 0), [c, d], [0, 1], !0));
|
|
|
+ this.group.add(new Ur({
|
|
|
+ silent: !0,
|
|
|
+ style: nl({}, s, {
|
|
|
+ x: u,
|
|
|
+ y: h,
|
|
|
+ text: a.getName(0),
|
|
|
+ textAlign: "center",
|
|
|
+ textVerticalAlign: "middle"
|
|
|
+ }, {
|
|
|
+ autoColor: f,
|
|
|
+ forceRich: !0
|
|
|
+ })
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderDetail: function(t, e, i, n, o) {
|
|
|
+ var a = t.getModel("detail")
|
|
|
+ , r = +t.get("min")
|
|
|
+ , s = +t.get("max");
|
|
|
+ if (a.get("show")) {
|
|
|
+ var l = a.get("offsetCenter")
|
|
|
+ , u = o.cx + Rl(l[0], o.r)
|
|
|
+ , h = o.cy + Rl(l[1], o.r)
|
|
|
+ , c = Rl(a.get("width"), o.r)
|
|
|
+ , d = Rl(a.get("height"), o.r)
|
|
|
+ , f = t.getData()
|
|
|
+ , p = f.get(f.mapDimension("value"), 0)
|
|
|
+ , g = n(El(p, [r, s], [0, 1], !0));
|
|
|
+ this.group.add(new Ur({
|
|
|
+ silent: !0,
|
|
|
+ style: nl({}, a, {
|
|
|
+ x: u,
|
|
|
+ y: h,
|
|
|
+ text: Uw(p, a.get("formatter")),
|
|
|
+ textWidth: isNaN(c) ? null : c,
|
|
|
+ textHeight: isNaN(d) ? null : d,
|
|
|
+ textAlign: "center",
|
|
|
+ textVerticalAlign: "middle"
|
|
|
+ }, {
|
|
|
+ autoColor: g,
|
|
|
+ forceRich: !0
|
|
|
+ })
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ Df({
|
|
|
+ type: "series.funnel",
|
|
|
+ init: function(t) {
|
|
|
+ Yw.superApply(this, "init", arguments),
|
|
|
+ this.legendVisualProvider = new qv(A(this.getData, this),A(this.getRawData, this)),
|
|
|
+ this._defaultLabelLine(t)
|
|
|
+ },
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return Yv(this, {
|
|
|
+ coordDimensions: ["value"],
|
|
|
+ encodeDefaulter: T(Ju, this)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _defaultLabelLine: function(t) {
|
|
|
+ Go(t, "labelLine", ["show"]);
|
|
|
+ var e = t.labelLine
|
|
|
+ , i = t.emphasis.labelLine;
|
|
|
+ e.show = e.show && t.label.show,
|
|
|
+ i.show = i.show && t.emphasis.label.show
|
|
|
+ },
|
|
|
+ getDataParams: function(t) {
|
|
|
+ var e = this.getData()
|
|
|
+ , i = Yw.superCall(this, "getDataParams", t)
|
|
|
+ , n = e.mapDimension("value")
|
|
|
+ , o = e.getSum(n);
|
|
|
+ return i.percent = o ? +(e.get(n, t) / o * 100).toFixed(2) : 0,
|
|
|
+ i.$vars.push("percent"),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ legendHoverLink: !0,
|
|
|
+ left: 80,
|
|
|
+ top: 60,
|
|
|
+ right: 80,
|
|
|
+ bottom: 60,
|
|
|
+ minSize: "0%",
|
|
|
+ maxSize: "100%",
|
|
|
+ sort: "descending",
|
|
|
+ gap: 0,
|
|
|
+ funnelAlign: "center",
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ position: "outer"
|
|
|
+ },
|
|
|
+ labelLine: {
|
|
|
+ show: !0,
|
|
|
+ length: 20,
|
|
|
+ lineStyle: {
|
|
|
+ width: 1,
|
|
|
+ type: "solid"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ borderColor: "#fff",
|
|
|
+ borderWidth: 1
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }));
|
|
|
+ function jw(t, e) {
|
|
|
+ Ci.call(this);
|
|
|
+ var i = new Qr
|
|
|
+ , n = new ts
|
|
|
+ , o = new Ur;
|
|
|
+ this.add(i),
|
|
|
+ this.add(n),
|
|
|
+ this.add(o),
|
|
|
+ this.highDownOnUpdate = function(t, e) {
|
|
|
+ "emphasis" === e ? (n.ignore = n.hoverIgnore,
|
|
|
+ o.ignore = o.hoverIgnore) : (n.ignore = n.normalIgnore,
|
|
|
+ o.ignore = o.normalIgnore)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.updateData(t, e, !0)
|
|
|
+ }
|
|
|
+ var qw = jw.prototype
|
|
|
+ , Kw = ["itemStyle", "opacity"];
|
|
|
+ qw.updateData = function(t, e, i) {
|
|
|
+ var n = this.childAt(0)
|
|
|
+ , o = t.hostModel
|
|
|
+ , a = t.getItemModel(e)
|
|
|
+ , r = t.getItemLayout(e)
|
|
|
+ , s = t.getItemModel(e).get(Kw);
|
|
|
+ s = null == s ? 1 : s,
|
|
|
+ n.useStyle({}),
|
|
|
+ i ? (n.setShape({
|
|
|
+ points: r.points
|
|
|
+ }),
|
|
|
+ n.setStyle({
|
|
|
+ opacity: 0
|
|
|
+ }),
|
|
|
+ dl(n, {
|
|
|
+ style: {
|
|
|
+ opacity: s
|
|
|
+ }
|
|
|
+ }, o, e)) : cl(n, {
|
|
|
+ style: {
|
|
|
+ opacity: s
|
|
|
+ },
|
|
|
+ shape: {
|
|
|
+ points: r.points
|
|
|
+ }
|
|
|
+ }, o, e);
|
|
|
+ var l = a.getModel("itemStyle")
|
|
|
+ , u = t.getItemVisual(e, "color");
|
|
|
+ n.setStyle(D({
|
|
|
+ lineJoin: "round",
|
|
|
+ fill: u
|
|
|
+ }, l.getItemStyle(["opacity"]))),
|
|
|
+ n.hoverStyle = l.getModel("emphasis").getItemStyle(),
|
|
|
+ this._updateLabel(t, e),
|
|
|
+ $s(this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ qw._updateLabel = function(t, e) {
|
|
|
+ var i = this.childAt(1)
|
|
|
+ , n = this.childAt(2)
|
|
|
+ , o = t.hostModel
|
|
|
+ , a = t.getItemModel(e)
|
|
|
+ , r = t.getItemLayout(e).label
|
|
|
+ , s = t.getItemVisual(e, "color");
|
|
|
+ cl(i, {
|
|
|
+ shape: {
|
|
|
+ points: r.linePoints || r.linePoints
|
|
|
+ }
|
|
|
+ }, o, e),
|
|
|
+ cl(n, {
|
|
|
+ style: {
|
|
|
+ x: r.x,
|
|
|
+ y: r.y
|
|
|
+ }
|
|
|
+ }, o, e),
|
|
|
+ n.attr({
|
|
|
+ rotation: r.rotation,
|
|
|
+ origin: [r.x, r.y],
|
|
|
+ z2: 10
|
|
|
+ });
|
|
|
+ var l = a.getModel("label")
|
|
|
+ , u = a.getModel("emphasis.label")
|
|
|
+ , h = a.getModel("labelLine")
|
|
|
+ , c = a.getModel("emphasis.labelLine");
|
|
|
+ s = t.getItemVisual(e, "color");
|
|
|
+ el(n.style, n.hoverStyle = {}, l, u, {
|
|
|
+ labelFetcher: t.hostModel,
|
|
|
+ labelDataIndex: e,
|
|
|
+ defaultText: t.getName(e),
|
|
|
+ autoColor: s,
|
|
|
+ useInsideStyle: !!r.inside
|
|
|
+ }, {
|
|
|
+ textAlign: r.textAlign,
|
|
|
+ textVerticalAlign: r.verticalAlign
|
|
|
+ }),
|
|
|
+ n.ignore = n.normalIgnore = !l.get("show"),
|
|
|
+ n.hoverIgnore = !u.get("show"),
|
|
|
+ i.ignore = i.normalIgnore = !h.get("show"),
|
|
|
+ i.hoverIgnore = !c.get("show"),
|
|
|
+ i.setStyle({
|
|
|
+ stroke: s
|
|
|
+ }),
|
|
|
+ i.setStyle(h.getModel("lineStyle").getLineStyle()),
|
|
|
+ i.hoverStyle = c.getModel("lineStyle").getLineStyle()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(jw, Ci);
|
|
|
+ _c.extend({
|
|
|
+ type: "funnel",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var n = t.getData()
|
|
|
+ , o = this._data
|
|
|
+ , a = this.group;
|
|
|
+ n.diff(o).add(function(t) {
|
|
|
+ var e = new jw(n,t);
|
|
|
+ n.setItemGraphicEl(t, e),
|
|
|
+ a.add(e)
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = o.getItemGraphicEl(e);
|
|
|
+ i.updateData(n, t),
|
|
|
+ a.add(i),
|
|
|
+ n.setItemGraphicEl(t, i)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = o.getItemGraphicEl(t);
|
|
|
+ a.remove(e)
|
|
|
+ }).execute(),
|
|
|
+ this._data = n
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._data = null
|
|
|
+ },
|
|
|
+ dispose: function() {}
|
|
|
+ });
|
|
|
+ Sf(iy("funnel")),
|
|
|
+ bf(function(t, w, e) {
|
|
|
+ t.eachSeriesByType("funnel", function(t) {
|
|
|
+ var o = t.getData()
|
|
|
+ , a = o.mapDimension("value")
|
|
|
+ , e = t.get("sort")
|
|
|
+ , r = function(t, e) {
|
|
|
+ return bu(t.getBoxLayoutParams(), {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ })
|
|
|
+ }(t, w)
|
|
|
+ , i = function(t, e) {
|
|
|
+ for (var i = t.mapDimension("value"), n = t.mapArray(i, function(t) {
|
|
|
+ return t
|
|
|
+ }), o = [], a = "ascending" === e, r = 0, s = t.count(); r < s; r++)
|
|
|
+ o[r] = r;
|
|
|
+ return "function" == typeof e ? o.sort(e) : "none" !== e && o.sort(function(t, e) {
|
|
|
+ return a ? n[t] - n[e] : n[e] - n[t]
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ }(o, e)
|
|
|
+ , s = [Rl(t.get("minSize"), r.width), Rl(t.get("maxSize"), r.width)]
|
|
|
+ , n = o.getDataExtent(a)
|
|
|
+ , l = t.get("min")
|
|
|
+ , u = t.get("max");
|
|
|
+ null == l && (l = Math.min(n[0], 0)),
|
|
|
+ null == u && (u = n[1]);
|
|
|
+ function h(t, e) {
|
|
|
+ var i, n = El(o.get(a, t) || 0, [l, u], s, !0);
|
|
|
+ switch (c) {
|
|
|
+ case "left":
|
|
|
+ i = r.x;
|
|
|
+ break;
|
|
|
+ case "center":
|
|
|
+ i = r.x + (r.width - n) / 2;
|
|
|
+ break;
|
|
|
+ case "right":
|
|
|
+ i = r.x + r.width - n
|
|
|
+ }
|
|
|
+ return [[i, e], [i + n, e]]
|
|
|
+ }
|
|
|
+ var c = t.get("funnelAlign")
|
|
|
+ , d = t.get("gap")
|
|
|
+ , f = (r.height - d * (o.count() - 1)) / o.count()
|
|
|
+ , p = r.y;
|
|
|
+ "ascending" === e && (f = -f,
|
|
|
+ d = -d,
|
|
|
+ p += r.height,
|
|
|
+ i = i.reverse());
|
|
|
+ for (var g = 0; g < i.length; g++) {
|
|
|
+ var m = i[g]
|
|
|
+ , v = i[g + 1]
|
|
|
+ , y = o.getItemModel(m).get("itemStyle.height");
|
|
|
+ null == y ? y = f : (y = Rl(y, r.height),
|
|
|
+ "ascending" === e && (y = -y));
|
|
|
+ var x = h(m, p)
|
|
|
+ , _ = h(v, p + y);
|
|
|
+ p += y + d,
|
|
|
+ o.setItemLayout(m, {
|
|
|
+ points: x.concat(_.slice().reverse())
|
|
|
+ })
|
|
|
+ }
|
|
|
+ !function(g) {
|
|
|
+ g.each(function(t) {
|
|
|
+ var e, i, n, o, a = g.getItemModel(t), r = a.getModel("label").get("position"), s = a.getModel("labelLine"), l = g.getItemLayout(t), u = l.points, h = "inner" === r || "inside" === r || "center" === r || "insideLeft" === r || "insideRight" === r;
|
|
|
+ if (h)
|
|
|
+ e = "insideLeft" === r ? (i = (u[0][0] + u[3][0]) / 2 + 5,
|
|
|
+ n = (u[0][1] + u[3][1]) / 2,
|
|
|
+ "left") : "insideRight" === r ? (i = (u[1][0] + u[2][0]) / 2 - 5,
|
|
|
+ n = (u[1][1] + u[2][1]) / 2,
|
|
|
+ "right") : (i = (u[0][0] + u[1][0] + u[2][0] + u[3][0]) / 4,
|
|
|
+ n = (u[0][1] + u[1][1] + u[2][1] + u[3][1]) / 4,
|
|
|
+ "center"),
|
|
|
+ o = [[i, n], [i, n]];
|
|
|
+ else {
|
|
|
+ var c, d, f, p = s.get("length");
|
|
|
+ e = "left" === r ? (c = (u[3][0] + u[0][0]) / 2,
|
|
|
+ d = (u[3][1] + u[0][1]) / 2,
|
|
|
+ i = (f = c - p) - 5,
|
|
|
+ "right") : "right" === r ? (c = (u[1][0] + u[2][0]) / 2,
|
|
|
+ d = (u[1][1] + u[2][1]) / 2,
|
|
|
+ i = (f = c + p) + 5,
|
|
|
+ "left") : "rightTop" === r ? (c = u[1][0],
|
|
|
+ d = u[1][1],
|
|
|
+ i = (f = c + p) + 5,
|
|
|
+ "top") : "rightBottom" === r ? (c = u[2][0],
|
|
|
+ d = u[2][1],
|
|
|
+ i = (f = c + p) + 5,
|
|
|
+ "bottom") : "leftTop" === r ? (c = u[0][0],
|
|
|
+ d = u[1][1],
|
|
|
+ i = (f = c - p) - 5,
|
|
|
+ "right") : "leftBottom" === r ? (c = u[3][0],
|
|
|
+ d = u[2][1],
|
|
|
+ i = (f = c - p) - 5,
|
|
|
+ "right") : (c = (u[1][0] + u[2][0]) / 2,
|
|
|
+ d = (u[1][1] + u[2][1]) / 2,
|
|
|
+ i = (f = c + p) + 5,
|
|
|
+ "left");
|
|
|
+ o = [[c, d], [f, d]],
|
|
|
+ n = d
|
|
|
+ }
|
|
|
+ l.label = {
|
|
|
+ linePoints: o,
|
|
|
+ x: i,
|
|
|
+ y: n,
|
|
|
+ verticalAlign: "middle",
|
|
|
+ textAlign: e,
|
|
|
+ inside: h
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }(o)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ xf(uy("funnel"));
|
|
|
+ function $w(t, e, i, n, o) {
|
|
|
+ Gg.call(this, t, e, i),
|
|
|
+ this.type = n || "value",
|
|
|
+ this.axisIndex = o
|
|
|
+ }
|
|
|
+ $w.prototype = {
|
|
|
+ constructor: $w,
|
|
|
+ model: null,
|
|
|
+ isHorizontal: function() {
|
|
|
+ return "horizontal" !== this.coordinateSystem.getModel().get("layout")
|
|
|
+ }
|
|
|
+ },
|
|
|
+ w($w, Gg);
|
|
|
+ function Jw(t, e, i, n, o, a) {
|
|
|
+ t = t || 0;
|
|
|
+ var r = i[1] - i[0];
|
|
|
+ if (null != o && (o = tb(o, [0, r])),
|
|
|
+ null != a && (a = Math.max(a, null != o ? o : 0)),
|
|
|
+ "all" === n) {
|
|
|
+ var s = Math.abs(e[1] - e[0]);
|
|
|
+ o = a = tb(s = tb(s, [0, r]), [o, a]),
|
|
|
+ n = 0
|
|
|
+ }
|
|
|
+ e[0] = tb(e[0], i),
|
|
|
+ e[1] = tb(e[1], i);
|
|
|
+ var l = Qw(e, n);
|
|
|
+ e[n] += t;
|
|
|
+ var u = o || 0
|
|
|
+ , h = i.slice();
|
|
|
+ l.sign < 0 ? h[0] += u : h[1] -= u,
|
|
|
+ e[n] = tb(e[n], h);
|
|
|
+ var c = Qw(e, n);
|
|
|
+ return null != o && (c.sign !== l.sign || c.span < o) && (e[1 - n] = e[n] + l.sign * o),
|
|
|
+ c = Qw(e, n),
|
|
|
+ null != a && c.span > a && (e[1 - n] = e[n] + c.sign * a),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function Qw(t, e) {
|
|
|
+ var i = t[e] - t[1 - e];
|
|
|
+ return {
|
|
|
+ span: Math.abs(i),
|
|
|
+ sign: 0 < i ? -1 : i < 0 ? 1 : e ? -1 : 1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function tb(t, e) {
|
|
|
+ return Math.min(null != e[1] ? e[1] : 1 / 0, Math.max(null != e[0] ? e[0] : -1 / 0, t))
|
|
|
+ }
|
|
|
+ var eb = E
|
|
|
+ , ib = Math.min
|
|
|
+ , nb = Math.max
|
|
|
+ , ob = Math.floor
|
|
|
+ , ab = Math.ceil
|
|
|
+ , rb = zl
|
|
|
+ , sb = Math.PI;
|
|
|
+ function lb(t, e, i) {
|
|
|
+ this._axesMap = Q(),
|
|
|
+ this._axesLayout = {},
|
|
|
+ this.dimensions = t.dimensions,
|
|
|
+ this._rect,
|
|
|
+ this._model = t,
|
|
|
+ this._init(t, e, i)
|
|
|
+ }
|
|
|
+ function ub(t, e) {
|
|
|
+ return ib(nb(t, e[0]), e[1])
|
|
|
+ }
|
|
|
+ lb.prototype = {
|
|
|
+ type: "parallel",
|
|
|
+ constructor: lb,
|
|
|
+ _init: function(t, r, e) {
|
|
|
+ var i = t.dimensions
|
|
|
+ , s = t.parallelAxisIndex;
|
|
|
+ eb(i, function(t, e) {
|
|
|
+ var i = s[e]
|
|
|
+ , n = r.getComponent("parallelAxis", i)
|
|
|
+ , o = this._axesMap.set(t, new $w(t,sg(n),[0, 0],n.get("type"),i))
|
|
|
+ , a = "category" === o.type;
|
|
|
+ o.onBand = a && n.get("boundaryGap"),
|
|
|
+ o.inverse = n.get("inverse"),
|
|
|
+ (n.axis = o).model = n,
|
|
|
+ o.coordinateSystem = n.coordinateSystem = this
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ update: function(t, e) {
|
|
|
+ this._updateAxesFromSeries(this._model, t)
|
|
|
+ },
|
|
|
+ containPoint: function(t) {
|
|
|
+ var e = this._makeLayoutInfo()
|
|
|
+ , i = e.axisBase
|
|
|
+ , n = e.layoutBase
|
|
|
+ , o = e.pixelDimIndex
|
|
|
+ , a = t[1 - o]
|
|
|
+ , r = t[o];
|
|
|
+ return i <= a && a <= i + e.axisLength && n <= r && r <= n + e.layoutLength
|
|
|
+ },
|
|
|
+ getModel: function() {
|
|
|
+ return this._model
|
|
|
+ },
|
|
|
+ _updateAxesFromSeries: function(e, n) {
|
|
|
+ n.eachSeries(function(t) {
|
|
|
+ if (e.contains(t, n)) {
|
|
|
+ var i = t.getData();
|
|
|
+ eb(this.dimensions, function(t) {
|
|
|
+ var e = this._axesMap.get(t);
|
|
|
+ e.scale.unionExtentFromData(i, i.mapDimension(t)),
|
|
|
+ rg(e.scale, e.model)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ resize: function(t, e) {
|
|
|
+ this._rect = bu(t.getBoxLayoutParams(), {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ }),
|
|
|
+ this._layoutAxes()
|
|
|
+ },
|
|
|
+ getRect: function() {
|
|
|
+ return this._rect
|
|
|
+ },
|
|
|
+ _makeLayoutInfo: function() {
|
|
|
+ var t, e = this._model, i = this._rect, n = ["x", "y"], o = ["width", "height"], a = e.get("layout"), r = "horizontal" === a ? 0 : 1, s = i[o[r]], l = [0, s], u = this.dimensions.length, h = ub(e.get("axisExpandWidth"), l), c = ub(e.get("axisExpandCount") || 0, [0, u]), d = e.get("axisExpandable") && 3 < u && c < u && 1 < c && 0 < h && 0 < s, f = e.get("axisExpandWindow");
|
|
|
+ f ? (t = ub(f[1] - f[0], l),
|
|
|
+ f[1] = f[0] + t) : (t = ub(h * (c - 1), l),
|
|
|
+ (f = [h * (e.get("axisExpandCenter") || ob(u / 2)) - t / 2])[1] = f[0] + t);
|
|
|
+ var p = (s - t) / (u - c);
|
|
|
+ p < 3 && (p = 0);
|
|
|
+ var g = [ob(rb(f[0] / h, 1)) + 1, ab(rb(f[1] / h, 1)) - 1]
|
|
|
+ , m = p / h * f[0];
|
|
|
+ return {
|
|
|
+ layout: a,
|
|
|
+ pixelDimIndex: r,
|
|
|
+ layoutBase: i[n[r]],
|
|
|
+ layoutLength: s,
|
|
|
+ axisBase: i[n[1 - r]],
|
|
|
+ axisLength: i[o[1 - r]],
|
|
|
+ axisExpandable: d,
|
|
|
+ axisExpandWidth: h,
|
|
|
+ axisCollapseWidth: p,
|
|
|
+ axisExpandWindow: f,
|
|
|
+ axisCount: u,
|
|
|
+ winInnerIndices: g,
|
|
|
+ axisExpandWindow0Pos: m
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _layoutAxes: function() {
|
|
|
+ var l = this._rect
|
|
|
+ , t = this._axesMap
|
|
|
+ , e = this.dimensions
|
|
|
+ , u = this._makeLayoutInfo()
|
|
|
+ , h = u.layout;
|
|
|
+ t.each(function(t) {
|
|
|
+ var e = [0, u.axisLength]
|
|
|
+ , i = t.inverse ? 1 : 0;
|
|
|
+ t.setExtent(e[i], e[1 - i])
|
|
|
+ }),
|
|
|
+ eb(e, function(t, e) {
|
|
|
+ var i = (u.axisExpandable ? function(t, e) {
|
|
|
+ var i, n, o = e.layoutLength, a = e.axisExpandWidth, r = e.axisCount, s = e.axisCollapseWidth, l = e.winInnerIndices, u = s, h = !1;
|
|
|
+ t < l[0] ? (i = t * s,
|
|
|
+ n = s) : t <= l[1] ? (i = e.axisExpandWindow0Pos + t * a - e.axisExpandWindow[0],
|
|
|
+ u = a,
|
|
|
+ h = !0) : (i = o - (r - 1 - t) * s,
|
|
|
+ n = s);
|
|
|
+ return {
|
|
|
+ position: i,
|
|
|
+ axisNameAvailableWidth: u,
|
|
|
+ axisLabelShow: h,
|
|
|
+ nameTruncateMaxWidth: n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ : function(t, e) {
|
|
|
+ var i = e.layoutLength / (e.axisCount - 1);
|
|
|
+ return {
|
|
|
+ position: i * t,
|
|
|
+ axisNameAvailableWidth: i,
|
|
|
+ axisLabelShow: !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ )(e, u)
|
|
|
+ , n = {
|
|
|
+ horizontal: {
|
|
|
+ x: i.position,
|
|
|
+ y: u.axisLength
|
|
|
+ },
|
|
|
+ vertical: {
|
|
|
+ x: 0,
|
|
|
+ y: i.position
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , o = {
|
|
|
+ horizontal: sb / 2,
|
|
|
+ vertical: 0
|
|
|
+ }
|
|
|
+ , a = [n[h].x + l.x, n[h].y + l.y]
|
|
|
+ , r = o[h]
|
|
|
+ , s = ae();
|
|
|
+ he(s, s, r),
|
|
|
+ ue(s, s, a),
|
|
|
+ this._axesLayout[t] = {
|
|
|
+ position: a,
|
|
|
+ rotation: r,
|
|
|
+ transform: s,
|
|
|
+ axisNameAvailableWidth: i.axisNameAvailableWidth,
|
|
|
+ axisLabelShow: i.axisLabelShow,
|
|
|
+ nameTruncateMaxWidth: i.nameTruncateMaxWidth,
|
|
|
+ tickDirection: 1,
|
|
|
+ labelDirection: 1
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ getAxis: function(t) {
|
|
|
+ return this._axesMap.get(t)
|
|
|
+ },
|
|
|
+ dataToPoint: function(t, e) {
|
|
|
+ return this.axisCoordToPoint(this._axesMap.get(e).dataToCoord(t), e)
|
|
|
+ },
|
|
|
+ eachActiveState: function(e, t, i, n) {
|
|
|
+ null == i && (i = 0),
|
|
|
+ null == n && (n = e.count());
|
|
|
+ var o = this._axesMap
|
|
|
+ , a = this.dimensions
|
|
|
+ , r = []
|
|
|
+ , s = [];
|
|
|
+ E(a, function(t) {
|
|
|
+ r.push(e.mapDimension(t)),
|
|
|
+ s.push(o.get(t).model)
|
|
|
+ });
|
|
|
+ for (var l = this.hasAxisBrushed(), u = i; u < n; u++) {
|
|
|
+ var h;
|
|
|
+ if (l) {
|
|
|
+ h = "active";
|
|
|
+ for (var c = e.getValues(r, u), d = 0, f = a.length; d < f; d++) {
|
|
|
+ if ("inactive" === s[d].getActiveState(c[d])) {
|
|
|
+ h = "inactive";
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ h = "normal";
|
|
|
+ t(h, u)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ hasAxisBrushed: function() {
|
|
|
+ for (var t = this.dimensions, e = this._axesMap, i = !1, n = 0, o = t.length; n < o; n++)
|
|
|
+ "normal" !== e.get(t[n]).model.getActiveState() && (i = !0);
|
|
|
+ return i
|
|
|
+ },
|
|
|
+ axisCoordToPoint: function(t, e) {
|
|
|
+ return pl([t, 0], this._axesLayout[e].transform)
|
|
|
+ },
|
|
|
+ getAxisLayout: function(t) {
|
|
|
+ return k(this._axesLayout[t])
|
|
|
+ },
|
|
|
+ getSlidedAxisExpandWindow: function(t) {
|
|
|
+ var e = this._makeLayoutInfo()
|
|
|
+ , i = e.pixelDimIndex
|
|
|
+ , n = e.axisExpandWindow.slice()
|
|
|
+ , o = n[1] - n[0]
|
|
|
+ , a = [0, e.axisExpandWidth * (e.axisCount - 1)];
|
|
|
+ if (!this.containPoint(t))
|
|
|
+ return {
|
|
|
+ behavior: "none",
|
|
|
+ axisExpandWindow: n
|
|
|
+ };
|
|
|
+ var r, s = t[i] - e.layoutBase - e.axisExpandWindow0Pos, l = "slide", u = e.axisCollapseWidth, h = this._model.get("axisExpandSlideTriggerArea"), c = null != h[0];
|
|
|
+ if (u)
|
|
|
+ c && u && s < o * h[0] ? (l = "jump",
|
|
|
+ r = s - o * h[2]) : c && u && s > o * (1 - h[0]) ? (l = "jump",
|
|
|
+ r = s - o * (1 - h[2])) : 0 <= (r = s - o * h[1]) && (r = s - o * (1 - h[1])) <= 0 && (r = 0),
|
|
|
+ (r *= e.axisExpandWidth / u) ? Jw(r, n, a, "all") : l = "none";
|
|
|
+ else {
|
|
|
+ o = n[1] - n[0];
|
|
|
+ (n = [nb(0, a[1] * s / o - o / 2)])[1] = ib(a[1], n[0] + o),
|
|
|
+ n[0] = n[1] - o
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ axisExpandWindow: n,
|
|
|
+ behavior: l
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ lh.register("parallel", {
|
|
|
+ create: function(n, o) {
|
|
|
+ var a = [];
|
|
|
+ return n.eachComponent("parallel", function(t, e) {
|
|
|
+ var i = new lb(t,n,o);
|
|
|
+ i.name = "parallel_" + e,
|
|
|
+ i.resize(t, o),
|
|
|
+ (t.coordinateSystem = i).model = t,
|
|
|
+ a.push(i)
|
|
|
+ }),
|
|
|
+ n.eachSeries(function(t) {
|
|
|
+ if ("parallel" === t.get("coordinateSystem")) {
|
|
|
+ var e = n.queryComponents({
|
|
|
+ mainType: "parallel",
|
|
|
+ index: t.get("parallelIndex"),
|
|
|
+ id: t.get("parallelId")
|
|
|
+ })[0];
|
|
|
+ t.coordinateSystem = e.coordinateSystem
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var hb = ku.extend({
|
|
|
+ type: "baseParallelAxis",
|
|
|
+ axis: null,
|
|
|
+ activeIntervals: [],
|
|
|
+ getAreaSelectStyle: function() {
|
|
|
+ return ha([["fill", "color"], ["lineWidth", "borderWidth"], ["stroke", "borderColor"], ["width", "width"], ["opacity", "opacity"]])(this.getModel("areaSelectStyle"))
|
|
|
+ },
|
|
|
+ setActiveIntervals: function(t) {
|
|
|
+ var e = this.activeIntervals = k(t);
|
|
|
+ if (e)
|
|
|
+ for (var i = e.length - 1; 0 <= i; i--)
|
|
|
+ Bl(e[i])
|
|
|
+ },
|
|
|
+ getActiveState: function(t) {
|
|
|
+ var e = this.activeIntervals;
|
|
|
+ if (!e.length)
|
|
|
+ return "normal";
|
|
|
+ if (null == t || isNaN(t))
|
|
|
+ return "inactive";
|
|
|
+ if (1 === e.length) {
|
|
|
+ var i = e[0];
|
|
|
+ if (i[0] <= t && t <= i[1])
|
|
|
+ return "active"
|
|
|
+ } else
|
|
|
+ for (var n = 0, o = e.length; n < o; n++)
|
|
|
+ if (e[n][0] <= t && t <= e[n][1])
|
|
|
+ return "active";
|
|
|
+ return "inactive"
|
|
|
+ }
|
|
|
+ });
|
|
|
+ m(hb.prototype, dg),
|
|
|
+ Gm("parallel", hb, function(t, e) {
|
|
|
+ return e.type || (e.data ? "category" : "value")
|
|
|
+ }, {
|
|
|
+ type: "value",
|
|
|
+ dim: null,
|
|
|
+ areaSelectStyle: {
|
|
|
+ width: 20,
|
|
|
+ borderWidth: 1,
|
|
|
+ borderColor: "rgba(160,197,232)",
|
|
|
+ color: "rgba(160,197,232)",
|
|
|
+ opacity: .3
|
|
|
+ },
|
|
|
+ realtime: !0,
|
|
|
+ z: 10
|
|
|
+ }),
|
|
|
+ ku.extend({
|
|
|
+ type: "parallel",
|
|
|
+ dependencies: ["parallelAxis"],
|
|
|
+ coordinateSystem: null,
|
|
|
+ dimensions: null,
|
|
|
+ parallelAxisIndex: null,
|
|
|
+ layoutMode: "box",
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 0,
|
|
|
+ left: 80,
|
|
|
+ top: 60,
|
|
|
+ right: 80,
|
|
|
+ bottom: 60,
|
|
|
+ layout: "horizontal",
|
|
|
+ axisExpandable: !1,
|
|
|
+ axisExpandCenter: null,
|
|
|
+ axisExpandCount: 0,
|
|
|
+ axisExpandWidth: 50,
|
|
|
+ axisExpandRate: 17,
|
|
|
+ axisExpandDebounce: 50,
|
|
|
+ axisExpandSlideTriggerArea: [-.15, .05, .4],
|
|
|
+ axisExpandTriggerOn: "click",
|
|
|
+ parallelAxisDefault: null
|
|
|
+ },
|
|
|
+ init: function() {
|
|
|
+ ku.prototype.init.apply(this, arguments),
|
|
|
+ this.mergeOption({})
|
|
|
+ },
|
|
|
+ mergeOption: function(t) {
|
|
|
+ var e = this.option;
|
|
|
+ t && m(e, t, !0),
|
|
|
+ this._initDimensions()
|
|
|
+ },
|
|
|
+ contains: function(t, e) {
|
|
|
+ var i = t.get("parallelIndex");
|
|
|
+ return null != i && e.getComponent("parallel", i) === this
|
|
|
+ },
|
|
|
+ setAxisExpand: function(e) {
|
|
|
+ E(["axisExpandable", "axisExpandCenter", "axisExpandCount", "axisExpandWidth", "axisExpandWindow"], function(t) {
|
|
|
+ e.hasOwnProperty(t) && (this.option[t] = e[t])
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _initDimensions: function() {
|
|
|
+ var e = this.dimensions = []
|
|
|
+ , i = this.parallelAxisIndex = [];
|
|
|
+ E(M(this.dependentModels.parallelAxis, function(t) {
|
|
|
+ return (t.get("parallelIndex") || 0) === this.componentIndex
|
|
|
+ }, this), function(t) {
|
|
|
+ e.push("dim" + t.get("dim")),
|
|
|
+ i.push(t.componentIndex)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ _f({
|
|
|
+ type: "axisAreaSelect",
|
|
|
+ event: "axisAreaSelected"
|
|
|
+ }, function(e, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "parallelAxis",
|
|
|
+ query: e
|
|
|
+ }, function(t) {
|
|
|
+ t.axis.model.setActiveIntervals(e.intervals)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ _f("parallelAxisExpand", function(e, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "parallel",
|
|
|
+ query: e
|
|
|
+ }, function(t) {
|
|
|
+ t.setAxisExpand(e)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var cb = T
|
|
|
+ , db = E
|
|
|
+ , fb = O
|
|
|
+ , pb = Math.min
|
|
|
+ , gb = Math.max
|
|
|
+ , mb = Math.pow
|
|
|
+ , vb = 1e4
|
|
|
+ , yb = 6
|
|
|
+ , xb = 6
|
|
|
+ , _b = "globalPan"
|
|
|
+ , wb = {
|
|
|
+ w: [0, 0],
|
|
|
+ e: [0, 1],
|
|
|
+ n: [1, 0],
|
|
|
+ s: [1, 1]
|
|
|
+ }
|
|
|
+ , bb = {
|
|
|
+ w: "ew",
|
|
|
+ e: "ew",
|
|
|
+ n: "ns",
|
|
|
+ s: "ns",
|
|
|
+ ne: "nesw",
|
|
|
+ sw: "nesw",
|
|
|
+ nw: "nwse",
|
|
|
+ se: "nwse"
|
|
|
+ }
|
|
|
+ , Sb = {
|
|
|
+ brushStyle: {
|
|
|
+ lineWidth: 2,
|
|
|
+ stroke: "rgba(0,0,0,0.3)",
|
|
|
+ fill: "rgba(0,0,0,0.1)"
|
|
|
+ },
|
|
|
+ transformable: !0,
|
|
|
+ brushMode: "single",
|
|
|
+ removeOnClick: !1
|
|
|
+ }
|
|
|
+ , Mb = 0;
|
|
|
+ function Ib(t) {
|
|
|
+ Ct.call(this),
|
|
|
+ this._zr = t,
|
|
|
+ this.group = new Ci,
|
|
|
+ this._brushType,
|
|
|
+ this._brushOption,
|
|
|
+ this._panels,
|
|
|
+ this._track = [],
|
|
|
+ this._dragging,
|
|
|
+ this._covers = [],
|
|
|
+ this._creatingCover,
|
|
|
+ this._creatingPanel,
|
|
|
+ this._enableGlobalPan,
|
|
|
+ this._uid = "brushController_" + Mb++,
|
|
|
+ this._handlers = {},
|
|
|
+ db($b, function(t, e) {
|
|
|
+ this._handlers[e] = A(t, this)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ function Tb(t, e) {
|
|
|
+ var i = Qb[e.brushType].createCover(t, e);
|
|
|
+ return i.__brushOption = e,
|
|
|
+ Cb(i, e),
|
|
|
+ t.group.add(i),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function Ab(t, e) {
|
|
|
+ var i = kb(e);
|
|
|
+ return i.endCreating && (i.endCreating(t, e),
|
|
|
+ Cb(e, e.__brushOption)),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function Db(t, e) {
|
|
|
+ var i = e.__brushOption;
|
|
|
+ kb(e).updateCoverShape(t, e, i.range, i)
|
|
|
+ }
|
|
|
+ function Cb(t, e) {
|
|
|
+ var i = e.z;
|
|
|
+ null == i && (i = vb),
|
|
|
+ t.traverse(function(t) {
|
|
|
+ t.z = i,
|
|
|
+ t.z2 = i
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Lb(t, e) {
|
|
|
+ kb(e).updateCommon(t, e),
|
|
|
+ Db(t, e)
|
|
|
+ }
|
|
|
+ function kb(t) {
|
|
|
+ return Qb[t.__brushOption.brushType]
|
|
|
+ }
|
|
|
+ function Pb(t, e, i) {
|
|
|
+ var n, o = t._panels;
|
|
|
+ if (!o)
|
|
|
+ return !0;
|
|
|
+ var a = t._transform;
|
|
|
+ return db(o, function(t) {
|
|
|
+ t.isTargetByCursor(e, i, a) && (n = t)
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ function Nb(t, e) {
|
|
|
+ var i = t._panels;
|
|
|
+ if (!i)
|
|
|
+ return !0;
|
|
|
+ var n = e.__brushOption.panelId;
|
|
|
+ return null == n || i[n]
|
|
|
+ }
|
|
|
+ function Ob(e) {
|
|
|
+ var t = e._covers
|
|
|
+ , i = t.length;
|
|
|
+ return db(t, function(t) {
|
|
|
+ e.group.remove(t)
|
|
|
+ }, e),
|
|
|
+ t.length = 0,
|
|
|
+ !!i
|
|
|
+ }
|
|
|
+ function Eb(t, e) {
|
|
|
+ var i = fb(t._covers, function(t) {
|
|
|
+ var e = t.__brushOption
|
|
|
+ , i = k(e.range);
|
|
|
+ return {
|
|
|
+ brushType: e.brushType,
|
|
|
+ panelId: e.panelId,
|
|
|
+ range: i
|
|
|
+ }
|
|
|
+ });
|
|
|
+ t.trigger("brush", i, {
|
|
|
+ isEnd: !!e.isEnd,
|
|
|
+ removeOnClick: !!e.removeOnClick
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Rb(t) {
|
|
|
+ var e = t.length - 1;
|
|
|
+ return e < 0 && (e = 0),
|
|
|
+ [t[0], t[e]]
|
|
|
+ }
|
|
|
+ function zb(e, i, t, n) {
|
|
|
+ var o = new Ci;
|
|
|
+ return o.add(new rs({
|
|
|
+ name: "main",
|
|
|
+ style: Fb(t),
|
|
|
+ silent: !0,
|
|
|
+ draggable: !0,
|
|
|
+ cursor: "move",
|
|
|
+ drift: cb(e, i, o, "nswe"),
|
|
|
+ ondragend: cb(Eb, i, {
|
|
|
+ isEnd: !0
|
|
|
+ })
|
|
|
+ })),
|
|
|
+ db(n, function(t) {
|
|
|
+ o.add(new rs({
|
|
|
+ name: t,
|
|
|
+ style: {
|
|
|
+ opacity: 0
|
|
|
+ },
|
|
|
+ draggable: !0,
|
|
|
+ silent: !0,
|
|
|
+ invisible: !0,
|
|
|
+ drift: cb(e, i, o, t),
|
|
|
+ ondragend: cb(Eb, i, {
|
|
|
+ isEnd: !0
|
|
|
+ })
|
|
|
+ }))
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ function Bb(t, e, i, n) {
|
|
|
+ var o = n.brushStyle.lineWidth || 0
|
|
|
+ , a = gb(o, xb)
|
|
|
+ , r = i[0][0]
|
|
|
+ , s = i[1][0]
|
|
|
+ , l = r - o / 2
|
|
|
+ , u = s - o / 2
|
|
|
+ , h = i[0][1]
|
|
|
+ , c = i[1][1]
|
|
|
+ , d = h - a + o / 2
|
|
|
+ , f = c - a + o / 2
|
|
|
+ , p = h - r
|
|
|
+ , g = c - s
|
|
|
+ , m = p + o
|
|
|
+ , v = g + o;
|
|
|
+ Gb(t, e, "main", r, s, p, g),
|
|
|
+ n.transformable && (Gb(t, e, "w", l, u, a, v),
|
|
|
+ Gb(t, e, "e", d, u, a, v),
|
|
|
+ Gb(t, e, "n", l, u, m, a),
|
|
|
+ Gb(t, e, "s", l, f, m, a),
|
|
|
+ Gb(t, e, "nw", l, u, a, a),
|
|
|
+ Gb(t, e, "ne", d, u, a, a),
|
|
|
+ Gb(t, e, "sw", l, f, a, a),
|
|
|
+ Gb(t, e, "se", d, f, a, a))
|
|
|
+ }
|
|
|
+ function Vb(n, o) {
|
|
|
+ var t = o.__brushOption
|
|
|
+ , a = t.transformable
|
|
|
+ , e = o.childAt(0);
|
|
|
+ e.useStyle(Fb(t)),
|
|
|
+ e.attr({
|
|
|
+ silent: !a,
|
|
|
+ cursor: a ? "move" : "default"
|
|
|
+ }),
|
|
|
+ db(["w", "e", "n", "s", "se", "sw", "ne", "nw"], function(t) {
|
|
|
+ var e = o.childOfName(t)
|
|
|
+ , i = function t(e, i) {
|
|
|
+ {
|
|
|
+ if (1 < i.length) {
|
|
|
+ i = i.split("");
|
|
|
+ var n = [t(e, i[0]), t(e, i[1])];
|
|
|
+ return "e" !== n[0] && "w" !== n[0] || n.reverse(),
|
|
|
+ n.join("")
|
|
|
+ }
|
|
|
+ var o = {
|
|
|
+ w: "left",
|
|
|
+ e: "right",
|
|
|
+ n: "top",
|
|
|
+ s: "bottom"
|
|
|
+ }
|
|
|
+ , a = {
|
|
|
+ left: "w",
|
|
|
+ right: "e",
|
|
|
+ top: "n",
|
|
|
+ bottom: "s"
|
|
|
+ }
|
|
|
+ , n = gl(o[i], fl(e.group));
|
|
|
+ return a[n]
|
|
|
+ }
|
|
|
+ }(n, t);
|
|
|
+ e && e.attr({
|
|
|
+ silent: !a,
|
|
|
+ invisible: !a,
|
|
|
+ cursor: a ? bb[i] + "-resize" : null
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Gb(t, e, i, n, o, a, r) {
|
|
|
+ var s = e.childOfName(i);
|
|
|
+ s && s.setShape(function(t) {
|
|
|
+ var e = pb(t[0][0], t[1][0])
|
|
|
+ , i = pb(t[0][1], t[1][1])
|
|
|
+ , n = gb(t[0][0], t[1][0])
|
|
|
+ , o = gb(t[0][1], t[1][1]);
|
|
|
+ return {
|
|
|
+ x: e,
|
|
|
+ y: i,
|
|
|
+ width: n - e,
|
|
|
+ height: o - i
|
|
|
+ }
|
|
|
+ }(Xb(t, e, [[n, o], [n + a, o + r]])))
|
|
|
+ }
|
|
|
+ function Fb(t) {
|
|
|
+ return D({
|
|
|
+ strokeNoScale: !0
|
|
|
+ }, t.brushStyle)
|
|
|
+ }
|
|
|
+ function Wb(t, e, i, n) {
|
|
|
+ var o = [pb(t, i), pb(e, n)]
|
|
|
+ , a = [gb(t, i), gb(e, n)];
|
|
|
+ return [[o[0], a[0]], [o[1], a[1]]]
|
|
|
+ }
|
|
|
+ function Hb(t, e, i, n, o, a, r, s) {
|
|
|
+ var l = n.__brushOption
|
|
|
+ , u = t(l.range)
|
|
|
+ , h = Ub(i, a, r);
|
|
|
+ db(o.split(""), function(t) {
|
|
|
+ var e = wb[t];
|
|
|
+ u[e[0]][e[1]] += h[e[0]]
|
|
|
+ }),
|
|
|
+ l.range = e(Wb(u[0][0], u[1][0], u[0][1], u[1][1])),
|
|
|
+ Lb(i, n),
|
|
|
+ Eb(i, {
|
|
|
+ isEnd: !1
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Zb(t, e, i, n, o) {
|
|
|
+ var a = e.__brushOption.range
|
|
|
+ , r = Ub(t, i, n);
|
|
|
+ db(a, function(t) {
|
|
|
+ t[0] += r[0],
|
|
|
+ t[1] += r[1]
|
|
|
+ }),
|
|
|
+ Lb(t, e),
|
|
|
+ Eb(t, {
|
|
|
+ isEnd: !1
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function Ub(t, e, i) {
|
|
|
+ var n = t.group
|
|
|
+ , o = n.transformCoordToLocal(e, i)
|
|
|
+ , a = n.transformCoordToLocal(0, 0);
|
|
|
+ return [o[0] - a[0], o[1] - a[1]]
|
|
|
+ }
|
|
|
+ function Xb(t, e, i) {
|
|
|
+ var n = Nb(t, e);
|
|
|
+ return n && !0 !== n ? n.clipPath(i, t._transform) : k(i)
|
|
|
+ }
|
|
|
+ function Yb(t) {
|
|
|
+ var e = t.event;
|
|
|
+ e.preventDefault && e.preventDefault()
|
|
|
+ }
|
|
|
+ function jb(t, e, i) {
|
|
|
+ return t.childOfName("main").contain(e, i)
|
|
|
+ }
|
|
|
+ function qb(t, e, i, n) {
|
|
|
+ var o, a = t._creatingCover, r = t._creatingPanel, s = t._brushOption;
|
|
|
+ if (t._track.push(i.slice()),
|
|
|
+ function(t) {
|
|
|
+ var e = t._track;
|
|
|
+ if (!e.length)
|
|
|
+ return !1;
|
|
|
+ var i = e[e.length - 1]
|
|
|
+ , n = e[0]
|
|
|
+ , o = i[0] - n[0]
|
|
|
+ , a = i[1] - n[1]
|
|
|
+ , r = mb(o * o + a * a, .5);
|
|
|
+ return yb < r
|
|
|
+ }(t) || a) {
|
|
|
+ if (r && !a) {
|
|
|
+ "single" === s.brushMode && Ob(t);
|
|
|
+ var l = k(s);
|
|
|
+ l.brushType = Kb(l.brushType, r),
|
|
|
+ l.panelId = !0 === r ? null : r.panelId,
|
|
|
+ a = t._creatingCover = Tb(t, l),
|
|
|
+ t._covers.push(a)
|
|
|
+ }
|
|
|
+ if (a) {
|
|
|
+ var u = Qb[Kb(t._brushType, r)];
|
|
|
+ a.__brushOption.range = u.getCreatingRange(Xb(t, a, t._track)),
|
|
|
+ n && (Ab(t, a),
|
|
|
+ u.updateCommon(t, a)),
|
|
|
+ Db(t, a),
|
|
|
+ o = {
|
|
|
+ isEnd: n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ n && "single" === s.brushMode && s.removeOnClick && Pb(t, e, i) && Ob(t) && (o = {
|
|
|
+ isEnd: n,
|
|
|
+ removeOnClick: !0
|
|
|
+ });
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ function Kb(t, e) {
|
|
|
+ return "auto" === t ? e.defaultBrushType : t
|
|
|
+ }
|
|
|
+ Ib.prototype = {
|
|
|
+ constructor: Ib,
|
|
|
+ enableBrush: function(t) {
|
|
|
+ return this._brushType && function(t) {
|
|
|
+ var e = t._zr;
|
|
|
+ (function(t, e, i) {
|
|
|
+ var n = By(t);
|
|
|
+ n[e] === i && (n[e] = null)
|
|
|
+ }
|
|
|
+ )(e, _b, t._uid),
|
|
|
+ function(i, t) {
|
|
|
+ db(t, function(t, e) {
|
|
|
+ i.off(e, t)
|
|
|
+ })
|
|
|
+ }(e, t._handlers),
|
|
|
+ t._brushType = t._brushOption = null
|
|
|
+ }(this),
|
|
|
+ t.brushType && function(t, e) {
|
|
|
+ var i = t._zr;
|
|
|
+ t._enableGlobalPan || function(t, e, i) {
|
|
|
+ By(t)[e] = i
|
|
|
+ }(i, _b, t._uid);
|
|
|
+ (function(i, t) {
|
|
|
+ db(t, function(t, e) {
|
|
|
+ i.on(e, t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ )(i, t._handlers),
|
|
|
+ t._brushType = e.brushType,
|
|
|
+ t._brushOption = m(k(Sb), e, !0)
|
|
|
+ }(this, t),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ setPanels: function(t) {
|
|
|
+ if (t && t.length) {
|
|
|
+ var e = this._panels = {};
|
|
|
+ E(t, function(t) {
|
|
|
+ e[t.panelId] = k(t)
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ this._panels = null;
|
|
|
+ return this
|
|
|
+ },
|
|
|
+ mount: function(t) {
|
|
|
+ t = t || {},
|
|
|
+ this._enableGlobalPan = t.enableGlobalPan;
|
|
|
+ var e = this.group;
|
|
|
+ return this._zr.add(e),
|
|
|
+ e.attr({
|
|
|
+ position: t.position || [0, 0],
|
|
|
+ rotation: t.rotation || 0,
|
|
|
+ scale: t.scale || [1, 1]
|
|
|
+ }),
|
|
|
+ this._transform = e.getLocalTransform(),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ eachCover: function(t, e) {
|
|
|
+ db(this._covers, t, e)
|
|
|
+ },
|
|
|
+ updateCovers: function(o) {
|
|
|
+ o = O(o, function(t) {
|
|
|
+ return m(k(Sb), t, !0)
|
|
|
+ });
|
|
|
+ var i = "\0-brush-index-"
|
|
|
+ , a = this._covers
|
|
|
+ , r = this._covers = []
|
|
|
+ , s = this
|
|
|
+ , l = this._creatingCover;
|
|
|
+ return new kf(a,o,function(t, e) {
|
|
|
+ return n(t.__brushOption, e)
|
|
|
+ }
|
|
|
+ ,n).add(t).update(t).remove(function(t) {
|
|
|
+ a[t] !== l && s.group.remove(a[t])
|
|
|
+ }).execute(),
|
|
|
+ this;
|
|
|
+ function n(t, e) {
|
|
|
+ return (null != t.id ? t.id : i + e) + "-" + t.brushType
|
|
|
+ }
|
|
|
+ function t(t, e) {
|
|
|
+ var i = o[t];
|
|
|
+ if (null != e && a[e] === l)
|
|
|
+ r[t] = a[e];
|
|
|
+ else {
|
|
|
+ var n = r[t] = null != e ? (a[e].__brushOption = i,
|
|
|
+ a[e]) : Ab(s, Tb(s, i));
|
|
|
+ Lb(s, n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ unmount: function() {
|
|
|
+ return this.enableBrush(!1),
|
|
|
+ Ob(this),
|
|
|
+ this._zr.remove(this.group),
|
|
|
+ this
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this.unmount(),
|
|
|
+ this.off()
|
|
|
+ }
|
|
|
+ },
|
|
|
+ b(Ib, Ct);
|
|
|
+ var $b = {
|
|
|
+ mousedown: function(t) {
|
|
|
+ if (this._dragging)
|
|
|
+ Jb(this, t);
|
|
|
+ else if (!t.target || !t.target.draggable) {
|
|
|
+ Yb(t);
|
|
|
+ var e = this.group.transformCoordToLocal(t.offsetX, t.offsetY);
|
|
|
+ this._creatingCover = null,
|
|
|
+ (this._creatingPanel = Pb(this, t, e)) && (this._dragging = !0,
|
|
|
+ this._track = [e.slice()])
|
|
|
+ }
|
|
|
+ },
|
|
|
+ mousemove: function(t) {
|
|
|
+ var e = t.offsetX
|
|
|
+ , i = t.offsetY
|
|
|
+ , n = this.group.transformCoordToLocal(e, i);
|
|
|
+ if (function(t, e, i) {
|
|
|
+ if (t._brushType && !function(t, e, i) {
|
|
|
+ var n = t._zr;
|
|
|
+ return e < 0 || e > n.getWidth() || i < 0 || i > n.getHeight()
|
|
|
+ }(t, e)) {
|
|
|
+ var n = t._zr
|
|
|
+ , o = t._covers
|
|
|
+ , a = Pb(t, e, i);
|
|
|
+ if (!t._dragging)
|
|
|
+ for (var r = 0; r < o.length; r++) {
|
|
|
+ var s = o[r].__brushOption;
|
|
|
+ if (a && (!0 === a || s.panelId === a.panelId) && Qb[s.brushType].contain(o[r], i[0], i[1]))
|
|
|
+ return
|
|
|
+ }
|
|
|
+ a && n.setCursorStyle("crosshair")
|
|
|
+ }
|
|
|
+ }(this, t, n),
|
|
|
+ this._dragging) {
|
|
|
+ Yb(t);
|
|
|
+ var o = qb(this, t, n, !1);
|
|
|
+ o && Eb(this, o)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ mouseup: function(t) {
|
|
|
+ Jb(this, t)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function Jb(t, e) {
|
|
|
+ if (t._dragging) {
|
|
|
+ Yb(e);
|
|
|
+ var i = e.offsetX
|
|
|
+ , n = e.offsetY
|
|
|
+ , o = t.group.transformCoordToLocal(i, n)
|
|
|
+ , a = qb(t, e, o, !0);
|
|
|
+ t._dragging = !1,
|
|
|
+ t._track = [],
|
|
|
+ t._creatingCover = null,
|
|
|
+ a && Eb(t, a)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var Qb = {
|
|
|
+ lineX: tS(0),
|
|
|
+ lineY: tS(1),
|
|
|
+ rect: {
|
|
|
+ createCover: function(t, e) {
|
|
|
+ return zb(cb(Hb, function(t) {
|
|
|
+ return t
|
|
|
+ }, function(t) {
|
|
|
+ return t
|
|
|
+ }), t, e, ["w", "e", "n", "s", "se", "sw", "ne", "nw"])
|
|
|
+ },
|
|
|
+ getCreatingRange: function(t) {
|
|
|
+ var e = Rb(t);
|
|
|
+ return Wb(e[1][0], e[1][1], e[0][0], e[0][1])
|
|
|
+ },
|
|
|
+ updateCoverShape: function(t, e, i, n) {
|
|
|
+ Bb(t, e, i, n)
|
|
|
+ },
|
|
|
+ updateCommon: Vb,
|
|
|
+ contain: jb
|
|
|
+ },
|
|
|
+ polygon: {
|
|
|
+ createCover: function(t, e) {
|
|
|
+ var i = new Ci;
|
|
|
+ return i.add(new ts({
|
|
|
+ name: "main",
|
|
|
+ style: Fb(e),
|
|
|
+ silent: !0
|
|
|
+ })),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ getCreatingRange: function(t) {
|
|
|
+ return t
|
|
|
+ },
|
|
|
+ endCreating: function(t, e) {
|
|
|
+ e.remove(e.childAt(0)),
|
|
|
+ e.add(new Qr({
|
|
|
+ name: "main",
|
|
|
+ draggable: !0,
|
|
|
+ drift: cb(Zb, t, e),
|
|
|
+ ondragend: cb(Eb, t, {
|
|
|
+ isEnd: !0
|
|
|
+ })
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ updateCoverShape: function(t, e, i, n) {
|
|
|
+ e.childAt(0).setShape({
|
|
|
+ points: Xb(t, e, i)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ updateCommon: Vb,
|
|
|
+ contain: jb
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function tS(l) {
|
|
|
+ return {
|
|
|
+ createCover: function(t, e) {
|
|
|
+ return zb(cb(Hb, function(t) {
|
|
|
+ var e = [t, [0, 100]];
|
|
|
+ return l && e.reverse(),
|
|
|
+ e
|
|
|
+ }, function(t) {
|
|
|
+ return t[l]
|
|
|
+ }), t, e, [["w", "e"], ["n", "s"]][l])
|
|
|
+ },
|
|
|
+ getCreatingRange: function(t) {
|
|
|
+ var e = Rb(t);
|
|
|
+ return [pb(e[0][l], e[1][l]), gb(e[0][l], e[1][l])]
|
|
|
+ },
|
|
|
+ updateCoverShape: function(t, e, i, n) {
|
|
|
+ var o, a = Nb(t, e);
|
|
|
+ if (!0 !== a && a.getLinearBrushOtherExtent)
|
|
|
+ o = a.getLinearBrushOtherExtent(l, t._transform);
|
|
|
+ else {
|
|
|
+ var r = t._zr;
|
|
|
+ o = [0, [r.getWidth(), r.getHeight()][1 - l]]
|
|
|
+ }
|
|
|
+ var s = [i, o];
|
|
|
+ l && s.reverse(),
|
|
|
+ Bb(t, e, s, n)
|
|
|
+ },
|
|
|
+ updateCommon: Vb,
|
|
|
+ contain: jb
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function eS(i) {
|
|
|
+ return i = oS(i),
|
|
|
+ function(t, e) {
|
|
|
+ return vl(t, i)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function iS(o, a) {
|
|
|
+ return o = oS(o),
|
|
|
+ function(t) {
|
|
|
+ var e = null != a ? a : t
|
|
|
+ , i = e ? o.width : o.height
|
|
|
+ , n = e ? o.x : o.y;
|
|
|
+ return [n, n + (i || 0)]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function nS(n, o, a) {
|
|
|
+ return n = oS(n),
|
|
|
+ function(t, e, i) {
|
|
|
+ return n.contain(e[0], e[1]) && !$y(t, o, a)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function oS(t) {
|
|
|
+ return Di.create(t)
|
|
|
+ }
|
|
|
+ var aS = ["axisLine", "axisTickLabel", "axisName"]
|
|
|
+ , rS = Af({
|
|
|
+ type: "parallelAxis",
|
|
|
+ init: function(t, e) {
|
|
|
+ rS.superApply(this, "init", arguments),
|
|
|
+ (this._brushController = new Ib(e.getZr())).on("brush", A(this._onBrush, this))
|
|
|
+ },
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ if (!function(t, e, i) {
|
|
|
+ return i && "axisAreaSelect" === i.type && e.findComponents({
|
|
|
+ mainType: "parallelAxis",
|
|
|
+ query: i
|
|
|
+ })[0] === t
|
|
|
+ }(t, e, n)) {
|
|
|
+ this.axisModel = t,
|
|
|
+ this.api = i,
|
|
|
+ this.group.removeAll();
|
|
|
+ var o = this._axisGroup;
|
|
|
+ if (this._axisGroup = new Ci,
|
|
|
+ this.group.add(this._axisGroup),
|
|
|
+ t.get("show")) {
|
|
|
+ var a = function(t, e) {
|
|
|
+ return e.getComponent("parallel", t.get("parallelIndex"))
|
|
|
+ }(t, e)
|
|
|
+ , r = a.coordinateSystem
|
|
|
+ , s = t.getAreaSelectStyle()
|
|
|
+ , l = s.width
|
|
|
+ , u = t.axis.dim
|
|
|
+ , h = P({
|
|
|
+ strokeContainThreshold: l
|
|
|
+ }, r.getAxisLayout(u))
|
|
|
+ , c = new Qm(t,h);
|
|
|
+ E(aS, c.add, c),
|
|
|
+ this._axisGroup.add(c.getGroup()),
|
|
|
+ this._refreshBrushController(h, s, t, a, l, i);
|
|
|
+ var d = n && !1 === n.animation ? null : t;
|
|
|
+ ml(o, this._axisGroup, d)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _refreshBrushController: function(t, e, i, n, o, a) {
|
|
|
+ var r = i.axis.getExtent()
|
|
|
+ , s = r[1] - r[0]
|
|
|
+ , l = Math.min(30, .1 * Math.abs(s))
|
|
|
+ , u = Di.create({
|
|
|
+ x: r[0],
|
|
|
+ y: -o / 2,
|
|
|
+ width: s,
|
|
|
+ height: o
|
|
|
+ });
|
|
|
+ u.x -= l,
|
|
|
+ u.width += 2 * l,
|
|
|
+ this._brushController.mount({
|
|
|
+ enableGlobalPan: !0,
|
|
|
+ rotation: t.rotation,
|
|
|
+ position: t.position
|
|
|
+ }).setPanels([{
|
|
|
+ panelId: "pl",
|
|
|
+ clipPath: eS(u),
|
|
|
+ isTargetByCursor: nS(u, a, n),
|
|
|
+ getLinearBrushOtherExtent: iS(u, 0)
|
|
|
+ }]).enableBrush({
|
|
|
+ brushType: "lineX",
|
|
|
+ brushStyle: e,
|
|
|
+ removeOnClick: !0
|
|
|
+ }).updateCovers(function(t) {
|
|
|
+ var e = t.axis;
|
|
|
+ return O(t.activeIntervals, function(t) {
|
|
|
+ return {
|
|
|
+ brushType: "lineX",
|
|
|
+ panelId: "pl",
|
|
|
+ range: [e.dataToCoord(t[0], !0), e.dataToCoord(t[1], !0)]
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }(i))
|
|
|
+ },
|
|
|
+ _onBrush: function(t, e) {
|
|
|
+ var i = this.axisModel
|
|
|
+ , n = i.axis
|
|
|
+ , o = O(t, function(t) {
|
|
|
+ return [n.coordToData(t.range[0], !0), n.coordToData(t.range[1], !0)]
|
|
|
+ });
|
|
|
+ !i.option.realtime !== e.isEnd && !e.removeOnClick || this.api.dispatchAction({
|
|
|
+ type: "axisAreaSelect",
|
|
|
+ parallelAxisId: i.id,
|
|
|
+ intervals: o
|
|
|
+ })
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._brushController.dispose()
|
|
|
+ }
|
|
|
+ });
|
|
|
+ Af({
|
|
|
+ type: "parallel",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ this._model = t,
|
|
|
+ this._api = i,
|
|
|
+ this._handlers || (this._handlers = {},
|
|
|
+ E(sS, function(t, e) {
|
|
|
+ i.getZr().on(e, this._handlers[e] = A(t, this))
|
|
|
+ }, this)),
|
|
|
+ kc(this, "_throttledDispatchExpand", t.get("axisExpandRate"), "fixRate")
|
|
|
+ },
|
|
|
+ dispose: function(t, i) {
|
|
|
+ E(this._handlers, function(t, e) {
|
|
|
+ i.getZr().off(e, t)
|
|
|
+ }),
|
|
|
+ this._handlers = null
|
|
|
+ },
|
|
|
+ _throttledDispatchExpand: function(t) {
|
|
|
+ this._dispatchExpand(t)
|
|
|
+ },
|
|
|
+ _dispatchExpand: function(t) {
|
|
|
+ t && this._api.dispatchAction(P({
|
|
|
+ type: "parallelAxisExpand"
|
|
|
+ }, t))
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var sS = {
|
|
|
+ mousedown: function(t) {
|
|
|
+ lS(this, "click") && (this._mouseDownPoint = [t.offsetX, t.offsetY])
|
|
|
+ },
|
|
|
+ mouseup: function(t) {
|
|
|
+ var e = this._mouseDownPoint;
|
|
|
+ if (lS(this, "click") && e) {
|
|
|
+ var i = [t.offsetX, t.offsetY];
|
|
|
+ if (5 < Math.pow(e[0] - i[0], 2) + Math.pow(e[1] - i[1], 2))
|
|
|
+ return;
|
|
|
+ var n = this._model.coordinateSystem.getSlidedAxisExpandWindow([t.offsetX, t.offsetY]);
|
|
|
+ "none" !== n.behavior && this._dispatchExpand({
|
|
|
+ axisExpandWindow: n.axisExpandWindow
|
|
|
+ })
|
|
|
+ }
|
|
|
+ this._mouseDownPoint = null
|
|
|
+ },
|
|
|
+ mousemove: function(t) {
|
|
|
+ if (!this._mouseDownPoint && lS(this, "mousemove")) {
|
|
|
+ var e = this._model
|
|
|
+ , i = e.coordinateSystem.getSlidedAxisExpandWindow([t.offsetX, t.offsetY])
|
|
|
+ , n = i.behavior;
|
|
|
+ "jump" === n && this._throttledDispatchExpand.debounceNextCall(e.get("axisExpandDebounce")),
|
|
|
+ this._throttledDispatchExpand("none" === n ? null : {
|
|
|
+ axisExpandWindow: i.axisExpandWindow,
|
|
|
+ animation: "jump" === n && null
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function lS(t, e) {
|
|
|
+ var i = t._model;
|
|
|
+ return i.get("axisExpandable") && i.get("axisExpandTriggerOn") === e
|
|
|
+ }
|
|
|
+ yf(function(t) {
|
|
|
+ !function(t) {
|
|
|
+ if (t.parallel)
|
|
|
+ return;
|
|
|
+ var e = !1;
|
|
|
+ E(t.series, function(t) {
|
|
|
+ t && "parallel" === t.type && (e = !0)
|
|
|
+ }),
|
|
|
+ e && (t.parallel = [{}])
|
|
|
+ }(t),
|
|
|
+ function(n) {
|
|
|
+ E(Vo(n.parallelAxis), function(t) {
|
|
|
+ if (z(t)) {
|
|
|
+ var e = t.parallelIndex || 0
|
|
|
+ , i = Vo(n.parallel)[e];
|
|
|
+ i && i.parallelAxisDefault && m(t, i.parallelAxisDefault, !1)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }(t)
|
|
|
+ }),
|
|
|
+ sc.extend({
|
|
|
+ type: "series.parallel",
|
|
|
+ dependencies: ["parallel"],
|
|
|
+ visualColorAccessPath: "lineStyle.color",
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ var i = this.getSource();
|
|
|
+ return function(t, e) {
|
|
|
+ if (t.encodeDefine)
|
|
|
+ return;
|
|
|
+ var i = e.ecModel.getComponent("parallel", e.get("parallelIndex"));
|
|
|
+ if (!i)
|
|
|
+ return;
|
|
|
+ var n = t.encodeDefine = Q();
|
|
|
+ E(i.dimensions, function(t) {
|
|
|
+ var e = function(t) {
|
|
|
+ return +t.replace("dim", "")
|
|
|
+ }(t);
|
|
|
+ n.set(t, e)
|
|
|
+ })
|
|
|
+ }(i, this),
|
|
|
+ gp(i, this)
|
|
|
+ },
|
|
|
+ getRawIndicesByActiveState: function(i) {
|
|
|
+ var t = this.coordinateSystem
|
|
|
+ , n = this.getData()
|
|
|
+ , o = [];
|
|
|
+ return t.eachActiveState(n, function(t, e) {
|
|
|
+ i === t && o.push(n.getRawIndex(e))
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "parallel",
|
|
|
+ parallelIndex: 0,
|
|
|
+ label: {
|
|
|
+ show: !1
|
|
|
+ },
|
|
|
+ inactiveOpacity: .05,
|
|
|
+ activeOpacity: 1,
|
|
|
+ lineStyle: {
|
|
|
+ width: 1,
|
|
|
+ opacity: .45,
|
|
|
+ type: "solid"
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !1
|
|
|
+ }
|
|
|
+ },
|
|
|
+ progressive: 500,
|
|
|
+ smooth: !1,
|
|
|
+ animationEasing: "linear"
|
|
|
+ }
|
|
|
+ });
|
|
|
+ _c.extend({
|
|
|
+ type: "parallel",
|
|
|
+ init: function() {
|
|
|
+ this._dataGroup = new Ci,
|
|
|
+ this.group.add(this._dataGroup),
|
|
|
+ this._data,
|
|
|
+ this._initialized
|
|
|
+ },
|
|
|
+ render: function(a, t, e, r) {
|
|
|
+ var i = this._dataGroup
|
|
|
+ , s = a.getData()
|
|
|
+ , l = this._data
|
|
|
+ , u = a.coordinateSystem
|
|
|
+ , h = u.dimensions
|
|
|
+ , c = cS(a);
|
|
|
+ if (s.diff(l).add(function(t) {
|
|
|
+ dS(hS(s, i, t, h, u), s, t, c)
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = l.getItemGraphicEl(e)
|
|
|
+ , n = uS(s, t, h, u);
|
|
|
+ s.setItemGraphicEl(t, i);
|
|
|
+ var o = r && !1 === r.animation ? null : a;
|
|
|
+ cl(i, {
|
|
|
+ shape: {
|
|
|
+ points: n
|
|
|
+ }
|
|
|
+ }, o, t),
|
|
|
+ dS(i, s, t, c)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = l.getItemGraphicEl(t);
|
|
|
+ i.remove(e)
|
|
|
+ }).execute(),
|
|
|
+ !this._initialized) {
|
|
|
+ this._initialized = !0;
|
|
|
+ var n = function(t, e, i) {
|
|
|
+ var n = t.model
|
|
|
+ , o = t.getRect()
|
|
|
+ , a = new rs({
|
|
|
+ shape: {
|
|
|
+ x: o.x,
|
|
|
+ y: o.y,
|
|
|
+ width: o.width,
|
|
|
+ height: o.height
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , r = "horizontal" === n.get("layout") ? "width" : "height";
|
|
|
+ return a.setShape(r, 0),
|
|
|
+ dl(a, {
|
|
|
+ shape: {
|
|
|
+ width: o.width,
|
|
|
+ height: o.height
|
|
|
+ }
|
|
|
+ }, e, i),
|
|
|
+ a
|
|
|
+ }(u, a, function() {
|
|
|
+ setTimeout(function() {
|
|
|
+ i.removeClipPath()
|
|
|
+ })
|
|
|
+ });
|
|
|
+ i.setClipPath(n)
|
|
|
+ }
|
|
|
+ this._data = s
|
|
|
+ },
|
|
|
+ incrementalPrepareRender: function(t, e, i) {
|
|
|
+ this._initialized = !0,
|
|
|
+ this._data = null,
|
|
|
+ this._dataGroup.removeAll()
|
|
|
+ },
|
|
|
+ incrementalRender: function(t, e, i) {
|
|
|
+ for (var n = e.getData(), o = e.coordinateSystem, a = o.dimensions, r = cS(e), s = t.start; s < t.end; s++) {
|
|
|
+ var l = hS(n, this._dataGroup, s, a, o);
|
|
|
+ l.incremental = !0,
|
|
|
+ dS(l, n, s, r)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dispose: function() {},
|
|
|
+ remove: function() {
|
|
|
+ this._dataGroup && this._dataGroup.removeAll(),
|
|
|
+ this._data = null
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function uS(t, e, i, n) {
|
|
|
+ for (var o, a = [], r = 0; r < i.length; r++) {
|
|
|
+ var s = i[r]
|
|
|
+ , l = t.get(t.mapDimension(s), e);
|
|
|
+ o = l,
|
|
|
+ ("category" === n.getAxis(s).type ? null == o : null == o || isNaN(o)) || a.push(n.dataToPoint(l, s))
|
|
|
+ }
|
|
|
+ return a
|
|
|
+ }
|
|
|
+ function hS(t, e, i, n, o) {
|
|
|
+ var a = uS(t, i, n, o)
|
|
|
+ , r = new ts({
|
|
|
+ shape: {
|
|
|
+ points: a
|
|
|
+ },
|
|
|
+ silent: !0,
|
|
|
+ z2: 10
|
|
|
+ });
|
|
|
+ return e.add(r),
|
|
|
+ t.setItemGraphicEl(i, r),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ function cS(t) {
|
|
|
+ var e = t.get("smooth", !0);
|
|
|
+ return !0 === e && (e = .3),
|
|
|
+ {
|
|
|
+ lineStyle: t.getModel("lineStyle").getLineStyle(),
|
|
|
+ smooth: null != e ? e : .3
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function dS(t, e, i, n) {
|
|
|
+ var o = n.lineStyle;
|
|
|
+ e.hasItemOption && (o = e.getItemModel(i).getModel("lineStyle").getLineStyle());
|
|
|
+ t.useStyle(o);
|
|
|
+ var a = t.style;
|
|
|
+ a.fill = null,
|
|
|
+ a.stroke = e.getItemVisual(i, "color"),
|
|
|
+ a.opacity = e.getItemVisual(i, "opacity"),
|
|
|
+ n.smooth && (t.shape.smooth = n.smooth)
|
|
|
+ }
|
|
|
+ var fS = ["lineStyle", "normal", "opacity"];
|
|
|
+ Sf({
|
|
|
+ seriesType: "parallel",
|
|
|
+ reset: function(t, e, i) {
|
|
|
+ var n = t.getModel("itemStyle")
|
|
|
+ , o = t.getModel("lineStyle")
|
|
|
+ , a = e.get("color")
|
|
|
+ , r = o.get("color") || n.get("color") || a[t.seriesIndex % a.length]
|
|
|
+ , s = t.get("inactiveOpacity")
|
|
|
+ , l = t.get("activeOpacity")
|
|
|
+ , u = t.getModel("lineStyle").getLineStyle()
|
|
|
+ , h = t.coordinateSystem
|
|
|
+ , c = t.getData()
|
|
|
+ , d = {
|
|
|
+ normal: u.opacity,
|
|
|
+ active: l,
|
|
|
+ inactive: s
|
|
|
+ };
|
|
|
+ return c.setVisual("color", r),
|
|
|
+ {
|
|
|
+ progress: function(t, o) {
|
|
|
+ h.eachActiveState(o, function(t, e) {
|
|
|
+ var i = d[t];
|
|
|
+ if ("normal" === t && o.hasItemOption) {
|
|
|
+ var n = o.getItemModel(e).get(fS, !0);
|
|
|
+ null != n && (i = n)
|
|
|
+ }
|
|
|
+ o.setItemVisual(e, "opacity", i)
|
|
|
+ }, t.start, t.end)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var pS = sc.extend({
|
|
|
+ type: "series.sankey",
|
|
|
+ layoutInfo: null,
|
|
|
+ levelModels: null,
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ for (var i = t.edges || t.links, n = t.data || t.nodes, o = t.levels, a = this.levelModels = {}, r = 0; r < o.length; r++)
|
|
|
+ null != o[r].depth && 0 <= o[r].depth && (a[o[r].depth] = new Cl(o[r],this,e));
|
|
|
+ if (n && i)
|
|
|
+ return iw(n, i, this, !0, function(t, e) {
|
|
|
+ t.wrapMethod("getItemModel", function(t, n) {
|
|
|
+ return t.customizeGetParent(function(t) {
|
|
|
+ var e = this.parentModel
|
|
|
+ , i = e.getData().getItemLayout(n).depth;
|
|
|
+ return e.levelModels[i] || this.parentModel
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ }),
|
|
|
+ e.wrapMethod("getItemModel", function(t, n) {
|
|
|
+ return t.customizeGetParent(function(t) {
|
|
|
+ var e = this.parentModel
|
|
|
+ , i = e.getGraph().getEdgeByIndex(n).node1.getLayout().depth;
|
|
|
+ return e.levelModels[i] || this.parentModel
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ })
|
|
|
+ }).data
|
|
|
+ },
|
|
|
+ setNodePosition: function(t, e) {
|
|
|
+ var i = this.option.data[t];
|
|
|
+ i.localX = e[0],
|
|
|
+ i.localY = e[1]
|
|
|
+ },
|
|
|
+ getGraph: function() {
|
|
|
+ return this.getData().graph
|
|
|
+ },
|
|
|
+ getEdgeData: function() {
|
|
|
+ return this.getGraph().edgeData
|
|
|
+ },
|
|
|
+ formatTooltip: function(t, e, i) {
|
|
|
+ if ("edge" === i) {
|
|
|
+ var n = this.getDataParams(t, i)
|
|
|
+ , o = n.data
|
|
|
+ , a = o.source + " -- " + o.target;
|
|
|
+ return n.value && (a += " : " + n.value),
|
|
|
+ au(a)
|
|
|
+ }
|
|
|
+ if ("node" !== i)
|
|
|
+ return pS.superCall(this, "formatTooltip", t, e);
|
|
|
+ var r = this.getGraph().getNodeByIndex(t).getLayout().value
|
|
|
+ , s = this.getDataParams(t, i).data.name;
|
|
|
+ if (r)
|
|
|
+ a = s + " : " + r;
|
|
|
+ return au(a)
|
|
|
+ },
|
|
|
+ optionUpdated: function() {
|
|
|
+ var t = this.option;
|
|
|
+ !0 === t.focusNodeAdjacency && (t.focusNodeAdjacency = "allEdges")
|
|
|
+ },
|
|
|
+ getDataParams: function(t, e) {
|
|
|
+ var i = pS.superCall(this, "getDataParams", t, e);
|
|
|
+ if (null == i.value && "node" === e) {
|
|
|
+ var n = this.getGraph().getNodeByIndex(t).getLayout().value;
|
|
|
+ i.value = n
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "view",
|
|
|
+ layout: null,
|
|
|
+ left: "5%",
|
|
|
+ top: "5%",
|
|
|
+ right: "20%",
|
|
|
+ bottom: "5%",
|
|
|
+ orient: "horizontal",
|
|
|
+ nodeWidth: 20,
|
|
|
+ nodeGap: 8,
|
|
|
+ draggable: !0,
|
|
|
+ focusNodeAdjacency: !1,
|
|
|
+ layoutIterations: 32,
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ position: "right",
|
|
|
+ color: "#000",
|
|
|
+ fontSize: 12
|
|
|
+ },
|
|
|
+ levels: [],
|
|
|
+ nodeAlign: "justify",
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: 1,
|
|
|
+ borderColor: "#333"
|
|
|
+ },
|
|
|
+ lineStyle: {
|
|
|
+ color: "#314656",
|
|
|
+ opacity: .2,
|
|
|
+ curveness: .5
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0
|
|
|
+ },
|
|
|
+ lineStyle: {
|
|
|
+ opacity: .5
|
|
|
+ }
|
|
|
+ },
|
|
|
+ animationEasing: "linear",
|
|
|
+ animationDuration: 1e3
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , gS = ["itemStyle", "opacity"]
|
|
|
+ , mS = ["emphasis", "itemStyle", "opacity"]
|
|
|
+ , vS = ["lineStyle", "opacity"]
|
|
|
+ , yS = ["emphasis", "lineStyle", "opacity"];
|
|
|
+ function xS(t, e) {
|
|
|
+ return t.getVisual("opacity") || t.getModel().get(e)
|
|
|
+ }
|
|
|
+ function _S(t, e, i) {
|
|
|
+ var n = t.getGraphicEl()
|
|
|
+ , o = xS(t, e);
|
|
|
+ null != i && (null == o && (o = 1),
|
|
|
+ o *= i),
|
|
|
+ n.downplay && n.downplay(),
|
|
|
+ n.traverse(function(t) {
|
|
|
+ "group" !== t.type && t.setStyle("opacity", o)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function wS(t, e) {
|
|
|
+ var i = xS(t, e)
|
|
|
+ , n = t.getGraphicEl();
|
|
|
+ n.traverse(function(t) {
|
|
|
+ "group" !== t.type && t.setStyle("opacity", i)
|
|
|
+ }),
|
|
|
+ n.highlight && n.highlight()
|
|
|
+ }
|
|
|
+ var bS = Cs({
|
|
|
+ shape: {
|
|
|
+ x1: 0,
|
|
|
+ y1: 0,
|
|
|
+ x2: 0,
|
|
|
+ y2: 0,
|
|
|
+ cpx1: 0,
|
|
|
+ cpy1: 0,
|
|
|
+ cpx2: 0,
|
|
|
+ cpy2: 0,
|
|
|
+ extent: 0,
|
|
|
+ orient: ""
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.extent;
|
|
|
+ t.moveTo(e.x1, e.y1),
|
|
|
+ t.bezierCurveTo(e.cpx1, e.cpy1, e.cpx2, e.cpy2, e.x2, e.y2),
|
|
|
+ "vertical" === e.orient ? (t.lineTo(e.x2 + i, e.y2),
|
|
|
+ t.bezierCurveTo(e.cpx2 + i, e.cpy2, e.cpx1 + i, e.cpy1, e.x1 + i, e.y1)) : (t.lineTo(e.x2, e.y2 + i),
|
|
|
+ t.bezierCurveTo(e.cpx2, e.cpy2 + i, e.cpx1, e.cpy1 + i, e.x1, e.y1 + i)),
|
|
|
+ t.closePath()
|
|
|
+ },
|
|
|
+ highlight: function() {
|
|
|
+ this.trigger("emphasis")
|
|
|
+ },
|
|
|
+ downplay: function() {
|
|
|
+ this.trigger("normal")
|
|
|
+ }
|
|
|
+ });
|
|
|
+ Cf({
|
|
|
+ type: "sankey",
|
|
|
+ _model: null,
|
|
|
+ _focusAdjacencyDisabled: !1,
|
|
|
+ render: function(w, t, n) {
|
|
|
+ var o = this
|
|
|
+ , e = w.getGraph()
|
|
|
+ , b = this.group
|
|
|
+ , i = w.layoutInfo
|
|
|
+ , S = i.width
|
|
|
+ , M = i.height
|
|
|
+ , u = w.getData()
|
|
|
+ , I = w.getData("edge")
|
|
|
+ , T = w.get("orient");
|
|
|
+ this._model = w,
|
|
|
+ b.removeAll(),
|
|
|
+ b.attr("position", [i.x, i.y]),
|
|
|
+ e.eachEdge(function(t) {
|
|
|
+ var e = new bS;
|
|
|
+ e.dataIndex = t.dataIndex,
|
|
|
+ e.seriesIndex = w.seriesIndex,
|
|
|
+ e.dataType = "edge";
|
|
|
+ var i, n, o, a, r, s, l, u, h = t.getModel("lineStyle"), c = h.get("curveness"), d = t.node1.getLayout(), f = t.node1.getModel(), p = f.get("localX"), g = f.get("localY"), m = t.node2.getLayout(), v = t.node2.getModel(), y = v.get("localX"), x = v.get("localY"), _ = t.getLayout();
|
|
|
+ switch (e.shape.extent = Math.max(1, _.dy),
|
|
|
+ u = "vertical" === (e.shape.orient = T) ? (i = (null != p ? p * S : d.x) + _.sy,
|
|
|
+ n = (null != g ? g * M : d.y) + d.dy,
|
|
|
+ o = (null != y ? y * S : m.x) + _.ty,
|
|
|
+ r = i,
|
|
|
+ s = n * (1 - c) + (a = null != x ? x * M : m.y) * c,
|
|
|
+ l = o,
|
|
|
+ n * c + a * (1 - c)) : (i = (null != p ? p * S : d.x) + d.dx,
|
|
|
+ n = (null != g ? g * M : d.y) + _.sy,
|
|
|
+ r = i * (1 - c) + (o = null != y ? y * S : m.x) * c,
|
|
|
+ s = n,
|
|
|
+ l = i * c + o * (1 - c),
|
|
|
+ a = (null != x ? x * M : m.y) + _.ty),
|
|
|
+ e.setShape({
|
|
|
+ x1: i,
|
|
|
+ y1: n,
|
|
|
+ x2: o,
|
|
|
+ y2: a,
|
|
|
+ cpx1: r,
|
|
|
+ cpy1: s,
|
|
|
+ cpx2: l,
|
|
|
+ cpy2: u
|
|
|
+ }),
|
|
|
+ e.setStyle(h.getItemStyle()),
|
|
|
+ e.style.fill) {
|
|
|
+ case "source":
|
|
|
+ e.style.fill = t.node1.getVisual("color");
|
|
|
+ break;
|
|
|
+ case "target":
|
|
|
+ e.style.fill = t.node2.getVisual("color")
|
|
|
+ }
|
|
|
+ $s(e, t.getModel("emphasis.lineStyle").getItemStyle()),
|
|
|
+ b.add(e),
|
|
|
+ I.setItemGraphicEl(t.dataIndex, e)
|
|
|
+ }),
|
|
|
+ e.eachNode(function(t) {
|
|
|
+ var e = t.getLayout()
|
|
|
+ , i = t.getModel()
|
|
|
+ , n = i.get("localX")
|
|
|
+ , o = i.get("localY")
|
|
|
+ , a = i.getModel("label")
|
|
|
+ , r = i.getModel("emphasis.label")
|
|
|
+ , s = new rs({
|
|
|
+ shape: {
|
|
|
+ x: null != n ? n * S : e.x,
|
|
|
+ y: null != o ? o * M : e.y,
|
|
|
+ width: e.dx,
|
|
|
+ height: e.dy
|
|
|
+ },
|
|
|
+ style: i.getModel("itemStyle").getItemStyle()
|
|
|
+ })
|
|
|
+ , l = t.getModel("emphasis.itemStyle").getItemStyle();
|
|
|
+ el(s.style, l, a, r, {
|
|
|
+ labelFetcher: w,
|
|
|
+ labelDataIndex: t.dataIndex,
|
|
|
+ defaultText: t.id,
|
|
|
+ isRectText: !0
|
|
|
+ }),
|
|
|
+ s.setStyle("fill", t.getVisual("color")),
|
|
|
+ $s(s, l),
|
|
|
+ b.add(s),
|
|
|
+ u.setItemGraphicEl(t.dataIndex, s),
|
|
|
+ s.dataType = "node"
|
|
|
+ }),
|
|
|
+ u.eachItemGraphicEl(function(t, i) {
|
|
|
+ var e = u.getItemModel(i);
|
|
|
+ e.get("draggable") && (t.drift = function(t, e) {
|
|
|
+ o._focusAdjacencyDisabled = !0,
|
|
|
+ this.shape.x += t,
|
|
|
+ this.shape.y += e,
|
|
|
+ this.dirty(),
|
|
|
+ n.dispatchAction({
|
|
|
+ type: "dragNode",
|
|
|
+ seriesId: w.id,
|
|
|
+ dataIndex: u.getRawIndex(i),
|
|
|
+ localX: this.shape.x / S,
|
|
|
+ localY: this.shape.y / M
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.ondragend = function() {
|
|
|
+ o._focusAdjacencyDisabled = !1
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.draggable = !0,
|
|
|
+ t.cursor = "move"),
|
|
|
+ t.highlight = function() {
|
|
|
+ this.trigger("emphasis")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.downplay = function() {
|
|
|
+ this.trigger("normal")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.focusNodeAdjHandler && t.off("mouseover", t.focusNodeAdjHandler),
|
|
|
+ t.unfocusNodeAdjHandler && t.off("mouseout", t.unfocusNodeAdjHandler),
|
|
|
+ e.get("focusNodeAdjacency") && (t.on("mouseover", t.focusNodeAdjHandler = function() {
|
|
|
+ o._focusAdjacencyDisabled || (o._clearTimer(),
|
|
|
+ n.dispatchAction({
|
|
|
+ type: "focusNodeAdjacency",
|
|
|
+ seriesId: w.id,
|
|
|
+ dataIndex: t.dataIndex
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ t.on("mouseout", t.unfocusNodeAdjHandler = function() {
|
|
|
+ o._focusAdjacencyDisabled || o._dispatchUnfocus(n)
|
|
|
+ }
|
|
|
+ ))
|
|
|
+ }),
|
|
|
+ I.eachItemGraphicEl(function(t, e) {
|
|
|
+ var i = I.getItemModel(e);
|
|
|
+ t.focusNodeAdjHandler && t.off("mouseover", t.focusNodeAdjHandler),
|
|
|
+ t.unfocusNodeAdjHandler && t.off("mouseout", t.unfocusNodeAdjHandler),
|
|
|
+ i.get("focusNodeAdjacency") && (t.on("mouseover", t.focusNodeAdjHandler = function() {
|
|
|
+ o._focusAdjacencyDisabled || (o._clearTimer(),
|
|
|
+ n.dispatchAction({
|
|
|
+ type: "focusNodeAdjacency",
|
|
|
+ seriesId: w.id,
|
|
|
+ edgeDataIndex: t.dataIndex
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ t.on("mouseout", t.unfocusNodeAdjHandler = function() {
|
|
|
+ o._focusAdjacencyDisabled || o._dispatchUnfocus(n)
|
|
|
+ }
|
|
|
+ ))
|
|
|
+ }),
|
|
|
+ !this._data && w.get("animation") && b.setClipPath(function(t, e, i) {
|
|
|
+ var n = new rs({
|
|
|
+ shape: {
|
|
|
+ x: t.x - 10,
|
|
|
+ y: t.y - 10,
|
|
|
+ width: 0,
|
|
|
+ height: t.height + 20
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return dl(n, {
|
|
|
+ shape: {
|
|
|
+ width: t.width + 20
|
|
|
+ }
|
|
|
+ }, e, i),
|
|
|
+ n
|
|
|
+ }(b.getBoundingRect(), w, function() {
|
|
|
+ b.removeClipPath()
|
|
|
+ })),
|
|
|
+ this._data = w.getData()
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._clearTimer()
|
|
|
+ },
|
|
|
+ _dispatchUnfocus: function(t) {
|
|
|
+ var e = this;
|
|
|
+ this._clearTimer(),
|
|
|
+ this._unfocusDelayTimer = setTimeout(function() {
|
|
|
+ e._unfocusDelayTimer = null,
|
|
|
+ t.dispatchAction({
|
|
|
+ type: "unfocusNodeAdjacency",
|
|
|
+ seriesId: e._model.id
|
|
|
+ })
|
|
|
+ }, 500)
|
|
|
+ },
|
|
|
+ _clearTimer: function() {
|
|
|
+ this._unfocusDelayTimer && (clearTimeout(this._unfocusDelayTimer),
|
|
|
+ this._unfocusDelayTimer = null)
|
|
|
+ },
|
|
|
+ focusNodeAdjacency: function(t, e, i, n) {
|
|
|
+ var o = t.getData()
|
|
|
+ , a = o.graph
|
|
|
+ , r = n.dataIndex
|
|
|
+ , s = o.getItemModel(r)
|
|
|
+ , l = n.edgeDataIndex;
|
|
|
+ if (null != r || null != l) {
|
|
|
+ var u = a.getNodeByIndex(r)
|
|
|
+ , h = a.getEdgeByIndex(l);
|
|
|
+ if (a.eachNode(function(t) {
|
|
|
+ _S(t, gS, .1)
|
|
|
+ }),
|
|
|
+ a.eachEdge(function(t) {
|
|
|
+ _S(t, vS, .1)
|
|
|
+ }),
|
|
|
+ u) {
|
|
|
+ wS(u, mS);
|
|
|
+ var c = s.get("focusNodeAdjacency");
|
|
|
+ "outEdges" === c ? E(u.outEdges, function(t) {
|
|
|
+ t.dataIndex < 0 || (wS(t, yS),
|
|
|
+ wS(t.node2, mS))
|
|
|
+ }) : "inEdges" === c ? E(u.inEdges, function(t) {
|
|
|
+ t.dataIndex < 0 || (wS(t, yS),
|
|
|
+ wS(t.node1, mS))
|
|
|
+ }) : "allEdges" === c && E(u.edges, function(t) {
|
|
|
+ t.dataIndex < 0 || (wS(t, yS),
|
|
|
+ t.node1 !== u && wS(t.node1, mS),
|
|
|
+ t.node2 !== u && wS(t.node2, mS))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ h && (wS(h, yS),
|
|
|
+ wS(h.node1, mS),
|
|
|
+ wS(h.node2, mS))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ unfocusNodeAdjacency: function(t, e, i, n) {
|
|
|
+ var o = t.getGraph();
|
|
|
+ o.eachNode(function(t) {
|
|
|
+ _S(t, gS)
|
|
|
+ }),
|
|
|
+ o.eachEdge(function(t) {
|
|
|
+ _S(t, vS)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "dragNode",
|
|
|
+ event: "dragnode",
|
|
|
+ update: "update"
|
|
|
+ }, function(e, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "sankey",
|
|
|
+ query: e
|
|
|
+ }, function(t) {
|
|
|
+ t.setNodePosition(e.dataIndex, [e.localX, e.localY])
|
|
|
+ })
|
|
|
+ });
|
|
|
+ function SS(t) {
|
|
|
+ var e = t.hostGraph.data.getRawDataItem(t.dataIndex);
|
|
|
+ return null != e.depth && 0 <= e.depth
|
|
|
+ }
|
|
|
+ function MS(t, l, u, h, c) {
|
|
|
+ var d = "vertical" === c ? "x" : "y";
|
|
|
+ E(t, function(t) {
|
|
|
+ var e, i, n;
|
|
|
+ t.sort(function(t, e) {
|
|
|
+ return t.getLayout()[d] - e.getLayout()[d]
|
|
|
+ });
|
|
|
+ for (var o = 0, a = t.length, r = "vertical" === c ? "dx" : "dy", s = 0; s < a; s++)
|
|
|
+ 0 < (n = o - (i = t[s]).getLayout()[d]) && (e = i.getLayout()[d] + n,
|
|
|
+ "vertical" === c ? i.setLayout({
|
|
|
+ x: e
|
|
|
+ }, !0) : i.setLayout({
|
|
|
+ y: e
|
|
|
+ }, !0)),
|
|
|
+ o = i.getLayout()[d] + i.getLayout()[r] + l;
|
|
|
+ if (0 < (n = o - l - ("vertical" === c ? h : u)))
|
|
|
+ for (e = i.getLayout()[d] - n,
|
|
|
+ "vertical" === c ? i.setLayout({
|
|
|
+ x: e
|
|
|
+ }, !0) : i.setLayout({
|
|
|
+ y: e
|
|
|
+ }, !0),
|
|
|
+ o = e,
|
|
|
+ s = a - 2; 0 <= s; --s)
|
|
|
+ 0 < (n = (i = t[s]).getLayout()[d] + i.getLayout()[r] + l - o) && (e = i.getLayout()[d] - n,
|
|
|
+ "vertical" === c ? i.setLayout({
|
|
|
+ x: e
|
|
|
+ }, !0) : i.setLayout({
|
|
|
+ y: e
|
|
|
+ }, !0)),
|
|
|
+ o = i.getLayout()[d]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function IS(t, a, r) {
|
|
|
+ E(t.slice().reverse(), function(t) {
|
|
|
+ E(t, function(t) {
|
|
|
+ if (t.outEdges.length) {
|
|
|
+ var e = PS(t.outEdges, TS, r) / PS(t.outEdges, kS, r);
|
|
|
+ if (isNaN(e)) {
|
|
|
+ var i = t.outEdges.length;
|
|
|
+ e = i ? PS(t.outEdges, AS, r) / i : 0
|
|
|
+ }
|
|
|
+ if ("vertical" === r) {
|
|
|
+ var n = t.getLayout().x + (e - LS(t, r)) * a;
|
|
|
+ t.setLayout({
|
|
|
+ x: n
|
|
|
+ }, !0)
|
|
|
+ } else {
|
|
|
+ var o = t.getLayout().y + (e - LS(t, r)) * a;
|
|
|
+ t.setLayout({
|
|
|
+ y: o
|
|
|
+ }, !0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function TS(t, e) {
|
|
|
+ return LS(t.node2, e) * t.getValue()
|
|
|
+ }
|
|
|
+ function AS(t, e) {
|
|
|
+ return LS(t.node2, e)
|
|
|
+ }
|
|
|
+ function DS(t, e) {
|
|
|
+ return LS(t.node1, e) * t.getValue()
|
|
|
+ }
|
|
|
+ function CS(t, e) {
|
|
|
+ return LS(t.node1, e)
|
|
|
+ }
|
|
|
+ function LS(t, e) {
|
|
|
+ return "vertical" === e ? t.getLayout().x + t.getLayout().dx / 2 : t.getLayout().y + t.getLayout().dy / 2
|
|
|
+ }
|
|
|
+ function kS(t) {
|
|
|
+ return t.getValue()
|
|
|
+ }
|
|
|
+ function PS(t, e, i) {
|
|
|
+ for (var n = 0, o = t.length, a = -1; ++a < o; ) {
|
|
|
+ var r = +e.call(t, t[a], i);
|
|
|
+ isNaN(r) || (n += r)
|
|
|
+ }
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ function NS(t, a, r) {
|
|
|
+ E(t, function(t) {
|
|
|
+ E(t, function(t) {
|
|
|
+ if (t.inEdges.length) {
|
|
|
+ var e = PS(t.inEdges, DS, r) / PS(t.inEdges, kS, r);
|
|
|
+ if (isNaN(e)) {
|
|
|
+ var i = t.inEdges.length;
|
|
|
+ e = i ? PS(t.inEdges, CS, r) / i : 0
|
|
|
+ }
|
|
|
+ if ("vertical" === r) {
|
|
|
+ var n = t.getLayout().x + (e - LS(t, r)) * a;
|
|
|
+ t.setLayout({
|
|
|
+ x: n
|
|
|
+ }, !0)
|
|
|
+ } else {
|
|
|
+ var o = t.getLayout().y + (e - LS(t, r)) * a;
|
|
|
+ t.setLayout({
|
|
|
+ y: o
|
|
|
+ }, !0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ bf(function(t, u, e) {
|
|
|
+ t.eachSeriesByType("sankey", function(t) {
|
|
|
+ var e = t.get("nodeWidth")
|
|
|
+ , i = t.get("nodeGap")
|
|
|
+ , n = function(t, e) {
|
|
|
+ return bu(t.getBoxLayoutParams(), {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ })
|
|
|
+ }(t, u)
|
|
|
+ , o = (t.layoutInfo = n).width
|
|
|
+ , a = n.height
|
|
|
+ , r = t.getGraph()
|
|
|
+ , s = r.nodes
|
|
|
+ , l = r.edges;
|
|
|
+ !function(t) {
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = PS(t.outEdges, kS)
|
|
|
+ , i = PS(t.inEdges, kS)
|
|
|
+ , n = t.getValue() || 0
|
|
|
+ , o = Math.max(e, i, n);
|
|
|
+ t.setLayout({
|
|
|
+ value: o
|
|
|
+ }, !0)
|
|
|
+ })
|
|
|
+ }(s),
|
|
|
+ function(t, e, i, n, o, a, r, s, l) {
|
|
|
+ (function(t, e, i, n, o, a, r) {
|
|
|
+ for (var s = [], l = [], u = [], h = [], c = 0, d = 0; d < e.length; d++)
|
|
|
+ s[d] = 1;
|
|
|
+ for (d = 0; d < t.length; d++)
|
|
|
+ l[d] = t[d].inEdges.length,
|
|
|
+ 0 === l[d] && u.push(t[d]);
|
|
|
+ var f = -1;
|
|
|
+ for (; u.length; ) {
|
|
|
+ for (var p = 0; p < u.length; p++) {
|
|
|
+ var g = u[p]
|
|
|
+ , m = g.hostGraph.data.getRawDataItem(g.dataIndex)
|
|
|
+ , v = null != m.depth && 0 <= m.depth;
|
|
|
+ v && m.depth > f && (f = m.depth),
|
|
|
+ g.setLayout({
|
|
|
+ depth: v ? m.depth : c
|
|
|
+ }, !0),
|
|
|
+ "vertical" === a ? g.setLayout({
|
|
|
+ dy: i
|
|
|
+ }, !0) : g.setLayout({
|
|
|
+ dx: i
|
|
|
+ }, !0);
|
|
|
+ for (var y = 0; y < g.outEdges.length; y++) {
|
|
|
+ var x = g.outEdges[y]
|
|
|
+ , _ = e.indexOf(x);
|
|
|
+ s[_] = 0;
|
|
|
+ var w = x.node2
|
|
|
+ , b = t.indexOf(w);
|
|
|
+ 0 == --l[b] && h.indexOf(w) < 0 && h.push(w)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ++c,
|
|
|
+ u = h,
|
|
|
+ h = []
|
|
|
+ }
|
|
|
+ for (d = 0; d < s.length; d++)
|
|
|
+ if (1 === s[d])
|
|
|
+ throw new Error("Sankey is a DAG, the original data has cycle!");
|
|
|
+ var S = c - 1 < f ? f : c - 1;
|
|
|
+ r && "left" !== r && function(t, e, i, n) {
|
|
|
+ if ("right" === e) {
|
|
|
+ for (var o = [], a = t, r = 0; a.length; ) {
|
|
|
+ for (var s = 0; s < a.length; s++) {
|
|
|
+ var l = a[s];
|
|
|
+ l.setLayout({
|
|
|
+ skNodeHeight: r
|
|
|
+ }, !0);
|
|
|
+ for (var u = 0; u < l.inEdges.length; u++) {
|
|
|
+ var h = l.inEdges[u];
|
|
|
+ o.indexOf(h.node1) < 0 && o.push(h.node1)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ a = o,
|
|
|
+ o = [],
|
|
|
+ ++r
|
|
|
+ }
|
|
|
+ E(t, function(t) {
|
|
|
+ SS(t) || t.setLayout({
|
|
|
+ depth: Math.max(0, n - t.getLayout().skNodeHeight)
|
|
|
+ }, !0)
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ "justify" === e && function(t, e) {
|
|
|
+ E(t, function(t) {
|
|
|
+ SS(t) || t.outEdges.length || t.setLayout({
|
|
|
+ depth: e
|
|
|
+ }, !0)
|
|
|
+ })
|
|
|
+ }(t, n)
|
|
|
+ }(t, r, 0, S);
|
|
|
+ !function(t, i, n) {
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = t.getLayout().depth * i;
|
|
|
+ "vertical" === n ? t.setLayout({
|
|
|
+ y: e
|
|
|
+ }, !0) : t.setLayout({
|
|
|
+ x: e
|
|
|
+ }, !0)
|
|
|
+ })
|
|
|
+ }(t, "vertical" === a ? (o - i) / S : (n - i) / S, a)
|
|
|
+ }
|
|
|
+ )(t, e, i, o, a, s, l),
|
|
|
+ function(t, e, i, n, o, a, r) {
|
|
|
+ var s = function(t, e) {
|
|
|
+ var i = []
|
|
|
+ , n = "vertical" === e ? "y" : "x"
|
|
|
+ , o = ta(t, function(t) {
|
|
|
+ return t.getLayout()[n]
|
|
|
+ });
|
|
|
+ return o.keys.sort(function(t, e) {
|
|
|
+ return t - e
|
|
|
+ }),
|
|
|
+ E(o.keys, function(t) {
|
|
|
+ i.push(o.buckets.get(t))
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }(t, r);
|
|
|
+ (function(t, e, o, a, r, s) {
|
|
|
+ var l = 1 / 0;
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = t.length
|
|
|
+ , i = 0;
|
|
|
+ E(t, function(t) {
|
|
|
+ i += t.getLayout().value
|
|
|
+ });
|
|
|
+ var n = "vertical" === s ? (a - (e - 1) * r) / i : (o - (e - 1) * r) / i;
|
|
|
+ n < l && (l = n)
|
|
|
+ }),
|
|
|
+ E(t, function(t) {
|
|
|
+ E(t, function(t, e) {
|
|
|
+ var i = t.getLayout().value * l;
|
|
|
+ "vertical" === s ? (t.setLayout({
|
|
|
+ x: e
|
|
|
+ }, !0),
|
|
|
+ t.setLayout({
|
|
|
+ dx: i
|
|
|
+ }, !0)) : (t.setLayout({
|
|
|
+ y: e
|
|
|
+ }, !0),
|
|
|
+ t.setLayout({
|
|
|
+ dy: i
|
|
|
+ }, !0))
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ E(e, function(t) {
|
|
|
+ var e = +t.getValue() * l;
|
|
|
+ t.setLayout({
|
|
|
+ dy: e
|
|
|
+ }, !0)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ )(s, e, i, n, o, r),
|
|
|
+ MS(s, o, i, n, r);
|
|
|
+ for (var l = 1; 0 < a; a--)
|
|
|
+ IS(s, l *= .99, r),
|
|
|
+ MS(s, o, i, n, r),
|
|
|
+ NS(s, l, r),
|
|
|
+ MS(s, o, i, n, r)
|
|
|
+ }(t, e, a, o, n, r, s),
|
|
|
+ function(t, e) {
|
|
|
+ var i = "vertical" === e ? "x" : "y";
|
|
|
+ E(t, function(t) {
|
|
|
+ t.outEdges.sort(function(t, e) {
|
|
|
+ return t.node2.getLayout()[i] - e.node2.getLayout()[i]
|
|
|
+ }),
|
|
|
+ t.inEdges.sort(function(t, e) {
|
|
|
+ return t.node1.getLayout()[i] - e.node1.getLayout()[i]
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = 0
|
|
|
+ , i = 0;
|
|
|
+ E(t.outEdges, function(t) {
|
|
|
+ t.setLayout({
|
|
|
+ sy: e
|
|
|
+ }, !0),
|
|
|
+ e += t.getLayout().dy
|
|
|
+ }),
|
|
|
+ E(t.inEdges, function(t) {
|
|
|
+ t.setLayout({
|
|
|
+ ty: i
|
|
|
+ }, !0),
|
|
|
+ i += t.getLayout().dy
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }(t, s)
|
|
|
+ }(s, l, e, i, o, a, 0 !== M(s, function(t) {
|
|
|
+ return 0 === t.getLayout().value
|
|
|
+ }).length ? 0 : t.get("layoutIterations"), t.get("orient"), t.get("nodeAlign"))
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ Sf(function(t, e) {
|
|
|
+ t.eachSeriesByType("sankey", function(n) {
|
|
|
+ var t = n.getGraph().nodes;
|
|
|
+ if (t.length) {
|
|
|
+ var o = 1 / 0
|
|
|
+ , a = -1 / 0;
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = t.getLayout().value;
|
|
|
+ e < o && (o = e),
|
|
|
+ a < e && (a = e)
|
|
|
+ }),
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = new g_({
|
|
|
+ type: "color",
|
|
|
+ mappingMethod: "linear",
|
|
|
+ dataExtent: [o, a],
|
|
|
+ visual: n.get("color")
|
|
|
+ }).mapValueToVisual(t.getLayout().value)
|
|
|
+ , i = t.getModel().get("itemStyle.color");
|
|
|
+ null != i ? t.setVisual("color", i) : t.setVisual("color", e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var OS = {
|
|
|
+ _baseAxisDim: null,
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ var i, n, o = e.getComponent("xAxis", this.get("xAxisIndex")), a = e.getComponent("yAxis", this.get("yAxisIndex")), r = o.get("type"), s = a.get("type");
|
|
|
+ "category" === r ? (t.layout = "horizontal",
|
|
|
+ i = o.getOrdinalMeta(),
|
|
|
+ n = !0) : "category" === s ? (t.layout = "vertical",
|
|
|
+ i = a.getOrdinalMeta(),
|
|
|
+ n = !0) : t.layout = t.layout || "horizontal";
|
|
|
+ var l = ["x", "y"]
|
|
|
+ , u = "horizontal" === t.layout ? 0 : 1
|
|
|
+ , h = this._baseAxisDim = l[u]
|
|
|
+ , c = l[1 - u]
|
|
|
+ , d = [o, a]
|
|
|
+ , f = d[u].get("type")
|
|
|
+ , p = d[1 - u].get("type")
|
|
|
+ , g = t.data;
|
|
|
+ if (g && n) {
|
|
|
+ var m = [];
|
|
|
+ E(g, function(t, e) {
|
|
|
+ var i;
|
|
|
+ t.value && L(t.value) ? (i = t.value.slice(),
|
|
|
+ t.value.unshift(e)) : L(t) ? (i = t.slice(),
|
|
|
+ t.unshift(e)) : i = t,
|
|
|
+ m.push(i)
|
|
|
+ }),
|
|
|
+ t.data = m
|
|
|
+ }
|
|
|
+ var v = this.defaultValueDimensions
|
|
|
+ , y = [{
|
|
|
+ name: h,
|
|
|
+ type: Ef(f),
|
|
|
+ ordinalMeta: i,
|
|
|
+ otherDims: {
|
|
|
+ tooltip: !1,
|
|
|
+ itemName: 0
|
|
|
+ },
|
|
|
+ dimsDef: ["base"]
|
|
|
+ }, {
|
|
|
+ name: c,
|
|
|
+ type: Ef(p),
|
|
|
+ dimsDef: v.slice()
|
|
|
+ }];
|
|
|
+ return Yv(this, {
|
|
|
+ coordDimensions: y,
|
|
|
+ dimensionsCount: v.length + 1,
|
|
|
+ encodeDefaulter: T($u, y, this)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ getBaseAxis: function() {
|
|
|
+ var t = this._baseAxisDim;
|
|
|
+ return this.ecModel.getComponent(t + "Axis", this.get(t + "AxisIndex")).axis
|
|
|
+ }
|
|
|
+ };
|
|
|
+ b(sc.extend({
|
|
|
+ type: "series.boxplot",
|
|
|
+ dependencies: ["xAxis", "yAxis", "grid"],
|
|
|
+ defaultValueDimensions: [{
|
|
|
+ name: "min",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }, {
|
|
|
+ name: "Q1",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }, {
|
|
|
+ name: "median",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }, {
|
|
|
+ name: "Q3",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }, {
|
|
|
+ name: "max",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }],
|
|
|
+ dimensions: null,
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "cartesian2d",
|
|
|
+ legendHoverLink: !0,
|
|
|
+ hoverAnimation: !0,
|
|
|
+ layout: null,
|
|
|
+ boxWidth: [7, 50],
|
|
|
+ itemStyle: {
|
|
|
+ color: "#fff",
|
|
|
+ borderWidth: 1
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: 2,
|
|
|
+ shadowBlur: 5,
|
|
|
+ shadowOffsetX: 2,
|
|
|
+ shadowOffsetY: 2,
|
|
|
+ shadowColor: "rgba(0,0,0,0.4)"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ animationEasing: "elasticOut",
|
|
|
+ animationDuration: 800
|
|
|
+ }
|
|
|
+ }), OS, !0);
|
|
|
+ var ES = ["itemStyle"]
|
|
|
+ , RS = ["emphasis", "itemStyle"]
|
|
|
+ , zS = (_c.extend({
|
|
|
+ type: "boxplot",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var o = t.getData()
|
|
|
+ , a = this.group
|
|
|
+ , r = this._data;
|
|
|
+ this._data || a.removeAll();
|
|
|
+ var s = "horizontal" === t.get("layout") ? 1 : 0;
|
|
|
+ o.diff(r).add(function(t) {
|
|
|
+ if (o.hasValue(t)) {
|
|
|
+ var e = BS(o.getItemLayout(t), o, t, s, !0);
|
|
|
+ o.setItemGraphicEl(t, e),
|
|
|
+ a.add(e)
|
|
|
+ }
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = r.getItemGraphicEl(e);
|
|
|
+ if (o.hasValue(t)) {
|
|
|
+ var n = o.getItemLayout(t);
|
|
|
+ i ? VS(n, i, o, t) : i = BS(n, o, t, s),
|
|
|
+ a.add(i),
|
|
|
+ o.setItemGraphicEl(t, i)
|
|
|
+ } else
|
|
|
+ a.remove(i)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = r.getItemGraphicEl(t);
|
|
|
+ e && a.remove(e)
|
|
|
+ }).execute(),
|
|
|
+ this._data = o
|
|
|
+ },
|
|
|
+ remove: function(t) {
|
|
|
+ var e = this.group
|
|
|
+ , i = this._data;
|
|
|
+ this._data = null,
|
|
|
+ i && i.eachItemGraphicEl(function(t) {
|
|
|
+ t && e.remove(t)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ dispose: et
|
|
|
+ }),
|
|
|
+ Ar.extend({
|
|
|
+ type: "boxplotBoxPath",
|
|
|
+ shape: {},
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.points
|
|
|
+ , n = 0;
|
|
|
+ for (t.moveTo(i[n][0], i[n][1]),
|
|
|
+ n++; n < 4; n++)
|
|
|
+ t.lineTo(i[n][0], i[n][1]);
|
|
|
+ for (t.closePath(); n < i.length; n++)
|
|
|
+ t.moveTo(i[n][0], i[n][1]),
|
|
|
+ n++,
|
|
|
+ t.lineTo(i[n][0], i[n][1])
|
|
|
+ }
|
|
|
+ }));
|
|
|
+ function BS(t, e, i, n, o) {
|
|
|
+ var a = t.ends
|
|
|
+ , r = new zS({
|
|
|
+ shape: {
|
|
|
+ points: o ? function(t, e, i) {
|
|
|
+ return O(t, function(t) {
|
|
|
+ return (t = t.slice())[e] = i.initBaseline,
|
|
|
+ t
|
|
|
+ })
|
|
|
+ }(a, n, t) : a
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return VS(t, r, e, i, o),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ function VS(t, e, i, n, o) {
|
|
|
+ var a = i.hostModel;
|
|
|
+ (0,
|
|
|
+ bl[o ? "initProps" : "updateProps"])(e, {
|
|
|
+ shape: {
|
|
|
+ points: t.ends
|
|
|
+ }
|
|
|
+ }, a, n);
|
|
|
+ var r = i.getItemModel(n)
|
|
|
+ , s = r.getModel(ES)
|
|
|
+ , l = i.getItemVisual(n, "color")
|
|
|
+ , u = s.getItemStyle(["borderColor"]);
|
|
|
+ u.stroke = l,
|
|
|
+ u.strokeNoScale = !0,
|
|
|
+ e.useStyle(u),
|
|
|
+ e.z2 = 100,
|
|
|
+ $s(e, r.getModel(RS).getItemStyle())
|
|
|
+ }
|
|
|
+ var GS = ["itemStyle", "borderColor"]
|
|
|
+ , FS = E;
|
|
|
+ Sf(function(n, t) {
|
|
|
+ var o = n.get("color");
|
|
|
+ n.eachRawSeriesByType("boxplot", function(t) {
|
|
|
+ var e = o[t.seriesIndex % o.length]
|
|
|
+ , i = t.getData();
|
|
|
+ i.setVisual({
|
|
|
+ legendSymbol: "roundRect",
|
|
|
+ color: t.get(GS) || e
|
|
|
+ }),
|
|
|
+ n.isSeriesFiltered(t) || i.each(function(t) {
|
|
|
+ var e = i.getItemModel(t);
|
|
|
+ i.setItemVisual(t, {
|
|
|
+ color: e.get(GS, !0)
|
|
|
+ })
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ bf(function(t) {
|
|
|
+ var e = function(t) {
|
|
|
+ var n = []
|
|
|
+ , o = [];
|
|
|
+ return t.eachSeriesByType("boxplot", function(t) {
|
|
|
+ var e = t.getBaseAxis()
|
|
|
+ , i = _(o, e);
|
|
|
+ i < 0 && (i = o.length,
|
|
|
+ o[i] = e,
|
|
|
+ n[i] = {
|
|
|
+ axis: e,
|
|
|
+ seriesModels: []
|
|
|
+ }),
|
|
|
+ n[i].seriesModels.push(t)
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }(t);
|
|
|
+ FS(e, function(i) {
|
|
|
+ var t = i.seriesModels;
|
|
|
+ t.length && (function(t) {
|
|
|
+ var e, i, n = t.axis, o = t.seriesModels, a = o.length, r = t.boxWidthList = [], s = t.boxOffsetList = [], l = [];
|
|
|
+ if ("category" === n.type)
|
|
|
+ i = n.getBandWidth();
|
|
|
+ else {
|
|
|
+ var u = 0;
|
|
|
+ FS(o, function(t) {
|
|
|
+ u = Math.max(u, t.getData().count())
|
|
|
+ }),
|
|
|
+ e = n.getExtent(),
|
|
|
+ Math.abs(e[1] - e[0])
|
|
|
+ }
|
|
|
+ FS(o, function(t) {
|
|
|
+ var e = t.get("boxWidth");
|
|
|
+ L(e) || (e = [e, e]),
|
|
|
+ l.push([Rl(e[0], i) || 0, Rl(e[1], i) || 0])
|
|
|
+ });
|
|
|
+ var h = .8 * i - 2
|
|
|
+ , c = h / a * .3
|
|
|
+ , d = (h - c * (a - 1)) / a
|
|
|
+ , f = d / 2 - h / 2;
|
|
|
+ FS(o, function(t, e) {
|
|
|
+ s.push(f),
|
|
|
+ f += c + d,
|
|
|
+ r.push(Math.min(Math.max(d, l[e][0]), l[e][1]))
|
|
|
+ })
|
|
|
+ }(i),
|
|
|
+ FS(t, function(t, e) {
|
|
|
+ !function(t, r, e) {
|
|
|
+ var s = t.coordinateSystem
|
|
|
+ , l = t.getData()
|
|
|
+ , a = e / 2
|
|
|
+ , u = "horizontal" === t.get("layout") ? 0 : 1
|
|
|
+ , h = 1 - u
|
|
|
+ , i = ["x", "y"]
|
|
|
+ , n = l.mapDimension(i[u])
|
|
|
+ , o = l.mapDimension(i[h], !0);
|
|
|
+ if (null == n || o.length < 5)
|
|
|
+ return;
|
|
|
+ for (var c = 0; c < l.count(); c++) {
|
|
|
+ var d = l.get(n, c)
|
|
|
+ , f = x(d, o[2], c)
|
|
|
+ , p = x(d, o[0], c)
|
|
|
+ , g = x(d, o[1], c)
|
|
|
+ , m = x(d, o[3], c)
|
|
|
+ , v = x(d, o[4], c)
|
|
|
+ , y = [];
|
|
|
+ _(y, g, 0),
|
|
|
+ _(y, m, 1),
|
|
|
+ y.push(p, g, v, m),
|
|
|
+ w(y, p),
|
|
|
+ w(y, v),
|
|
|
+ w(y, f),
|
|
|
+ l.setItemLayout(c, {
|
|
|
+ initBaseline: f[h],
|
|
|
+ ends: y
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function x(t, e, i) {
|
|
|
+ var n, o = l.get(e, i), a = [];
|
|
|
+ return a[u] = t,
|
|
|
+ a[h] = o,
|
|
|
+ isNaN(t) || isNaN(o) ? n = [NaN, NaN] : (n = s.dataToPoint(a))[u] += r,
|
|
|
+ n
|
|
|
+ }
|
|
|
+ function _(t, e, i) {
|
|
|
+ var n = e.slice()
|
|
|
+ , o = e.slice();
|
|
|
+ n[u] += a,
|
|
|
+ o[u] -= a,
|
|
|
+ i ? t.push(n, o) : t.push(o, n)
|
|
|
+ }
|
|
|
+ function w(t, e) {
|
|
|
+ var i = e.slice()
|
|
|
+ , n = e.slice();
|
|
|
+ i[u] -= a,
|
|
|
+ n[u] += a,
|
|
|
+ t.push(i, n)
|
|
|
+ }
|
|
|
+ }(t, i.boxOffsetList[e], i.boxWidthList[e])
|
|
|
+ }))
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ b(sc.extend({
|
|
|
+ type: "series.candlestick",
|
|
|
+ dependencies: ["xAxis", "yAxis", "grid"],
|
|
|
+ defaultValueDimensions: [{
|
|
|
+ name: "open",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }, {
|
|
|
+ name: "close",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }, {
|
|
|
+ name: "lowest",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }, {
|
|
|
+ name: "highest",
|
|
|
+ defaultTooltip: !0
|
|
|
+ }],
|
|
|
+ dimensions: null,
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "cartesian2d",
|
|
|
+ legendHoverLink: !0,
|
|
|
+ hoverAnimation: !0,
|
|
|
+ layout: null,
|
|
|
+ clip: !0,
|
|
|
+ itemStyle: {
|
|
|
+ color: "#c23531",
|
|
|
+ color0: "#314656",
|
|
|
+ borderWidth: 1,
|
|
|
+ borderColor: "#c23531",
|
|
|
+ borderColor0: "#314656"
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: 2
|
|
|
+ }
|
|
|
+ },
|
|
|
+ barMaxWidth: null,
|
|
|
+ barMinWidth: null,
|
|
|
+ barWidth: null,
|
|
|
+ large: !0,
|
|
|
+ largeThreshold: 600,
|
|
|
+ progressive: 3e3,
|
|
|
+ progressiveThreshold: 1e4,
|
|
|
+ progressiveChunkMode: "mod",
|
|
|
+ animationUpdate: !1,
|
|
|
+ animationEasing: "linear",
|
|
|
+ animationDuration: 300
|
|
|
+ },
|
|
|
+ getShadowDim: function() {
|
|
|
+ return "open"
|
|
|
+ },
|
|
|
+ brushSelector: function(t, e, i) {
|
|
|
+ var n = e.getItemLayout(t);
|
|
|
+ return n && i.rect(n.brushRect)
|
|
|
+ }
|
|
|
+ }), OS, !0);
|
|
|
+ var WS = ["itemStyle"]
|
|
|
+ , HS = ["emphasis", "itemStyle"]
|
|
|
+ , ZS = ["color", "color0", "borderColor", "borderColor0"]
|
|
|
+ , US = (_c.extend({
|
|
|
+ type: "candlestick",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ this.group.removeClipPath(),
|
|
|
+ this._updateDrawMode(t),
|
|
|
+ this._isLargeDraw ? this._renderLarge(t) : this._renderNormal(t)
|
|
|
+ },
|
|
|
+ incrementalPrepareRender: function(t, e, i) {
|
|
|
+ this._clear(),
|
|
|
+ this._updateDrawMode(t)
|
|
|
+ },
|
|
|
+ incrementalRender: function(t, e, i, n) {
|
|
|
+ this._isLargeDraw ? this._incrementalRenderLarge(t, e) : this._incrementalRenderNormal(t, e)
|
|
|
+ },
|
|
|
+ _updateDrawMode: function(t) {
|
|
|
+ var e = t.pipelineContext.large;
|
|
|
+ (null == this._isLargeDraw || e ^ this._isLargeDraw) && (this._isLargeDraw = e,
|
|
|
+ this._clear())
|
|
|
+ },
|
|
|
+ _renderNormal: function(o) {
|
|
|
+ var a = o.getData()
|
|
|
+ , r = this._data
|
|
|
+ , s = this.group
|
|
|
+ , l = a.getLayout("isSimpleBox")
|
|
|
+ , u = o.get("clip", !0)
|
|
|
+ , t = o.coordinateSystem
|
|
|
+ , h = t.getArea && t.getArea();
|
|
|
+ this._data || s.removeAll(),
|
|
|
+ a.diff(r).add(function(t) {
|
|
|
+ if (a.hasValue(t)) {
|
|
|
+ var e, i = a.getItemLayout(t);
|
|
|
+ if (u && YS(h, i))
|
|
|
+ return;
|
|
|
+ dl(e = XS(i, t, !0), {
|
|
|
+ shape: {
|
|
|
+ points: i.ends
|
|
|
+ }
|
|
|
+ }, o, t),
|
|
|
+ jS(e, a, t, l),
|
|
|
+ s.add(e),
|
|
|
+ a.setItemGraphicEl(t, e)
|
|
|
+ }
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = r.getItemGraphicEl(e);
|
|
|
+ if (a.hasValue(t)) {
|
|
|
+ var n = a.getItemLayout(t);
|
|
|
+ u && YS(h, n) ? s.remove(i) : (i ? cl(i, {
|
|
|
+ shape: {
|
|
|
+ points: n.ends
|
|
|
+ }
|
|
|
+ }, o, t) : i = XS(n, t),
|
|
|
+ jS(i, a, t, l),
|
|
|
+ s.add(i),
|
|
|
+ a.setItemGraphicEl(t, i))
|
|
|
+ } else
|
|
|
+ s.remove(i)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = r.getItemGraphicEl(t);
|
|
|
+ e && s.remove(e)
|
|
|
+ }).execute(),
|
|
|
+ this._data = a
|
|
|
+ },
|
|
|
+ _renderLarge: function(t) {
|
|
|
+ this._clear(),
|
|
|
+ KS(t, this.group);
|
|
|
+ var e = t.get("clip", !0) ? Sm(t.coordinateSystem, !1, t) : null;
|
|
|
+ e ? this.group.setClipPath(e) : this.group.removeClipPath()
|
|
|
+ },
|
|
|
+ _incrementalRenderNormal: function(t, e) {
|
|
|
+ for (var i, n = e.getData(), o = n.getLayout("isSimpleBox"); null != (i = t.next()); ) {
|
|
|
+ var a;
|
|
|
+ jS(a = XS(n.getItemLayout(i), i), n, i, o),
|
|
|
+ a.incremental = !0,
|
|
|
+ this.group.add(a)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _incrementalRenderLarge: function(t, e) {
|
|
|
+ KS(e, this.group, !0)
|
|
|
+ },
|
|
|
+ remove: function(t) {
|
|
|
+ this._clear()
|
|
|
+ },
|
|
|
+ _clear: function() {
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._data = null
|
|
|
+ },
|
|
|
+ dispose: et
|
|
|
+ }),
|
|
|
+ Ar.extend({
|
|
|
+ type: "normalCandlestickBox",
|
|
|
+ shape: {},
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.points;
|
|
|
+ this.__simpleBox ? (t.moveTo(i[4][0], i[4][1]),
|
|
|
+ t.lineTo(i[6][0], i[6][1])) : (t.moveTo(i[0][0], i[0][1]),
|
|
|
+ t.lineTo(i[1][0], i[1][1]),
|
|
|
+ t.lineTo(i[2][0], i[2][1]),
|
|
|
+ t.lineTo(i[3][0], i[3][1]),
|
|
|
+ t.closePath(),
|
|
|
+ t.moveTo(i[4][0], i[4][1]),
|
|
|
+ t.lineTo(i[5][0], i[5][1]),
|
|
|
+ t.moveTo(i[6][0], i[6][1]),
|
|
|
+ t.lineTo(i[7][0], i[7][1]))
|
|
|
+ }
|
|
|
+ }));
|
|
|
+ function XS(t, e, i) {
|
|
|
+ var n = t.ends;
|
|
|
+ return new US({
|
|
|
+ shape: {
|
|
|
+ points: i ? function(t, e) {
|
|
|
+ return O(t, function(t) {
|
|
|
+ return (t = t.slice())[1] = e.initBaseline,
|
|
|
+ t
|
|
|
+ })
|
|
|
+ }(n, t) : n
|
|
|
+ },
|
|
|
+ z2: 100
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function YS(t, e) {
|
|
|
+ for (var i = !0, n = 0; n < e.ends.length; n++)
|
|
|
+ if (t.contain(e.ends[n][0], e.ends[n][1])) {
|
|
|
+ i = !1;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ function jS(t, e, i, n) {
|
|
|
+ var o = e.getItemModel(i)
|
|
|
+ , a = o.getModel(WS)
|
|
|
+ , r = e.getItemVisual(i, "color")
|
|
|
+ , s = e.getItemVisual(i, "borderColor") || r
|
|
|
+ , l = a.getItemStyle(ZS);
|
|
|
+ t.useStyle(l),
|
|
|
+ t.style.strokeNoScale = !0,
|
|
|
+ t.style.fill = r,
|
|
|
+ t.style.stroke = s,
|
|
|
+ t.__simpleBox = n,
|
|
|
+ $s(t, o.getModel(HS).getItemStyle())
|
|
|
+ }
|
|
|
+ var qS = Ar.extend({
|
|
|
+ type: "largeCandlestickBox",
|
|
|
+ shape: {},
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ for (var i = e.points, n = 0; n < i.length; )
|
|
|
+ if (this.__sign === i[n++]) {
|
|
|
+ var o = i[n++];
|
|
|
+ t.moveTo(o, i[n++]),
|
|
|
+ t.lineTo(o, i[n++])
|
|
|
+ } else
|
|
|
+ n += 3
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function KS(t, e, i) {
|
|
|
+ var n = t.getData()
|
|
|
+ , o = n.getLayout("largePoints")
|
|
|
+ , a = new qS({
|
|
|
+ shape: {
|
|
|
+ points: o
|
|
|
+ },
|
|
|
+ __sign: 1
|
|
|
+ });
|
|
|
+ e.add(a);
|
|
|
+ var r = new qS({
|
|
|
+ shape: {
|
|
|
+ points: o
|
|
|
+ },
|
|
|
+ __sign: -1
|
|
|
+ });
|
|
|
+ e.add(r),
|
|
|
+ $S(1, a, t, n),
|
|
|
+ $S(-1, r, t, n),
|
|
|
+ i && (a.incremental = !0,
|
|
|
+ r.incremental = !0)
|
|
|
+ }
|
|
|
+ function $S(t, e, i, n) {
|
|
|
+ var o = 0 < t ? "P" : "N"
|
|
|
+ , a = n.getVisual("borderColor" + o) || n.getVisual("color" + o)
|
|
|
+ , r = i.getModel(WS).getItemStyle(ZS);
|
|
|
+ e.useStyle(r),
|
|
|
+ e.style.fill = null,
|
|
|
+ e.style.stroke = a
|
|
|
+ }
|
|
|
+ var JS = ["itemStyle", "borderColor"]
|
|
|
+ , QS = ["itemStyle", "borderColor0"]
|
|
|
+ , tM = ["itemStyle", "color"]
|
|
|
+ , eM = ["itemStyle", "color0"]
|
|
|
+ , iM = {
|
|
|
+ seriesType: "candlestick",
|
|
|
+ plan: vc(),
|
|
|
+ performRawSeries: !0,
|
|
|
+ reset: function(t, e) {
|
|
|
+ if (t.getData().setVisual({
|
|
|
+ legendSymbol: "roundRect",
|
|
|
+ colorP: a(1, t),
|
|
|
+ colorN: a(-1, t),
|
|
|
+ borderColorP: r(1, t),
|
|
|
+ borderColorN: r(-1, t)
|
|
|
+ }),
|
|
|
+ !e.isSeriesFiltered(t))
|
|
|
+ return !t.pipelineContext.large && {
|
|
|
+ progress: function(t, e) {
|
|
|
+ var i;
|
|
|
+ for (; null != (i = t.next()); ) {
|
|
|
+ var n = e.getItemModel(i)
|
|
|
+ , o = e.getItemLayout(i).sign;
|
|
|
+ e.setItemVisual(i, {
|
|
|
+ color: a(o, n),
|
|
|
+ borderColor: r(o, n)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function a(t, e) {
|
|
|
+ return e.get(0 < t ? tM : eM)
|
|
|
+ }
|
|
|
+ function r(t, e) {
|
|
|
+ return e.get(0 < t ? JS : QS)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , nM = "undefined" != typeof Float32Array ? Float32Array : Array
|
|
|
+ , oM = {
|
|
|
+ seriesType: "candlestick",
|
|
|
+ plan: vc(),
|
|
|
+ reset: function(t) {
|
|
|
+ var x = t.coordinateSystem
|
|
|
+ , e = t.getData()
|
|
|
+ , _ = function(t, e) {
|
|
|
+ var i, n = t.getBaseAxis(), o = "category" === n.type ? n.getBandWidth() : (i = n.getExtent(),
|
|
|
+ Math.abs(i[1] - i[0]) / e.count()), a = Rl(H(t.get("barMaxWidth"), o), o), r = Rl(H(t.get("barMinWidth"), 1), o), s = t.get("barWidth");
|
|
|
+ return null != s ? Rl(s, o) : Math.max(Math.min(o / 2, a), r)
|
|
|
+ }(t, e)
|
|
|
+ , i = ["x", "y"]
|
|
|
+ , w = e.mapDimension(i[0])
|
|
|
+ , n = e.mapDimension(i[1], !0)
|
|
|
+ , b = n[0]
|
|
|
+ , S = n[1]
|
|
|
+ , M = n[2]
|
|
|
+ , I = n[3];
|
|
|
+ if (e.setLayout({
|
|
|
+ candleWidth: _,
|
|
|
+ isSimpleBox: _ <= 1.3
|
|
|
+ }),
|
|
|
+ !(null == w || n.length < 4))
|
|
|
+ return {
|
|
|
+ progress: t.pipelineContext.large ? function(t, e) {
|
|
|
+ var i, n, o = new nM(4 * t.count), a = 0, r = [], s = [];
|
|
|
+ for (; null != (n = t.next()); ) {
|
|
|
+ var l = e.get(w, n)
|
|
|
+ , u = e.get(b, n)
|
|
|
+ , h = e.get(S, n)
|
|
|
+ , c = e.get(M, n)
|
|
|
+ , d = e.get(I, n);
|
|
|
+ isNaN(l) || isNaN(c) || isNaN(d) ? (o[a++] = NaN,
|
|
|
+ a += 3) : (o[a++] = aM(e, n, u, h, S),
|
|
|
+ r[0] = l,
|
|
|
+ r[1] = c,
|
|
|
+ i = x.dataToPoint(r, null, s),
|
|
|
+ o[a++] = i ? i[0] : NaN,
|
|
|
+ o[a++] = i ? i[1] : NaN,
|
|
|
+ r[1] = d,
|
|
|
+ i = x.dataToPoint(r, null, s),
|
|
|
+ o[a++] = i ? i[1] : NaN)
|
|
|
+ }
|
|
|
+ e.setLayout("largePoints", o)
|
|
|
+ }
|
|
|
+ : function(t, e) {
|
|
|
+ var i;
|
|
|
+ for (; null != (i = t.next()); ) {
|
|
|
+ var n = e.get(w, i)
|
|
|
+ , o = e.get(b, i)
|
|
|
+ , a = e.get(S, i)
|
|
|
+ , r = e.get(M, i)
|
|
|
+ , s = e.get(I, i)
|
|
|
+ , l = Math.min(o, a)
|
|
|
+ , u = Math.max(o, a)
|
|
|
+ , h = g(l, n)
|
|
|
+ , c = g(u, n)
|
|
|
+ , d = g(r, n)
|
|
|
+ , f = g(s, n)
|
|
|
+ , p = [];
|
|
|
+ m(p, c, 0),
|
|
|
+ m(p, h, 1),
|
|
|
+ p.push(y(f), y(c), y(d), y(h)),
|
|
|
+ e.setItemLayout(i, {
|
|
|
+ sign: aM(e, i, o, a, S),
|
|
|
+ initBaseline: a < o ? c[1] : h[1],
|
|
|
+ ends: p,
|
|
|
+ brushRect: v(r, s, n)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function g(t, e) {
|
|
|
+ var i = [];
|
|
|
+ return i[0] = e,
|
|
|
+ i[1] = t,
|
|
|
+ isNaN(e) || isNaN(t) ? [NaN, NaN] : x.dataToPoint(i)
|
|
|
+ }
|
|
|
+ function m(t, e, i) {
|
|
|
+ var n = e.slice()
|
|
|
+ , o = e.slice();
|
|
|
+ n[0] = zs(n[0] + _ / 2, 1, !1),
|
|
|
+ o[0] = zs(o[0] - _ / 2, 1, !0),
|
|
|
+ i ? t.push(n, o) : t.push(o, n)
|
|
|
+ }
|
|
|
+ function v(t, e, i) {
|
|
|
+ var n = g(t, i)
|
|
|
+ , o = g(e, i);
|
|
|
+ return n[0] -= _ / 2,
|
|
|
+ o[0] -= _ / 2,
|
|
|
+ {
|
|
|
+ x: n[0],
|
|
|
+ y: n[1],
|
|
|
+ width: _,
|
|
|
+ height: o[1] - n[1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function y(t) {
|
|
|
+ return t[0] = zs(t[0], 1),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function aM(t, e, i, n, o) {
|
|
|
+ return n < i ? -1 : i < n ? 1 : 0 < e ? t.get(o, e - 1) <= n ? 1 : -1 : 1
|
|
|
+ }
|
|
|
+ yf(function(t) {
|
|
|
+ t && L(t.series) && E(t.series, function(t) {
|
|
|
+ z(t) && "k" === t.type && (t.type = "candlestick")
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ Sf(iM),
|
|
|
+ bf(oM),
|
|
|
+ sc.extend({
|
|
|
+ type: "series.effectScatter",
|
|
|
+ dependencies: ["grid", "polar"],
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return gp(this.getSource(), this, {
|
|
|
+ useEncodeDefaulter: !0
|
|
|
+ })
|
|
|
+ },
|
|
|
+ brushSelector: "point",
|
|
|
+ defaultOption: {
|
|
|
+ coordinateSystem: "cartesian2d",
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ legendHoverLink: !0,
|
|
|
+ effectType: "ripple",
|
|
|
+ progressive: 0,
|
|
|
+ showEffectOn: "render",
|
|
|
+ rippleEffect: {
|
|
|
+ period: 4,
|
|
|
+ scale: 2.5,
|
|
|
+ brushType: "fill"
|
|
|
+ },
|
|
|
+ symbolSize: 10
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function rM(t, e) {
|
|
|
+ var i = e.rippleEffectColor || e.color;
|
|
|
+ t.eachChild(function(t) {
|
|
|
+ t.attr({
|
|
|
+ z: e.z,
|
|
|
+ zlevel: e.zlevel,
|
|
|
+ style: {
|
|
|
+ stroke: "stroke" === e.brushType ? i : null,
|
|
|
+ fill: "fill" === e.brushType ? i : null
|
|
|
+ }
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function sM(t, e) {
|
|
|
+ Ci.call(this);
|
|
|
+ var i = new Xg(t,e)
|
|
|
+ , n = new Ci;
|
|
|
+ this.add(i),
|
|
|
+ this.add(n),
|
|
|
+ n.beforeUpdate = function() {
|
|
|
+ this.attr(i.getScale())
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.updateData(t, e)
|
|
|
+ }
|
|
|
+ var lM = sM.prototype;
|
|
|
+ lM.stopEffectAnimation = function() {
|
|
|
+ this.childAt(1).removeAll()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lM.startEffectAnimation = function(t) {
|
|
|
+ for (var e = t.symbolType, i = t.color, n = this.childAt(1), o = 0; o < 3; o++) {
|
|
|
+ var a = wg(e, -1, -1, 2, 2, i);
|
|
|
+ a.attr({
|
|
|
+ style: {
|
|
|
+ strokeNoScale: !0
|
|
|
+ },
|
|
|
+ z2: 99,
|
|
|
+ silent: !0,
|
|
|
+ scale: [.5, .5]
|
|
|
+ });
|
|
|
+ var r = -o / 3 * t.period + t.effectOffset;
|
|
|
+ a.animate("", !0).when(t.period, {
|
|
|
+ scale: [t.rippleScale / 2, t.rippleScale / 2]
|
|
|
+ }).delay(r).start(),
|
|
|
+ a.animateStyle(!0).when(t.period, {
|
|
|
+ opacity: 0
|
|
|
+ }).delay(r).start(),
|
|
|
+ n.add(a)
|
|
|
+ }
|
|
|
+ rM(n, t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lM.updateEffectAnimation = function(t) {
|
|
|
+ for (var e = this._effectCfg, i = this.childAt(1), n = ["symbolType", "period", "rippleScale"], o = 0; o < n.length; o++) {
|
|
|
+ var a = n[o];
|
|
|
+ if (e[a] !== t[a])
|
|
|
+ return this.stopEffectAnimation(),
|
|
|
+ void this.startEffectAnimation(t)
|
|
|
+ }
|
|
|
+ rM(i, t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lM.highlight = function() {
|
|
|
+ this.trigger("emphasis")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lM.downplay = function() {
|
|
|
+ this.trigger("normal")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lM.updateData = function(t, e) {
|
|
|
+ var i = t.hostModel;
|
|
|
+ this.childAt(0).updateData(t, e);
|
|
|
+ var n = this.childAt(1)
|
|
|
+ , o = t.getItemModel(e)
|
|
|
+ , a = t.getItemVisual(e, "symbol")
|
|
|
+ , r = function(t) {
|
|
|
+ return L(t) || (t = [+t, +t]),
|
|
|
+ t
|
|
|
+ }(t.getItemVisual(e, "symbolSize"))
|
|
|
+ , s = t.getItemVisual(e, "color");
|
|
|
+ n.attr("scale", r),
|
|
|
+ n.traverse(function(t) {
|
|
|
+ t.attr({
|
|
|
+ fill: s
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var l = o.getShallow("symbolOffset");
|
|
|
+ if (l) {
|
|
|
+ var u = n.position;
|
|
|
+ u[0] = Rl(l[0], r[0]),
|
|
|
+ u[1] = Rl(l[1], r[1])
|
|
|
+ }
|
|
|
+ var h = t.getItemVisual(e, "symbolRotate");
|
|
|
+ n.rotation = (h || 0) * Math.PI / 180 || 0;
|
|
|
+ var c = {};
|
|
|
+ if (c.showEffectOn = i.get("showEffectOn"),
|
|
|
+ c.rippleScale = o.get("rippleEffect.scale"),
|
|
|
+ c.brushType = o.get("rippleEffect.brushType"),
|
|
|
+ c.period = 1e3 * o.get("rippleEffect.period"),
|
|
|
+ c.effectOffset = e / t.count(),
|
|
|
+ c.z = o.getShallow("z") || 0,
|
|
|
+ c.zlevel = o.getShallow("zlevel") || 0,
|
|
|
+ c.symbolType = a,
|
|
|
+ c.color = s,
|
|
|
+ c.rippleEffectColor = o.get("rippleEffect.color"),
|
|
|
+ this.off("mouseover").off("mouseout").off("emphasis").off("normal"),
|
|
|
+ "render" === c.showEffectOn)
|
|
|
+ this._effectCfg ? this.updateEffectAnimation(c) : this.startEffectAnimation(c),
|
|
|
+ this._effectCfg = c;
|
|
|
+ else {
|
|
|
+ this._effectCfg = null,
|
|
|
+ this.stopEffectAnimation();
|
|
|
+ var d = this.childAt(0)
|
|
|
+ , f = function() {
|
|
|
+ d.highlight(),
|
|
|
+ "render" !== c.showEffectOn && this.startEffectAnimation(c)
|
|
|
+ }
|
|
|
+ , p = function() {
|
|
|
+ d.downplay(),
|
|
|
+ "render" !== c.showEffectOn && this.stopEffectAnimation()
|
|
|
+ };
|
|
|
+ this.on("mouseover", f, this).on("mouseout", p, this).on("emphasis", f, this).on("normal", p, this)
|
|
|
+ }
|
|
|
+ this._effectCfg = c
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lM.fadeOut = function(t) {
|
|
|
+ this.off("mouseover").off("mouseout").off("emphasis").off("normal"),
|
|
|
+ t && t()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(sM, Ci),
|
|
|
+ Cf({
|
|
|
+ type: "effectScatter",
|
|
|
+ init: function() {
|
|
|
+ this._symbolDraw = new im(sM)
|
|
|
+ },
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var n = t.getData()
|
|
|
+ , o = this._symbolDraw;
|
|
|
+ o.updateData(n),
|
|
|
+ this.group.add(o.group)
|
|
|
+ },
|
|
|
+ updateTransform: function(t, e, i) {
|
|
|
+ var n = t.getData();
|
|
|
+ this.group.dirty();
|
|
|
+ var o = km().reset(t);
|
|
|
+ o.progress && o.progress({
|
|
|
+ start: 0,
|
|
|
+ end: n.count()
|
|
|
+ }, n),
|
|
|
+ this._symbolDraw.updateLayout(n)
|
|
|
+ },
|
|
|
+ _updateGroupTransform: function(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ e && e.getRoamTransform && (this.group.transform = fe(e.getRoamTransform()),
|
|
|
+ this.group.decomposeTransform())
|
|
|
+ },
|
|
|
+ remove: function(t, e) {
|
|
|
+ this._symbolDraw && this._symbolDraw.remove(e)
|
|
|
+ },
|
|
|
+ dispose: function() {}
|
|
|
+ }),
|
|
|
+ Sf(Lm("effectScatter", "circle")),
|
|
|
+ bf(km("effectScatter"));
|
|
|
+ var uM = "undefined" == typeof Uint32Array ? Array : Uint32Array
|
|
|
+ , hM = "undefined" == typeof Float64Array ? Array : Float64Array;
|
|
|
+ function cM(t) {
|
|
|
+ var e = t.data;
|
|
|
+ e && e[0] && e[0][0] && e[0][0].coord && (t.data = O(e, function(t) {
|
|
|
+ var e = {
|
|
|
+ coords: [t[0].coord, t[1].coord]
|
|
|
+ };
|
|
|
+ return t[0].name && (e.fromName = t[0].name),
|
|
|
+ t[1].name && (e.toName = t[1].name),
|
|
|
+ p([e, t[0], t[1]])
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ var dM = sc.extend({
|
|
|
+ type: "series.lines",
|
|
|
+ dependencies: ["grid", "polar"],
|
|
|
+ visualColorAccessPath: "lineStyle.color",
|
|
|
+ init: function(t) {
|
|
|
+ t.data = t.data || [],
|
|
|
+ cM(t);
|
|
|
+ var e = this._processFlatCoordsArray(t.data);
|
|
|
+ this._flatCoords = e.flatCoords,
|
|
|
+ this._flatCoordsOffset = e.flatCoordsOffset,
|
|
|
+ e.flatCoords && (t.data = new Float32Array(e.count)),
|
|
|
+ dM.superApply(this, "init", arguments)
|
|
|
+ },
|
|
|
+ mergeOption: function(t) {
|
|
|
+ if (t.data = t.data || [],
|
|
|
+ cM(t),
|
|
|
+ t.data) {
|
|
|
+ var e = this._processFlatCoordsArray(t.data);
|
|
|
+ this._flatCoords = e.flatCoords,
|
|
|
+ this._flatCoordsOffset = e.flatCoordsOffset,
|
|
|
+ e.flatCoords && (t.data = new Float32Array(e.count))
|
|
|
+ }
|
|
|
+ dM.superApply(this, "mergeOption", arguments)
|
|
|
+ },
|
|
|
+ appendData: function(t) {
|
|
|
+ var e = this._processFlatCoordsArray(t.data);
|
|
|
+ e.flatCoords && (this._flatCoords ? (this._flatCoords = tt(this._flatCoords, e.flatCoords),
|
|
|
+ this._flatCoordsOffset = tt(this._flatCoordsOffset, e.flatCoordsOffset)) : (this._flatCoords = e.flatCoords,
|
|
|
+ this._flatCoordsOffset = e.flatCoordsOffset),
|
|
|
+ t.data = new Float32Array(e.count)),
|
|
|
+ this.getRawData().appendData(t.data)
|
|
|
+ },
|
|
|
+ _getCoordsFromItemModel: function(t) {
|
|
|
+ var e = this.getData().getItemModel(t);
|
|
|
+ return e.option instanceof Array ? e.option : e.getShallow("coords")
|
|
|
+ },
|
|
|
+ getLineCoordsCount: function(t) {
|
|
|
+ return this._flatCoordsOffset ? this._flatCoordsOffset[2 * t + 1] : this._getCoordsFromItemModel(t).length
|
|
|
+ },
|
|
|
+ getLineCoords: function(t, e) {
|
|
|
+ if (this._flatCoordsOffset) {
|
|
|
+ for (var i = this._flatCoordsOffset[2 * t], n = this._flatCoordsOffset[2 * t + 1], o = 0; o < n; o++)
|
|
|
+ e[o] = e[o] || [],
|
|
|
+ e[o][0] = this._flatCoords[i + 2 * o],
|
|
|
+ e[o][1] = this._flatCoords[i + 2 * o + 1];
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ var a = this._getCoordsFromItemModel(t);
|
|
|
+ for (o = 0; o < a.length; o++)
|
|
|
+ e[o] = e[o] || [],
|
|
|
+ e[o][0] = a[o][0],
|
|
|
+ e[o][1] = a[o][1];
|
|
|
+ return a.length
|
|
|
+ },
|
|
|
+ _processFlatCoordsArray: function(t) {
|
|
|
+ var e = 0;
|
|
|
+ if (this._flatCoords && (e = this._flatCoords.length),
|
|
|
+ "number" != typeof t[0])
|
|
|
+ return {
|
|
|
+ flatCoordsOffset: null,
|
|
|
+ flatCoords: null,
|
|
|
+ count: t.length
|
|
|
+ };
|
|
|
+ for (var i = t.length, n = new uM(i), o = new hM(i), a = 0, r = 0, s = 0, l = 0; l < i; ) {
|
|
|
+ s++;
|
|
|
+ var u = t[l++];
|
|
|
+ n[r++] = a + e,
|
|
|
+ n[r++] = u;
|
|
|
+ for (var h = 0; h < u; h++) {
|
|
|
+ var c = t[l++]
|
|
|
+ , d = t[l++];
|
|
|
+ o[a++] = c,
|
|
|
+ o[a++] = d
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ flatCoordsOffset: new Uint32Array(n.buffer,0,r),
|
|
|
+ flatCoords: o,
|
|
|
+ count: s
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ var a = new Yf(["value"],this);
|
|
|
+ return a.hasItemOption = !1,
|
|
|
+ a.initData(t.data, [], function(t, e, i, n) {
|
|
|
+ if (t instanceof Array)
|
|
|
+ return NaN;
|
|
|
+ a.hasItemOption = !0;
|
|
|
+ var o = t.value;
|
|
|
+ return null != o ? o instanceof Array ? o[n] : o : void 0
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ },
|
|
|
+ formatTooltip: function(t) {
|
|
|
+ var e = this.getData().getItemModel(t)
|
|
|
+ , i = e.get("name");
|
|
|
+ if (i)
|
|
|
+ return i;
|
|
|
+ var n = e.get("fromName")
|
|
|
+ , o = e.get("toName")
|
|
|
+ , a = [];
|
|
|
+ return null != n && a.push(n),
|
|
|
+ null != o && a.push(o),
|
|
|
+ au(a.join(" > "))
|
|
|
+ },
|
|
|
+ preventIncremental: function() {
|
|
|
+ return !!this.get("effect.show")
|
|
|
+ },
|
|
|
+ getProgressive: function() {
|
|
|
+ var t = this.option.progressive;
|
|
|
+ return null == t ? this.option.large ? 1e4 : this.get("progressive") : t
|
|
|
+ },
|
|
|
+ getProgressiveThreshold: function() {
|
|
|
+ var t = this.option.progressiveThreshold;
|
|
|
+ return null == t ? this.option.large ? 2e4 : this.get("progressiveThreshold") : t
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ coordinateSystem: "geo",
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ legendHoverLink: !0,
|
|
|
+ hoverAnimation: !0,
|
|
|
+ xAxisIndex: 0,
|
|
|
+ yAxisIndex: 0,
|
|
|
+ symbol: ["none", "none"],
|
|
|
+ symbolSize: [10, 10],
|
|
|
+ geoIndex: 0,
|
|
|
+ effect: {
|
|
|
+ show: !1,
|
|
|
+ period: 4,
|
|
|
+ constantSpeed: 0,
|
|
|
+ symbol: "circle",
|
|
|
+ symbolSize: 3,
|
|
|
+ loop: !0,
|
|
|
+ trailLength: .2
|
|
|
+ },
|
|
|
+ large: !1,
|
|
|
+ largeThreshold: 2e3,
|
|
|
+ polyline: !1,
|
|
|
+ clip: !0,
|
|
|
+ label: {
|
|
|
+ show: !1,
|
|
|
+ position: "end"
|
|
|
+ },
|
|
|
+ lineStyle: {
|
|
|
+ opacity: .5
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function fM(t, e, i) {
|
|
|
+ Ci.call(this),
|
|
|
+ this.add(this.createLine(t, e, i)),
|
|
|
+ this._updateEffectSymbol(t, e)
|
|
|
+ }
|
|
|
+ var pM = fM.prototype;
|
|
|
+ function gM(t, e, i) {
|
|
|
+ Ci.call(this),
|
|
|
+ this._createPolyline(t, e, i)
|
|
|
+ }
|
|
|
+ pM.createLine = function(t, e, i) {
|
|
|
+ return new dw(t,e,i)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pM._updateEffectSymbol = function(t, e) {
|
|
|
+ var i = t.getItemModel(e).getModel("effect")
|
|
|
+ , n = i.get("symbolSize")
|
|
|
+ , o = i.get("symbol");
|
|
|
+ L(n) || (n = [n, n]);
|
|
|
+ var a = i.get("color") || t.getItemVisual(e, "color")
|
|
|
+ , r = this.childAt(1);
|
|
|
+ this._symbolType !== o && (this.remove(r),
|
|
|
+ (r = wg(o, -.5, -.5, 1, 1, a)).z2 = 100,
|
|
|
+ r.culling = !0,
|
|
|
+ this.add(r)),
|
|
|
+ r && (r.setStyle("shadowColor", a),
|
|
|
+ r.setStyle(i.getItemStyle(["color"])),
|
|
|
+ r.attr("scale", n),
|
|
|
+ r.setColor(a),
|
|
|
+ r.attr("scale", n),
|
|
|
+ this._symbolType = o,
|
|
|
+ this._symbolScale = n,
|
|
|
+ this._updateEffectAnimation(t, i, e))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pM._updateEffectAnimation = function(e, t, i) {
|
|
|
+ var n = this.childAt(1);
|
|
|
+ if (n) {
|
|
|
+ var o = this
|
|
|
+ , a = e.getItemLayout(i)
|
|
|
+ , r = 1e3 * t.get("period")
|
|
|
+ , s = t.get("loop")
|
|
|
+ , l = t.get("constantSpeed")
|
|
|
+ , u = W(t.get("delay"), function(t) {
|
|
|
+ return t / e.count() * r / 3
|
|
|
+ })
|
|
|
+ , h = "function" == typeof u;
|
|
|
+ if (n.ignore = !0,
|
|
|
+ this.updateAnimationPoints(n, a),
|
|
|
+ 0 < l && (r = this.getLineLength(n) / l * 1e3),
|
|
|
+ r !== this._period || s !== this._loop) {
|
|
|
+ n.stopAnimation();
|
|
|
+ var c = u;
|
|
|
+ h && (c = u(i)),
|
|
|
+ 0 < n.__t && (c = -r * n.__t),
|
|
|
+ n.__t = 0;
|
|
|
+ var d = n.animate("", s).when(r, {
|
|
|
+ __t: 1
|
|
|
+ }).delay(c).during(function() {
|
|
|
+ o.updateSymbolPosition(n)
|
|
|
+ });
|
|
|
+ s || d.done(function() {
|
|
|
+ o.remove(n)
|
|
|
+ }),
|
|
|
+ d.start()
|
|
|
+ }
|
|
|
+ this._period = r,
|
|
|
+ this._loop = s
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pM.getLineLength = function(t) {
|
|
|
+ return yt(t.__p1, t.__cp1) + yt(t.__cp1, t.__p2)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pM.updateAnimationPoints = function(t, e) {
|
|
|
+ t.__p1 = e[0],
|
|
|
+ t.__p2 = e[1],
|
|
|
+ t.__cp1 = e[2] || [(e[0][0] + e[1][0]) / 2, (e[0][1] + e[1][1]) / 2]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pM.updateData = function(t, e, i) {
|
|
|
+ this.childAt(0).updateData(t, e, i),
|
|
|
+ this._updateEffectSymbol(t, e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pM.updateSymbolPosition = function(t) {
|
|
|
+ var e = t.__p1
|
|
|
+ , i = t.__p2
|
|
|
+ , n = t.__cp1
|
|
|
+ , o = t.__t
|
|
|
+ , a = t.position
|
|
|
+ , r = [a[0], a[1]]
|
|
|
+ , s = La
|
|
|
+ , l = ka;
|
|
|
+ a[0] = s(e[0], n[0], i[0], o),
|
|
|
+ a[1] = s(e[1], n[1], i[1], o);
|
|
|
+ var u = l(e[0], n[0], i[0], o)
|
|
|
+ , h = l(e[1], n[1], i[1], o);
|
|
|
+ if (t.rotation = -Math.atan2(h, u) - Math.PI / 2,
|
|
|
+ "line" === this._symbolType || "rect" === this._symbolType || "roundRect" === this._symbolType)
|
|
|
+ if (void 0 !== t.__lastT && t.__lastT < t.__t) {
|
|
|
+ var c = 1.05 * yt(r, a);
|
|
|
+ t.attr("scale", [t.scale[0], c]),
|
|
|
+ 1 === o && (a[0] = r[0] + (a[0] - r[0]) / 2,
|
|
|
+ a[1] = r[1] + (a[1] - r[1]) / 2)
|
|
|
+ } else if (1 === t.__lastT) {
|
|
|
+ c = 2 * yt(e, a);
|
|
|
+ t.attr("scale", [t.scale[0], c])
|
|
|
+ } else
|
|
|
+ t.attr("scale", this._symbolScale);
|
|
|
+ t.__lastT = t.__t,
|
|
|
+ t.ignore = !1
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pM.updateLayout = function(t, e) {
|
|
|
+ this.childAt(0).updateLayout(t, e);
|
|
|
+ var i = t.getItemModel(e).getModel("effect");
|
|
|
+ this._updateEffectAnimation(t, i, e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(fM, Ci);
|
|
|
+ var mM = gM.prototype;
|
|
|
+ function vM(t, e, i) {
|
|
|
+ fM.call(this, t, e, i),
|
|
|
+ this._lastFrame = 0,
|
|
|
+ this._lastFramePercent = 0
|
|
|
+ }
|
|
|
+ mM._createPolyline = function(t, e, i) {
|
|
|
+ var n = t.getItemLayout(e)
|
|
|
+ , o = new ts({
|
|
|
+ shape: {
|
|
|
+ points: n
|
|
|
+ }
|
|
|
+ });
|
|
|
+ this.add(o),
|
|
|
+ this._updateCommonStl(t, e, i)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mM.updateData = function(t, e, i) {
|
|
|
+ var n = t.hostModel;
|
|
|
+ cl(this.childAt(0), {
|
|
|
+ shape: {
|
|
|
+ points: t.getItemLayout(e)
|
|
|
+ }
|
|
|
+ }, n, e),
|
|
|
+ this._updateCommonStl(t, e, i)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mM._updateCommonStl = function(t, e, i) {
|
|
|
+ var n = this.childAt(0)
|
|
|
+ , o = t.getItemModel(e)
|
|
|
+ , a = t.getItemVisual(e, "color")
|
|
|
+ , r = i && i.lineStyle
|
|
|
+ , s = i && i.hoverLineStyle;
|
|
|
+ i && !t.hasItemOption || (r = o.getModel("lineStyle").getLineStyle(),
|
|
|
+ s = o.getModel("emphasis.lineStyle").getLineStyle()),
|
|
|
+ n.useStyle(D({
|
|
|
+ strokeNoScale: !0,
|
|
|
+ fill: "none",
|
|
|
+ stroke: a
|
|
|
+ }, r)),
|
|
|
+ n.hoverStyle = s,
|
|
|
+ $s(this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ mM.updateLayout = function(t, e) {
|
|
|
+ this.childAt(0).setShape("points", t.getItemLayout(e))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(gM, Ci);
|
|
|
+ var yM = vM.prototype;
|
|
|
+ yM.createLine = function(t, e, i) {
|
|
|
+ return new gM(t,e,i)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ yM.updateAnimationPoints = function(t, e) {
|
|
|
+ this._points = e;
|
|
|
+ for (var i = [0], n = 0, o = 1; o < e.length; o++) {
|
|
|
+ var a = e[o - 1]
|
|
|
+ , r = e[o];
|
|
|
+ n += yt(a, r),
|
|
|
+ i.push(n)
|
|
|
+ }
|
|
|
+ if (0 !== n) {
|
|
|
+ for (o = 0; o < i.length; o++)
|
|
|
+ i[o] /= n;
|
|
|
+ this._offsets = i,
|
|
|
+ this._length = n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ yM.getLineLength = function(t) {
|
|
|
+ return this._length
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ yM.updateSymbolPosition = function(t) {
|
|
|
+ var e = t.__t
|
|
|
+ , i = this._points
|
|
|
+ , n = this._offsets
|
|
|
+ , o = i.length;
|
|
|
+ if (n) {
|
|
|
+ var a = this._lastFrame;
|
|
|
+ if (e < this._lastFramePercent) {
|
|
|
+ for (r = Math.min(a + 1, o - 1); 0 <= r && !(n[r] <= e); r--)
|
|
|
+ ;
|
|
|
+ r = Math.min(r, o - 2)
|
|
|
+ } else {
|
|
|
+ for (var r = a; r < o && !(n[r] > e); r++)
|
|
|
+ ;
|
|
|
+ r = Math.min(r - 1, o - 2)
|
|
|
+ }
|
|
|
+ wt(t.position, i[r], i[r + 1], (e - n[r]) / (n[r + 1] - n[r]));
|
|
|
+ var s = i[r + 1][0] - i[r][0]
|
|
|
+ , l = i[r + 1][1] - i[r][1];
|
|
|
+ t.rotation = -Math.atan2(l, s) - Math.PI / 2,
|
|
|
+ this._lastFrame = r,
|
|
|
+ this._lastFramePercent = e,
|
|
|
+ t.ignore = !1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(vM, fM);
|
|
|
+ var xM = Cs({
|
|
|
+ shape: {
|
|
|
+ polyline: !1,
|
|
|
+ curveness: 0,
|
|
|
+ segs: []
|
|
|
+ },
|
|
|
+ buildPath: function(t, e) {
|
|
|
+ var i = e.segs
|
|
|
+ , n = e.curveness;
|
|
|
+ if (e.polyline)
|
|
|
+ for (var o = 0; o < i.length; ) {
|
|
|
+ var a = i[o++];
|
|
|
+ if (0 < a) {
|
|
|
+ t.moveTo(i[o++], i[o++]);
|
|
|
+ for (var r = 1; r < a; r++)
|
|
|
+ t.lineTo(i[o++], i[o++])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ for (o = 0; o < i.length; ) {
|
|
|
+ var s = i[o++]
|
|
|
+ , l = i[o++]
|
|
|
+ , u = i[o++]
|
|
|
+ , h = i[o++];
|
|
|
+ if (t.moveTo(s, l),
|
|
|
+ 0 < n) {
|
|
|
+ var c = (s + u) / 2 - (l - h) * n
|
|
|
+ , d = (l + h) / 2 - (u - s) * n;
|
|
|
+ t.quadraticCurveTo(c, d, u, h)
|
|
|
+ } else
|
|
|
+ t.lineTo(u, h)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ findDataIndex: function(t, e) {
|
|
|
+ var i = this.shape
|
|
|
+ , n = i.segs
|
|
|
+ , o = i.curveness;
|
|
|
+ if (i.polyline)
|
|
|
+ for (var a = 0, r = 0; r < n.length; ) {
|
|
|
+ var s = n[r++];
|
|
|
+ if (0 < s)
|
|
|
+ for (var l = n[r++], u = n[r++], h = 1; h < s; h++) {
|
|
|
+ if (sr(l, u, c = n[r++], d = n[r++]))
|
|
|
+ return a
|
|
|
+ }
|
|
|
+ a++
|
|
|
+ }
|
|
|
+ else
|
|
|
+ for (a = 0,
|
|
|
+ r = 0; r < n.length; ) {
|
|
|
+ l = n[r++],
|
|
|
+ u = n[r++];
|
|
|
+ var c = n[r++]
|
|
|
+ , d = n[r++];
|
|
|
+ if (0 < o) {
|
|
|
+ if (ur(l, u, (l + c) / 2 - (u - d) * o, (u + d) / 2 - (c - l) * o, c, d))
|
|
|
+ return a
|
|
|
+ } else if (sr(l, u, c, d))
|
|
|
+ return a;
|
|
|
+ a++
|
|
|
+ }
|
|
|
+ return -1
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function _M() {
|
|
|
+ this.group = new Ci
|
|
|
+ }
|
|
|
+ var wM = _M.prototype;
|
|
|
+ wM.isPersistent = function() {
|
|
|
+ return !this._incremental
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ wM.updateData = function(t) {
|
|
|
+ this.group.removeAll();
|
|
|
+ var e = new xM({
|
|
|
+ rectHover: !0,
|
|
|
+ cursor: "default"
|
|
|
+ });
|
|
|
+ e.setShape({
|
|
|
+ segs: t.getLayout("linesPoints")
|
|
|
+ }),
|
|
|
+ this._setCommon(e, t),
|
|
|
+ this.group.add(e),
|
|
|
+ this._incremental = null
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ wM.incrementalPrepareUpdate = function(t) {
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._clearIncremental(),
|
|
|
+ 5e5 < t.count() ? (this._incremental || (this._incremental = new vs({
|
|
|
+ silent: !0
|
|
|
+ })),
|
|
|
+ this.group.add(this._incremental)) : this._incremental = null
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ wM.incrementalUpdate = function(t, e) {
|
|
|
+ var i = new xM;
|
|
|
+ i.setShape({
|
|
|
+ segs: e.getLayout("linesPoints")
|
|
|
+ }),
|
|
|
+ this._setCommon(i, e, !!this._incremental),
|
|
|
+ this._incremental ? this._incremental.addDisplayable(i, !0) : (i.rectHover = !0,
|
|
|
+ i.cursor = "default",
|
|
|
+ i.__startIndex = t.start,
|
|
|
+ this.group.add(i))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ wM.remove = function() {
|
|
|
+ this._clearIncremental(),
|
|
|
+ this._incremental = null,
|
|
|
+ this.group.removeAll()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ wM._setCommon = function(i, t, e) {
|
|
|
+ var n = t.hostModel;
|
|
|
+ i.setShape({
|
|
|
+ polyline: n.get("polyline"),
|
|
|
+ curveness: n.get("lineStyle.curveness")
|
|
|
+ }),
|
|
|
+ i.useStyle(n.getModel("lineStyle").getLineStyle()),
|
|
|
+ i.style.strokeNoScale = !0;
|
|
|
+ var o = t.getVisual("color");
|
|
|
+ o && i.setStyle("stroke", o),
|
|
|
+ i.setStyle("fill"),
|
|
|
+ e || (i.seriesIndex = n.seriesIndex,
|
|
|
+ i.on("mousemove", function(t) {
|
|
|
+ i.dataIndex = null;
|
|
|
+ var e = i.findDataIndex(t.offsetX, t.offsetY);
|
|
|
+ 0 < e && (i.dataIndex = e + i.__startIndex)
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ wM._clearIncremental = function() {
|
|
|
+ var t = this._incremental;
|
|
|
+ t && t.clearDisplaybles()
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var bM = {
|
|
|
+ seriesType: "lines",
|
|
|
+ plan: vc(),
|
|
|
+ reset: function(g) {
|
|
|
+ var m = g.coordinateSystem
|
|
|
+ , v = g.get("polyline")
|
|
|
+ , y = g.pipelineContext.large;
|
|
|
+ return {
|
|
|
+ progress: function(t, e) {
|
|
|
+ var i = [];
|
|
|
+ if (y) {
|
|
|
+ var n, o = t.end - t.start;
|
|
|
+ if (v) {
|
|
|
+ for (var a = 0, r = t.start; r < t.end; r++)
|
|
|
+ a += g.getLineCoordsCount(r);
|
|
|
+ n = new Float32Array(o + 2 * a)
|
|
|
+ } else
|
|
|
+ n = new Float32Array(4 * o);
|
|
|
+ var s = 0
|
|
|
+ , l = [];
|
|
|
+ for (r = t.start; r < t.end; r++) {
|
|
|
+ var u = g.getLineCoords(r, i);
|
|
|
+ v && (n[s++] = u);
|
|
|
+ for (var h = 0; h < u; h++)
|
|
|
+ l = m.dataToPoint(i[h], !1, l),
|
|
|
+ n[s++] = l[0],
|
|
|
+ n[s++] = l[1]
|
|
|
+ }
|
|
|
+ e.setLayout("linesPoints", n)
|
|
|
+ } else
|
|
|
+ for (r = t.start; r < t.end; r++) {
|
|
|
+ var c = e.getItemModel(r)
|
|
|
+ , d = (u = g.getLineCoords(r, i),
|
|
|
+ []);
|
|
|
+ if (v)
|
|
|
+ for (var f = 0; f < u; f++)
|
|
|
+ d.push(m.dataToPoint(i[f]));
|
|
|
+ else {
|
|
|
+ d[0] = m.dataToPoint(i[0]),
|
|
|
+ d[1] = m.dataToPoint(i[1]);
|
|
|
+ var p = c.get("lineStyle.curveness");
|
|
|
+ +p && (d[2] = [(d[0][0] + d[1][0]) / 2 - (d[0][1] - d[1][1]) * p, (d[0][1] + d[1][1]) / 2 - (d[1][0] - d[0][0]) * p])
|
|
|
+ }
|
|
|
+ e.setItemLayout(r, d)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function SM(t) {
|
|
|
+ return t instanceof Array || (t = [t, t]),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ Cf({
|
|
|
+ type: "lines",
|
|
|
+ init: function() {},
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var n = t.getData()
|
|
|
+ , o = this._updateLineDraw(n, t)
|
|
|
+ , a = t.get("zlevel")
|
|
|
+ , r = t.get("effect.trailLength")
|
|
|
+ , s = i.getZr()
|
|
|
+ , l = "svg" === s.painter.getType();
|
|
|
+ l || s.painter.getLayer(a).clear(!0),
|
|
|
+ null == this._lastZlevel || l || s.configLayer(this._lastZlevel, {
|
|
|
+ motionBlur: !1
|
|
|
+ }),
|
|
|
+ this._showEffect(t) && r && (l || s.configLayer(a, {
|
|
|
+ motionBlur: !0,
|
|
|
+ lastFrameAlpha: Math.max(Math.min(r / 10 + .9, 1), 0)
|
|
|
+ })),
|
|
|
+ o.updateData(n);
|
|
|
+ var u = t.get("clip", !0) && Sm(t.coordinateSystem, !1, t);
|
|
|
+ u ? this.group.setClipPath(u) : this.group.removeClipPath(),
|
|
|
+ this._lastZlevel = a,
|
|
|
+ this._finished = !0
|
|
|
+ },
|
|
|
+ incrementalPrepareRender: function(t, e, i) {
|
|
|
+ var n = t.getData();
|
|
|
+ this._updateLineDraw(n, t).incrementalPrepareUpdate(n),
|
|
|
+ this._clearLayer(i),
|
|
|
+ this._finished = !1
|
|
|
+ },
|
|
|
+ incrementalRender: function(t, e, i) {
|
|
|
+ this._lineDraw.incrementalUpdate(t, e.getData()),
|
|
|
+ this._finished = t.end === e.getData().count()
|
|
|
+ },
|
|
|
+ updateTransform: function(t, e, i) {
|
|
|
+ var n = t.getData()
|
|
|
+ , o = t.pipelineContext;
|
|
|
+ if (!this._finished || o.large || o.progressiveRender)
|
|
|
+ return {
|
|
|
+ update: !0
|
|
|
+ };
|
|
|
+ var a = bM.reset(t);
|
|
|
+ a.progress && a.progress({
|
|
|
+ start: 0,
|
|
|
+ end: n.count()
|
|
|
+ }, n),
|
|
|
+ this._lineDraw.updateLayout(),
|
|
|
+ this._clearLayer(i)
|
|
|
+ },
|
|
|
+ _updateLineDraw: function(t, e) {
|
|
|
+ var i = this._lineDraw
|
|
|
+ , n = this._showEffect(e)
|
|
|
+ , o = !!e.get("polyline")
|
|
|
+ , a = e.pipelineContext.large;
|
|
|
+ return i && n === this._hasEffet && o === this._isPolyline && a === this._isLargeDraw || (i && i.remove(),
|
|
|
+ i = this._lineDraw = a ? new _M : new pw(o ? n ? vM : gM : n ? fM : dw),
|
|
|
+ this._hasEffet = n,
|
|
|
+ this._isPolyline = o,
|
|
|
+ this._isLargeDraw = a,
|
|
|
+ this.group.removeAll()),
|
|
|
+ this.group.add(i.group),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ _showEffect: function(t) {
|
|
|
+ return !!t.get("effect.show")
|
|
|
+ },
|
|
|
+ _clearLayer: function(t) {
|
|
|
+ var e = t.getZr();
|
|
|
+ "svg" === e.painter.getType() || null == this._lastZlevel || e.painter.getLayer(this._lastZlevel).clear(!0)
|
|
|
+ },
|
|
|
+ remove: function(t, e) {
|
|
|
+ this._lineDraw && this._lineDraw.remove(),
|
|
|
+ this._lineDraw = null,
|
|
|
+ this._clearLayer(e)
|
|
|
+ },
|
|
|
+ dispose: function() {}
|
|
|
+ });
|
|
|
+ var MM = "lineStyle.opacity".split(".")
|
|
|
+ , IM = {
|
|
|
+ seriesType: "lines",
|
|
|
+ reset: function(t, e, i) {
|
|
|
+ var n = SM(t.get("symbol"))
|
|
|
+ , o = SM(t.get("symbolSize"))
|
|
|
+ , a = t.getData();
|
|
|
+ return a.setVisual("fromSymbol", n && n[0]),
|
|
|
+ a.setVisual("toSymbol", n && n[1]),
|
|
|
+ a.setVisual("fromSymbolSize", o && o[0]),
|
|
|
+ a.setVisual("toSymbolSize", o && o[1]),
|
|
|
+ a.setVisual("opacity", t.get(MM)),
|
|
|
+ {
|
|
|
+ dataEach: a.hasItemOption ? function(t, e) {
|
|
|
+ var i = t.getItemModel(e)
|
|
|
+ , n = SM(i.getShallow("symbol", !0))
|
|
|
+ , o = SM(i.getShallow("symbolSize", !0))
|
|
|
+ , a = i.get(MM);
|
|
|
+ n[0] && t.setItemVisual(e, "fromSymbol", n[0]),
|
|
|
+ n[1] && t.setItemVisual(e, "toSymbol", n[1]),
|
|
|
+ o[0] && t.setItemVisual(e, "fromSymbolSize", o[0]),
|
|
|
+ o[1] && t.setItemVisual(e, "toSymbolSize", o[1]),
|
|
|
+ t.setItemVisual(e, "opacity", a)
|
|
|
+ }
|
|
|
+ : null
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ bf(bM),
|
|
|
+ Sf(IM),
|
|
|
+ sc.extend({
|
|
|
+ type: "series.heatmap",
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return gp(this.getSource(), this, {
|
|
|
+ generateCoord: "value"
|
|
|
+ })
|
|
|
+ },
|
|
|
+ preventIncremental: function() {
|
|
|
+ var t = lh.get(this.get("coordinateSystem"));
|
|
|
+ if (t && t.dimensions)
|
|
|
+ return "lng" === t.dimensions[0] && "lat" === t.dimensions[1]
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ coordinateSystem: "cartesian2d",
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ geoIndex: 0,
|
|
|
+ blurSize: 30,
|
|
|
+ pointSize: 20,
|
|
|
+ maxOpacity: 1,
|
|
|
+ minOpacity: 0
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function TM() {
|
|
|
+ var t = y();
|
|
|
+ this.canvas = t,
|
|
|
+ this.blurSize = 30,
|
|
|
+ this.pointSize = 20,
|
|
|
+ this.maxOpacity = 1,
|
|
|
+ this.minOpacity = 0,
|
|
|
+ this._gradientPixels = {}
|
|
|
+ }
|
|
|
+ TM.prototype = {
|
|
|
+ update: function(t, e, i, n, o, a) {
|
|
|
+ var r = this._getBrush()
|
|
|
+ , s = this._getGradient(t, o, "inRange")
|
|
|
+ , l = this._getGradient(t, o, "outOfRange")
|
|
|
+ , u = this.pointSize + this.blurSize
|
|
|
+ , h = this.canvas
|
|
|
+ , c = h.getContext("2d")
|
|
|
+ , d = t.length;
|
|
|
+ h.width = e,
|
|
|
+ h.height = i;
|
|
|
+ for (var f = 0; f < d; ++f) {
|
|
|
+ var p = t[f]
|
|
|
+ , g = p[0]
|
|
|
+ , m = p[1]
|
|
|
+ , v = n(p[2]);
|
|
|
+ c.globalAlpha = v,
|
|
|
+ c.drawImage(r, g - u, m - u)
|
|
|
+ }
|
|
|
+ if (!h.width || !h.height)
|
|
|
+ return h;
|
|
|
+ for (var y = c.getImageData(0, 0, h.width, h.height), x = y.data, _ = 0, w = x.length, b = this.minOpacity, S = this.maxOpacity - b; _ < w; ) {
|
|
|
+ v = x[_ + 3] / 256;
|
|
|
+ var M = 4 * Math.floor(255 * v);
|
|
|
+ if (0 < v) {
|
|
|
+ var I = a(v) ? s : l;
|
|
|
+ 0 < v && (v = v * S + b),
|
|
|
+ x[_++] = I[M],
|
|
|
+ x[_++] = I[1 + M],
|
|
|
+ x[_++] = I[2 + M],
|
|
|
+ x[_++] = I[3 + M] * v * 256
|
|
|
+ } else
|
|
|
+ _ += 4
|
|
|
+ }
|
|
|
+ return c.putImageData(y, 0, 0),
|
|
|
+ h
|
|
|
+ },
|
|
|
+ _getBrush: function() {
|
|
|
+ var t = this._brushCanvas || (this._brushCanvas = y())
|
|
|
+ , e = this.pointSize + this.blurSize
|
|
|
+ , i = 2 * e;
|
|
|
+ t.width = i,
|
|
|
+ t.height = i;
|
|
|
+ var n = t.getContext("2d");
|
|
|
+ return n.clearRect(0, 0, i, i),
|
|
|
+ n.shadowOffsetX = i,
|
|
|
+ n.shadowBlur = this.blurSize,
|
|
|
+ n.shadowColor = "#000",
|
|
|
+ n.beginPath(),
|
|
|
+ n.arc(-e, e, this.pointSize, 0, 2 * Math.PI, !0),
|
|
|
+ n.closePath(),
|
|
|
+ n.fill(),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ _getGradient: function(t, e, i) {
|
|
|
+ for (var n = this._gradientPixels, o = n[i] || (n[i] = new Uint8ClampedArray(1024)), a = [0, 0, 0, 0], r = 0, s = 0; s < 256; s++)
|
|
|
+ e[i](s / 255, !0, a),
|
|
|
+ o[r++] = a[0],
|
|
|
+ o[r++] = a[1],
|
|
|
+ o[r++] = a[2],
|
|
|
+ o[r++] = a[3];
|
|
|
+ return o
|
|
|
+ }
|
|
|
+ },
|
|
|
+ Cf({
|
|
|
+ type: "heatmap",
|
|
|
+ render: function(i, t, e) {
|
|
|
+ var n;
|
|
|
+ t.eachComponent("visualMap", function(e) {
|
|
|
+ e.eachTargetSeries(function(t) {
|
|
|
+ t === i && (n = e)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._incrementalDisplayable = null;
|
|
|
+ var o = i.coordinateSystem;
|
|
|
+ "cartesian2d" === o.type || "calendar" === o.type ? this._renderOnCartesianAndCalendar(i, e, 0, i.getData().count()) : function(t) {
|
|
|
+ var e = t.dimensions;
|
|
|
+ return "lng" === e[0] && "lat" === e[1]
|
|
|
+ }(o) && this._renderOnGeo(o, i, n, e)
|
|
|
+ },
|
|
|
+ incrementalPrepareRender: function(t, e, i) {
|
|
|
+ this.group.removeAll()
|
|
|
+ },
|
|
|
+ incrementalRender: function(t, e, i, n) {
|
|
|
+ e.coordinateSystem && this._renderOnCartesianAndCalendar(e, n, t.start, t.end, !0)
|
|
|
+ },
|
|
|
+ _renderOnCartesianAndCalendar: function(t, e, i, n, o) {
|
|
|
+ var a, r, s = t.coordinateSystem;
|
|
|
+ if ("cartesian2d" === s.type) {
|
|
|
+ var l = s.getAxis("x")
|
|
|
+ , u = s.getAxis("y");
|
|
|
+ a = l.getBandWidth(),
|
|
|
+ r = u.getBandWidth()
|
|
|
+ }
|
|
|
+ for (var h = this.group, c = t.getData(), d = "emphasis.itemStyle", f = "emphasis.label", p = t.getModel("itemStyle").getItemStyle(["color"]), g = t.getModel(d).getItemStyle(), m = t.getModel("label"), v = t.getModel(f), y = s.type, x = "cartesian2d" === y ? [c.mapDimension("x"), c.mapDimension("y"), c.mapDimension("value")] : [c.mapDimension("time"), c.mapDimension("value")], _ = i; _ < n; _++) {
|
|
|
+ var w;
|
|
|
+ if ("cartesian2d" === y) {
|
|
|
+ if (isNaN(c.get(x[2], _)))
|
|
|
+ continue;
|
|
|
+ var b = s.dataToPoint([c.get(x[0], _), c.get(x[1], _)]);
|
|
|
+ w = new rs({
|
|
|
+ shape: {
|
|
|
+ x: Math.floor(Math.round(b[0]) - a / 2),
|
|
|
+ y: Math.floor(Math.round(b[1]) - r / 2),
|
|
|
+ width: Math.ceil(a),
|
|
|
+ height: Math.ceil(r)
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ fill: c.getItemVisual(_, "color"),
|
|
|
+ opacity: c.getItemVisual(_, "opacity")
|
|
|
+ }
|
|
|
+ })
|
|
|
+ } else {
|
|
|
+ if (isNaN(c.get(x[1], _)))
|
|
|
+ continue;
|
|
|
+ w = new rs({
|
|
|
+ z2: 1,
|
|
|
+ shape: s.dataToRect([c.get(x[0], _)]).contentShape,
|
|
|
+ style: {
|
|
|
+ fill: c.getItemVisual(_, "color"),
|
|
|
+ opacity: c.getItemVisual(_, "opacity")
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var S = c.getItemModel(_);
|
|
|
+ c.hasItemOption && (p = S.getModel("itemStyle").getItemStyle(["color"]),
|
|
|
+ g = S.getModel(d).getItemStyle(),
|
|
|
+ m = S.getModel("label"),
|
|
|
+ v = S.getModel(f));
|
|
|
+ var M = t.getRawValue(_)
|
|
|
+ , I = "-";
|
|
|
+ M && null != M[2] && (I = M[2]),
|
|
|
+ el(p, g, m, v, {
|
|
|
+ labelFetcher: t,
|
|
|
+ labelDataIndex: _,
|
|
|
+ defaultText: I,
|
|
|
+ isRectText: !0
|
|
|
+ }),
|
|
|
+ w.setStyle(p),
|
|
|
+ $s(w, c.hasItemOption ? g : P({}, g)),
|
|
|
+ (w.incremental = o) && (w.useHoverLayer = !0),
|
|
|
+ h.add(w),
|
|
|
+ c.setItemGraphicEl(_, w)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderOnGeo: function(o, t, e, i) {
|
|
|
+ var n = e.targetVisuals.inRange
|
|
|
+ , a = e.targetVisuals.outOfRange
|
|
|
+ , r = t.getData()
|
|
|
+ , s = this._hmLayer || this._hmLayer || new TM;
|
|
|
+ s.blurSize = t.get("blurSize"),
|
|
|
+ s.pointSize = t.get("pointSize"),
|
|
|
+ s.minOpacity = t.get("minOpacity"),
|
|
|
+ s.maxOpacity = t.get("maxOpacity");
|
|
|
+ var l = o.getViewRect().clone()
|
|
|
+ , u = o.getRoamTransform();
|
|
|
+ l.applyTransform(u);
|
|
|
+ var h = Math.max(l.x, 0)
|
|
|
+ , c = Math.max(l.y, 0)
|
|
|
+ , d = Math.min(l.width + l.x, i.getWidth())
|
|
|
+ , f = Math.min(l.height + l.y, i.getHeight())
|
|
|
+ , p = d - h
|
|
|
+ , g = f - c
|
|
|
+ , m = [r.mapDimension("lng"), r.mapDimension("lat"), r.mapDimension("value")]
|
|
|
+ , v = r.mapArray(m, function(t, e, i) {
|
|
|
+ var n = o.dataToPoint([t, e]);
|
|
|
+ return n[0] -= h,
|
|
|
+ n[1] -= c,
|
|
|
+ n.push(i),
|
|
|
+ n
|
|
|
+ })
|
|
|
+ , y = e.getExtent()
|
|
|
+ , x = "visualMap.continuous" === e.type ? function(t, e) {
|
|
|
+ var i = t[1] - t[0];
|
|
|
+ return e = [(e[0] - t[0]) / i, (e[1] - t[0]) / i],
|
|
|
+ function(t) {
|
|
|
+ return t >= e[0] && t <= e[1]
|
|
|
+ }
|
|
|
+ }(y, e.option.range) : function(e, n, o) {
|
|
|
+ var i = e[1] - e[0]
|
|
|
+ , a = (n = O(n, function(t) {
|
|
|
+ return {
|
|
|
+ interval: [(t.interval[0] - e[0]) / i, (t.interval[1] - e[0]) / i]
|
|
|
+ }
|
|
|
+ })).length
|
|
|
+ , r = 0;
|
|
|
+ return function(t) {
|
|
|
+ for (var e = r; e < a; e++) {
|
|
|
+ if ((i = n[e].interval)[0] <= t && t <= i[1]) {
|
|
|
+ r = e;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (e === a)
|
|
|
+ for (e = r - 1; 0 <= e; e--) {
|
|
|
+ var i;
|
|
|
+ if ((i = n[e].interval)[0] <= t && t <= i[1]) {
|
|
|
+ r = e;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0 <= e && e < a && o[e]
|
|
|
+ }
|
|
|
+ }(y, e.getPieceList(), e.option.selected);
|
|
|
+ s.update(v, p, g, n.color.getNormalizer(), {
|
|
|
+ inRange: n.color.getColorMapper(),
|
|
|
+ outOfRange: a.color.getColorMapper()
|
|
|
+ }, x);
|
|
|
+ var _ = new Qn({
|
|
|
+ style: {
|
|
|
+ width: p,
|
|
|
+ height: g,
|
|
|
+ x: h,
|
|
|
+ y: c,
|
|
|
+ image: s.canvas
|
|
|
+ },
|
|
|
+ silent: !0
|
|
|
+ });
|
|
|
+ this.group.add(_)
|
|
|
+ },
|
|
|
+ dispose: function() {}
|
|
|
+ });
|
|
|
+ var AM = Tv.extend({
|
|
|
+ type: "series.pictorialBar",
|
|
|
+ dependencies: ["grid"],
|
|
|
+ defaultOption: {
|
|
|
+ symbol: "circle",
|
|
|
+ symbolSize: null,
|
|
|
+ symbolRotate: null,
|
|
|
+ symbolPosition: null,
|
|
|
+ symbolOffset: null,
|
|
|
+ symbolMargin: null,
|
|
|
+ symbolRepeat: !1,
|
|
|
+ symbolRepeatDirection: "end",
|
|
|
+ symbolClip: !1,
|
|
|
+ symbolBoundingData: null,
|
|
|
+ symbolPatternSize: 400,
|
|
|
+ barGap: "-100%",
|
|
|
+ progressive: 0,
|
|
|
+ hoverAnimation: !1
|
|
|
+ },
|
|
|
+ getInitialData: function(t) {
|
|
|
+ return t.stack = null,
|
|
|
+ AM.superApply(this, "getInitialData", arguments)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , DM = ["itemStyle", "borderWidth"]
|
|
|
+ , CM = [{
|
|
|
+ xy: "x",
|
|
|
+ wh: "width",
|
|
|
+ index: 0,
|
|
|
+ posDesc: ["left", "right"]
|
|
|
+ }, {
|
|
|
+ xy: "y",
|
|
|
+ wh: "height",
|
|
|
+ index: 1,
|
|
|
+ posDesc: ["top", "bottom"]
|
|
|
+ }]
|
|
|
+ , LM = new Yr;
|
|
|
+ Cf({
|
|
|
+ type: "pictorialBar",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var r = this.group
|
|
|
+ , s = t.getData()
|
|
|
+ , l = this._data
|
|
|
+ , n = t.coordinateSystem
|
|
|
+ , o = !!n.getBaseAxis().isHorizontal()
|
|
|
+ , a = n.grid.getRect()
|
|
|
+ , u = {
|
|
|
+ ecSize: {
|
|
|
+ width: i.getWidth(),
|
|
|
+ height: i.getHeight()
|
|
|
+ },
|
|
|
+ seriesModel: t,
|
|
|
+ coordSys: n,
|
|
|
+ coordSysExtent: [[a.x, a.x + a.width], [a.y, a.y + a.height]],
|
|
|
+ isHorizontal: o,
|
|
|
+ valueDim: CM[+o],
|
|
|
+ categoryDim: CM[1 - o]
|
|
|
+ };
|
|
|
+ return s.diff(l).add(function(t) {
|
|
|
+ if (s.hasValue(t)) {
|
|
|
+ var e = BM(s, t)
|
|
|
+ , i = kM(s, t, e, u)
|
|
|
+ , n = WM(s, u, i);
|
|
|
+ s.setItemGraphicEl(t, n),
|
|
|
+ r.add(n),
|
|
|
+ YM(n, u, i)
|
|
|
+ }
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = l.getItemGraphicEl(e);
|
|
|
+ if (s.hasValue(t)) {
|
|
|
+ var n = BM(s, t)
|
|
|
+ , o = kM(s, t, n, u)
|
|
|
+ , a = ZM(s, o);
|
|
|
+ i && a !== i.__pictorialShapeStr && (r.remove(i),
|
|
|
+ s.setItemGraphicEl(t, null),
|
|
|
+ i = null),
|
|
|
+ i ? function(t, e, i) {
|
|
|
+ var n = i.animationModel
|
|
|
+ , o = i.dataIndex;
|
|
|
+ cl(t.__pictorialBundle, {
|
|
|
+ position: i.bundlePosition.slice()
|
|
|
+ }, n, o),
|
|
|
+ i.symbolRepeat ? OM(t, e, i, !0) : EM(t, e, i, !0);
|
|
|
+ RM(t, i, !0),
|
|
|
+ zM(t, e, i, !0)
|
|
|
+ }(i, u, o) : i = WM(s, u, o, !0),
|
|
|
+ s.setItemGraphicEl(t, i),
|
|
|
+ i.__pictorialSymbolMeta = o,
|
|
|
+ r.add(i),
|
|
|
+ YM(i, u, o)
|
|
|
+ } else
|
|
|
+ r.remove(i)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = l.getItemGraphicEl(t);
|
|
|
+ e && HM(l, t, e.__pictorialSymbolMeta.animationModel, e)
|
|
|
+ }).execute(),
|
|
|
+ this._data = s,
|
|
|
+ this.group
|
|
|
+ },
|
|
|
+ dispose: et,
|
|
|
+ remove: function(e, t) {
|
|
|
+ var i = this.group
|
|
|
+ , n = this._data;
|
|
|
+ e.get("animation") ? n && n.eachItemGraphicEl(function(t) {
|
|
|
+ HM(n, t.dataIndex, e, t)
|
|
|
+ }) : i.removeAll()
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function kM(t, e, i, n) {
|
|
|
+ var o = t.getItemLayout(e)
|
|
|
+ , a = i.get("symbolRepeat")
|
|
|
+ , r = i.get("symbolClip")
|
|
|
+ , s = i.get("symbolPosition") || "start"
|
|
|
+ , l = (i.get("symbolRotate") || 0) * Math.PI / 180 || 0
|
|
|
+ , u = i.get("symbolPatternSize") || 2
|
|
|
+ , h = i.isAnimationEnabled()
|
|
|
+ , c = {
|
|
|
+ dataIndex: e,
|
|
|
+ layout: o,
|
|
|
+ itemModel: i,
|
|
|
+ symbolType: t.getItemVisual(e, "symbol") || "circle",
|
|
|
+ color: t.getItemVisual(e, "color"),
|
|
|
+ symbolClip: r,
|
|
|
+ symbolRepeat: a,
|
|
|
+ symbolRepeatDirection: i.get("symbolRepeatDirection"),
|
|
|
+ symbolPatternSize: u,
|
|
|
+ rotation: l,
|
|
|
+ animationModel: h ? i : null,
|
|
|
+ hoverAnimation: h && i.get("hoverAnimation"),
|
|
|
+ z2: i.getShallow("z", !0) || 0
|
|
|
+ };
|
|
|
+ !function(t, e, i, n, o) {
|
|
|
+ var a, r = n.valueDim, s = t.get("symbolBoundingData"), l = n.coordSys.getOtherAxis(n.coordSys.getBaseAxis()), u = l.toGlobalCoord(l.dataToCoord(0)), h = 1 - +(i[r.wh] <= 0);
|
|
|
+ if (L(s)) {
|
|
|
+ var c = [PM(l, s[0]) - u, PM(l, s[1]) - u];
|
|
|
+ c[1] < c[0] && c.reverse(),
|
|
|
+ a = c[h]
|
|
|
+ } else
|
|
|
+ a = null != s ? PM(l, s) - u : e ? n.coordSysExtent[r.index][h] - u : i[r.wh];
|
|
|
+ o.boundingLength = a,
|
|
|
+ e && (o.repeatCutLength = i[r.wh]);
|
|
|
+ o.pxSign = 0 < a ? 1 : a < 0 ? -1 : 0
|
|
|
+ }(i, a, o, n, c),
|
|
|
+ function(t, e, i, n, o, a, r, s, l, u) {
|
|
|
+ var h = l.valueDim
|
|
|
+ , c = l.categoryDim
|
|
|
+ , d = Math.abs(i[c.wh])
|
|
|
+ , f = t.getItemVisual(e, "symbolSize");
|
|
|
+ f = L(f) ? f.slice() : (null == f && (f = "100%"),
|
|
|
+ [f, f]);
|
|
|
+ f[c.index] = Rl(f[c.index], d),
|
|
|
+ f[h.index] = Rl(f[h.index], n ? d : Math.abs(a)),
|
|
|
+ u.symbolSize = f,
|
|
|
+ (u.symbolScale = [f[0] / s, f[1] / s])[h.index] *= (l.isHorizontal ? -1 : 1) * r
|
|
|
+ }(t, e, o, a, 0, c.boundingLength, c.pxSign, u, n, c),
|
|
|
+ function(t, e, i, n, o) {
|
|
|
+ var a = t.get(DM) || 0;
|
|
|
+ a && (LM.attr({
|
|
|
+ scale: e.slice(),
|
|
|
+ rotation: i
|
|
|
+ }),
|
|
|
+ LM.updateTransform(),
|
|
|
+ a /= LM.getLineScale(),
|
|
|
+ a *= e[n.valueDim.index]);
|
|
|
+ o.valueLineWidth = a
|
|
|
+ }(i, c.symbolScale, l, n, c);
|
|
|
+ var d = c.symbolSize
|
|
|
+ , f = i.get("symbolOffset");
|
|
|
+ return L(f) && (f = [Rl(f[0], d[0]), Rl(f[1], d[1])]),
|
|
|
+ function(t, e, i, n, o, a, r, s, l, u, h, c) {
|
|
|
+ var d = h.categoryDim
|
|
|
+ , f = h.valueDim
|
|
|
+ , p = c.pxSign
|
|
|
+ , g = Math.max(e[f.index] + s, 0)
|
|
|
+ , m = g;
|
|
|
+ if (n) {
|
|
|
+ var v = Math.abs(l)
|
|
|
+ , y = W(t.get("symbolMargin"), "15%") + ""
|
|
|
+ , x = !1;
|
|
|
+ y.lastIndexOf("!") === y.length - 1 && (x = !0,
|
|
|
+ y = y.slice(0, y.length - 1)),
|
|
|
+ y = Rl(y, e[f.index]);
|
|
|
+ var _ = Math.max(g + 2 * y, 0)
|
|
|
+ , w = x ? 0 : 2 * y
|
|
|
+ , b = Jl(n)
|
|
|
+ , S = b ? n : jM((v + w) / _);
|
|
|
+ _ = g + 2 * (y = (v - S * g) / 2 / (x ? S : S - 1)),
|
|
|
+ w = x ? 0 : 2 * y,
|
|
|
+ b || "fixed" === n || (S = u ? jM((Math.abs(u) + w) / _) : 0),
|
|
|
+ m = S * _ - w,
|
|
|
+ c.repeatTimes = S,
|
|
|
+ c.symbolMargin = y
|
|
|
+ }
|
|
|
+ var M = p * (m / 2)
|
|
|
+ , I = c.pathPosition = [];
|
|
|
+ I[d.index] = i[d.wh] / 2,
|
|
|
+ I[f.index] = "start" === r ? M : "end" === r ? l - M : l / 2,
|
|
|
+ a && (I[0] += a[0],
|
|
|
+ I[1] += a[1]);
|
|
|
+ var T = c.bundlePosition = [];
|
|
|
+ T[d.index] = i[d.xy],
|
|
|
+ T[f.index] = i[f.xy];
|
|
|
+ var A = c.barRectShape = P({}, i);
|
|
|
+ A[f.wh] = p * Math.max(Math.abs(i[f.wh]), Math.abs(I[f.index] + M)),
|
|
|
+ A[d.wh] = i[d.wh];
|
|
|
+ var D = c.clipShape = {};
|
|
|
+ D[d.xy] = -i[d.xy],
|
|
|
+ D[d.wh] = h.ecSize[d.wh],
|
|
|
+ D[f.xy] = 0,
|
|
|
+ D[f.wh] = i[f.wh]
|
|
|
+ }(i, d, o, a, 0, f, s, c.valueLineWidth, c.boundingLength, c.repeatCutLength, n, c),
|
|
|
+ c
|
|
|
+ }
|
|
|
+ function PM(t, e) {
|
|
|
+ return t.toGlobalCoord(t.dataToCoord(t.scale.parse(e)))
|
|
|
+ }
|
|
|
+ function NM(t) {
|
|
|
+ var e = t.symbolPatternSize
|
|
|
+ , i = wg(t.symbolType, -e / 2, -e / 2, e, e, t.color);
|
|
|
+ return i.attr({
|
|
|
+ culling: !0
|
|
|
+ }),
|
|
|
+ "image" !== i.type && i.setStyle({
|
|
|
+ strokeNoScale: !0
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function OM(t, e, o, i) {
|
|
|
+ var n = t.__pictorialBundle
|
|
|
+ , a = o.symbolSize
|
|
|
+ , r = o.valueLineWidth
|
|
|
+ , s = o.pathPosition
|
|
|
+ , l = e.valueDim
|
|
|
+ , u = o.repeatTimes || 0
|
|
|
+ , h = 0
|
|
|
+ , c = a[e.valueDim.index] + r + 2 * o.symbolMargin;
|
|
|
+ for (UM(t, function(t) {
|
|
|
+ t.__pictorialAnimationIndex = h,
|
|
|
+ t.__pictorialRepeatTimes = u,
|
|
|
+ h < u ? XM(t, null, p(h), o, i) : XM(t, null, {
|
|
|
+ scale: [0, 0]
|
|
|
+ }, o, i, function() {
|
|
|
+ n.remove(t)
|
|
|
+ }),
|
|
|
+ FM(t, o),
|
|
|
+ h++
|
|
|
+ }); h < u; h++) {
|
|
|
+ var d = NM(o);
|
|
|
+ d.__pictorialAnimationIndex = h,
|
|
|
+ d.__pictorialRepeatTimes = u,
|
|
|
+ n.add(d);
|
|
|
+ var f = p(h);
|
|
|
+ XM(d, {
|
|
|
+ position: f.position,
|
|
|
+ scale: [0, 0]
|
|
|
+ }, {
|
|
|
+ scale: f.scale,
|
|
|
+ rotation: f.rotation
|
|
|
+ }, o, i),
|
|
|
+ d.on("mouseover", g).on("mouseout", m),
|
|
|
+ FM(d, o)
|
|
|
+ }
|
|
|
+ function p(t) {
|
|
|
+ var e = s.slice()
|
|
|
+ , i = o.pxSign
|
|
|
+ , n = t;
|
|
|
+ return ("start" === o.symbolRepeatDirection ? 0 < i : i < 0) && (n = u - 1 - t),
|
|
|
+ e[l.index] = c * (n - u / 2 + .5) + s[l.index],
|
|
|
+ {
|
|
|
+ position: e,
|
|
|
+ scale: o.symbolScale.slice(),
|
|
|
+ rotation: o.rotation
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function g() {
|
|
|
+ UM(t, function(t) {
|
|
|
+ t.trigger("emphasis")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function m() {
|
|
|
+ UM(t, function(t) {
|
|
|
+ t.trigger("normal")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function EM(t, e, i, n) {
|
|
|
+ var o = t.__pictorialBundle
|
|
|
+ , a = t.__pictorialMainPath;
|
|
|
+ a ? XM(a, null, {
|
|
|
+ position: i.pathPosition.slice(),
|
|
|
+ scale: i.symbolScale.slice(),
|
|
|
+ rotation: i.rotation
|
|
|
+ }, i, n) : (a = t.__pictorialMainPath = NM(i),
|
|
|
+ o.add(a),
|
|
|
+ XM(a, {
|
|
|
+ position: i.pathPosition.slice(),
|
|
|
+ scale: [0, 0],
|
|
|
+ rotation: i.rotation
|
|
|
+ }, {
|
|
|
+ scale: i.symbolScale.slice()
|
|
|
+ }, i, n),
|
|
|
+ a.on("mouseover", function() {
|
|
|
+ this.trigger("emphasis")
|
|
|
+ }).on("mouseout", function() {
|
|
|
+ this.trigger("normal")
|
|
|
+ })),
|
|
|
+ FM(a, i)
|
|
|
+ }
|
|
|
+ function RM(t, e, i) {
|
|
|
+ var n = P({}, e.barRectShape)
|
|
|
+ , o = t.__pictorialBarRect;
|
|
|
+ o ? XM(o, null, {
|
|
|
+ shape: n
|
|
|
+ }, e, i) : (o = t.__pictorialBarRect = new rs({
|
|
|
+ z2: 2,
|
|
|
+ shape: n,
|
|
|
+ silent: !0,
|
|
|
+ style: {
|
|
|
+ stroke: "transparent",
|
|
|
+ fill: "transparent",
|
|
|
+ lineWidth: 0
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ t.add(o))
|
|
|
+ }
|
|
|
+ function zM(t, e, i, n) {
|
|
|
+ if (i.symbolClip) {
|
|
|
+ var o = t.__pictorialClipPath
|
|
|
+ , a = P({}, i.clipShape)
|
|
|
+ , r = e.valueDim
|
|
|
+ , s = i.animationModel
|
|
|
+ , l = i.dataIndex;
|
|
|
+ if (o)
|
|
|
+ cl(o, {
|
|
|
+ shape: a
|
|
|
+ }, s, l);
|
|
|
+ else {
|
|
|
+ a[r.wh] = 0,
|
|
|
+ o = new rs({
|
|
|
+ shape: a
|
|
|
+ }),
|
|
|
+ t.__pictorialBundle.setClipPath(o),
|
|
|
+ t.__pictorialClipPath = o;
|
|
|
+ var u = {};
|
|
|
+ u[r.wh] = i.clipShape[r.wh],
|
|
|
+ bl[n ? "updateProps" : "initProps"](o, {
|
|
|
+ shape: u
|
|
|
+ }, s, l)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function BM(t, e) {
|
|
|
+ var i = t.getItemModel(e);
|
|
|
+ return i.getAnimationDelayParams = VM,
|
|
|
+ i.isAnimationEnabled = GM,
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function VM(t) {
|
|
|
+ return {
|
|
|
+ index: t.__pictorialAnimationIndex,
|
|
|
+ count: t.__pictorialRepeatTimes
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function GM() {
|
|
|
+ return this.parentModel.isAnimationEnabled() && !!this.getShallow("animation")
|
|
|
+ }
|
|
|
+ function FM(t, e) {
|
|
|
+ t.off("emphasis").off("normal");
|
|
|
+ var i = e.symbolScale.slice();
|
|
|
+ e.hoverAnimation && t.on("emphasis", function() {
|
|
|
+ this.animateTo({
|
|
|
+ scale: [1.1 * i[0], 1.1 * i[1]]
|
|
|
+ }, 400, "elasticOut")
|
|
|
+ }).on("normal", function() {
|
|
|
+ this.animateTo({
|
|
|
+ scale: i.slice()
|
|
|
+ }, 400, "elasticOut")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function WM(t, e, i, n) {
|
|
|
+ var o = new Ci
|
|
|
+ , a = new Ci;
|
|
|
+ return o.add(a),
|
|
|
+ (o.__pictorialBundle = a).attr("position", i.bundlePosition.slice()),
|
|
|
+ i.symbolRepeat ? OM(o, e, i) : EM(o, 0, i),
|
|
|
+ RM(o, i, n),
|
|
|
+ zM(o, e, i, n),
|
|
|
+ o.__pictorialShapeStr = ZM(t, i),
|
|
|
+ o.__pictorialSymbolMeta = i,
|
|
|
+ o
|
|
|
+ }
|
|
|
+ function HM(t, e, i, n) {
|
|
|
+ var o = n.__pictorialBarRect;
|
|
|
+ o && (o.style.text = null);
|
|
|
+ var a = [];
|
|
|
+ UM(n, function(t) {
|
|
|
+ a.push(t)
|
|
|
+ }),
|
|
|
+ n.__pictorialMainPath && a.push(n.__pictorialMainPath),
|
|
|
+ n.__pictorialClipPath && (i = null),
|
|
|
+ E(a, function(t) {
|
|
|
+ cl(t, {
|
|
|
+ scale: [0, 0]
|
|
|
+ }, i, e, function() {
|
|
|
+ n.parent && n.parent.remove(n)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ t.setItemGraphicEl(e, null)
|
|
|
+ }
|
|
|
+ function ZM(t, e) {
|
|
|
+ return [t.getItemVisual(e.dataIndex, "symbol") || "none", !!e.symbolRepeat, !!e.symbolClip].join(":")
|
|
|
+ }
|
|
|
+ function UM(e, i, n) {
|
|
|
+ E(e.__pictorialBundle.children(), function(t) {
|
|
|
+ t !== e.__pictorialBarRect && i.call(n, t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function XM(t, e, i, n, o, a) {
|
|
|
+ e && t.attr(e),
|
|
|
+ n.symbolClip && !o ? i && t.attr(i) : i && bl[o ? "updateProps" : "initProps"](t, i, n.animationModel, n.dataIndex, a)
|
|
|
+ }
|
|
|
+ function YM(t, e, i) {
|
|
|
+ var n = i.color
|
|
|
+ , o = i.dataIndex
|
|
|
+ , a = i.itemModel
|
|
|
+ , r = a.getModel("itemStyle").getItemStyle(["color"])
|
|
|
+ , s = a.getModel("emphasis.itemStyle").getItemStyle()
|
|
|
+ , l = a.getShallow("cursor");
|
|
|
+ UM(t, function(t) {
|
|
|
+ t.setColor(n),
|
|
|
+ t.setStyle(D({
|
|
|
+ fill: n,
|
|
|
+ opacity: i.opacity
|
|
|
+ }, r)),
|
|
|
+ $s(t, s),
|
|
|
+ l && (t.cursor = l),
|
|
|
+ t.z2 = i.z2
|
|
|
+ });
|
|
|
+ var u = {}
|
|
|
+ , h = (e.valueDim.posDesc[+(0 < i.boundingLength)],
|
|
|
+ t.__pictorialBarRect);
|
|
|
+ Av(h.style, u, a, n, e.seriesModel, o),
|
|
|
+ $s(h, u)
|
|
|
+ }
|
|
|
+ function jM(t) {
|
|
|
+ var e = Math.round(t);
|
|
|
+ return Math.abs(t - e) < 1e-4 ? e : Math.ceil(t)
|
|
|
+ }
|
|
|
+ bf(T(zp, "pictorialBar")),
|
|
|
+ Sf(Lm("pictorialBar", "roundRect"));
|
|
|
+ function qM(t, e, i, n, o) {
|
|
|
+ Gg.call(this, t, e, i),
|
|
|
+ this.type = n || "value",
|
|
|
+ this.position = o || "bottom",
|
|
|
+ this.orient = null
|
|
|
+ }
|
|
|
+ function KM(t, e, i) {
|
|
|
+ this.dimension = "single",
|
|
|
+ this.dimensions = ["single"],
|
|
|
+ this._axis = null,
|
|
|
+ this._rect,
|
|
|
+ this._init(t, e, i),
|
|
|
+ this.model = t
|
|
|
+ }
|
|
|
+ function $M(t, e) {
|
|
|
+ e = e || {};
|
|
|
+ var i = t.coordinateSystem
|
|
|
+ , n = t.axis
|
|
|
+ , o = {}
|
|
|
+ , a = n.position
|
|
|
+ , r = n.orient
|
|
|
+ , s = i.getRect()
|
|
|
+ , l = [s.x, s.x + s.width, s.y, s.y + s.height]
|
|
|
+ , u = {
|
|
|
+ horizontal: {
|
|
|
+ top: l[2],
|
|
|
+ bottom: l[3]
|
|
|
+ },
|
|
|
+ vertical: {
|
|
|
+ left: l[0],
|
|
|
+ right: l[1]
|
|
|
+ }
|
|
|
+ };
|
|
|
+ o.position = ["vertical" === r ? u.vertical[a] : l[0], "horizontal" === r ? u.horizontal[a] : l[3]];
|
|
|
+ o.rotation = Math.PI / 2 * {
|
|
|
+ horizontal: 0,
|
|
|
+ vertical: 1
|
|
|
+ }[r];
|
|
|
+ o.labelDirection = o.tickDirection = o.nameDirection = {
|
|
|
+ top: -1,
|
|
|
+ bottom: 1,
|
|
|
+ right: 1,
|
|
|
+ left: -1
|
|
|
+ }[a],
|
|
|
+ t.get("axisTick.inside") && (o.tickDirection = -o.tickDirection),
|
|
|
+ W(e.labelInside, t.get("axisLabel.inside")) && (o.labelDirection = -o.labelDirection);
|
|
|
+ var h = e.rotate;
|
|
|
+ return null == h && (h = t.get("axisLabel.rotate")),
|
|
|
+ o.labelRotation = "top" === a ? -h : h,
|
|
|
+ o.z2 = 1,
|
|
|
+ o
|
|
|
+ }
|
|
|
+ qM.prototype = {
|
|
|
+ constructor: qM,
|
|
|
+ model: null,
|
|
|
+ isHorizontal: function() {
|
|
|
+ var t = this.position;
|
|
|
+ return "top" === t || "bottom" === t
|
|
|
+ },
|
|
|
+ pointToData: function(t, e) {
|
|
|
+ return this.coordinateSystem.pointToData(t, e)[0]
|
|
|
+ },
|
|
|
+ toGlobalCoord: null,
|
|
|
+ toLocalCoord: null
|
|
|
+ },
|
|
|
+ w(qM, Gg),
|
|
|
+ lh.register("single", {
|
|
|
+ create: function(n, o) {
|
|
|
+ var a = [];
|
|
|
+ return n.eachComponent("singleAxis", function(t, e) {
|
|
|
+ var i = new KM(t,n,o);
|
|
|
+ i.name = "single_" + e,
|
|
|
+ i.resize(t, o),
|
|
|
+ t.coordinateSystem = i,
|
|
|
+ a.push(i)
|
|
|
+ }),
|
|
|
+ n.eachSeries(function(t) {
|
|
|
+ if ("singleAxis" === t.get("coordinateSystem")) {
|
|
|
+ var e = n.queryComponents({
|
|
|
+ mainType: "singleAxis",
|
|
|
+ index: t.get("singleAxisIndex"),
|
|
|
+ id: t.get("singleAxisId")
|
|
|
+ })[0];
|
|
|
+ t.coordinateSystem = e && e.coordinateSystem
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ },
|
|
|
+ dimensions: (KM.prototype = {
|
|
|
+ type: "singleAxis",
|
|
|
+ axisPointerEnabled: !0,
|
|
|
+ constructor: KM,
|
|
|
+ _init: function(t, e, i) {
|
|
|
+ var n = this.dimension
|
|
|
+ , o = new qM(n,sg(t),[0, 0],t.get("type"),t.get("position"))
|
|
|
+ , a = "category" === o.type;
|
|
|
+ o.onBand = a && t.get("boundaryGap"),
|
|
|
+ o.inverse = t.get("inverse"),
|
|
|
+ o.orient = t.get("orient"),
|
|
|
+ (t.axis = o).model = t,
|
|
|
+ (o.coordinateSystem = this)._axis = o
|
|
|
+ },
|
|
|
+ update: function(t, e) {
|
|
|
+ t.eachSeries(function(t) {
|
|
|
+ if (t.coordinateSystem === this) {
|
|
|
+ var e = t.getData();
|
|
|
+ E(e.mapDimension(this.dimension, !0), function(t) {
|
|
|
+ this._axis.scale.unionExtentFromData(e, t)
|
|
|
+ }, this),
|
|
|
+ rg(this._axis.scale, this._axis.model)
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ resize: function(t, e) {
|
|
|
+ this._rect = bu({
|
|
|
+ left: t.get("left"),
|
|
|
+ top: t.get("top"),
|
|
|
+ right: t.get("right"),
|
|
|
+ bottom: t.get("bottom"),
|
|
|
+ width: t.get("width"),
|
|
|
+ height: t.get("height")
|
|
|
+ }, {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ }),
|
|
|
+ this._adjustAxis()
|
|
|
+ },
|
|
|
+ getRect: function() {
|
|
|
+ return this._rect
|
|
|
+ },
|
|
|
+ _adjustAxis: function() {
|
|
|
+ var t = this._rect
|
|
|
+ , e = this._axis
|
|
|
+ , i = e.isHorizontal()
|
|
|
+ , n = i ? [0, t.width] : [0, t.height]
|
|
|
+ , o = e.reverse ? 1 : 0;
|
|
|
+ e.setExtent(n[o], n[1 - o]),
|
|
|
+ this._updateAxisTransform(e, i ? t.x : t.y)
|
|
|
+ },
|
|
|
+ _updateAxisTransform: function(t, e) {
|
|
|
+ var i = t.getExtent()
|
|
|
+ , n = i[0] + i[1]
|
|
|
+ , o = t.isHorizontal();
|
|
|
+ t.toGlobalCoord = o ? function(t) {
|
|
|
+ return t + e
|
|
|
+ }
|
|
|
+ : function(t) {
|
|
|
+ return n - t + e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.toLocalCoord = o ? function(t) {
|
|
|
+ return t - e
|
|
|
+ }
|
|
|
+ : function(t) {
|
|
|
+ return n - t + e
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getAxis: function() {
|
|
|
+ return this._axis
|
|
|
+ },
|
|
|
+ getBaseAxis: function() {
|
|
|
+ return this._axis
|
|
|
+ },
|
|
|
+ getAxes: function() {
|
|
|
+ return [this._axis]
|
|
|
+ },
|
|
|
+ getTooltipAxes: function() {
|
|
|
+ return {
|
|
|
+ baseAxes: [this.getAxis()]
|
|
|
+ }
|
|
|
+ },
|
|
|
+ containPoint: function(t) {
|
|
|
+ var e = this.getRect()
|
|
|
+ , i = this.getAxis();
|
|
|
+ return "horizontal" === i.orient ? i.contain(i.toLocalCoord(t[0])) && t[1] >= e.y && t[1] <= e.y + e.height : i.contain(i.toLocalCoord(t[1])) && t[0] >= e.y && t[0] <= e.y + e.height
|
|
|
+ },
|
|
|
+ pointToData: function(t) {
|
|
|
+ var e = this.getAxis();
|
|
|
+ return [e.coordToData(e.toLocalCoord(t["horizontal" === e.orient ? 0 : 1]))]
|
|
|
+ },
|
|
|
+ dataToPoint: function(t) {
|
|
|
+ var e = this.getAxis()
|
|
|
+ , i = this.getRect()
|
|
|
+ , n = []
|
|
|
+ , o = "horizontal" === e.orient ? 0 : 1;
|
|
|
+ return t instanceof Array && (t = t[0]),
|
|
|
+ n[o] = e.toGlobalCoord(e.dataToCoord(+t)),
|
|
|
+ n[1 - o] = 0 == o ? i.y + i.height / 2 : i.x + i.width / 2,
|
|
|
+ n
|
|
|
+ }
|
|
|
+ }).dimensions
|
|
|
+ });
|
|
|
+ var JM = ["axisLine", "axisTickLabel", "axisName"]
|
|
|
+ , QM = ["splitArea", "splitLine"]
|
|
|
+ , tI = mv.extend({
|
|
|
+ type: "singleAxis",
|
|
|
+ axisPointerClass: "SingleAxisPointer",
|
|
|
+ render: function(e, t, i, n) {
|
|
|
+ var o = this.group;
|
|
|
+ o.removeAll();
|
|
|
+ var a = this._axisGroup;
|
|
|
+ this._axisGroup = new Ci;
|
|
|
+ var r = $M(e)
|
|
|
+ , s = new Qm(e,r);
|
|
|
+ E(JM, s.add, s),
|
|
|
+ o.add(this._axisGroup),
|
|
|
+ o.add(s.getGroup()),
|
|
|
+ E(QM, function(t) {
|
|
|
+ e.get(t + ".show") && this["_" + t](e)
|
|
|
+ }, this),
|
|
|
+ ml(a, this._axisGroup, e),
|
|
|
+ tI.superCall(this, "render", e, t, i, n)
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ bv(this)
|
|
|
+ },
|
|
|
+ _splitLine: function(t) {
|
|
|
+ var e = t.axis;
|
|
|
+ if (!e.scale.isBlank()) {
|
|
|
+ var i = t.getModel("splitLine")
|
|
|
+ , n = i.getModel("lineStyle")
|
|
|
+ , o = n.get("width")
|
|
|
+ , a = n.get("color");
|
|
|
+ a = a instanceof Array ? a : [a];
|
|
|
+ for (var r = t.coordinateSystem.getRect(), s = e.isHorizontal(), l = [], u = 0, h = e.getTicksCoords({
|
|
|
+ tickModel: i
|
|
|
+ }), c = [], d = [], f = 0; f < h.length; ++f) {
|
|
|
+ var p = e.toGlobalCoord(h[f].coord);
|
|
|
+ s ? (c[0] = p,
|
|
|
+ c[1] = r.y,
|
|
|
+ d[0] = p,
|
|
|
+ d[1] = r.y + r.height) : (c[0] = r.x,
|
|
|
+ c[1] = p,
|
|
|
+ d[0] = r.x + r.width,
|
|
|
+ d[1] = p);
|
|
|
+ var g = u++ % a.length;
|
|
|
+ l[g] = l[g] || [],
|
|
|
+ l[g].push(new ls({
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ shape: {
|
|
|
+ x1: c[0],
|
|
|
+ y1: c[1],
|
|
|
+ x2: d[0],
|
|
|
+ y2: d[1]
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ lineWidth: o
|
|
|
+ },
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ for (f = 0; f < l.length; ++f)
|
|
|
+ this.group.add(Es(l[f], {
|
|
|
+ style: {
|
|
|
+ stroke: a[f % a.length],
|
|
|
+ lineDash: n.getLineDash(o),
|
|
|
+ lineWidth: o
|
|
|
+ },
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _splitArea: function(t) {
|
|
|
+ wv(this, this._axisGroup, t, t)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , eI = ku.extend({
|
|
|
+ type: "singleAxis",
|
|
|
+ layoutMode: "box",
|
|
|
+ axis: null,
|
|
|
+ coordinateSystem: null,
|
|
|
+ getCoordSysModel: function() {
|
|
|
+ return this
|
|
|
+ }
|
|
|
+ });
|
|
|
+ m(eI.prototype, dg),
|
|
|
+ Gm("single", eI, function(t, e) {
|
|
|
+ return e.type || (e.data ? "category" : "value")
|
|
|
+ }, {
|
|
|
+ left: "5%",
|
|
|
+ top: "5%",
|
|
|
+ right: "5%",
|
|
|
+ bottom: "5%",
|
|
|
+ type: "value",
|
|
|
+ position: "bottom",
|
|
|
+ orient: "horizontal",
|
|
|
+ axisLine: {
|
|
|
+ show: !0,
|
|
|
+ lineStyle: {
|
|
|
+ width: 1,
|
|
|
+ type: "solid"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ tooltip: {
|
|
|
+ show: !0
|
|
|
+ },
|
|
|
+ axisTick: {
|
|
|
+ show: !0,
|
|
|
+ length: 6,
|
|
|
+ lineStyle: {
|
|
|
+ width: 1
|
|
|
+ }
|
|
|
+ },
|
|
|
+ axisLabel: {
|
|
|
+ show: !0,
|
|
|
+ interval: "auto"
|
|
|
+ },
|
|
|
+ splitLine: {
|
|
|
+ show: !0,
|
|
|
+ lineStyle: {
|
|
|
+ type: "dashed",
|
|
|
+ opacity: .2
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function iI(t, e) {
|
|
|
+ var i, n = [], o = t.seriesIndex;
|
|
|
+ if (null == o || !(i = e.getSeriesByIndex(o)))
|
|
|
+ return {
|
|
|
+ point: []
|
|
|
+ };
|
|
|
+ var a = i.getData()
|
|
|
+ , r = Yo(a, t);
|
|
|
+ if (null == r || r < 0 || L(r))
|
|
|
+ return {
|
|
|
+ point: []
|
|
|
+ };
|
|
|
+ var s = a.getItemGraphicEl(r)
|
|
|
+ , l = i.coordinateSystem;
|
|
|
+ if (i.getTooltipPosition)
|
|
|
+ n = i.getTooltipPosition(r) || [];
|
|
|
+ else if (l && l.dataToPoint)
|
|
|
+ n = l.dataToPoint(a.getValues(O(l.dimensions, function(t) {
|
|
|
+ return a.mapDimension(t)
|
|
|
+ }), r, !0)) || [];
|
|
|
+ else if (s) {
|
|
|
+ var u = s.getBoundingRect().clone();
|
|
|
+ u.applyTransform(s.transform),
|
|
|
+ n = [u.x + u.width / 2, u.y + u.height / 2]
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ point: n,
|
|
|
+ el: s
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var nI = E
|
|
|
+ , oI = T
|
|
|
+ , aI = jo();
|
|
|
+ function rI(t, e, i, n, o) {
|
|
|
+ var a = t.axis;
|
|
|
+ if (!a.scale.isBlank() && a.containData(e))
|
|
|
+ if (t.involveSeries) {
|
|
|
+ var r = function(l, t) {
|
|
|
+ var u = t.axis
|
|
|
+ , h = u.dim
|
|
|
+ , c = l
|
|
|
+ , d = []
|
|
|
+ , f = Number.MAX_VALUE
|
|
|
+ , p = -1;
|
|
|
+ return nI(t.seriesModels, function(e, t) {
|
|
|
+ var i, n, o = e.getData().mapDimension(h, !0);
|
|
|
+ if (e.getAxisTooltipData) {
|
|
|
+ var a = e.getAxisTooltipData(o, l, u);
|
|
|
+ n = a.dataIndices,
|
|
|
+ i = a.nestestValue
|
|
|
+ } else {
|
|
|
+ if (!(n = e.getData().indicesOfNearest(o[0], l, "category" === u.type ? .5 : null)).length)
|
|
|
+ return;
|
|
|
+ i = e.getData().get(o[0], n[0])
|
|
|
+ }
|
|
|
+ if (null != i && isFinite(i)) {
|
|
|
+ var r = l - i
|
|
|
+ , s = Math.abs(r);
|
|
|
+ s <= f && ((s < f || 0 <= r && p < 0) && (f = s,
|
|
|
+ p = r,
|
|
|
+ c = i,
|
|
|
+ d.length = 0),
|
|
|
+ nI(n, function(t) {
|
|
|
+ d.push({
|
|
|
+ seriesIndex: e.seriesIndex,
|
|
|
+ dataIndexInside: t,
|
|
|
+ dataIndex: e.getData().getRawIndex(t)
|
|
|
+ })
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ payloadBatch: d,
|
|
|
+ snapToValue: c
|
|
|
+ }
|
|
|
+ }(e, t)
|
|
|
+ , s = r.payloadBatch
|
|
|
+ , l = r.snapToValue;
|
|
|
+ s[0] && null == o.seriesIndex && P(o, s[0]),
|
|
|
+ !n && t.snap && a.containData(l) && null != l && (e = l),
|
|
|
+ i.showPointer(t, e, s, o),
|
|
|
+ i.showTooltip(t, r, l)
|
|
|
+ } else
|
|
|
+ i.showPointer(t, e)
|
|
|
+ }
|
|
|
+ function sI(t, e, i, n) {
|
|
|
+ t[e.key] = {
|
|
|
+ value: i,
|
|
|
+ payloadBatch: n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function lI(t, e, i, n) {
|
|
|
+ var o = i.payloadBatch
|
|
|
+ , a = e.axis
|
|
|
+ , r = a.model
|
|
|
+ , s = e.axisPointerModel;
|
|
|
+ if (e.triggerTooltip && o.length) {
|
|
|
+ var l = e.coordSys.model
|
|
|
+ , u = gv(l)
|
|
|
+ , h = t.map[u];
|
|
|
+ h || (h = t.map[u] = {
|
|
|
+ coordSysId: l.id,
|
|
|
+ coordSysIndex: l.componentIndex,
|
|
|
+ coordSysType: l.type,
|
|
|
+ coordSysMainType: l.mainType,
|
|
|
+ dataByAxis: []
|
|
|
+ },
|
|
|
+ t.list.push(h)),
|
|
|
+ h.dataByAxis.push({
|
|
|
+ axisDim: a.dim,
|
|
|
+ axisIndex: r.componentIndex,
|
|
|
+ axisType: r.type,
|
|
|
+ axisId: r.id,
|
|
|
+ value: n,
|
|
|
+ valueLabelOpt: {
|
|
|
+ precision: s.get("label.precision"),
|
|
|
+ formatter: s.get("label.formatter")
|
|
|
+ },
|
|
|
+ seriesDataIndices: o.slice()
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function uI(t) {
|
|
|
+ var e = t.axis.model
|
|
|
+ , i = {}
|
|
|
+ , n = i.axisDim = t.axis.dim;
|
|
|
+ return i.axisIndex = i[n + "AxisIndex"] = e.componentIndex,
|
|
|
+ i.axisName = i[n + "AxisName"] = e.name,
|
|
|
+ i.axisId = i[n + "AxisId"] = e.id,
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function hI(t) {
|
|
|
+ return !t || null == t[0] || isNaN(t[0]) || null == t[1] || isNaN(t[1])
|
|
|
+ }
|
|
|
+ Tf({
|
|
|
+ type: "axisPointer",
|
|
|
+ coordSysAxesInfo: null,
|
|
|
+ defaultOption: {
|
|
|
+ show: "auto",
|
|
|
+ triggerOn: null,
|
|
|
+ zlevel: 0,
|
|
|
+ z: 50,
|
|
|
+ type: "line",
|
|
|
+ snap: !1,
|
|
|
+ triggerTooltip: !0,
|
|
|
+ value: null,
|
|
|
+ status: null,
|
|
|
+ link: [],
|
|
|
+ animation: null,
|
|
|
+ animationDurationUpdate: 200,
|
|
|
+ lineStyle: {
|
|
|
+ color: "#aaa",
|
|
|
+ width: 1,
|
|
|
+ type: "solid"
|
|
|
+ },
|
|
|
+ shadowStyle: {
|
|
|
+ color: "rgba(150,150,150,0.3)"
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ formatter: null,
|
|
|
+ precision: "auto",
|
|
|
+ margin: 3,
|
|
|
+ color: "#fff",
|
|
|
+ padding: [5, 7, 5, 7],
|
|
|
+ backgroundColor: "auto",
|
|
|
+ borderColor: null,
|
|
|
+ borderWidth: 0,
|
|
|
+ shadowBlur: 3,
|
|
|
+ shadowColor: "#aaa"
|
|
|
+ },
|
|
|
+ handle: {
|
|
|
+ show: !1,
|
|
|
+ icon: "M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4h1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7v-1.2h6.6z M13.3,22H6.7v-1.2h6.6z M13.3,19.6H6.7v-1.2h6.6z",
|
|
|
+ size: 45,
|
|
|
+ margin: 50,
|
|
|
+ color: "#333",
|
|
|
+ shadowBlur: 3,
|
|
|
+ shadowColor: "#aaa",
|
|
|
+ shadowOffsetX: 0,
|
|
|
+ shadowOffsetY: 2,
|
|
|
+ throttle: 40
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var cI = jo()
|
|
|
+ , dI = E;
|
|
|
+ function fI(t, e, i) {
|
|
|
+ if (!v.node) {
|
|
|
+ var n = e.getZr();
|
|
|
+ cI(n).records || (cI(n).records = {}),
|
|
|
+ function(o, a) {
|
|
|
+ if (cI(o).initialized)
|
|
|
+ return;
|
|
|
+ function t(t, n) {
|
|
|
+ o.on(t, function(e) {
|
|
|
+ var i = function(i) {
|
|
|
+ var n = {
|
|
|
+ showTip: [],
|
|
|
+ hideTip: []
|
|
|
+ }
|
|
|
+ , o = function(t) {
|
|
|
+ var e = n[t.type];
|
|
|
+ e ? e.push(t) : (t.dispatchAction = o,
|
|
|
+ i.dispatchAction(t))
|
|
|
+ };
|
|
|
+ return {
|
|
|
+ dispatchAction: o,
|
|
|
+ pendings: n
|
|
|
+ }
|
|
|
+ }(a);
|
|
|
+ dI(cI(o).records, function(t) {
|
|
|
+ t && n(t, e, i.dispatchAction)
|
|
|
+ }),
|
|
|
+ function(t, e) {
|
|
|
+ var i, n = t.showTip.length, o = t.hideTip.length;
|
|
|
+ n ? i = t.showTip[n - 1] : o && (i = t.hideTip[o - 1]);
|
|
|
+ i && (i.dispatchAction = null,
|
|
|
+ e.dispatchAction(i))
|
|
|
+ }(i.pendings, a)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ cI(o).initialized = !0,
|
|
|
+ t("click", T(gI, "click")),
|
|
|
+ t("mousemove", T(gI, "mousemove")),
|
|
|
+ t("globalout", pI)
|
|
|
+ }(n, e),
|
|
|
+ (cI(n).records[t] || (cI(n).records[t] = {})).handler = i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function pI(t, e, i) {
|
|
|
+ t.handler("leave", null, i)
|
|
|
+ }
|
|
|
+ function gI(t, e, i, n) {
|
|
|
+ e.handler(t, i, n)
|
|
|
+ }
|
|
|
+ function mI(t, e) {
|
|
|
+ if (!v.node) {
|
|
|
+ var i = e.getZr();
|
|
|
+ (cI(i).records || {})[t] && (cI(i).records[t] = null)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var vI = Af({
|
|
|
+ type: "axisPointer",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var n = e.getComponent("tooltip")
|
|
|
+ , o = t.get("triggerOn") || n && n.get("triggerOn") || "mousemove|click";
|
|
|
+ fI("axisPointer", i, function(t, e, i) {
|
|
|
+ "none" !== o && ("leave" === t || 0 <= o.indexOf(t)) && i({
|
|
|
+ type: "updateAxisPointer",
|
|
|
+ currTrigger: t,
|
|
|
+ x: e && e.offsetX,
|
|
|
+ y: e && e.offsetY
|
|
|
+ })
|
|
|
+ })
|
|
|
+ },
|
|
|
+ remove: function(t, e) {
|
|
|
+ mI(e.getZr(), "axisPointer"),
|
|
|
+ vI.superApply(this._model, "remove", arguments)
|
|
|
+ },
|
|
|
+ dispose: function(t, e) {
|
|
|
+ mI("axisPointer", e),
|
|
|
+ vI.superApply(this._model, "dispose", arguments)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , yI = jo()
|
|
|
+ , xI = k
|
|
|
+ , _I = A;
|
|
|
+ function wI() {}
|
|
|
+ function bI(t, e, i, n) {
|
|
|
+ !function i(n, t) {
|
|
|
+ {
|
|
|
+ if (z(n) && z(t)) {
|
|
|
+ var o = !0;
|
|
|
+ return E(t, function(t, e) {
|
|
|
+ o = o && i(n[e], t)
|
|
|
+ }),
|
|
|
+ !!o
|
|
|
+ }
|
|
|
+ return n === t
|
|
|
+ }
|
|
|
+ }(yI(i).lastProp, n) && (yI(i).lastProp = n,
|
|
|
+ e ? cl(i, n, t) : (i.stopAnimation(),
|
|
|
+ i.attr(n)))
|
|
|
+ }
|
|
|
+ function SI(t, e) {
|
|
|
+ t[e.get("label.show") ? "show" : "hide"]()
|
|
|
+ }
|
|
|
+ function MI(t) {
|
|
|
+ return {
|
|
|
+ position: t.position.slice(),
|
|
|
+ rotation: t.rotation || 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function II(t, e, i) {
|
|
|
+ var n = e.get("z")
|
|
|
+ , o = e.get("zlevel");
|
|
|
+ t && t.traverse(function(t) {
|
|
|
+ "group" !== t.type && (null != n && (t.z = n),
|
|
|
+ null != o && (t.zlevel = o),
|
|
|
+ t.silent = i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function TI(t) {
|
|
|
+ var e, i = t.get("type"), n = t.getModel(i + "Style");
|
|
|
+ return "line" === i ? (e = n.getLineStyle()).fill = null : "shadow" === i && ((e = n.getAreaStyle()).stroke = null),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ function AI(t, e, i, n, o) {
|
|
|
+ var a = DI(i.get("value"), e.axis, e.ecModel, i.get("seriesDataIndices"), {
|
|
|
+ precision: i.get("label.precision"),
|
|
|
+ formatter: i.get("label.formatter")
|
|
|
+ })
|
|
|
+ , r = i.getModel("label")
|
|
|
+ , s = iu(r.get("padding") || 0)
|
|
|
+ , l = r.getFont()
|
|
|
+ , u = gn(a, l)
|
|
|
+ , h = o.position
|
|
|
+ , c = u.width + s[1] + s[3]
|
|
|
+ , d = u.height + s[0] + s[2]
|
|
|
+ , f = o.align;
|
|
|
+ "right" === f && (h[0] -= c),
|
|
|
+ "center" === f && (h[0] -= c / 2);
|
|
|
+ var p = o.verticalAlign;
|
|
|
+ "bottom" === p && (h[1] -= d),
|
|
|
+ "middle" === p && (h[1] -= d / 2),
|
|
|
+ function(t, e, i, n) {
|
|
|
+ var o = n.getWidth()
|
|
|
+ , a = n.getHeight();
|
|
|
+ t[0] = Math.min(t[0] + e, o) - e,
|
|
|
+ t[1] = Math.min(t[1] + i, a) - i,
|
|
|
+ t[0] = Math.max(t[0], 0),
|
|
|
+ t[1] = Math.max(t[1], 0)
|
|
|
+ }(h, c, d, n);
|
|
|
+ var g = r.get("backgroundColor");
|
|
|
+ g && "auto" !== g || (g = e.get("axisLine.lineStyle.color")),
|
|
|
+ t.label = {
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: c,
|
|
|
+ height: d,
|
|
|
+ r: r.get("borderRadius")
|
|
|
+ },
|
|
|
+ position: h.slice(),
|
|
|
+ style: {
|
|
|
+ text: a,
|
|
|
+ textFont: l,
|
|
|
+ textFill: r.getTextColor(),
|
|
|
+ textPosition: "inside",
|
|
|
+ textPadding: s,
|
|
|
+ fill: g,
|
|
|
+ stroke: r.get("borderColor") || "transparent",
|
|
|
+ lineWidth: r.get("borderWidth") || 0,
|
|
|
+ shadowBlur: r.get("shadowBlur"),
|
|
|
+ shadowColor: r.get("shadowColor"),
|
|
|
+ shadowOffsetX: r.get("shadowOffsetX"),
|
|
|
+ shadowOffsetY: r.get("shadowOffsetY")
|
|
|
+ },
|
|
|
+ z2: 10
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function DI(t, e, o, i, n) {
|
|
|
+ t = e.scale.parse(t);
|
|
|
+ var a = e.scale.getLabel(t, {
|
|
|
+ precision: n.precision
|
|
|
+ })
|
|
|
+ , r = n.formatter;
|
|
|
+ if (r) {
|
|
|
+ var s = {
|
|
|
+ value: ug(e, t),
|
|
|
+ axisDimension: e.dim,
|
|
|
+ axisIndex: e.index,
|
|
|
+ seriesData: []
|
|
|
+ };
|
|
|
+ E(i, function(t) {
|
|
|
+ var e = o.getSeriesByIndex(t.seriesIndex)
|
|
|
+ , i = t.dataIndexInside
|
|
|
+ , n = e && e.getDataParams(i);
|
|
|
+ n && s.seriesData.push(n)
|
|
|
+ }),
|
|
|
+ R(r) ? a = r.replace("{value}", a) : C(r) && (a = r(s))
|
|
|
+ }
|
|
|
+ return a
|
|
|
+ }
|
|
|
+ function CI(t, e, i) {
|
|
|
+ var n = ae();
|
|
|
+ return he(n, n, i.rotation),
|
|
|
+ ue(n, n, i.position),
|
|
|
+ pl([t.dataToCoord(e), (i.labelOffset || 0) + (i.labelDirection || 1) * (i.labelMargin || 0)], n)
|
|
|
+ }
|
|
|
+ function LI(t, e, i, n, o, a) {
|
|
|
+ var r = Qm.innerTextLayout(i.rotation, 0, i.labelDirection);
|
|
|
+ i.labelMargin = o.get("label.margin"),
|
|
|
+ AI(e, n, o, a, {
|
|
|
+ position: CI(n.axis, t, i),
|
|
|
+ align: r.textAlign,
|
|
|
+ verticalAlign: r.textVerticalAlign
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function kI(t, e, i) {
|
|
|
+ return {
|
|
|
+ x1: t[i = i || 0],
|
|
|
+ y1: t[1 - i],
|
|
|
+ x2: e[i],
|
|
|
+ y2: e[1 - i]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function PI(t, e, i) {
|
|
|
+ return {
|
|
|
+ x: t[i = i || 0],
|
|
|
+ y: t[1 - i],
|
|
|
+ width: e[i],
|
|
|
+ height: e[1 - i]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function NI(t, e, i, n, o, a) {
|
|
|
+ return {
|
|
|
+ cx: t,
|
|
|
+ cy: e,
|
|
|
+ r0: i,
|
|
|
+ r: n,
|
|
|
+ startAngle: o,
|
|
|
+ endAngle: a,
|
|
|
+ clockwise: !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ oa((wI.prototype = {
|
|
|
+ _group: null,
|
|
|
+ _lastGraphicKey: null,
|
|
|
+ _handle: null,
|
|
|
+ _dragging: !1,
|
|
|
+ _lastValue: null,
|
|
|
+ _lastStatus: null,
|
|
|
+ _payloadInfo: null,
|
|
|
+ animationThreshold: 15,
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ var o = e.get("value")
|
|
|
+ , a = e.get("status");
|
|
|
+ if (this._axisModel = t,
|
|
|
+ this._axisPointerModel = e,
|
|
|
+ this._api = i,
|
|
|
+ n || this._lastValue !== o || this._lastStatus !== a) {
|
|
|
+ this._lastValue = o,
|
|
|
+ this._lastStatus = a;
|
|
|
+ var r = this._group
|
|
|
+ , s = this._handle;
|
|
|
+ if (!a || "hide" === a)
|
|
|
+ return r && r.hide(),
|
|
|
+ void (s && s.hide());
|
|
|
+ r && r.show(),
|
|
|
+ s && s.show();
|
|
|
+ var l = {};
|
|
|
+ this.makeElOption(l, o, t, e, i);
|
|
|
+ var u = l.graphicKey;
|
|
|
+ u !== this._lastGraphicKey && this.clear(i),
|
|
|
+ this._lastGraphicKey = u;
|
|
|
+ var h = this._moveAnimation = this.determineAnimation(t, e);
|
|
|
+ if (r) {
|
|
|
+ var c = T(bI, e, h);
|
|
|
+ this.updatePointerEl(r, l, c, e),
|
|
|
+ this.updateLabelEl(r, l, c, e)
|
|
|
+ } else
|
|
|
+ r = this._group = new Ci,
|
|
|
+ this.createPointerEl(r, l, t, e),
|
|
|
+ this.createLabelEl(r, l, t, e),
|
|
|
+ i.getZr().add(r);
|
|
|
+ II(r, e, !0),
|
|
|
+ this._renderHandle(o)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ remove: function(t) {
|
|
|
+ this.clear(t)
|
|
|
+ },
|
|
|
+ dispose: function(t) {
|
|
|
+ this.clear(t)
|
|
|
+ },
|
|
|
+ determineAnimation: function(t, e) {
|
|
|
+ var i = e.get("animation")
|
|
|
+ , n = t.axis
|
|
|
+ , o = "category" === n.type
|
|
|
+ , a = e.get("snap");
|
|
|
+ if (!a && !o)
|
|
|
+ return !1;
|
|
|
+ if ("auto" !== i && null != i)
|
|
|
+ return !0 === i;
|
|
|
+ var r = this.animationThreshold;
|
|
|
+ if (o && n.getBandWidth() > r)
|
|
|
+ return !0;
|
|
|
+ if (a) {
|
|
|
+ var s = fv(t).seriesDataCount
|
|
|
+ , l = n.getExtent();
|
|
|
+ return Math.abs(l[0] - l[1]) / s > r
|
|
|
+ }
|
|
|
+ return !1
|
|
|
+ },
|
|
|
+ makeElOption: function(t, e, i, n, o) {},
|
|
|
+ createPointerEl: function(t, e, i, n) {
|
|
|
+ var o = e.pointer;
|
|
|
+ if (o) {
|
|
|
+ var a = yI(t).pointerEl = new bl[o.type](xI(e.pointer));
|
|
|
+ t.add(a)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ createLabelEl: function(t, e, i, n) {
|
|
|
+ if (e.label) {
|
|
|
+ var o = yI(t).labelEl = new rs(xI(e.label));
|
|
|
+ t.add(o),
|
|
|
+ SI(o, n)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ updatePointerEl: function(t, e, i) {
|
|
|
+ var n = yI(t).pointerEl;
|
|
|
+ n && e.pointer && (n.setStyle(e.pointer.style),
|
|
|
+ i(n, {
|
|
|
+ shape: e.pointer.shape
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ updateLabelEl: function(t, e, i, n) {
|
|
|
+ var o = yI(t).labelEl;
|
|
|
+ o && (o.setStyle(e.label.style),
|
|
|
+ i(o, {
|
|
|
+ shape: e.label.shape,
|
|
|
+ position: e.label.position
|
|
|
+ }),
|
|
|
+ SI(o, n))
|
|
|
+ },
|
|
|
+ _renderHandle: function(t) {
|
|
|
+ if (!this._dragging && this.updateHandleTransform) {
|
|
|
+ var e, i = this._axisPointerModel, n = this._api.getZr(), o = this._handle, a = i.getModel("handle"), r = i.get("status");
|
|
|
+ if (!a.get("show") || !r || "hide" === r)
|
|
|
+ return o && n.remove(o),
|
|
|
+ void (this._handle = null);
|
|
|
+ this._handle || (e = !0,
|
|
|
+ o = this._handle = yl(a.get("icon"), {
|
|
|
+ cursor: "move",
|
|
|
+ draggable: !0,
|
|
|
+ onmousemove: function(t) {
|
|
|
+ Xt(t.event)
|
|
|
+ },
|
|
|
+ onmousedown: _I(this._onHandleDragMove, this, 0, 0),
|
|
|
+ drift: _I(this._onHandleDragMove, this),
|
|
|
+ ondragend: _I(this._onHandleDragEnd, this)
|
|
|
+ }),
|
|
|
+ n.add(o)),
|
|
|
+ II(o, i, !1);
|
|
|
+ o.setStyle(a.getItemStyle(null, ["color", "borderColor", "borderWidth", "opacity", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"]));
|
|
|
+ var s = a.get("size");
|
|
|
+ L(s) || (s = [s, s]),
|
|
|
+ o.attr("scale", [s[0] / 2, s[1] / 2]),
|
|
|
+ kc(this, "_doDispatchAxisPointer", a.get("throttle") || 0, "fixRate"),
|
|
|
+ this._moveHandleToValue(t, e)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _moveHandleToValue: function(t, e) {
|
|
|
+ bI(this._axisPointerModel, !e && this._moveAnimation, this._handle, MI(this.getHandleTransform(t, this._axisModel, this._axisPointerModel)))
|
|
|
+ },
|
|
|
+ _onHandleDragMove: function(t, e) {
|
|
|
+ var i = this._handle;
|
|
|
+ if (i) {
|
|
|
+ this._dragging = !0;
|
|
|
+ var n = this.updateHandleTransform(MI(i), [t, e], this._axisModel, this._axisPointerModel);
|
|
|
+ this._payloadInfo = n,
|
|
|
+ i.stopAnimation(),
|
|
|
+ i.attr(MI(n)),
|
|
|
+ yI(i).lastProp = null,
|
|
|
+ this._doDispatchAxisPointer()
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _doDispatchAxisPointer: function() {
|
|
|
+ if (this._handle) {
|
|
|
+ var t = this._payloadInfo
|
|
|
+ , e = this._axisModel;
|
|
|
+ this._api.dispatchAction({
|
|
|
+ type: "updateAxisPointer",
|
|
|
+ x: t.cursorPoint[0],
|
|
|
+ y: t.cursorPoint[1],
|
|
|
+ tooltipOption: t.tooltipOption,
|
|
|
+ axesInfo: [{
|
|
|
+ axisDim: e.axis.dim,
|
|
|
+ axisIndex: e.componentIndex
|
|
|
+ }]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _onHandleDragEnd: function(t) {
|
|
|
+ if (this._dragging = !1,
|
|
|
+ this._handle) {
|
|
|
+ var e = this._axisPointerModel.get("value");
|
|
|
+ this._moveHandleToValue(e),
|
|
|
+ this._api.dispatchAction({
|
|
|
+ type: "hideTip"
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getHandleTransform: null,
|
|
|
+ updateHandleTransform: null,
|
|
|
+ clear: function(t) {
|
|
|
+ this._lastValue = null,
|
|
|
+ this._lastStatus = null;
|
|
|
+ var e = t.getZr()
|
|
|
+ , i = this._group
|
|
|
+ , n = this._handle;
|
|
|
+ e && i && (this._lastGraphicKey = null,
|
|
|
+ i && e.remove(i),
|
|
|
+ n && e.remove(n),
|
|
|
+ this._group = null,
|
|
|
+ this._handle = null,
|
|
|
+ this._payloadInfo = null)
|
|
|
+ },
|
|
|
+ doClear: function() {},
|
|
|
+ buildLabel: function(t, e, i) {
|
|
|
+ return {
|
|
|
+ x: t[i = i || 0],
|
|
|
+ y: t[1 - i],
|
|
|
+ width: e[i],
|
|
|
+ height: e[1 - i]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }).constructor = wI);
|
|
|
+ var OI = wI.extend({
|
|
|
+ makeElOption: function(t, e, i, n, o) {
|
|
|
+ var a = i.axis
|
|
|
+ , r = a.grid
|
|
|
+ , s = n.get("type")
|
|
|
+ , l = EI(r, a).getOtherAxis(a).getGlobalExtent()
|
|
|
+ , u = a.toGlobalCoord(a.dataToCoord(e, !0));
|
|
|
+ if (s && "none" !== s) {
|
|
|
+ var h = TI(n)
|
|
|
+ , c = RI[s](a, u, l);
|
|
|
+ c.style = h,
|
|
|
+ t.graphicKey = c.type,
|
|
|
+ t.pointer = c
|
|
|
+ }
|
|
|
+ LI(e, t, _v(r.model, i), i, n, o)
|
|
|
+ },
|
|
|
+ getHandleTransform: function(t, e, i) {
|
|
|
+ var n = _v(e.axis.grid.model, e, {
|
|
|
+ labelInside: !1
|
|
|
+ });
|
|
|
+ return n.labelMargin = i.get("handle.margin"),
|
|
|
+ {
|
|
|
+ position: CI(e.axis, t, n),
|
|
|
+ rotation: n.rotation + (n.labelDirection < 0 ? Math.PI : 0)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ updateHandleTransform: function(t, e, i, n) {
|
|
|
+ var o = i.axis
|
|
|
+ , a = o.grid
|
|
|
+ , r = o.getGlobalExtent(!0)
|
|
|
+ , s = EI(a, o).getOtherAxis(o).getGlobalExtent()
|
|
|
+ , l = "x" === o.dim ? 0 : 1
|
|
|
+ , u = t.position;
|
|
|
+ u[l] += e[l],
|
|
|
+ u[l] = Math.min(r[1], u[l]),
|
|
|
+ u[l] = Math.max(r[0], u[l]);
|
|
|
+ var h = (s[1] + s[0]) / 2
|
|
|
+ , c = [h, h];
|
|
|
+ c[l] = u[l];
|
|
|
+ return {
|
|
|
+ position: u,
|
|
|
+ rotation: t.rotation,
|
|
|
+ cursorPoint: c,
|
|
|
+ tooltipOption: [{
|
|
|
+ verticalAlign: "middle"
|
|
|
+ }, {
|
|
|
+ align: "center"
|
|
|
+ }][l]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function EI(t, e) {
|
|
|
+ var i = {};
|
|
|
+ return i[e.dim + "AxisIndex"] = e.index,
|
|
|
+ t.getCartesian(i)
|
|
|
+ }
|
|
|
+ var RI = {
|
|
|
+ line: function(t, e, i) {
|
|
|
+ return {
|
|
|
+ type: "Line",
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ shape: kI([e, i[0]], [e, i[1]], zI(t))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ shadow: function(t, e, i) {
|
|
|
+ var n = Math.max(1, t.getBandWidth())
|
|
|
+ , o = i[1] - i[0];
|
|
|
+ return {
|
|
|
+ type: "Rect",
|
|
|
+ shape: PI([e - n / 2, i[0]], [n, o], zI(t))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function zI(t) {
|
|
|
+ return "x" === t.dim ? 0 : 1
|
|
|
+ }
|
|
|
+ mv.registerAxisPointerClass("CartesianAxisPointer", OI),
|
|
|
+ yf(function(t) {
|
|
|
+ if (t) {
|
|
|
+ t.axisPointer && 0 !== t.axisPointer.length || (t.axisPointer = {});
|
|
|
+ var e = t.axisPointer.link;
|
|
|
+ e && !L(e) && (t.axisPointer.link = [e])
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ xf(Ld.PROCESSOR.STATISTIC, function(t, e) {
|
|
|
+ t.getComponent("axisPointer").coordSysAxesInfo = cv(t, e)
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "updateAxisPointer",
|
|
|
+ event: "updateAxisPointer",
|
|
|
+ update: ":updateAxisPointer"
|
|
|
+ }, function(t, e, i) {
|
|
|
+ var n = t.currTrigger
|
|
|
+ , r = [t.x, t.y]
|
|
|
+ , o = t
|
|
|
+ , a = t.dispatchAction || A(i.dispatchAction, i)
|
|
|
+ , s = e.getComponent("axisPointer").coordSysAxesInfo;
|
|
|
+ if (s) {
|
|
|
+ hI(r) && (r = iI({
|
|
|
+ seriesIndex: o.seriesIndex,
|
|
|
+ dataIndex: o.dataIndex
|
|
|
+ }, e).point);
|
|
|
+ var l = hI(r)
|
|
|
+ , u = o.axesInfo
|
|
|
+ , h = s.axesInfo
|
|
|
+ , c = "leave" === n || hI(r)
|
|
|
+ , d = {}
|
|
|
+ , f = {}
|
|
|
+ , p = {
|
|
|
+ list: [],
|
|
|
+ map: {}
|
|
|
+ }
|
|
|
+ , g = {
|
|
|
+ showPointer: oI(sI, f),
|
|
|
+ showTooltip: oI(lI, p)
|
|
|
+ };
|
|
|
+ nI(s.coordSysMap, function(t, e) {
|
|
|
+ var a = l || t.containPoint(r);
|
|
|
+ nI(s.coordSysAxesInfo[e], function(t, e) {
|
|
|
+ var i = t.axis
|
|
|
+ , n = function(t, e) {
|
|
|
+ for (var i = 0; i < (t || []).length; i++) {
|
|
|
+ var n = t[i];
|
|
|
+ if (e.axis.dim === n.axisDim && e.axis.model.componentIndex === n.axisIndex)
|
|
|
+ return n
|
|
|
+ }
|
|
|
+ }(u, t);
|
|
|
+ if (!c && a && (!u || n)) {
|
|
|
+ var o = n && n.value;
|
|
|
+ null != o || l || (o = i.pointToData(r)),
|
|
|
+ null != o && rI(t, o, g, !1, d)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var m = {};
|
|
|
+ return nI(h, function(o, t) {
|
|
|
+ var a = o.linkGroup;
|
|
|
+ a && !f[t] && nI(a.axesInfo, function(t, e) {
|
|
|
+ var i = f[e];
|
|
|
+ if (t !== o && i) {
|
|
|
+ var n = i.value;
|
|
|
+ a.mapper && (n = o.axis.scale.parse(a.mapper(n, uI(t), uI(o)))),
|
|
|
+ m[o.key] = n
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ nI(m, function(t, e) {
|
|
|
+ rI(h[e], t, g, !0, d)
|
|
|
+ }),
|
|
|
+ function(o, t, e) {
|
|
|
+ var a = e.axesInfo = [];
|
|
|
+ nI(t, function(t, e) {
|
|
|
+ var i = t.axisPointerModel.option
|
|
|
+ , n = o[e];
|
|
|
+ n ? (t.useHandle || (i.status = "show"),
|
|
|
+ i.value = n.value,
|
|
|
+ i.seriesDataIndices = (n.payloadBatch || []).slice()) : t.useHandle || (i.status = "hide"),
|
|
|
+ "show" === i.status && a.push({
|
|
|
+ axisDim: t.axis.dim,
|
|
|
+ axisIndex: t.axis.model.componentIndex,
|
|
|
+ value: i.value
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }(f, h, d),
|
|
|
+ function(t, e, i, n) {
|
|
|
+ if (hI(e) || !t.list.length)
|
|
|
+ return n({
|
|
|
+ type: "hideTip"
|
|
|
+ });
|
|
|
+ var o = ((t.list[0].dataByAxis[0] || {}).seriesDataIndices || [])[0] || {};
|
|
|
+ n({
|
|
|
+ type: "showTip",
|
|
|
+ escapeConnect: !0,
|
|
|
+ x: e[0],
|
|
|
+ y: e[1],
|
|
|
+ tooltipOption: i.tooltipOption,
|
|
|
+ position: i.position,
|
|
|
+ dataIndexInside: o.dataIndexInside,
|
|
|
+ dataIndex: o.dataIndex,
|
|
|
+ seriesIndex: o.seriesIndex,
|
|
|
+ dataByCoordSys: t.list
|
|
|
+ })
|
|
|
+ }(p, r, t, a),
|
|
|
+ function(t, e, i) {
|
|
|
+ var n = i.getZr()
|
|
|
+ , o = "axisPointerLastHighlights"
|
|
|
+ , a = aI(n)[o] || {}
|
|
|
+ , r = aI(n)[o] = {};
|
|
|
+ nI(t, function(t, e) {
|
|
|
+ var i = t.axisPointerModel.option;
|
|
|
+ "show" === i.status && nI(i.seriesDataIndices, function(t) {
|
|
|
+ var e = t.seriesIndex + " | " + t.dataIndex;
|
|
|
+ r[e] = t
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var s = []
|
|
|
+ , l = [];
|
|
|
+ E(a, function(t, e) {
|
|
|
+ r[e] || l.push(t)
|
|
|
+ }),
|
|
|
+ E(r, function(t, e) {
|
|
|
+ a[e] || s.push(t)
|
|
|
+ }),
|
|
|
+ l.length && i.dispatchAction({
|
|
|
+ type: "downplay",
|
|
|
+ escapeConnect: !0,
|
|
|
+ batch: l
|
|
|
+ }),
|
|
|
+ s.length && i.dispatchAction({
|
|
|
+ type: "highlight",
|
|
|
+ escapeConnect: !0,
|
|
|
+ batch: s
|
|
|
+ })
|
|
|
+ }(h, 0, i),
|
|
|
+ d
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var BI = ["x", "y"]
|
|
|
+ , VI = ["width", "height"]
|
|
|
+ , GI = wI.extend({
|
|
|
+ makeElOption: function(t, e, i, n, o) {
|
|
|
+ var a = i.axis
|
|
|
+ , r = a.coordinateSystem
|
|
|
+ , s = HI(r, 1 - WI(a))
|
|
|
+ , l = r.dataToPoint(e)[0]
|
|
|
+ , u = n.get("type");
|
|
|
+ if (u && "none" !== u) {
|
|
|
+ var h = TI(n)
|
|
|
+ , c = FI[u](a, l, s);
|
|
|
+ c.style = h,
|
|
|
+ t.graphicKey = c.type,
|
|
|
+ t.pointer = c
|
|
|
+ }
|
|
|
+ LI(e, t, $M(i), i, n, o)
|
|
|
+ },
|
|
|
+ getHandleTransform: function(t, e, i) {
|
|
|
+ var n = $M(e, {
|
|
|
+ labelInside: !1
|
|
|
+ });
|
|
|
+ return n.labelMargin = i.get("handle.margin"),
|
|
|
+ {
|
|
|
+ position: CI(e.axis, t, n),
|
|
|
+ rotation: n.rotation + (n.labelDirection < 0 ? Math.PI : 0)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ updateHandleTransform: function(t, e, i, n) {
|
|
|
+ var o = i.axis
|
|
|
+ , a = o.coordinateSystem
|
|
|
+ , r = WI(o)
|
|
|
+ , s = HI(a, r)
|
|
|
+ , l = t.position;
|
|
|
+ l[r] += e[r],
|
|
|
+ l[r] = Math.min(s[1], l[r]),
|
|
|
+ l[r] = Math.max(s[0], l[r]);
|
|
|
+ var u = HI(a, 1 - r)
|
|
|
+ , h = (u[1] + u[0]) / 2
|
|
|
+ , c = [h, h];
|
|
|
+ return c[r] = l[r],
|
|
|
+ {
|
|
|
+ position: l,
|
|
|
+ rotation: t.rotation,
|
|
|
+ cursorPoint: c,
|
|
|
+ tooltipOption: {
|
|
|
+ verticalAlign: "middle"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , FI = {
|
|
|
+ line: function(t, e, i) {
|
|
|
+ return {
|
|
|
+ type: "Line",
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ shape: kI([e, i[0]], [e, i[1]], WI(t))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ shadow: function(t, e, i) {
|
|
|
+ var n = t.getBandWidth()
|
|
|
+ , o = i[1] - i[0];
|
|
|
+ return {
|
|
|
+ type: "Rect",
|
|
|
+ shape: PI([e - n / 2, i[0]], [n, o], WI(t))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function WI(t) {
|
|
|
+ return t.isHorizontal() ? 0 : 1
|
|
|
+ }
|
|
|
+ function HI(t, e) {
|
|
|
+ var i = t.getRect();
|
|
|
+ return [i[BI[e]], i[BI[e]] + i[VI[e]]]
|
|
|
+ }
|
|
|
+ mv.registerAxisPointerClass("SingleAxisPointer", GI),
|
|
|
+ Af({
|
|
|
+ type: "single"
|
|
|
+ });
|
|
|
+ var ZI = sc.extend({
|
|
|
+ type: "series.themeRiver",
|
|
|
+ dependencies: ["singleAxis"],
|
|
|
+ nameMap: null,
|
|
|
+ init: function(t) {
|
|
|
+ ZI.superApply(this, "init", arguments),
|
|
|
+ this.legendVisualProvider = new qv(A(this.getData, this),A(this.getRawData, this))
|
|
|
+ },
|
|
|
+ fixData: function(t) {
|
|
|
+ var e = t.length
|
|
|
+ , i = ta(t, function(t) {
|
|
|
+ return t[2]
|
|
|
+ })
|
|
|
+ , n = [];
|
|
|
+ i.buckets.each(function(t, e) {
|
|
|
+ n.push({
|
|
|
+ name: e,
|
|
|
+ dataList: t
|
|
|
+ })
|
|
|
+ });
|
|
|
+ for (var o = n.length, a = -1, r = -1, s = 0; s < o; ++s) {
|
|
|
+ var l = n[s].dataList.length;
|
|
|
+ a < l && (a = l,
|
|
|
+ r = s)
|
|
|
+ }
|
|
|
+ for (var u = 0; u < o; ++u)
|
|
|
+ if (u !== r)
|
|
|
+ for (var h = n[u].name, c = 0; c < a; ++c) {
|
|
|
+ for (var d = n[r].dataList[c][0], f = n[u].dataList.length, p = -1, g = 0; g < f; ++g) {
|
|
|
+ if (n[u].dataList[g][0] === d) {
|
|
|
+ p = g;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ -1 === p && (t[e] = [],
|
|
|
+ t[e][0] = d,
|
|
|
+ t[e][1] = 0,
|
|
|
+ t[e][2] = h,
|
|
|
+ e++)
|
|
|
+ }
|
|
|
+ return t
|
|
|
+ },
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ for (var i = e.queryComponents({
|
|
|
+ mainType: "singleAxis",
|
|
|
+ index: this.get("singleAxisIndex"),
|
|
|
+ id: this.get("singleAxisId")
|
|
|
+ })[0].get("type"), n = M(t.data, function(t) {
|
|
|
+ return void 0 !== t[2]
|
|
|
+ }), o = this.fixData(n || []), a = [], r = this.nameMap = Q(), s = 0, l = 0; l < o.length; ++l)
|
|
|
+ a.push(o[l][2]),
|
|
|
+ r.get(o[l][2]) || (r.set(o[l][2], s),
|
|
|
+ s++);
|
|
|
+ var u = lp(o, {
|
|
|
+ coordDimensions: ["single"],
|
|
|
+ dimensionsDefine: [{
|
|
|
+ name: "time",
|
|
|
+ type: Ef(i)
|
|
|
+ }, {
|
|
|
+ name: "value",
|
|
|
+ type: "float"
|
|
|
+ }, {
|
|
|
+ name: "name",
|
|
|
+ type: "ordinal"
|
|
|
+ }],
|
|
|
+ encodeDefine: {
|
|
|
+ single: 0,
|
|
|
+ value: 1,
|
|
|
+ itemName: 2
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , h = new Yf(u,this);
|
|
|
+ return h.initData(o),
|
|
|
+ h
|
|
|
+ },
|
|
|
+ getLayerSeries: function() {
|
|
|
+ for (var i = this.getData(), t = i.count(), e = [], n = 0; n < t; ++n)
|
|
|
+ e[n] = n;
|
|
|
+ var o = i.mapDimension("single")
|
|
|
+ , a = ta(e, function(t) {
|
|
|
+ return i.get("name", t)
|
|
|
+ })
|
|
|
+ , r = [];
|
|
|
+ return a.buckets.each(function(t, e) {
|
|
|
+ t.sort(function(t, e) {
|
|
|
+ return i.get(o, t) - i.get(o, e)
|
|
|
+ }),
|
|
|
+ r.push({
|
|
|
+ name: e,
|
|
|
+ indices: t
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ r
|
|
|
+ },
|
|
|
+ getAxisTooltipData: function(t, e, i) {
|
|
|
+ L(t) || (t = t ? [t] : []);
|
|
|
+ for (var n, o = this.getData(), a = this.getLayerSeries(), r = [], s = a.length, l = 0; l < s; ++l) {
|
|
|
+ for (var u = Number.MAX_VALUE, h = -1, c = a[l].indices.length, d = 0; d < c; ++d) {
|
|
|
+ var f = o.get(t[0], a[l].indices[d])
|
|
|
+ , p = Math.abs(f - e);
|
|
|
+ p <= u && (n = f,
|
|
|
+ u = p,
|
|
|
+ h = a[l].indices[d])
|
|
|
+ }
|
|
|
+ r.push(h)
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ dataIndices: r,
|
|
|
+ nestestValue: n
|
|
|
+ }
|
|
|
+ },
|
|
|
+ formatTooltip: function(t) {
|
|
|
+ var e = this.getData()
|
|
|
+ , i = e.getName(t)
|
|
|
+ , n = e.get(e.mapDimension("value"), t);
|
|
|
+ return !isNaN(n) && null != n || (n = "-"),
|
|
|
+ au(i + " : " + n)
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ coordinateSystem: "singleAxis",
|
|
|
+ boundaryGap: ["10%", "10%"],
|
|
|
+ singleAxisIndex: 0,
|
|
|
+ animationEasing: "linear",
|
|
|
+ label: {
|
|
|
+ margin: 4,
|
|
|
+ show: !0,
|
|
|
+ position: "left",
|
|
|
+ color: "#000",
|
|
|
+ fontSize: 11
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ Cf({
|
|
|
+ type: "themeRiver",
|
|
|
+ init: function() {
|
|
|
+ this._layers = []
|
|
|
+ },
|
|
|
+ render: function(b, t, e) {
|
|
|
+ var S = b.getData()
|
|
|
+ , M = this.group
|
|
|
+ , I = b.getLayerSeries()
|
|
|
+ , i = S.getLayout("layoutInfo")
|
|
|
+ , n = i.rect
|
|
|
+ , o = i.boundaryGap;
|
|
|
+ function a(t) {
|
|
|
+ return t.name
|
|
|
+ }
|
|
|
+ M.attr("position", [0, n.y + o[0]]);
|
|
|
+ var r = new kf(this._layersSeries || [],I,a,a)
|
|
|
+ , T = {};
|
|
|
+ function s(t, e, i) {
|
|
|
+ var n = this._layers;
|
|
|
+ if ("remove" !== t) {
|
|
|
+ for (var o, a, r, s = [], l = [], u = I[e].indices, h = 0; h < u.length; h++) {
|
|
|
+ var c = S.getItemLayout(u[h])
|
|
|
+ , d = c.x
|
|
|
+ , f = c.y0
|
|
|
+ , p = c.y;
|
|
|
+ s.push([d, f]),
|
|
|
+ l.push([d, f + p]),
|
|
|
+ o = S.getItemVisual(u[h], "color")
|
|
|
+ }
|
|
|
+ var g = S.getItemLayout(u[0])
|
|
|
+ , m = S.getItemModel(u[h - 1])
|
|
|
+ , v = m.getModel("label")
|
|
|
+ , y = v.get("margin");
|
|
|
+ if ("add" === t) {
|
|
|
+ var x = T[e] = new Ci;
|
|
|
+ a = new _m({
|
|
|
+ shape: {
|
|
|
+ points: s,
|
|
|
+ stackedOnPoints: l,
|
|
|
+ smooth: .4,
|
|
|
+ stackedOnSmooth: .4,
|
|
|
+ smoothConstraint: !1
|
|
|
+ },
|
|
|
+ z2: 0
|
|
|
+ }),
|
|
|
+ r = new Ur({
|
|
|
+ style: {
|
|
|
+ x: g.x - y,
|
|
|
+ y: g.y0 + g.y / 2
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ x.add(a),
|
|
|
+ x.add(r),
|
|
|
+ M.add(x),
|
|
|
+ a.setClipPath(function(t, e, i) {
|
|
|
+ var n = new rs({
|
|
|
+ shape: {
|
|
|
+ x: t.x - 10,
|
|
|
+ y: t.y - 10,
|
|
|
+ width: 0,
|
|
|
+ height: t.height + 20
|
|
|
+ }
|
|
|
+ });
|
|
|
+ return dl(n, {
|
|
|
+ shape: {
|
|
|
+ width: t.width + 20,
|
|
|
+ height: t.height + 20
|
|
|
+ }
|
|
|
+ }, e, i),
|
|
|
+ n
|
|
|
+ }(a.getBoundingRect(), b, function() {
|
|
|
+ a.removeClipPath()
|
|
|
+ }))
|
|
|
+ } else {
|
|
|
+ x = n[i];
|
|
|
+ a = x.childAt(0),
|
|
|
+ r = x.childAt(1),
|
|
|
+ M.add(x),
|
|
|
+ T[e] = x,
|
|
|
+ cl(a, {
|
|
|
+ shape: {
|
|
|
+ points: s,
|
|
|
+ stackedOnPoints: l
|
|
|
+ }
|
|
|
+ }, b),
|
|
|
+ cl(r, {
|
|
|
+ style: {
|
|
|
+ x: g.x - y,
|
|
|
+ y: g.y0 + g.y / 2
|
|
|
+ }
|
|
|
+ }, b)
|
|
|
+ }
|
|
|
+ var _ = m.getModel("emphasis.itemStyle")
|
|
|
+ , w = m.getModel("itemStyle");
|
|
|
+ nl(r.style, v, {
|
|
|
+ text: v.get("show") ? b.getFormattedLabel(u[h - 1], "normal") || S.getName(u[h - 1]) : null,
|
|
|
+ textVerticalAlign: "middle"
|
|
|
+ }),
|
|
|
+ a.setStyle(P({
|
|
|
+ fill: o
|
|
|
+ }, w.getItemStyle(["color"]))),
|
|
|
+ $s(a, _.getItemStyle())
|
|
|
+ } else
|
|
|
+ M.remove(n[e])
|
|
|
+ }
|
|
|
+ r.add(A(s, this, "add")).update(A(s, this, "update")).remove(A(s, this, "remove")).execute(),
|
|
|
+ this._layersSeries = I,
|
|
|
+ this._layers = T
|
|
|
+ },
|
|
|
+ dispose: function() {}
|
|
|
+ });
|
|
|
+ function UI(i, t, e) {
|
|
|
+ if (i.count())
|
|
|
+ for (var n, o = t.coordinateSystem, a = t.getLayerSeries(), r = i.mapDimension("single"), s = i.mapDimension("value"), l = O(a, function(t) {
|
|
|
+ return O(t.indices, function(t) {
|
|
|
+ var e = o.dataToPoint(i.get(r, t));
|
|
|
+ return e[1] = i.get(s, t),
|
|
|
+ e
|
|
|
+ })
|
|
|
+ }), u = function(t) {
|
|
|
+ for (var e = t.length, i = t[0].length, n = [], o = [], a = 0, r = {}, s = 0; s < i; ++s) {
|
|
|
+ for (var l = 0, u = 0; l < e; ++l)
|
|
|
+ u += t[l][s][1];
|
|
|
+ a < u && (a = u),
|
|
|
+ n.push(u)
|
|
|
+ }
|
|
|
+ for (var h = 0; h < i; ++h)
|
|
|
+ o[h] = (a - n[h]) / 2;
|
|
|
+ for (var c = a = 0; c < i; ++c) {
|
|
|
+ var d = n[c] + o[c];
|
|
|
+ a < d && (a = d)
|
|
|
+ }
|
|
|
+ return r.y0 = o,
|
|
|
+ r.max = a,
|
|
|
+ r
|
|
|
+ }(l), h = u.y0, c = e / u.max, d = a.length, f = a[0].indices.length, p = 0; p < f; ++p) {
|
|
|
+ n = h[p] * c,
|
|
|
+ i.setItemLayout(a[0].indices[p], {
|
|
|
+ layerIndex: 0,
|
|
|
+ x: l[0][p][0],
|
|
|
+ y0: n,
|
|
|
+ y: l[0][p][1] * c
|
|
|
+ });
|
|
|
+ for (var g = 1; g < d; ++g)
|
|
|
+ n += l[g - 1][p][1] * c,
|
|
|
+ i.setItemLayout(a[g].indices[p], {
|
|
|
+ layerIndex: g,
|
|
|
+ x: l[g][p][0],
|
|
|
+ y0: n,
|
|
|
+ y: l[g][p][1] * c
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ bf(function(t, e) {
|
|
|
+ t.eachSeriesByType("themeRiver", function(t) {
|
|
|
+ var e = t.getData()
|
|
|
+ , i = t.coordinateSystem
|
|
|
+ , n = {}
|
|
|
+ , o = i.getRect();
|
|
|
+ n.rect = o;
|
|
|
+ var a = t.get("boundaryGap")
|
|
|
+ , r = i.getAxis();
|
|
|
+ (n.boundaryGap = a,
|
|
|
+ "horizontal" === r.orient) ? (a[0] = Rl(a[0], o.height),
|
|
|
+ a[1] = Rl(a[1], o.height),
|
|
|
+ UI(e, t, o.height - a[0] - a[1])) : (a[0] = Rl(a[0], o.width),
|
|
|
+ a[1] = Rl(a[1], o.width),
|
|
|
+ UI(e, t, o.width - a[0] - a[1]));
|
|
|
+ e.setLayout("layoutInfo", n)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ Sf(function(t) {
|
|
|
+ t.eachSeriesByType("themeRiver", function(o) {
|
|
|
+ var a = o.getData()
|
|
|
+ , r = o.getRawData()
|
|
|
+ , s = o.get("color")
|
|
|
+ , l = Q();
|
|
|
+ a.each(function(t) {
|
|
|
+ l.set(a.getRawIndex(t), t)
|
|
|
+ }),
|
|
|
+ r.each(function(t) {
|
|
|
+ var e = r.getName(t)
|
|
|
+ , i = s[(o.nameMap.get(e) - 1) % s.length];
|
|
|
+ r.setItemVisual(t, "color", i);
|
|
|
+ var n = l.get(t);
|
|
|
+ null != n && a.setItemVisual(n, "color", i)
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ xf(uy("themeRiver")),
|
|
|
+ sc.extend({
|
|
|
+ type: "series.sunburst",
|
|
|
+ _viewRoot: null,
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ var i = {
|
|
|
+ name: t.name,
|
|
|
+ children: t.data
|
|
|
+ };
|
|
|
+ !function i(t) {
|
|
|
+ var n = 0;
|
|
|
+ E(t.children, function(t) {
|
|
|
+ i(t);
|
|
|
+ var e = t.value;
|
|
|
+ L(e) && (e = e[0]),
|
|
|
+ n += e
|
|
|
+ });
|
|
|
+ var e = t.value;
|
|
|
+ L(e) && (e = e[0]);
|
|
|
+ null != e && !isNaN(e) || (e = n);
|
|
|
+ e < 0 && (e = 0);
|
|
|
+ L(t.value) ? t.value[0] = e : t.value = e
|
|
|
+ }(i);
|
|
|
+ var n = t.levels || []
|
|
|
+ , o = {};
|
|
|
+ return o.levels = n,
|
|
|
+ Ax.createTree(i, this, o).data
|
|
|
+ },
|
|
|
+ optionUpdated: function() {
|
|
|
+ this.resetViewRoot()
|
|
|
+ },
|
|
|
+ getDataParams: function(t) {
|
|
|
+ var e = sc.prototype.getDataParams.apply(this, arguments)
|
|
|
+ , i = this.getData().tree.getNodeByDataIndex(t);
|
|
|
+ return e.treePathInfo = Yx(i, this),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ center: ["50%", "50%"],
|
|
|
+ radius: [0, "75%"],
|
|
|
+ clockwise: !0,
|
|
|
+ startAngle: 90,
|
|
|
+ minAngle: 0,
|
|
|
+ percentPrecision: 2,
|
|
|
+ stillShowZeroSum: !0,
|
|
|
+ highlightPolicy: "descendant",
|
|
|
+ nodeClick: "rootToNode",
|
|
|
+ renderLabelForZeroData: !1,
|
|
|
+ label: {
|
|
|
+ rotate: "radial",
|
|
|
+ show: !0,
|
|
|
+ opacity: 1,
|
|
|
+ align: "center",
|
|
|
+ position: "inside",
|
|
|
+ distance: 5,
|
|
|
+ silent: !0
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: 1,
|
|
|
+ borderColor: "white",
|
|
|
+ borderType: "solid",
|
|
|
+ shadowBlur: 0,
|
|
|
+ shadowColor: "rgba(0, 0, 0, 0.2)",
|
|
|
+ shadowOffsetX: 0,
|
|
|
+ shadowOffsetY: 0,
|
|
|
+ opacity: 1
|
|
|
+ },
|
|
|
+ highlight: {
|
|
|
+ itemStyle: {
|
|
|
+ opacity: 1
|
|
|
+ }
|
|
|
+ },
|
|
|
+ downplay: {
|
|
|
+ itemStyle: {
|
|
|
+ opacity: .5
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ opacity: .6
|
|
|
+ }
|
|
|
+ },
|
|
|
+ animationType: "expansion",
|
|
|
+ animationDuration: 1e3,
|
|
|
+ animationDurationUpdate: 500,
|
|
|
+ animationEasing: "cubicOut",
|
|
|
+ data: [],
|
|
|
+ levels: [],
|
|
|
+ sort: "desc"
|
|
|
+ },
|
|
|
+ getViewRoot: function() {
|
|
|
+ return this._viewRoot
|
|
|
+ },
|
|
|
+ resetViewRoot: function(t) {
|
|
|
+ t ? this._viewRoot = t : t = this._viewRoot;
|
|
|
+ var e = this.getRawData().tree.root;
|
|
|
+ t && (t === e || e.contains(t)) || (this._viewRoot = e)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var XI = "none"
|
|
|
+ , YI = "ancestor"
|
|
|
+ , jI = "self"
|
|
|
+ , qI = 2
|
|
|
+ , KI = 4;
|
|
|
+ function $I(t, e, i) {
|
|
|
+ Ci.call(this);
|
|
|
+ var n = new qr({
|
|
|
+ z2: qI
|
|
|
+ });
|
|
|
+ n.seriesIndex = e.seriesIndex;
|
|
|
+ var o = new Ur({
|
|
|
+ z2: KI,
|
|
|
+ silent: t.getModel("label").get("silent")
|
|
|
+ });
|
|
|
+ function a() {
|
|
|
+ o.ignore = o.hoverIgnore
|
|
|
+ }
|
|
|
+ function r() {
|
|
|
+ o.ignore = o.normalIgnore
|
|
|
+ }
|
|
|
+ this.add(n),
|
|
|
+ this.add(o),
|
|
|
+ this.updateData(!0, t, "normal", e, i),
|
|
|
+ this.on("emphasis", a).on("normal", r).on("mouseover", a).on("mouseout", r)
|
|
|
+ }
|
|
|
+ var JI = $I.prototype;
|
|
|
+ JI.updateData = function(t, e, i, n, o) {
|
|
|
+ (this.node = e).piece = this,
|
|
|
+ n = n || this._seriesModel,
|
|
|
+ o = o || this._ecModel;
|
|
|
+ var a = this.childAt(0);
|
|
|
+ a.dataIndex = e.dataIndex;
|
|
|
+ var r = e.getModel()
|
|
|
+ , s = e.getLayout()
|
|
|
+ , l = P({}, s);
|
|
|
+ l.label = null;
|
|
|
+ var u = function(t, e, i) {
|
|
|
+ var n = t.getVisual("color")
|
|
|
+ , o = t.getVisual("visualMeta");
|
|
|
+ o && 0 !== o.length || (n = null);
|
|
|
+ var a = t.getModel("itemStyle").get("color");
|
|
|
+ {
|
|
|
+ if (a)
|
|
|
+ return a;
|
|
|
+ if (n)
|
|
|
+ return n;
|
|
|
+ if (0 === t.depth)
|
|
|
+ return i.option.color[0];
|
|
|
+ var r = i.option.color.length;
|
|
|
+ a = i.option.color[function(t) {
|
|
|
+ var e = t;
|
|
|
+ for (; 1 < e.depth; )
|
|
|
+ e = e.parentNode;
|
|
|
+ return _(t.getAncestors()[0].children, e)
|
|
|
+ }(t) % r]
|
|
|
+ }
|
|
|
+ return a
|
|
|
+ }(e, 0, o);
|
|
|
+ !function(t, e, i) {
|
|
|
+ e.getData().setItemVisual(t.dataIndex, "color", i)
|
|
|
+ }(e, n, u);
|
|
|
+ var h, c = r.getModel("itemStyle").getItemStyle();
|
|
|
+ "normal" === i ? h = c : h = m(r.getModel(i + ".itemStyle").getItemStyle(), c);
|
|
|
+ h = D({
|
|
|
+ lineJoin: "bevel",
|
|
|
+ fill: h.fill || u
|
|
|
+ }, h),
|
|
|
+ t ? (a.setShape(l),
|
|
|
+ a.shape.r = s.r0,
|
|
|
+ cl(a, {
|
|
|
+ shape: {
|
|
|
+ r: s.r
|
|
|
+ }
|
|
|
+ }, n, e.dataIndex),
|
|
|
+ a.useStyle(h)) : "object" == typeof h.fill && h.fill.type || "object" == typeof a.style.fill && a.style.fill.type ? (cl(a, {
|
|
|
+ shape: l
|
|
|
+ }, n),
|
|
|
+ a.useStyle(h)) : cl(a, {
|
|
|
+ shape: l,
|
|
|
+ style: h
|
|
|
+ }, n),
|
|
|
+ this._updateLabel(n, u, i);
|
|
|
+ var d = r.getShallow("cursor");
|
|
|
+ if (d && a.attr("cursor", d),
|
|
|
+ t) {
|
|
|
+ var f = n.getShallow("highlightPolicy");
|
|
|
+ this._initEvents(a, e, n, f)
|
|
|
+ }
|
|
|
+ this._seriesModel = n || this._seriesModel,
|
|
|
+ this._ecModel = o || this._ecModel,
|
|
|
+ $s(this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ JI.onEmphasis = function(e) {
|
|
|
+ var i = this;
|
|
|
+ this.node.hostTree.root.eachNode(function(t) {
|
|
|
+ t.piece && (i.node === t ? t.piece.updateData(!1, t, "emphasis") : !function(t, e, i) {
|
|
|
+ return i !== XI && (i === jI ? t === e : i === YI ? t === e || t.isAncestorOf(e) : t === e || t.isDescendantOf(e))
|
|
|
+ }(t, i.node, e) ? e !== XI && t.piece.childAt(0).trigger("downplay") : t.piece.childAt(0).trigger("highlight"))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ JI.onNormal = function() {
|
|
|
+ this.node.hostTree.root.eachNode(function(t) {
|
|
|
+ t.piece && t.piece.updateData(!1, t, "normal")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ JI.onHighlight = function() {
|
|
|
+ this.updateData(!1, this.node, "highlight")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ JI.onDownplay = function() {
|
|
|
+ this.updateData(!1, this.node, "downplay")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ JI._updateLabel = function(t, e, i) {
|
|
|
+ var n = this.node.getModel()
|
|
|
+ , o = n.getModel("label")
|
|
|
+ , a = "normal" === i || "emphasis" === i ? o : n.getModel(i + ".label")
|
|
|
+ , r = n.getModel("emphasis.label")
|
|
|
+ , s = W(t.getFormattedLabel(this.node.dataIndex, i, null, null, "label"), this.node.name);
|
|
|
+ !1 === S("show") && (s = "");
|
|
|
+ var l = this.node.getLayout()
|
|
|
+ , u = a.get("minAngle");
|
|
|
+ null == u && (u = o.get("minAngle")),
|
|
|
+ u = u / 180 * Math.PI;
|
|
|
+ var h = l.endAngle - l.startAngle;
|
|
|
+ null != u && Math.abs(h) < u && (s = "");
|
|
|
+ var c = this.childAt(1);
|
|
|
+ el(c.style, c.hoverStyle || {}, o, r, {
|
|
|
+ defaultText: a.getShallow("show") ? s : null,
|
|
|
+ autoColor: e,
|
|
|
+ useInsideStyle: !0
|
|
|
+ });
|
|
|
+ var d, f = (l.startAngle + l.endAngle) / 2, p = Math.cos(f), g = Math.sin(f), m = S("position"), v = S("distance") || 0, y = S("align");
|
|
|
+ "outside" === m ? (d = l.r + v,
|
|
|
+ y = f > Math.PI / 2 ? "right" : "left") : y && "center" !== y ? "left" === y ? (d = l.r0 + v,
|
|
|
+ f > Math.PI / 2 && (y = "right")) : "right" === y && (d = l.r - v,
|
|
|
+ f > Math.PI / 2 && (y = "left")) : (d = (l.r + l.r0) / 2,
|
|
|
+ y = "center"),
|
|
|
+ c.attr("style", {
|
|
|
+ text: s,
|
|
|
+ textAlign: y,
|
|
|
+ textVerticalAlign: S("verticalAlign") || "middle",
|
|
|
+ opacity: S("opacity")
|
|
|
+ });
|
|
|
+ var x = d * p + l.cx
|
|
|
+ , _ = d * g + l.cy;
|
|
|
+ c.attr("position", [x, _]);
|
|
|
+ var w = S("rotate")
|
|
|
+ , b = 0;
|
|
|
+ function S(t) {
|
|
|
+ var e = a.get(t);
|
|
|
+ return null == e ? o.get(t) : e
|
|
|
+ }
|
|
|
+ "radial" === w ? (b = -f) < -Math.PI / 2 && (b += Math.PI) : "tangential" === w ? (b = Math.PI / 2 - f) > Math.PI / 2 ? b -= Math.PI : b < -Math.PI / 2 && (b += Math.PI) : "number" == typeof w && (b = w * Math.PI / 180),
|
|
|
+ c.attr("rotation", b)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ JI._initEvents = function(t, e, i, n) {
|
|
|
+ t.off("mouseover").off("mouseout").off("emphasis").off("normal");
|
|
|
+ function o() {
|
|
|
+ r.onEmphasis(n)
|
|
|
+ }
|
|
|
+ function a() {
|
|
|
+ r.onNormal()
|
|
|
+ }
|
|
|
+ var r = this;
|
|
|
+ i.isAnimationEnabled() && t.on("mouseover", o).on("mouseout", a).on("emphasis", o).on("normal", a).on("downplay", function() {
|
|
|
+ r.onDownplay()
|
|
|
+ }).on("highlight", function() {
|
|
|
+ r.onHighlight()
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w($I, Ci);
|
|
|
+ _c.extend({
|
|
|
+ type: "sunburst",
|
|
|
+ init: function() {},
|
|
|
+ render: function(o, a, t, e) {
|
|
|
+ var n = this;
|
|
|
+ this.seriesModel = o,
|
|
|
+ this.api = t,
|
|
|
+ this.ecModel = a;
|
|
|
+ var r = o.getData()
|
|
|
+ , s = r.tree.root
|
|
|
+ , i = o.getViewRoot()
|
|
|
+ , l = this.group
|
|
|
+ , u = o.get("renderLabelForZeroData")
|
|
|
+ , h = [];
|
|
|
+ i.eachNode(function(t) {
|
|
|
+ h.push(t)
|
|
|
+ });
|
|
|
+ var c = this._oldChildren || [];
|
|
|
+ if (function(i, n) {
|
|
|
+ if (0 === i.length && 0 === n.length)
|
|
|
+ return;
|
|
|
+ function t(t) {
|
|
|
+ return t.getId()
|
|
|
+ }
|
|
|
+ function e(t, e) {
|
|
|
+ !function(t, e) {
|
|
|
+ u || !t || t.getValue() || (t = null);
|
|
|
+ if (t !== s && e !== s)
|
|
|
+ if (e && e.piece)
|
|
|
+ t ? (e.piece.updateData(!1, t, "normal", o, a),
|
|
|
+ r.setItemGraphicEl(t.dataIndex, e.piece)) : function(t) {
|
|
|
+ if (!t)
|
|
|
+ return;
|
|
|
+ t.piece && (l.remove(t.piece),
|
|
|
+ t.piece = null)
|
|
|
+ }(e);
|
|
|
+ else if (t) {
|
|
|
+ var i = new $I(t,o,a);
|
|
|
+ l.add(i),
|
|
|
+ r.setItemGraphicEl(t.dataIndex, i)
|
|
|
+ }
|
|
|
+ }(null == t ? null : i[t], null == e ? null : n[e])
|
|
|
+ }
|
|
|
+ new kf(n,i,t,t).add(e).update(e).remove(T(e, null)).execute()
|
|
|
+ }(h, c),
|
|
|
+ function(t, e) {
|
|
|
+ if (0 < e.depth) {
|
|
|
+ n.virtualPiece ? n.virtualPiece.updateData(!1, t, "normal", o, a) : (n.virtualPiece = new $I(t,o,a),
|
|
|
+ l.add(n.virtualPiece)),
|
|
|
+ e.piece._onclickEvent && e.piece.off("click", e.piece._onclickEvent);
|
|
|
+ var i = function(t) {
|
|
|
+ n._rootToNode(e.parentNode)
|
|
|
+ };
|
|
|
+ e.piece._onclickEvent = i,
|
|
|
+ n.virtualPiece.on("click", i)
|
|
|
+ } else
|
|
|
+ n.virtualPiece && (l.remove(n.virtualPiece),
|
|
|
+ n.virtualPiece = null)
|
|
|
+ }(s, i),
|
|
|
+ e && e.highlight && e.highlight.piece) {
|
|
|
+ var d = o.getShallow("highlightPolicy");
|
|
|
+ e.highlight.piece.onEmphasis(d)
|
|
|
+ } else if (e && e.unhighlight) {
|
|
|
+ var f = this.virtualPiece;
|
|
|
+ !f && s.children.length && (f = s.children[0].piece),
|
|
|
+ f && f.onNormal()
|
|
|
+ }
|
|
|
+ this._initEvents(),
|
|
|
+ this._oldChildren = h
|
|
|
+ },
|
|
|
+ dispose: function() {},
|
|
|
+ _initEvents: function() {
|
|
|
+ function t(o) {
|
|
|
+ var a = !1;
|
|
|
+ r.seriesModel.getViewRoot().eachNode(function(t) {
|
|
|
+ if (!a && t.piece && t.piece.childAt(0) === o.target) {
|
|
|
+ var e = t.getModel().get("nodeClick");
|
|
|
+ if ("rootToNode" === e)
|
|
|
+ r._rootToNode(t);
|
|
|
+ else if ("link" === e) {
|
|
|
+ var i = t.getModel()
|
|
|
+ , n = i.get("link");
|
|
|
+ if (n)
|
|
|
+ gu(n, i.get("target", !0) || "_blank")
|
|
|
+ }
|
|
|
+ a = !0
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var r = this;
|
|
|
+ this.group._onclickEvent && this.group.off("click", this.group._onclickEvent),
|
|
|
+ this.group.on("click", t),
|
|
|
+ this.group._onclickEvent = t
|
|
|
+ },
|
|
|
+ _rootToNode: function(t) {
|
|
|
+ t !== this.seriesModel.getViewRoot() && this.api.dispatchAction({
|
|
|
+ type: "sunburstRootToNode",
|
|
|
+ from: this.uid,
|
|
|
+ seriesId: this.seriesModel.id,
|
|
|
+ targetNode: t
|
|
|
+ })
|
|
|
+ },
|
|
|
+ containPoint: function(t, e) {
|
|
|
+ var i = e.getData().getItemLayout(0);
|
|
|
+ if (i) {
|
|
|
+ var n = t[0] - i.cx
|
|
|
+ , o = t[1] - i.cy
|
|
|
+ , a = Math.sqrt(n * n + o * o);
|
|
|
+ return a <= i.r && a >= i.r0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var QI = "sunburstRootToNode";
|
|
|
+ _f({
|
|
|
+ type: QI,
|
|
|
+ update: "updateView"
|
|
|
+ }, function(o, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "sunburst",
|
|
|
+ query: o
|
|
|
+ }, function(t, e) {
|
|
|
+ var i = Zx(o, [QI], t);
|
|
|
+ if (i) {
|
|
|
+ var n = t.getViewRoot();
|
|
|
+ n && (o.direction = Xx(n, i.node) ? "rollUp" : "drillDown"),
|
|
|
+ t.resetViewRoot(i.node)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var tT = "sunburstHighlight";
|
|
|
+ _f({
|
|
|
+ type: tT,
|
|
|
+ update: "updateView"
|
|
|
+ }, function(n, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "sunburst",
|
|
|
+ query: n
|
|
|
+ }, function(t, e) {
|
|
|
+ var i = Zx(n, [tT], t);
|
|
|
+ i && (n.highlight = i.node)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ _f({
|
|
|
+ type: "sunburstUnhighlight",
|
|
|
+ update: "updateView"
|
|
|
+ }, function(i, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ subType: "sunburst",
|
|
|
+ query: i
|
|
|
+ }, function(t, e) {
|
|
|
+ i.unhighlight = !0
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var eT = Math.PI / 180;
|
|
|
+ function iT(t, e) {
|
|
|
+ if ("function" == typeof e)
|
|
|
+ return t.sort(e);
|
|
|
+ var n = "asc" === e;
|
|
|
+ return t.sort(function(t, e) {
|
|
|
+ var i = (t.getValue() - e.getValue()) * (n ? 1 : -1);
|
|
|
+ return 0 == i ? (t.dataIndex - e.dataIndex) * (n ? -1 : 1) : i
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function nT(a, r) {
|
|
|
+ return r = r || [0, 0],
|
|
|
+ O(["x", "y"], function(t, e) {
|
|
|
+ var i = this.getAxis(t)
|
|
|
+ , n = r[e]
|
|
|
+ , o = a[e] / 2;
|
|
|
+ return "category" === i.type ? i.getBandWidth() : Math.abs(i.dataToCoord(n - o) - i.dataToCoord(n + o))
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ Sf(T(iy, "sunburst")),
|
|
|
+ bf(T(function(t, e, C, i) {
|
|
|
+ e.eachSeriesByType(t, function(t) {
|
|
|
+ var e = t.get("center")
|
|
|
+ , i = t.get("radius");
|
|
|
+ L(i) || (i = [0, i]),
|
|
|
+ L(e) || (e = [e, e]);
|
|
|
+ var n = C.getWidth()
|
|
|
+ , o = C.getHeight()
|
|
|
+ , h = Math.min(n, o)
|
|
|
+ , c = Rl(e[0], n)
|
|
|
+ , d = Rl(e[1], o)
|
|
|
+ , f = Rl(i[0], h / 2)
|
|
|
+ , a = Rl(i[1], h / 2)
|
|
|
+ , r = -t.get("startAngle") * eT
|
|
|
+ , p = t.get("minAngle") * eT
|
|
|
+ , g = t.getData().tree.root
|
|
|
+ , s = t.getViewRoot()
|
|
|
+ , m = s.depth
|
|
|
+ , l = t.get("sort");
|
|
|
+ null != l && !function e(t, i) {
|
|
|
+ var n = t.children || [];
|
|
|
+ t.children = iT(n, i);
|
|
|
+ n.length && E(t.children, function(t) {
|
|
|
+ e(t, i)
|
|
|
+ })
|
|
|
+ }(s, l);
|
|
|
+ var u = 0;
|
|
|
+ E(s.children, function(t) {
|
|
|
+ isNaN(t.getValue()) || u++
|
|
|
+ });
|
|
|
+ var v = s.getValue()
|
|
|
+ , y = Math.PI / (v || u) * 2
|
|
|
+ , x = 0 < s.depth
|
|
|
+ , _ = s.height - (x ? -1 : 1)
|
|
|
+ , w = (a - f) / (_ || 1)
|
|
|
+ , b = t.get("clockwise")
|
|
|
+ , S = t.get("stillShowZeroSum")
|
|
|
+ , M = b ? 1 : -1
|
|
|
+ , I = function(t, e) {
|
|
|
+ if (t) {
|
|
|
+ var i = e;
|
|
|
+ if (t !== g) {
|
|
|
+ var n = t.getValue()
|
|
|
+ , o = 0 === v && S ? y : n * y;
|
|
|
+ o < p && (o = p),
|
|
|
+ i = e + M * o;
|
|
|
+ var a = t.depth - m - (x ? -1 : 1)
|
|
|
+ , r = f + w * a
|
|
|
+ , s = f + w * (1 + a)
|
|
|
+ , l = t.getModel();
|
|
|
+ null != l.get("r0") && (r = Rl(l.get("r0"), h / 2)),
|
|
|
+ null != l.get("r") && (s = Rl(l.get("r"), h / 2)),
|
|
|
+ t.setLayout({
|
|
|
+ angle: o,
|
|
|
+ startAngle: e,
|
|
|
+ endAngle: i,
|
|
|
+ clockwise: b,
|
|
|
+ cx: c,
|
|
|
+ cy: d,
|
|
|
+ r0: r,
|
|
|
+ r: s
|
|
|
+ })
|
|
|
+ }
|
|
|
+ if (t.children && t.children.length) {
|
|
|
+ var u = 0;
|
|
|
+ E(t.children, function(t) {
|
|
|
+ u += I(t, e + u)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return i - e
|
|
|
+ }
|
|
|
+ };
|
|
|
+ if (x) {
|
|
|
+ var T = f
|
|
|
+ , A = f + w
|
|
|
+ , D = 2 * Math.PI;
|
|
|
+ g.setLayout({
|
|
|
+ angle: D,
|
|
|
+ startAngle: r,
|
|
|
+ endAngle: r + D,
|
|
|
+ clockwise: b,
|
|
|
+ cx: c,
|
|
|
+ cy: d,
|
|
|
+ r0: T,
|
|
|
+ r: A
|
|
|
+ })
|
|
|
+ }
|
|
|
+ I(s, r)
|
|
|
+ })
|
|
|
+ }, "sunburst")),
|
|
|
+ xf(T(uy, "sunburst"));
|
|
|
+ function oT(a, r) {
|
|
|
+ return r = r || [0, 0],
|
|
|
+ O([0, 1], function(t) {
|
|
|
+ var e = r[t]
|
|
|
+ , i = a[t] / 2
|
|
|
+ , n = []
|
|
|
+ , o = [];
|
|
|
+ return n[t] = e - i,
|
|
|
+ o[t] = e + i,
|
|
|
+ n[1 - t] = o[1 - t] = r[1 - t],
|
|
|
+ Math.abs(this.dataToPoint(n)[t] - this.dataToPoint(o)[t])
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ function aT(t, e) {
|
|
|
+ var i = this.getAxis()
|
|
|
+ , n = e instanceof Array ? e[0] : e
|
|
|
+ , o = (t instanceof Array ? t[0] : t) / 2;
|
|
|
+ return "category" === i.type ? i.getBandWidth() : Math.abs(i.dataToCoord(n - o) - i.dataToCoord(n + o))
|
|
|
+ }
|
|
|
+ function rT(s, l) {
|
|
|
+ return O(["Radius", "Angle"], function(t, e) {
|
|
|
+ var i = this["get" + t + "Axis"]()
|
|
|
+ , n = l[e]
|
|
|
+ , o = s[e] / 2
|
|
|
+ , a = "dataTo" + t
|
|
|
+ , r = "category" === i.type ? i.getBandWidth() : Math.abs(i[a](n - o) - i[a](n + o));
|
|
|
+ return "Angle" === t && (r = r * Math.PI / 180),
|
|
|
+ r
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ var sT = Ss
|
|
|
+ , lT = ["itemStyle"]
|
|
|
+ , uT = ["emphasis", "itemStyle"]
|
|
|
+ , hT = ["label"]
|
|
|
+ , cT = ["emphasis", "label"]
|
|
|
+ , dT = "e\0\0"
|
|
|
+ , fT = {
|
|
|
+ cartesian2d: function(e) {
|
|
|
+ var t = e.grid.getRect();
|
|
|
+ return {
|
|
|
+ coordSys: {
|
|
|
+ type: "cartesian2d",
|
|
|
+ x: t.x,
|
|
|
+ y: t.y,
|
|
|
+ width: t.width,
|
|
|
+ height: t.height
|
|
|
+ },
|
|
|
+ api: {
|
|
|
+ coord: function(t) {
|
|
|
+ return e.dataToPoint(t)
|
|
|
+ },
|
|
|
+ size: A(nT, e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ geo: function(e) {
|
|
|
+ var t = e.getBoundingRect();
|
|
|
+ return {
|
|
|
+ coordSys: {
|
|
|
+ type: "geo",
|
|
|
+ x: t.x,
|
|
|
+ y: t.y,
|
|
|
+ width: t.width,
|
|
|
+ height: t.height,
|
|
|
+ zoom: e.getZoom()
|
|
|
+ },
|
|
|
+ api: {
|
|
|
+ coord: function(t) {
|
|
|
+ return e.dataToPoint(t)
|
|
|
+ },
|
|
|
+ size: A(oT, e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ singleAxis: function(e) {
|
|
|
+ var t = e.getRect();
|
|
|
+ return {
|
|
|
+ coordSys: {
|
|
|
+ type: "singleAxis",
|
|
|
+ x: t.x,
|
|
|
+ y: t.y,
|
|
|
+ width: t.width,
|
|
|
+ height: t.height
|
|
|
+ },
|
|
|
+ api: {
|
|
|
+ coord: function(t) {
|
|
|
+ return e.dataToPoint(t)
|
|
|
+ },
|
|
|
+ size: A(aT, e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ polar: function(o) {
|
|
|
+ var a = o.getRadiusAxis()
|
|
|
+ , r = o.getAngleAxis()
|
|
|
+ , t = a.getExtent();
|
|
|
+ return t[0] > t[1] && t.reverse(),
|
|
|
+ {
|
|
|
+ coordSys: {
|
|
|
+ type: "polar",
|
|
|
+ cx: o.cx,
|
|
|
+ cy: o.cy,
|
|
|
+ r: t[1],
|
|
|
+ r0: t[0]
|
|
|
+ },
|
|
|
+ api: {
|
|
|
+ coord: A(function(t) {
|
|
|
+ var e = a.dataToRadius(t[0])
|
|
|
+ , i = r.dataToAngle(t[1])
|
|
|
+ , n = o.coordToPoint([e, i]);
|
|
|
+ return n.push(e, i * Math.PI / 180),
|
|
|
+ n
|
|
|
+ }),
|
|
|
+ size: A(rT, o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ calendar: function(i) {
|
|
|
+ var t = i.getRect()
|
|
|
+ , e = i.getRangeInfo();
|
|
|
+ return {
|
|
|
+ coordSys: {
|
|
|
+ type: "calendar",
|
|
|
+ x: t.x,
|
|
|
+ y: t.y,
|
|
|
+ width: t.width,
|
|
|
+ height: t.height,
|
|
|
+ cellWidth: i.getCellWidth(),
|
|
|
+ cellHeight: i.getCellHeight(),
|
|
|
+ rangeInfo: {
|
|
|
+ start: e.start,
|
|
|
+ end: e.end,
|
|
|
+ weeks: e.weeks,
|
|
|
+ dayCount: e.allDay
|
|
|
+ }
|
|
|
+ },
|
|
|
+ api: {
|
|
|
+ coord: function(t, e) {
|
|
|
+ return i.dataToPoint(t, e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function pT(t, e, i, n, o) {
|
|
|
+ null == i[t] || o || (e[t] = i[t],
|
|
|
+ i[t] = n[t])
|
|
|
+ }
|
|
|
+ function gT(a, r, e, t) {
|
|
|
+ var i = a.get("renderItem")
|
|
|
+ , n = a.coordinateSystem
|
|
|
+ , o = {};
|
|
|
+ n && (o = n.prepareCustoms ? n.prepareCustoms() : fT[n.type](n));
|
|
|
+ var s, l, u, h, c, d = D({
|
|
|
+ getWidth: t.getWidth,
|
|
|
+ getHeight: t.getHeight,
|
|
|
+ getZr: t.getZr,
|
|
|
+ getDevicePixelRatio: t.getDevicePixelRatio,
|
|
|
+ value: function(t, e) {
|
|
|
+ return null == e && (e = s),
|
|
|
+ r.get(r.getDimension(t || 0), e)
|
|
|
+ },
|
|
|
+ style: function(t, e) {
|
|
|
+ null == e && (e = s),
|
|
|
+ g(e);
|
|
|
+ var i = l.getModel(lT).getItemStyle();
|
|
|
+ null != c && (i.fill = c);
|
|
|
+ var n = r.getItemVisual(e, "opacity");
|
|
|
+ null != n && (i.opacity = n);
|
|
|
+ var o = t ? _T(t, u) : u;
|
|
|
+ return nl(i, o, null, {
|
|
|
+ autoColor: c,
|
|
|
+ isRectText: !0
|
|
|
+ }),
|
|
|
+ i.text = o.getShallow("show") ? H(a.getFormattedLabel(e, "normal"), Ug(r, e)) : null,
|
|
|
+ t && wT(i, t),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ styleEmphasis: function(t, e) {
|
|
|
+ null == e && (e = s),
|
|
|
+ g(e);
|
|
|
+ var i = l.getModel(uT).getItemStyle()
|
|
|
+ , n = t ? _T(t, h) : h;
|
|
|
+ return nl(i, n, null, {
|
|
|
+ isRectText: !0
|
|
|
+ }, !0),
|
|
|
+ i.text = n.getShallow("show") ? Z(a.getFormattedLabel(e, "emphasis"), a.getFormattedLabel(e, "normal"), Ug(r, e)) : null,
|
|
|
+ t && wT(i, t),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ visual: function(t, e) {
|
|
|
+ return null == e && (e = s),
|
|
|
+ r.getItemVisual(e, t)
|
|
|
+ },
|
|
|
+ barLayout: function(t) {
|
|
|
+ if (n.getBaseAxis) {
|
|
|
+ return function(t) {
|
|
|
+ var e = []
|
|
|
+ , i = t.axis;
|
|
|
+ if ("category" === i.type) {
|
|
|
+ for (var n = i.getBandWidth(), o = 0; o < t.count; o++)
|
|
|
+ e.push(D({
|
|
|
+ bandWidth: n,
|
|
|
+ axisKey: "axis0",
|
|
|
+ stackId: Cp + o
|
|
|
+ }, t));
|
|
|
+ var a = Ep(e)
|
|
|
+ , r = [];
|
|
|
+ for (o = 0; o < t.count; o++) {
|
|
|
+ var s = a.axis0[Cp + o];
|
|
|
+ s.offsetCenter = s.offset + s.width / 2,
|
|
|
+ r.push(s)
|
|
|
+ }
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ }(D({
|
|
|
+ axis: n.getBaseAxis()
|
|
|
+ }, t))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ currentSeriesIndices: function() {
|
|
|
+ return e.getCurrentSeriesIndices()
|
|
|
+ },
|
|
|
+ font: function(t) {
|
|
|
+ return ul(t, e)
|
|
|
+ }
|
|
|
+ }, o.api || {}), f = {
|
|
|
+ context: {},
|
|
|
+ seriesId: a.id,
|
|
|
+ seriesName: a.name,
|
|
|
+ seriesIndex: a.seriesIndex,
|
|
|
+ coordSys: o.coordSys,
|
|
|
+ dataInsideLength: r.count(),
|
|
|
+ encode: function(o) {
|
|
|
+ var a = {};
|
|
|
+ return E(o.dimensions, function(t, e) {
|
|
|
+ var i = o.getDimensionInfo(t);
|
|
|
+ if (!i.isExtraCoord) {
|
|
|
+ var n = i.coordDim;
|
|
|
+ (a[n] = a[n] || [])[i.coordDimIndex] = e
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ }(a.getData())
|
|
|
+ }, p = !0;
|
|
|
+ return function(t, e) {
|
|
|
+ return s = t,
|
|
|
+ p = !0,
|
|
|
+ i && i(D({
|
|
|
+ dataIndexInside: t,
|
|
|
+ dataIndex: r.getRawIndex(t),
|
|
|
+ actionType: e ? e.type : null
|
|
|
+ }, f), d)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function g(t) {
|
|
|
+ null == t && (t = s),
|
|
|
+ p && (l = r.getItemModel(t),
|
|
|
+ u = l.getModel(hT),
|
|
|
+ h = l.getModel(cT),
|
|
|
+ c = r.getItemVisual(t, "color"),
|
|
|
+ p = !1)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function mT(t, e, i, n, o, a) {
|
|
|
+ return (t = vT(t, e, i, n, o, a, !0)) && a.setItemGraphicEl(e, t),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function vT(t, e, i, n, o, a, r) {
|
|
|
+ var s = !i
|
|
|
+ , l = (i = i || {}).type
|
|
|
+ , u = i.shape
|
|
|
+ , h = i.style;
|
|
|
+ if (t && (s || null != l && l !== t.__customGraphicType || "path" === l && function(t) {
|
|
|
+ return t && (t.hasOwnProperty("pathData") || t.hasOwnProperty("d"))
|
|
|
+ }(u) && ST(u) !== t.__customPathData || "image" === l && MT(h, "image") && h.image !== t.__customImagePath || "text" === l && MT(u, "text") && h.text !== t.__customText) && (o.remove(t),
|
|
|
+ t = null),
|
|
|
+ !s) {
|
|
|
+ var c = !t;
|
|
|
+ return function(e, t, i, n, o, a, r) {
|
|
|
+ var s = {}
|
|
|
+ , l = i.style || {};
|
|
|
+ if (i.shape && (s.shape = k(i.shape)),
|
|
|
+ i.position && (s.position = i.position.slice()),
|
|
|
+ i.scale && (s.scale = i.scale.slice()),
|
|
|
+ i.origin && (s.origin = i.origin.slice()),
|
|
|
+ i.rotation && (s.rotation = i.rotation),
|
|
|
+ "image" === e.type && i.style) {
|
|
|
+ var u = s.style = {};
|
|
|
+ E(["x", "y", "width", "height"], function(t) {
|
|
|
+ pT(t, u, l, e.style, a)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ if ("text" === e.type && i.style) {
|
|
|
+ u = s.style = {};
|
|
|
+ E(["x", "y"], function(t) {
|
|
|
+ pT(t, u, l, e.style, a)
|
|
|
+ }),
|
|
|
+ !l.hasOwnProperty("textFill") && l.fill && (l.textFill = l.fill),
|
|
|
+ !l.hasOwnProperty("textStroke") && l.stroke && (l.textStroke = l.stroke)
|
|
|
+ }
|
|
|
+ if ("group" !== e.type && (e.useStyle(l),
|
|
|
+ a)) {
|
|
|
+ e.style.opacity = 0;
|
|
|
+ var h = l.opacity;
|
|
|
+ null == h && (h = 1),
|
|
|
+ dl(e, {
|
|
|
+ style: {
|
|
|
+ opacity: h
|
|
|
+ }
|
|
|
+ }, n, t)
|
|
|
+ }
|
|
|
+ a ? e.attr(s) : cl(e, s, n, t),
|
|
|
+ i.hasOwnProperty("z2") && e.attr("z2", i.z2 || 0),
|
|
|
+ i.hasOwnProperty("silent") && e.attr("silent", i.silent),
|
|
|
+ i.hasOwnProperty("invisible") && e.attr("invisible", i.invisible),
|
|
|
+ i.hasOwnProperty("ignore") && e.attr("ignore", i.ignore),
|
|
|
+ i.hasOwnProperty("info") && e.attr("info", i.info);
|
|
|
+ var c = i.styleEmphasis;
|
|
|
+ Us(e, c),
|
|
|
+ r && Js(e, !1 !== c)
|
|
|
+ }(t = t || function(t) {
|
|
|
+ var e, i = t.type;
|
|
|
+ if ("path" === i) {
|
|
|
+ var n = t.shape
|
|
|
+ , o = null != n.width && null != n.height ? {
|
|
|
+ x: n.x || 0,
|
|
|
+ y: n.y || 0,
|
|
|
+ width: n.width,
|
|
|
+ height: n.height
|
|
|
+ } : null
|
|
|
+ , a = ST(n);
|
|
|
+ (e = Ps(a, null, o, n.layout || "center")).__customPathData = a
|
|
|
+ } else if ("image" === i)
|
|
|
+ (e = new Qn({})).__customImagePath = t.style.image;
|
|
|
+ else if ("text" === i)
|
|
|
+ (e = new Ur({})).__customText = t.style.text;
|
|
|
+ else if ("group" === i)
|
|
|
+ e = new Ci;
|
|
|
+ else {
|
|
|
+ if ("compoundPath" === i)
|
|
|
+ throw new Error('"compoundPath" is not supported yet.');
|
|
|
+ e = new (ks(i))
|
|
|
+ }
|
|
|
+ return e.__customGraphicType = i,
|
|
|
+ e.name = t.name,
|
|
|
+ e
|
|
|
+ }(i), e, i, n, 0, c, r),
|
|
|
+ "group" === l && function(t, e, i, n, o) {
|
|
|
+ var a = i.children
|
|
|
+ , r = a ? a.length : 0
|
|
|
+ , s = i.$mergeChildren
|
|
|
+ , l = "byName" === s || i.diffChildrenByName
|
|
|
+ , u = !1 === s;
|
|
|
+ if (!r && !l && !u)
|
|
|
+ return;
|
|
|
+ if (l)
|
|
|
+ return function(t) {
|
|
|
+ new kf(t.oldChildren,t.newChildren,yT,yT,t).add(xT).update(xT).remove(bT).execute()
|
|
|
+ }({
|
|
|
+ oldChildren: t.children() || [],
|
|
|
+ newChildren: a || [],
|
|
|
+ dataIndex: e,
|
|
|
+ animatableModel: n,
|
|
|
+ group: t,
|
|
|
+ data: o
|
|
|
+ });
|
|
|
+ u && t.removeAll();
|
|
|
+ for (var h = 0; h < r; h++)
|
|
|
+ a[h] && vT(t.childAt(h), e, a[h], n, t, o)
|
|
|
+ }(t, e, i, n, a),
|
|
|
+ o.add(t),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function yT(t, e) {
|
|
|
+ var i = t && t.name;
|
|
|
+ return null != i ? i : dT + e
|
|
|
+ }
|
|
|
+ function xT(t, e) {
|
|
|
+ var i = this.context
|
|
|
+ , n = null != t ? i.newChildren[t] : null;
|
|
|
+ vT(null != e ? i.oldChildren[e] : null, i.dataIndex, n, i.animatableModel, i.group, i.data)
|
|
|
+ }
|
|
|
+ function _T(i, t) {
|
|
|
+ var n = new Cl({},t);
|
|
|
+ return E(sT, function(t, e) {
|
|
|
+ i.hasOwnProperty(t) && (n.option[e] = i[t])
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ function wT(t, e) {
|
|
|
+ for (var i in e)
|
|
|
+ !e.hasOwnProperty(i) && sT.hasOwnProperty(i) || (t[i] = e[i])
|
|
|
+ }
|
|
|
+ function bT(t) {
|
|
|
+ var e = this.context
|
|
|
+ , i = e.oldChildren[t];
|
|
|
+ i && e.group.remove(i)
|
|
|
+ }
|
|
|
+ function ST(t) {
|
|
|
+ return t && (t.pathData || t.d)
|
|
|
+ }
|
|
|
+ function MT(t, e) {
|
|
|
+ return t && t.hasOwnProperty(e)
|
|
|
+ }
|
|
|
+ function IT(t) {
|
|
|
+ return t.get("stack") || "__ec_stack_" + t.seriesIndex
|
|
|
+ }
|
|
|
+ function TT(t, e) {
|
|
|
+ return e.dim + t.model.componentIndex
|
|
|
+ }
|
|
|
+ function AT(t, e) {
|
|
|
+ Gg.call(this, "radius", t, e),
|
|
|
+ this.type = "category"
|
|
|
+ }
|
|
|
+ sc.extend({
|
|
|
+ type: "series.custom",
|
|
|
+ dependencies: ["grid", "polar", "geo", "singleAxis", "calendar"],
|
|
|
+ defaultOption: {
|
|
|
+ coordinateSystem: "cartesian2d",
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ legendHoverLink: !0,
|
|
|
+ useTransform: !0,
|
|
|
+ clip: !1
|
|
|
+ },
|
|
|
+ getInitialData: function(t, e) {
|
|
|
+ return gp(this.getSource(), this)
|
|
|
+ },
|
|
|
+ getDataParams: function(t, e, i) {
|
|
|
+ var n = sc.prototype.getDataParams.apply(this, arguments);
|
|
|
+ return i && (n.info = i.info),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _c.extend({
|
|
|
+ type: "custom",
|
|
|
+ _data: null,
|
|
|
+ render: function(i, t, e, n) {
|
|
|
+ var o = this._data
|
|
|
+ , a = i.getData()
|
|
|
+ , r = this.group
|
|
|
+ , s = gT(i, a, t, e);
|
|
|
+ a.diff(o).add(function(t) {
|
|
|
+ mT(null, t, s(t, n), i, r, a)
|
|
|
+ }).update(function(t, e) {
|
|
|
+ mT(o.getItemGraphicEl(e), t, s(t, n), i, r, a)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = o.getItemGraphicEl(t);
|
|
|
+ e && r.remove(e)
|
|
|
+ }).execute();
|
|
|
+ var l = i.get("clip", !0) ? Sm(i.coordinateSystem, !1, i) : null;
|
|
|
+ l ? r.setClipPath(l) : r.removeClipPath(),
|
|
|
+ this._data = a
|
|
|
+ },
|
|
|
+ incrementalPrepareRender: function(t, e, i) {
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._data = null
|
|
|
+ },
|
|
|
+ incrementalRender: function(t, e, i, n, o) {
|
|
|
+ var a = e.getData()
|
|
|
+ , r = gT(e, a, i, n);
|
|
|
+ function s(t) {
|
|
|
+ t.isGroup || (t.incremental = !0,
|
|
|
+ t.useHoverLayer = !0)
|
|
|
+ }
|
|
|
+ for (var l = t.start; l < t.end; l++) {
|
|
|
+ mT(null, l, r(l, o), e, this.group, a).traverse(s)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dispose: et,
|
|
|
+ filterForExposedEvent: function(t, e, i, n) {
|
|
|
+ var o = e.element;
|
|
|
+ if (null == o || i.name === o)
|
|
|
+ return !0;
|
|
|
+ for (; (i = i.parent) && i !== this.group; )
|
|
|
+ if (i.name === o)
|
|
|
+ return !0;
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ AT.prototype = {
|
|
|
+ constructor: AT,
|
|
|
+ pointToData: function(t, e) {
|
|
|
+ return this.polar.pointToData(t, e)["radius" === this.dim ? 0 : 1]
|
|
|
+ },
|
|
|
+ dataToRadius: Gg.prototype.dataToCoord,
|
|
|
+ radiusToData: Gg.prototype.coordToData
|
|
|
+ },
|
|
|
+ w(AT, Gg);
|
|
|
+ var DT = jo();
|
|
|
+ function CT(t, e) {
|
|
|
+ e = e || [0, 360],
|
|
|
+ Gg.call(this, "angle", t, e),
|
|
|
+ this.type = "category"
|
|
|
+ }
|
|
|
+ CT.prototype = {
|
|
|
+ constructor: CT,
|
|
|
+ pointToData: function(t, e) {
|
|
|
+ return this.polar.pointToData(t, e)["radius" === this.dim ? 0 : 1]
|
|
|
+ },
|
|
|
+ dataToAngle: Gg.prototype.dataToCoord,
|
|
|
+ angleToData: Gg.prototype.coordToData,
|
|
|
+ calculateCategoryInterval: function() {
|
|
|
+ var t = this.getLabelModel()
|
|
|
+ , e = this.scale
|
|
|
+ , i = e.getExtent()
|
|
|
+ , n = e.count();
|
|
|
+ if (i[1] - i[0] < 1)
|
|
|
+ return 0;
|
|
|
+ var o = i[0]
|
|
|
+ , a = this.dataToCoord(o + 1) - this.dataToCoord(o)
|
|
|
+ , r = Math.abs(a)
|
|
|
+ , s = gn(o, t.getFont(), "center", "top")
|
|
|
+ , l = Math.max(s.height, 7) / r;
|
|
|
+ isNaN(l) && (l = 1 / 0);
|
|
|
+ var u = Math.max(0, Math.floor(l))
|
|
|
+ , h = DT(this.model)
|
|
|
+ , c = h.lastAutoInterval
|
|
|
+ , d = h.lastTickCount;
|
|
|
+ return null != c && null != d && Math.abs(c - u) <= 1 && Math.abs(d - n) <= 1 && u < c ? u = c : (h.lastTickCount = n,
|
|
|
+ h.lastAutoInterval = u),
|
|
|
+ u
|
|
|
+ }
|
|
|
+ },
|
|
|
+ w(CT, Gg);
|
|
|
+ function LT(t) {
|
|
|
+ this.name = t || "",
|
|
|
+ this.cx = 0,
|
|
|
+ this.cy = 0,
|
|
|
+ this._radiusAxis = new AT,
|
|
|
+ this._angleAxis = new CT,
|
|
|
+ this._radiusAxis.polar = this._angleAxis.polar = this
|
|
|
+ }
|
|
|
+ LT.prototype = {
|
|
|
+ type: "polar",
|
|
|
+ axisPointerEnabled: !0,
|
|
|
+ constructor: LT,
|
|
|
+ dimensions: ["radius", "angle"],
|
|
|
+ model: null,
|
|
|
+ containPoint: function(t) {
|
|
|
+ var e = this.pointToCoord(t);
|
|
|
+ return this._radiusAxis.contain(e[0]) && this._angleAxis.contain(e[1])
|
|
|
+ },
|
|
|
+ containData: function(t) {
|
|
|
+ return this._radiusAxis.containData(t[0]) && this._angleAxis.containData(t[1])
|
|
|
+ },
|
|
|
+ getAxis: function(t) {
|
|
|
+ return this["_" + t + "Axis"]
|
|
|
+ },
|
|
|
+ getAxes: function() {
|
|
|
+ return [this._radiusAxis, this._angleAxis]
|
|
|
+ },
|
|
|
+ getAxesByScale: function(t) {
|
|
|
+ var e = []
|
|
|
+ , i = this._angleAxis
|
|
|
+ , n = this._radiusAxis;
|
|
|
+ return i.scale.type === t && e.push(i),
|
|
|
+ n.scale.type === t && e.push(n),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ getAngleAxis: function() {
|
|
|
+ return this._angleAxis
|
|
|
+ },
|
|
|
+ getRadiusAxis: function() {
|
|
|
+ return this._radiusAxis
|
|
|
+ },
|
|
|
+ getOtherAxis: function(t) {
|
|
|
+ var e = this._angleAxis;
|
|
|
+ return t === e ? this._radiusAxis : e
|
|
|
+ },
|
|
|
+ getBaseAxis: function() {
|
|
|
+ return this.getAxesByScale("ordinal")[0] || this.getAxesByScale("time")[0] || this.getAngleAxis()
|
|
|
+ },
|
|
|
+ getTooltipAxes: function(t) {
|
|
|
+ var e = null != t && "auto" !== t ? this.getAxis(t) : this.getBaseAxis();
|
|
|
+ return {
|
|
|
+ baseAxes: [e],
|
|
|
+ otherAxes: [this.getOtherAxis(e)]
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dataToPoint: function(t, e) {
|
|
|
+ return this.coordToPoint([this._radiusAxis.dataToRadius(t[0], e), this._angleAxis.dataToAngle(t[1], e)])
|
|
|
+ },
|
|
|
+ pointToData: function(t, e) {
|
|
|
+ var i = this.pointToCoord(t);
|
|
|
+ return [this._radiusAxis.radiusToData(i[0], e), this._angleAxis.angleToData(i[1], e)]
|
|
|
+ },
|
|
|
+ pointToCoord: function(t) {
|
|
|
+ var e = t[0] - this.cx
|
|
|
+ , i = t[1] - this.cy
|
|
|
+ , n = this.getAngleAxis()
|
|
|
+ , o = n.getExtent()
|
|
|
+ , a = Math.min(o[0], o[1])
|
|
|
+ , r = Math.max(o[0], o[1]);
|
|
|
+ n.inverse ? a = r - 360 : r = a + 360;
|
|
|
+ var s = Math.sqrt(e * e + i * i);
|
|
|
+ e /= s,
|
|
|
+ i /= s;
|
|
|
+ for (var l = Math.atan2(-i, e) / Math.PI * 180, u = l < a ? 1 : -1; l < a || r < l; )
|
|
|
+ l += 360 * u;
|
|
|
+ return [s, l]
|
|
|
+ },
|
|
|
+ coordToPoint: function(t) {
|
|
|
+ var e = t[0]
|
|
|
+ , i = t[1] / 180 * Math.PI;
|
|
|
+ return [Math.cos(i) * e + this.cx, -Math.sin(i) * e + this.cy]
|
|
|
+ },
|
|
|
+ getArea: function() {
|
|
|
+ var t = this.getAngleAxis()
|
|
|
+ , e = this.getRadiusAxis().getExtent().slice();
|
|
|
+ e[0] > e[1] && e.reverse();
|
|
|
+ var i = t.getExtent()
|
|
|
+ , n = Math.PI / 180;
|
|
|
+ return {
|
|
|
+ cx: this.cx,
|
|
|
+ cy: this.cy,
|
|
|
+ r0: e[0],
|
|
|
+ r: e[1],
|
|
|
+ startAngle: -i[0] * n,
|
|
|
+ endAngle: -i[1] * n,
|
|
|
+ clockwise: t.inverse,
|
|
|
+ contain: function(t, e) {
|
|
|
+ var i = t - this.cx
|
|
|
+ , n = e - this.cy
|
|
|
+ , o = i * i + n * n
|
|
|
+ , a = this.r
|
|
|
+ , r = this.r0;
|
|
|
+ return o <= a * a && r * r <= o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var kT = ku.extend({
|
|
|
+ type: "polarAxis",
|
|
|
+ axis: null,
|
|
|
+ getCoordSysModel: function() {
|
|
|
+ return this.ecModel.queryComponents({
|
|
|
+ mainType: "polar",
|
|
|
+ index: this.option.polarIndex,
|
|
|
+ id: this.option.polarId
|
|
|
+ })[0]
|
|
|
+ }
|
|
|
+ });
|
|
|
+ m(kT.prototype, dg);
|
|
|
+ var PT = {
|
|
|
+ splitNumber: 5
|
|
|
+ };
|
|
|
+ function NT(t, e) {
|
|
|
+ return e.type || (e.data ? "category" : "value")
|
|
|
+ }
|
|
|
+ function OT(t, e) {
|
|
|
+ var i = this
|
|
|
+ , n = i.getAngleAxis()
|
|
|
+ , o = i.getRadiusAxis();
|
|
|
+ if (n.scale.setExtent(1 / 0, -1 / 0),
|
|
|
+ o.scale.setExtent(1 / 0, -1 / 0),
|
|
|
+ t.eachSeries(function(t) {
|
|
|
+ if (t.coordinateSystem === i) {
|
|
|
+ var e = t.getData();
|
|
|
+ E(e.mapDimension("radius", !0), function(t) {
|
|
|
+ o.scale.unionExtentFromData(e, pp(e, t))
|
|
|
+ }),
|
|
|
+ E(e.mapDimension("angle", !0), function(t) {
|
|
|
+ n.scale.unionExtentFromData(e, pp(e, t))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ rg(n.scale, n.model),
|
|
|
+ rg(o.scale, o.model),
|
|
|
+ "category" === n.type && !n.onBand) {
|
|
|
+ var a = n.getExtent()
|
|
|
+ , r = 360 / n.scale.count();
|
|
|
+ n.inverse ? a[1] += r : a[1] -= r,
|
|
|
+ n.setExtent(a[0], a[1])
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ET(t, e) {
|
|
|
+ if (t.type = e.get("type"),
|
|
|
+ t.scale = sg(e),
|
|
|
+ t.onBand = e.get("boundaryGap") && "category" === t.type,
|
|
|
+ t.inverse = e.get("inverse"),
|
|
|
+ "angleAxis" === e.mainType) {
|
|
|
+ t.inverse ^= e.get("clockwise");
|
|
|
+ var i = e.get("startAngle");
|
|
|
+ t.setExtent(i, i + (t.inverse ? -360 : 360))
|
|
|
+ }
|
|
|
+ (e.axis = t).model = e
|
|
|
+ }
|
|
|
+ Gm("angle", kT, NT, {
|
|
|
+ startAngle: 90,
|
|
|
+ clockwise: !0,
|
|
|
+ splitNumber: 12,
|
|
|
+ axisLabel: {
|
|
|
+ rotate: !1
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ Gm("radius", kT, NT, PT),
|
|
|
+ Tf({
|
|
|
+ type: "polar",
|
|
|
+ dependencies: ["polarAxis", "angleAxis"],
|
|
|
+ coordinateSystem: null,
|
|
|
+ findAxisModel: function(t) {
|
|
|
+ var e;
|
|
|
+ return this.ecModel.eachComponent(t, function(t) {
|
|
|
+ t.getCoordSysModel() === this && (e = t)
|
|
|
+ }, this),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 0,
|
|
|
+ center: ["50%", "50%"],
|
|
|
+ radius: "80%"
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ lh.register("polar", {
|
|
|
+ dimensions: LT.prototype.dimensions,
|
|
|
+ create: function(i, s) {
|
|
|
+ var l = [];
|
|
|
+ return i.eachComponent("polar", function(t, e) {
|
|
|
+ var i = new LT(e);
|
|
|
+ i.update = OT;
|
|
|
+ var n = i.getRadiusAxis()
|
|
|
+ , o = i.getAngleAxis()
|
|
|
+ , a = t.findAxisModel("radiusAxis")
|
|
|
+ , r = t.findAxisModel("angleAxis");
|
|
|
+ ET(n, a),
|
|
|
+ ET(o, r),
|
|
|
+ function(t, e, i) {
|
|
|
+ var n = e.get("center")
|
|
|
+ , o = i.getWidth()
|
|
|
+ , a = i.getHeight();
|
|
|
+ t.cx = Rl(n[0], o),
|
|
|
+ t.cy = Rl(n[1], a);
|
|
|
+ var r = t.getRadiusAxis()
|
|
|
+ , s = Math.min(o, a) / 2
|
|
|
+ , l = e.get("radius");
|
|
|
+ null == l ? l = [0, "100%"] : L(l) || (l = [0, l]),
|
|
|
+ l = [Rl(l[0], s), Rl(l[1], s)],
|
|
|
+ r.inverse ? r.setExtent(l[1], l[0]) : r.setExtent(l[0], l[1])
|
|
|
+ }(i, t, s),
|
|
|
+ l.push(i),
|
|
|
+ (t.coordinateSystem = i).model = t
|
|
|
+ }),
|
|
|
+ i.eachSeries(function(t) {
|
|
|
+ if ("polar" === t.get("coordinateSystem")) {
|
|
|
+ var e = i.queryComponents({
|
|
|
+ mainType: "polar",
|
|
|
+ index: t.get("polarIndex"),
|
|
|
+ id: t.get("polarId")
|
|
|
+ })[0];
|
|
|
+ t.coordinateSystem = e.coordinateSystem
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ l
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var RT = ["axisLine", "axisLabel", "axisTick", "minorTick", "splitLine", "minorSplitLine", "splitArea"];
|
|
|
+ function zT(t, e, i) {
|
|
|
+ e[1] > e[0] && (e = e.slice().reverse());
|
|
|
+ var n = t.coordToPoint([e[0], i])
|
|
|
+ , o = t.coordToPoint([e[1], i]);
|
|
|
+ return {
|
|
|
+ x1: n[0],
|
|
|
+ y1: n[1],
|
|
|
+ x2: o[0],
|
|
|
+ y2: o[1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function BT(t) {
|
|
|
+ return t.getRadiusAxis().inverse ? 0 : 1
|
|
|
+ }
|
|
|
+ function VT(t) {
|
|
|
+ var e = t[0]
|
|
|
+ , i = t[t.length - 1];
|
|
|
+ e && i && Math.abs(Math.abs(e.coord - i.coord) - 360) < 1e-4 && t.pop()
|
|
|
+ }
|
|
|
+ mv.extend({
|
|
|
+ type: "angleAxis",
|
|
|
+ axisPointerClass: "PolarAxisPointer",
|
|
|
+ render: function(e, t) {
|
|
|
+ if (this.group.removeAll(),
|
|
|
+ e.get("show")) {
|
|
|
+ var i = e.axis
|
|
|
+ , n = i.polar
|
|
|
+ , o = n.getRadiusAxis().getExtent()
|
|
|
+ , a = i.getTicksCoords()
|
|
|
+ , r = i.getMinorTicksCoords()
|
|
|
+ , s = O(i.getViewLabels(), function(t) {
|
|
|
+ return (t = k(t)).coord = i.dataToCoord(t.tickValue),
|
|
|
+ t
|
|
|
+ });
|
|
|
+ VT(s),
|
|
|
+ VT(a),
|
|
|
+ E(RT, function(t) {
|
|
|
+ !e.get(t + ".show") || i.scale.isBlank() && "axisLine" !== t || this["_" + t](e, n, a, r, o, s)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _axisLine: function(t, e, i, n, o) {
|
|
|
+ var a, r = t.getModel("axisLine.lineStyle"), s = BT(e), l = s ? 0 : 1;
|
|
|
+ (a = 0 === o[l] ? new Yr({
|
|
|
+ shape: {
|
|
|
+ cx: e.cx,
|
|
|
+ cy: e.cy,
|
|
|
+ r: o[s]
|
|
|
+ },
|
|
|
+ style: r.getLineStyle(),
|
|
|
+ z2: 1,
|
|
|
+ silent: !0
|
|
|
+ }) : new Kr({
|
|
|
+ shape: {
|
|
|
+ cx: e.cx,
|
|
|
+ cy: e.cy,
|
|
|
+ r: o[s],
|
|
|
+ r0: o[l]
|
|
|
+ },
|
|
|
+ style: r.getLineStyle(),
|
|
|
+ z2: 1,
|
|
|
+ silent: !0
|
|
|
+ })).style.fill = null,
|
|
|
+ this.group.add(a)
|
|
|
+ },
|
|
|
+ _axisTick: function(t, e, i, n, o) {
|
|
|
+ var a = t.getModel("axisTick")
|
|
|
+ , r = (a.get("inside") ? -1 : 1) * a.get("length")
|
|
|
+ , s = o[BT(e)]
|
|
|
+ , l = O(i, function(t) {
|
|
|
+ return new ls({
|
|
|
+ shape: zT(e, [s, s + r], t.coord)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ this.group.add(Es(l, {
|
|
|
+ style: D(a.getModel("lineStyle").getLineStyle(), {
|
|
|
+ stroke: t.get("axisLine.lineStyle.color")
|
|
|
+ })
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ _minorTick: function(t, e, i, n, o) {
|
|
|
+ if (n.length) {
|
|
|
+ for (var a = t.getModel("axisTick"), r = t.getModel("minorTick"), s = (a.get("inside") ? -1 : 1) * r.get("length"), l = o[BT(e)], u = [], h = 0; h < n.length; h++)
|
|
|
+ for (var c = 0; c < n[h].length; c++)
|
|
|
+ u.push(new ls({
|
|
|
+ shape: zT(e, [l, l + s], n[h][c].coord)
|
|
|
+ }));
|
|
|
+ this.group.add(Es(u, {
|
|
|
+ style: D(r.getModel("lineStyle").getLineStyle(), D(a.getLineStyle(), {
|
|
|
+ stroke: t.get("axisLine.lineStyle.color")
|
|
|
+ }))
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _axisLabel: function(c, d, t, e, f, i) {
|
|
|
+ var p = c.getCategories(!0)
|
|
|
+ , g = c.getModel("axisLabel")
|
|
|
+ , m = g.get("margin")
|
|
|
+ , v = c.get("triggerEvent");
|
|
|
+ E(i, function(t, e) {
|
|
|
+ var i = g
|
|
|
+ , n = t.tickValue
|
|
|
+ , o = f[BT(d)]
|
|
|
+ , a = d.coordToPoint([o + m, t.coord])
|
|
|
+ , r = d.cx
|
|
|
+ , s = d.cy
|
|
|
+ , l = Math.abs(a[0] - r) / o < .3 ? "center" : a[0] > r ? "left" : "right"
|
|
|
+ , u = Math.abs(a[1] - s) / o < .3 ? "middle" : a[1] > s ? "top" : "bottom";
|
|
|
+ p && p[n] && p[n].textStyle && (i = new Cl(p[n].textStyle,g,g.ecModel));
|
|
|
+ var h = new Ur({
|
|
|
+ silent: Qm.isLabelSilent(c)
|
|
|
+ });
|
|
|
+ this.group.add(h),
|
|
|
+ nl(h.style, i, {
|
|
|
+ x: a[0],
|
|
|
+ y: a[1],
|
|
|
+ textFill: i.getTextColor() || c.get("axisLine.lineStyle.color"),
|
|
|
+ text: t.formattedLabel,
|
|
|
+ textAlign: l,
|
|
|
+ textVerticalAlign: u
|
|
|
+ }),
|
|
|
+ v && (h.eventData = Qm.makeAxisEventDataBase(c),
|
|
|
+ h.eventData.targetType = "axisLabel",
|
|
|
+ h.eventData.value = t.rawLabel)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _splitLine: function(t, e, i, n, o) {
|
|
|
+ var a = t.getModel("splitLine").getModel("lineStyle")
|
|
|
+ , r = a.get("color")
|
|
|
+ , s = 0;
|
|
|
+ r = r instanceof Array ? r : [r];
|
|
|
+ for (var l = [], u = 0; u < i.length; u++) {
|
|
|
+ var h = s++ % r.length;
|
|
|
+ l[h] = l[h] || [],
|
|
|
+ l[h].push(new ls({
|
|
|
+ shape: zT(e, o, i[u].coord)
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ for (u = 0; u < l.length; u++)
|
|
|
+ this.group.add(Es(l[u], {
|
|
|
+ style: D({
|
|
|
+ stroke: r[u % r.length]
|
|
|
+ }, a.getLineStyle()),
|
|
|
+ silent: !0,
|
|
|
+ z: t.get("z")
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ _minorSplitLine: function(t, e, i, n, o) {
|
|
|
+ if (n.length) {
|
|
|
+ for (var a = t.getModel("minorSplitLine").getModel("lineStyle"), r = [], s = 0; s < n.length; s++)
|
|
|
+ for (var l = 0; l < n[s].length; l++)
|
|
|
+ r.push(new ls({
|
|
|
+ shape: zT(e, o, n[s][l].coord)
|
|
|
+ }));
|
|
|
+ this.group.add(Es(r, {
|
|
|
+ style: a.getLineStyle(),
|
|
|
+ silent: !0,
|
|
|
+ z: t.get("z")
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _splitArea: function(t, e, i, n, o) {
|
|
|
+ if (i.length) {
|
|
|
+ var a = t.getModel("splitArea").getModel("areaStyle")
|
|
|
+ , r = a.get("color")
|
|
|
+ , s = 0;
|
|
|
+ r = r instanceof Array ? r : [r];
|
|
|
+ for (var l = [], u = Math.PI / 180, h = -i[0].coord * u, c = Math.min(o[0], o[1]), d = Math.max(o[0], o[1]), f = t.get("clockwise"), p = 1; p < i.length; p++) {
|
|
|
+ var g = s++ % r.length;
|
|
|
+ l[g] = l[g] || [],
|
|
|
+ l[g].push(new qr({
|
|
|
+ shape: {
|
|
|
+ cx: e.cx,
|
|
|
+ cy: e.cy,
|
|
|
+ r0: c,
|
|
|
+ r: d,
|
|
|
+ startAngle: h,
|
|
|
+ endAngle: -i[p].coord * u,
|
|
|
+ clockwise: f
|
|
|
+ },
|
|
|
+ silent: !0
|
|
|
+ })),
|
|
|
+ h = -i[p].coord * u
|
|
|
+ }
|
|
|
+ for (p = 0; p < l.length; p++)
|
|
|
+ this.group.add(Es(l[p], {
|
|
|
+ style: D({
|
|
|
+ fill: r[p % r.length]
|
|
|
+ }, a.getAreaStyle()),
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var GT = ["axisLine", "axisTickLabel", "axisName"]
|
|
|
+ , FT = ["splitLine", "splitArea", "minorSplitLine"];
|
|
|
+ mv.extend({
|
|
|
+ type: "radiusAxis",
|
|
|
+ axisPointerClass: "PolarAxisPointer",
|
|
|
+ render: function(e, t) {
|
|
|
+ if (this.group.removeAll(),
|
|
|
+ e.get("show")) {
|
|
|
+ var i = e.axis
|
|
|
+ , n = i.polar
|
|
|
+ , o = n.getAngleAxis()
|
|
|
+ , a = i.getTicksCoords()
|
|
|
+ , r = i.getMinorTicksCoords()
|
|
|
+ , s = o.getExtent()[0]
|
|
|
+ , l = i.getExtent()
|
|
|
+ , u = function(t, e, i) {
|
|
|
+ return {
|
|
|
+ position: [t.cx, t.cy],
|
|
|
+ rotation: i / 180 * Math.PI,
|
|
|
+ labelDirection: -1,
|
|
|
+ tickDirection: -1,
|
|
|
+ nameDirection: 1,
|
|
|
+ labelRotate: e.getModel("axisLabel").get("rotate"),
|
|
|
+ z2: 1
|
|
|
+ }
|
|
|
+ }(n, e, s)
|
|
|
+ , h = new Qm(e,u);
|
|
|
+ E(GT, h.add, h),
|
|
|
+ this.group.add(h.getGroup()),
|
|
|
+ E(FT, function(t) {
|
|
|
+ e.get(t + ".show") && !i.scale.isBlank() && this["_" + t](e, n, s, l, a, r)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _splitLine: function(t, e, i, n, o) {
|
|
|
+ var a = t.getModel("splitLine").getModel("lineStyle")
|
|
|
+ , r = a.get("color")
|
|
|
+ , s = 0;
|
|
|
+ r = r instanceof Array ? r : [r];
|
|
|
+ for (var l = [], u = 0; u < o.length; u++) {
|
|
|
+ var h = s++ % r.length;
|
|
|
+ l[h] = l[h] || [],
|
|
|
+ l[h].push(new Yr({
|
|
|
+ shape: {
|
|
|
+ cx: e.cx,
|
|
|
+ cy: e.cy,
|
|
|
+ r: o[u].coord
|
|
|
+ }
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ for (u = 0; u < l.length; u++)
|
|
|
+ this.group.add(Es(l[u], {
|
|
|
+ style: D({
|
|
|
+ stroke: r[u % r.length],
|
|
|
+ fill: null
|
|
|
+ }, a.getLineStyle()),
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ _minorSplitLine: function(t, e, i, n, o, a) {
|
|
|
+ if (a.length) {
|
|
|
+ for (var r = t.getModel("minorSplitLine").getModel("lineStyle"), s = [], l = 0; l < a.length; l++)
|
|
|
+ for (var u = 0; u < a[l].length; u++)
|
|
|
+ s.push(new Yr({
|
|
|
+ shape: {
|
|
|
+ cx: e.cx,
|
|
|
+ cy: e.cy,
|
|
|
+ r: a[l][u].coord
|
|
|
+ }
|
|
|
+ }));
|
|
|
+ this.group.add(Es(s, {
|
|
|
+ style: D({
|
|
|
+ fill: null
|
|
|
+ }, r.getLineStyle()),
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _splitArea: function(t, e, i, n, o) {
|
|
|
+ if (o.length) {
|
|
|
+ var a = t.getModel("splitArea").getModel("areaStyle")
|
|
|
+ , r = a.get("color")
|
|
|
+ , s = 0;
|
|
|
+ r = r instanceof Array ? r : [r];
|
|
|
+ for (var l = [], u = o[0].coord, h = 1; h < o.length; h++) {
|
|
|
+ var c = s++ % r.length;
|
|
|
+ l[c] = l[c] || [],
|
|
|
+ l[c].push(new qr({
|
|
|
+ shape: {
|
|
|
+ cx: e.cx,
|
|
|
+ cy: e.cy,
|
|
|
+ r0: u,
|
|
|
+ r: o[h].coord,
|
|
|
+ startAngle: 0,
|
|
|
+ endAngle: 2 * Math.PI
|
|
|
+ },
|
|
|
+ silent: !0
|
|
|
+ })),
|
|
|
+ u = o[h].coord
|
|
|
+ }
|
|
|
+ for (h = 0; h < l.length; h++)
|
|
|
+ this.group.add(Es(l[h], {
|
|
|
+ style: D({
|
|
|
+ fill: r[h % r.length]
|
|
|
+ }, a.getAreaStyle()),
|
|
|
+ silent: !0
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var WT = wI.extend({
|
|
|
+ makeElOption: function(t, e, i, n, o) {
|
|
|
+ var a = i.axis;
|
|
|
+ "angle" === a.dim && (this.animationThreshold = Math.PI / 18);
|
|
|
+ var r, s = a.polar, l = s.getOtherAxis(a).getExtent();
|
|
|
+ r = a["dataTo" + fu(a.dim)](e);
|
|
|
+ var u = n.get("type");
|
|
|
+ if (u && "none" !== u) {
|
|
|
+ var h = TI(n)
|
|
|
+ , c = HT[u](a, s, r, l, h);
|
|
|
+ c.style = h,
|
|
|
+ t.graphicKey = c.type,
|
|
|
+ t.pointer = c
|
|
|
+ }
|
|
|
+ var d = n.get("label.margin");
|
|
|
+ AI(t, i, n, o, function(t, e, i, n, o) {
|
|
|
+ var a = e.axis
|
|
|
+ , r = a.dataToCoord(t)
|
|
|
+ , s = n.getAngleAxis().getExtent()[0];
|
|
|
+ s = s / 180 * Math.PI;
|
|
|
+ var l, u, h, c = n.getRadiusAxis().getExtent();
|
|
|
+ if ("radius" === a.dim) {
|
|
|
+ var d = ae();
|
|
|
+ he(d, d, s),
|
|
|
+ ue(d, d, [n.cx, n.cy]),
|
|
|
+ l = pl([r, -o], d);
|
|
|
+ var f = e.getModel("axisLabel").get("rotate") || 0
|
|
|
+ , p = Qm.innerTextLayout(s, f * Math.PI / 180, -1);
|
|
|
+ u = p.textAlign,
|
|
|
+ h = p.textVerticalAlign
|
|
|
+ } else {
|
|
|
+ var g = c[1];
|
|
|
+ l = n.coordToPoint([g + o, r]);
|
|
|
+ var m = n.cx
|
|
|
+ , v = n.cy;
|
|
|
+ u = Math.abs(l[0] - m) / g < .3 ? "center" : l[0] > m ? "left" : "right",
|
|
|
+ h = Math.abs(l[1] - v) / g < .3 ? "middle" : l[1] > v ? "top" : "bottom"
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ position: l,
|
|
|
+ align: u,
|
|
|
+ verticalAlign: h
|
|
|
+ }
|
|
|
+ }(e, i, 0, s, d))
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var HT = {
|
|
|
+ line: function(t, e, i, n, o) {
|
|
|
+ return "angle" === t.dim ? {
|
|
|
+ type: "Line",
|
|
|
+ shape: kI(e.coordToPoint([n[0], i]), e.coordToPoint([n[1], i]))
|
|
|
+ } : {
|
|
|
+ type: "Circle",
|
|
|
+ shape: {
|
|
|
+ cx: e.cx,
|
|
|
+ cy: e.cy,
|
|
|
+ r: i
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ shadow: function(t, e, i, n, o) {
|
|
|
+ var a = Math.max(1, t.getBandWidth())
|
|
|
+ , r = Math.PI / 180;
|
|
|
+ return "angle" === t.dim ? {
|
|
|
+ type: "Sector",
|
|
|
+ shape: NI(e.cx, e.cy, n[0], n[1], (-i - a / 2) * r, (a / 2 - i) * r)
|
|
|
+ } : {
|
|
|
+ type: "Sector",
|
|
|
+ shape: NI(e.cx, e.cy, i - a / 2, i + a / 2, 0, 2 * Math.PI)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function ZT(n, t) {
|
|
|
+ t.update = "updateView",
|
|
|
+ _f(t, function(t, e) {
|
|
|
+ var i = {};
|
|
|
+ return e.eachComponent({
|
|
|
+ mainType: "geo",
|
|
|
+ query: t
|
|
|
+ }, function(e) {
|
|
|
+ e[n](t.name),
|
|
|
+ E(e.coordinateSystem.regions, function(t) {
|
|
|
+ i[t.name] = e.isSelected(t.name) || !1
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ selected: i,
|
|
|
+ name: t.name
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ mv.registerAxisPointerClass("PolarAxisPointer", WT),
|
|
|
+ bf(T(function(t, e, i) {
|
|
|
+ var N = {}
|
|
|
+ , O = function(t) {
|
|
|
+ var g = {};
|
|
|
+ E(t, function(t, e) {
|
|
|
+ var i = t.getData()
|
|
|
+ , n = t.coordinateSystem
|
|
|
+ , o = n.getBaseAxis()
|
|
|
+ , a = TT(n, o)
|
|
|
+ , r = o.getExtent()
|
|
|
+ , s = "category" === o.type ? o.getBandWidth() : Math.abs(r[1] - r[0]) / i.count()
|
|
|
+ , l = g[a] || {
|
|
|
+ bandWidth: s,
|
|
|
+ remainedWidth: s,
|
|
|
+ autoWidthCount: 0,
|
|
|
+ categoryGap: "20%",
|
|
|
+ gap: "30%",
|
|
|
+ stacks: {}
|
|
|
+ }
|
|
|
+ , u = l.stacks;
|
|
|
+ g[a] = l;
|
|
|
+ var h = IT(t);
|
|
|
+ u[h] || l.autoWidthCount++,
|
|
|
+ u[h] = u[h] || {
|
|
|
+ width: 0,
|
|
|
+ maxWidth: 0
|
|
|
+ };
|
|
|
+ var c = Rl(t.get("barWidth"), s)
|
|
|
+ , d = Rl(t.get("barMaxWidth"), s)
|
|
|
+ , f = t.get("barGap")
|
|
|
+ , p = t.get("barCategoryGap");
|
|
|
+ c && !u[h].width && (c = Math.min(l.remainedWidth, c),
|
|
|
+ u[h].width = c,
|
|
|
+ l.remainedWidth -= c),
|
|
|
+ d && (u[h].maxWidth = d),
|
|
|
+ null != f && (l.gap = f),
|
|
|
+ null != p && (l.categoryGap = p)
|
|
|
+ });
|
|
|
+ var d = {};
|
|
|
+ return E(g, function(t, i) {
|
|
|
+ d[i] = {};
|
|
|
+ var e = t.stacks
|
|
|
+ , n = t.bandWidth
|
|
|
+ , o = Rl(t.categoryGap, n)
|
|
|
+ , a = Rl(t.gap, 1)
|
|
|
+ , r = t.remainedWidth
|
|
|
+ , s = t.autoWidthCount
|
|
|
+ , l = (r - o) / (s + (s - 1) * a);
|
|
|
+ l = Math.max(l, 0),
|
|
|
+ E(e, function(t, e) {
|
|
|
+ var i = t.maxWidth;
|
|
|
+ i && i < l && (i = Math.min(i, r),
|
|
|
+ t.width && (i = Math.min(i, t.width)),
|
|
|
+ r -= i,
|
|
|
+ t.width = i,
|
|
|
+ s--)
|
|
|
+ }),
|
|
|
+ l = (r - o) / (s + (s - 1) * a),
|
|
|
+ l = Math.max(l, 0);
|
|
|
+ var u, h = 0;
|
|
|
+ E(e, function(t, e) {
|
|
|
+ t.width || (t.width = l),
|
|
|
+ h += (u = t).width * (1 + a)
|
|
|
+ }),
|
|
|
+ u && (h -= u.width * a);
|
|
|
+ var c = -h / 2;
|
|
|
+ E(e, function(t, e) {
|
|
|
+ d[i][e] = d[i][e] || {
|
|
|
+ offset: c,
|
|
|
+ width: t.width
|
|
|
+ },
|
|
|
+ c += t.width * (1 + a)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ d
|
|
|
+ }(M(e.getSeriesByType(t), function(t) {
|
|
|
+ return !e.isSeriesFiltered(t) && t.coordinateSystem && "polar" === t.coordinateSystem.type
|
|
|
+ }));
|
|
|
+ e.eachSeriesByType(t, function(t) {
|
|
|
+ if ("polar" === t.coordinateSystem.type) {
|
|
|
+ var e = t.getData()
|
|
|
+ , i = t.coordinateSystem
|
|
|
+ , n = i.getBaseAxis()
|
|
|
+ , o = TT(i, n)
|
|
|
+ , a = IT(t)
|
|
|
+ , r = O[o][a]
|
|
|
+ , s = r.offset
|
|
|
+ , l = r.width
|
|
|
+ , u = i.getOtherAxis(n)
|
|
|
+ , h = t.coordinateSystem.cx
|
|
|
+ , c = t.coordinateSystem.cy
|
|
|
+ , d = t.get("barMinHeight") || 0
|
|
|
+ , f = t.get("barMinAngle") || 0;
|
|
|
+ N[a] = N[a] || [];
|
|
|
+ for (var p = e.mapDimension(u.dim), g = e.mapDimension(n.dim), m = fp(e, p), v = "radius" !== n.dim || !t.get("roundCap", !0), y = u.getExtent()[0], x = 0, _ = e.count(); x < _; x++) {
|
|
|
+ var w, b, S, M, I = e.get(p, x), T = e.get(g, x), A = 0 <= I ? "p" : "n", D = y;
|
|
|
+ if (m && (N[a][T] || (N[a][T] = {
|
|
|
+ p: y,
|
|
|
+ n: y
|
|
|
+ }),
|
|
|
+ D = N[a][T][A]),
|
|
|
+ "radius" === u.dim) {
|
|
|
+ var C = u.dataToRadius(I) - y
|
|
|
+ , L = n.dataToAngle(T);
|
|
|
+ Math.abs(C) < d && (C = (C < 0 ? -1 : 1) * d),
|
|
|
+ b = (w = D) + C,
|
|
|
+ M = (S = L - s) - l,
|
|
|
+ m && (N[a][T][A] = b)
|
|
|
+ } else {
|
|
|
+ var k = u.dataToAngle(I, v) - y
|
|
|
+ , P = n.dataToRadius(T);
|
|
|
+ Math.abs(k) < f && (k = (k < 0 ? -1 : 1) * f),
|
|
|
+ b = (w = P + s) + l,
|
|
|
+ M = (S = D) + k,
|
|
|
+ m && (N[a][T][A] = M)
|
|
|
+ }
|
|
|
+ e.setItemLayout(x, {
|
|
|
+ cx: h,
|
|
|
+ cy: c,
|
|
|
+ r0: w,
|
|
|
+ r: b,
|
|
|
+ startAngle: -S * Math.PI / 180,
|
|
|
+ endAngle: -M * Math.PI / 180
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }, "bar")),
|
|
|
+ Af({
|
|
|
+ type: "polar"
|
|
|
+ }),
|
|
|
+ b(ku.extend({
|
|
|
+ type: "geo",
|
|
|
+ coordinateSystem: null,
|
|
|
+ layoutMode: "box",
|
|
|
+ init: function(t) {
|
|
|
+ ku.prototype.init.apply(this, arguments),
|
|
|
+ Go(t, "label", ["show"])
|
|
|
+ },
|
|
|
+ optionUpdated: function() {
|
|
|
+ var t = this.option
|
|
|
+ , i = this;
|
|
|
+ t.regions = px.getFilledRegions(t.regions, t.map, t.nameMap),
|
|
|
+ this._optionModelMap = S(t.regions || [], function(t, e) {
|
|
|
+ return e.name && t.set(e.name, new Cl(e,i)),
|
|
|
+ t
|
|
|
+ }, Q()),
|
|
|
+ this.updateSelectedMap(t.regions)
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 0,
|
|
|
+ show: !0,
|
|
|
+ left: "center",
|
|
|
+ top: "center",
|
|
|
+ aspectScale: null,
|
|
|
+ silent: !1,
|
|
|
+ map: "",
|
|
|
+ boundingCoords: null,
|
|
|
+ center: null,
|
|
|
+ zoom: 1,
|
|
|
+ scaleLimit: null,
|
|
|
+ label: {
|
|
|
+ show: !1,
|
|
|
+ color: "#000"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: .5,
|
|
|
+ borderColor: "#444",
|
|
|
+ color: "#eee"
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ color: "rgb(100,0,0)"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ color: "rgba(255,215,0,0.8)"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ regions: []
|
|
|
+ },
|
|
|
+ getRegionModel: function(t) {
|
|
|
+ return this._optionModelMap.get(t) || new Cl(null,this,this.ecModel)
|
|
|
+ },
|
|
|
+ getFormattedLabel: function(t, e) {
|
|
|
+ var i = this.getRegionModel(t).get("label" + ("normal" === e ? "." : e + ".") + "formatter")
|
|
|
+ , n = {
|
|
|
+ name: t
|
|
|
+ };
|
|
|
+ return "function" == typeof i ? (n.status = e,
|
|
|
+ i(n)) : "string" == typeof i ? i.replace("{a}", null != t ? t : "") : void 0
|
|
|
+ },
|
|
|
+ setZoom: function(t) {
|
|
|
+ this.option.zoom = t
|
|
|
+ },
|
|
|
+ setCenter: function(t) {
|
|
|
+ this.option.center = t
|
|
|
+ }
|
|
|
+ }), jv),
|
|
|
+ Af({
|
|
|
+ type: "geo",
|
|
|
+ init: function(t, e) {
|
|
|
+ var i = new tx(e,!0);
|
|
|
+ this._mapDraw = i,
|
|
|
+ this.group.add(i.group)
|
|
|
+ },
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ if (!n || "geoToggleSelect" !== n.type || n.from !== this.uid) {
|
|
|
+ var o = this._mapDraw;
|
|
|
+ t.get("show") ? o.draw(t, e, i, this, n) : this._mapDraw.group.removeAll(),
|
|
|
+ this.group.silent = t.get("silent")
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._mapDraw && this._mapDraw.remove()
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ ZT("toggleSelected", {
|
|
|
+ type: "geoToggleSelect",
|
|
|
+ event: "geoselectchanged"
|
|
|
+ }),
|
|
|
+ ZT("select", {
|
|
|
+ type: "geoSelect",
|
|
|
+ event: "geoselected"
|
|
|
+ }),
|
|
|
+ ZT("unSelect", {
|
|
|
+ type: "geoUnSelect",
|
|
|
+ event: "geounselected"
|
|
|
+ });
|
|
|
+ function UT(t, e, i) {
|
|
|
+ this._model = t
|
|
|
+ }
|
|
|
+ function XT(t, e, i, n) {
|
|
|
+ var o = i.calendarModel
|
|
|
+ , a = i.seriesModel
|
|
|
+ , r = o ? o.coordinateSystem : a ? a.coordinateSystem : null;
|
|
|
+ return r === this ? r[t](n) : null
|
|
|
+ }
|
|
|
+ UT.prototype = {
|
|
|
+ constructor: UT,
|
|
|
+ type: "calendar",
|
|
|
+ dimensions: ["time", "value"],
|
|
|
+ getDimensionsInfo: function() {
|
|
|
+ return [{
|
|
|
+ name: "time",
|
|
|
+ type: "time"
|
|
|
+ }, "value"]
|
|
|
+ },
|
|
|
+ getRangeInfo: function() {
|
|
|
+ return this._rangeInfo
|
|
|
+ },
|
|
|
+ getModel: function() {
|
|
|
+ return this._model
|
|
|
+ },
|
|
|
+ getRect: function() {
|
|
|
+ return this._rect
|
|
|
+ },
|
|
|
+ getCellWidth: function() {
|
|
|
+ return this._sw
|
|
|
+ },
|
|
|
+ getCellHeight: function() {
|
|
|
+ return this._sh
|
|
|
+ },
|
|
|
+ getOrient: function() {
|
|
|
+ return this._orient
|
|
|
+ },
|
|
|
+ getFirstDayOfWeek: function() {
|
|
|
+ return this._firstDayOfWeek
|
|
|
+ },
|
|
|
+ getDateInfo: function(t) {
|
|
|
+ var e = (t = Yl(t)).getFullYear()
|
|
|
+ , i = t.getMonth() + 1;
|
|
|
+ i = i < 10 ? "0" + i : i;
|
|
|
+ var n = t.getDate();
|
|
|
+ n = n < 10 ? "0" + n : n;
|
|
|
+ var o = t.getDay();
|
|
|
+ return {
|
|
|
+ y: e,
|
|
|
+ m: i,
|
|
|
+ d: n,
|
|
|
+ day: o = Math.abs((o + 7 - this.getFirstDayOfWeek()) % 7),
|
|
|
+ time: t.getTime(),
|
|
|
+ formatedDate: e + "-" + i + "-" + n,
|
|
|
+ date: t
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getNextNDay: function(t, e) {
|
|
|
+ return 0 === (e = e || 0) || (t = new Date(this.getDateInfo(t).time)).setDate(t.getDate() + e),
|
|
|
+ this.getDateInfo(t)
|
|
|
+ },
|
|
|
+ update: function(t, e) {
|
|
|
+ this._firstDayOfWeek = +this._model.getModel("dayLabel").get("firstDay"),
|
|
|
+ this._orient = this._model.get("orient"),
|
|
|
+ this._lineWidth = this._model.getModel("itemStyle").getItemStyle().lineWidth || 0,
|
|
|
+ this._rangeInfo = this._getRangeInfo(this._initRangeOption());
|
|
|
+ var i = this._rangeInfo.weeks || 1
|
|
|
+ , n = ["width", "height"]
|
|
|
+ , o = this._model.get("cellSize").slice()
|
|
|
+ , a = this._model.getBoxLayoutParams()
|
|
|
+ , r = "horizontal" === this._orient ? [i, 7] : [7, i];
|
|
|
+ E([0, 1], function(t) {
|
|
|
+ u(o, t) && (a[n[t]] = o[t] * r[t])
|
|
|
+ });
|
|
|
+ var s = {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ }
|
|
|
+ , l = this._rect = bu(a, s);
|
|
|
+ function u(t, e) {
|
|
|
+ return null != t[e] && "auto" !== t[e]
|
|
|
+ }
|
|
|
+ E([0, 1], function(t) {
|
|
|
+ u(o, t) || (o[t] = l[n[t]] / r[t])
|
|
|
+ }),
|
|
|
+ this._sw = o[0],
|
|
|
+ this._sh = o[1]
|
|
|
+ },
|
|
|
+ dataToPoint: function(t, e) {
|
|
|
+ L(t) && (t = t[0]),
|
|
|
+ null == e && (e = !0);
|
|
|
+ var i = this.getDateInfo(t)
|
|
|
+ , n = this._rangeInfo
|
|
|
+ , o = i.formatedDate;
|
|
|
+ if (e && !(i.time >= n.start.time && i.time < n.end.time + 864e5))
|
|
|
+ return [NaN, NaN];
|
|
|
+ var a = i.day
|
|
|
+ , r = this._getRangeInfo([n.start.time, o]).nthWeek;
|
|
|
+ return "vertical" === this._orient ? [this._rect.x + a * this._sw + this._sw / 2, this._rect.y + r * this._sh + this._sh / 2] : [this._rect.x + r * this._sw + this._sw / 2, this._rect.y + a * this._sh + this._sh / 2]
|
|
|
+ },
|
|
|
+ pointToData: function(t) {
|
|
|
+ var e = this.pointToDate(t);
|
|
|
+ return e && e.time
|
|
|
+ },
|
|
|
+ dataToRect: function(t, e) {
|
|
|
+ var i = this.dataToPoint(t, e);
|
|
|
+ return {
|
|
|
+ contentShape: {
|
|
|
+ x: i[0] - (this._sw - this._lineWidth) / 2,
|
|
|
+ y: i[1] - (this._sh - this._lineWidth) / 2,
|
|
|
+ width: this._sw - this._lineWidth,
|
|
|
+ height: this._sh - this._lineWidth
|
|
|
+ },
|
|
|
+ center: i,
|
|
|
+ tl: [i[0] - this._sw / 2, i[1] - this._sh / 2],
|
|
|
+ tr: [i[0] + this._sw / 2, i[1] - this._sh / 2],
|
|
|
+ br: [i[0] + this._sw / 2, i[1] + this._sh / 2],
|
|
|
+ bl: [i[0] - this._sw / 2, i[1] + this._sh / 2]
|
|
|
+ }
|
|
|
+ },
|
|
|
+ pointToDate: function(t) {
|
|
|
+ var e = Math.floor((t[0] - this._rect.x) / this._sw) + 1
|
|
|
+ , i = Math.floor((t[1] - this._rect.y) / this._sh) + 1
|
|
|
+ , n = this._rangeInfo.range;
|
|
|
+ return "vertical" === this._orient ? this._getDateByWeeksAndDay(i, e - 1, n) : this._getDateByWeeksAndDay(e, i - 1, n)
|
|
|
+ },
|
|
|
+ convertToPixel: T(XT, "dataToPoint"),
|
|
|
+ convertFromPixel: T(XT, "pointToData"),
|
|
|
+ _initRangeOption: function() {
|
|
|
+ var t = this._model.get("range")
|
|
|
+ , e = t;
|
|
|
+ if (L(e) && 1 === e.length && (e = e[0]),
|
|
|
+ /^\d{4}$/.test(e) && (t = [e + "-01-01", e + "-12-31"]),
|
|
|
+ /^\d{4}[\/|-]\d{1,2}$/.test(e)) {
|
|
|
+ var i = this.getDateInfo(e)
|
|
|
+ , n = i.date;
|
|
|
+ n.setMonth(n.getMonth() + 1);
|
|
|
+ var o = this.getNextNDay(n, -1);
|
|
|
+ t = [i.formatedDate, o.formatedDate]
|
|
|
+ }
|
|
|
+ /^\d{4}[\/|-]\d{1,2}[\/|-]\d{1,2}$/.test(e) && (t = [e, e]);
|
|
|
+ var a = this._getRangeInfo(t);
|
|
|
+ return a.start.time > a.end.time && t.reverse(),
|
|
|
+ t
|
|
|
+ },
|
|
|
+ _getRangeInfo: function(t) {
|
|
|
+ var e;
|
|
|
+ (t = [this.getDateInfo(t[0]), this.getDateInfo(t[1])])[0].time > t[1].time && (e = !0,
|
|
|
+ t.reverse());
|
|
|
+ var i = Math.floor(t[1].time / 864e5) - Math.floor(t[0].time / 864e5) + 1
|
|
|
+ , n = new Date(t[0].time)
|
|
|
+ , o = n.getDate()
|
|
|
+ , a = t[1].date.getDate();
|
|
|
+ n.setDate(o + i - 1);
|
|
|
+ var r = n.getDate();
|
|
|
+ if (r !== a)
|
|
|
+ for (var s = 0 < n.getTime() - t[1].time ? 1 : -1; (r = n.getDate()) !== a && 0 < (n.getTime() - t[1].time) * s; )
|
|
|
+ i -= s,
|
|
|
+ n.setDate(r - s);
|
|
|
+ var l = Math.floor((i + t[0].day + 6) / 7)
|
|
|
+ , u = e ? 1 - l : l - 1;
|
|
|
+ return e && t.reverse(),
|
|
|
+ {
|
|
|
+ range: [t[0].formatedDate, t[1].formatedDate],
|
|
|
+ start: t[0],
|
|
|
+ end: t[1],
|
|
|
+ allDay: i,
|
|
|
+ weeks: l,
|
|
|
+ nthWeek: u,
|
|
|
+ fweek: t[0].day,
|
|
|
+ lweek: t[1].day
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _getDateByWeeksAndDay: function(t, e, i) {
|
|
|
+ var n = this._getRangeInfo(i);
|
|
|
+ if (t > n.weeks || 0 === t && e < n.fweek || t === n.weeks && e > n.lweek)
|
|
|
+ return !1;
|
|
|
+ var o = 7 * (t - 1) - n.fweek + e
|
|
|
+ , a = new Date(n.start.time);
|
|
|
+ return a.setDate(n.start.d + o),
|
|
|
+ this.getDateInfo(a)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ UT.dimensions = UT.prototype.dimensions,
|
|
|
+ UT.getDimensionsInfo = UT.prototype.getDimensionsInfo,
|
|
|
+ UT.create = function(i, n) {
|
|
|
+ var o = [];
|
|
|
+ return i.eachComponent("calendar", function(t) {
|
|
|
+ var e = new UT(t,i,n);
|
|
|
+ o.push(e),
|
|
|
+ t.coordinateSystem = e
|
|
|
+ }),
|
|
|
+ i.eachSeries(function(t) {
|
|
|
+ "calendar" === t.get("coordinateSystem") && (t.coordinateSystem = o[t.get("calendarIndex") || 0])
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ lh.register("calendar", UT);
|
|
|
+ var YT = ku.extend({
|
|
|
+ type: "calendar",
|
|
|
+ coordinateSystem: null,
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 2,
|
|
|
+ left: 80,
|
|
|
+ top: 60,
|
|
|
+ cellSize: 20,
|
|
|
+ orient: "horizontal",
|
|
|
+ splitLine: {
|
|
|
+ show: !0,
|
|
|
+ lineStyle: {
|
|
|
+ color: "#000",
|
|
|
+ width: 1,
|
|
|
+ type: "solid"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ color: "#fff",
|
|
|
+ borderWidth: 1,
|
|
|
+ borderColor: "#ccc"
|
|
|
+ },
|
|
|
+ dayLabel: {
|
|
|
+ show: !0,
|
|
|
+ firstDay: 0,
|
|
|
+ position: "start",
|
|
|
+ margin: "50%",
|
|
|
+ nameMap: "en",
|
|
|
+ color: "#000"
|
|
|
+ },
|
|
|
+ monthLabel: {
|
|
|
+ show: !0,
|
|
|
+ position: "start",
|
|
|
+ margin: 5,
|
|
|
+ align: "center",
|
|
|
+ nameMap: "en",
|
|
|
+ formatter: null,
|
|
|
+ color: "#000"
|
|
|
+ },
|
|
|
+ yearLabel: {
|
|
|
+ show: !0,
|
|
|
+ position: null,
|
|
|
+ margin: 30,
|
|
|
+ formatter: null,
|
|
|
+ color: "#ccc",
|
|
|
+ fontFamily: "sans-serif",
|
|
|
+ fontWeight: "bolder",
|
|
|
+ fontSize: 20
|
|
|
+ }
|
|
|
+ },
|
|
|
+ init: function(t, e, i, n) {
|
|
|
+ var o = Iu(t);
|
|
|
+ YT.superApply(this, "init", arguments),
|
|
|
+ jT(t, o)
|
|
|
+ },
|
|
|
+ mergeOption: function(t, e) {
|
|
|
+ YT.superApply(this, "mergeOption", arguments),
|
|
|
+ jT(this.option, t)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function jT(t, e) {
|
|
|
+ var i = t.cellSize;
|
|
|
+ L(i) ? 1 === i.length && (i[1] = i[0]) : i = t.cellSize = [i, i];
|
|
|
+ var n = O([0, 1], function(t) {
|
|
|
+ return function(t, e) {
|
|
|
+ return null != t[xu[e][0]] || null != t[xu[e][1]] && null != t[xu[e][2]]
|
|
|
+ }(e, t) && (i[t] = "auto"),
|
|
|
+ null != i[t] && "auto" !== i[t]
|
|
|
+ });
|
|
|
+ Mu(t, e, {
|
|
|
+ type: "box",
|
|
|
+ ignoreSize: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var qT = {
|
|
|
+ EN: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
|
|
|
+ CN: ["一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"]
|
|
|
+ }
|
|
|
+ , KT = {
|
|
|
+ EN: ["S", "M", "T", "W", "T", "F", "S"],
|
|
|
+ CN: ["日", "一", "二", "三", "四", "五", "六"]
|
|
|
+ };
|
|
|
+ Af({
|
|
|
+ type: "calendar",
|
|
|
+ _tlpoints: null,
|
|
|
+ _blpoints: null,
|
|
|
+ _firstDayOfMonth: null,
|
|
|
+ _firstDayPoints: null,
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var n = this.group;
|
|
|
+ n.removeAll();
|
|
|
+ var o = t.coordinateSystem
|
|
|
+ , a = o.getRangeInfo()
|
|
|
+ , r = o.getOrient();
|
|
|
+ this._renderDayRect(t, a, n),
|
|
|
+ this._renderLines(t, a, r, n),
|
|
|
+ this._renderYearText(t, a, r, n),
|
|
|
+ this._renderMonthText(t, r, n),
|
|
|
+ this._renderWeekText(t, a, r, n)
|
|
|
+ },
|
|
|
+ _renderDayRect: function(t, e, i) {
|
|
|
+ for (var n = t.coordinateSystem, o = t.getModel("itemStyle").getItemStyle(), a = n.getCellWidth(), r = n.getCellHeight(), s = e.start.time; s <= e.end.time; s = n.getNextNDay(s, 1).time) {
|
|
|
+ var l = n.dataToRect([s], !1).tl
|
|
|
+ , u = new rs({
|
|
|
+ shape: {
|
|
|
+ x: l[0],
|
|
|
+ y: l[1],
|
|
|
+ width: a,
|
|
|
+ height: r
|
|
|
+ },
|
|
|
+ cursor: "default",
|
|
|
+ style: o
|
|
|
+ });
|
|
|
+ i.add(u)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderLines: function(i, t, n, o) {
|
|
|
+ var a = this
|
|
|
+ , r = i.coordinateSystem
|
|
|
+ , s = i.getModel("splitLine.lineStyle").getLineStyle()
|
|
|
+ , l = i.get("splitLine.show")
|
|
|
+ , e = s.lineWidth;
|
|
|
+ this._tlpoints = [],
|
|
|
+ this._blpoints = [],
|
|
|
+ this._firstDayOfMonth = [],
|
|
|
+ this._firstDayPoints = [];
|
|
|
+ for (var u = t.start, h = 0; u.time <= t.end.time; h++) {
|
|
|
+ d(u.formatedDate),
|
|
|
+ 0 === h && (u = r.getDateInfo(t.start.y + "-" + t.start.m));
|
|
|
+ var c = u.date;
|
|
|
+ c.setMonth(c.getMonth() + 1),
|
|
|
+ u = r.getDateInfo(c)
|
|
|
+ }
|
|
|
+ function d(t) {
|
|
|
+ a._firstDayOfMonth.push(r.getDateInfo(t)),
|
|
|
+ a._firstDayPoints.push(r.dataToRect([t], !1).tl);
|
|
|
+ var e = a._getLinePointsOfOneWeek(i, t, n);
|
|
|
+ a._tlpoints.push(e[0]),
|
|
|
+ a._blpoints.push(e[e.length - 1]),
|
|
|
+ l && a._drawSplitline(e, s, o)
|
|
|
+ }
|
|
|
+ d(r.getNextNDay(t.end.time, 1).formatedDate),
|
|
|
+ l && this._drawSplitline(a._getEdgesPoints(a._tlpoints, e, n), s, o),
|
|
|
+ l && this._drawSplitline(a._getEdgesPoints(a._blpoints, e, n), s, o)
|
|
|
+ },
|
|
|
+ _getEdgesPoints: function(t, e, i) {
|
|
|
+ var n = [t[0].slice(), t[t.length - 1].slice()]
|
|
|
+ , o = "horizontal" === i ? 0 : 1;
|
|
|
+ return n[0][o] = n[0][o] - e / 2,
|
|
|
+ n[1][o] = n[1][o] + e / 2,
|
|
|
+ n
|
|
|
+ },
|
|
|
+ _drawSplitline: function(t, e, i) {
|
|
|
+ var n = new ts({
|
|
|
+ z2: 20,
|
|
|
+ shape: {
|
|
|
+ points: t
|
|
|
+ },
|
|
|
+ style: e
|
|
|
+ });
|
|
|
+ i.add(n)
|
|
|
+ },
|
|
|
+ _getLinePointsOfOneWeek: function(t, e, i) {
|
|
|
+ var n = t.coordinateSystem;
|
|
|
+ e = n.getDateInfo(e);
|
|
|
+ for (var o = [], a = 0; a < 7; a++) {
|
|
|
+ var r = n.getNextNDay(e.time, a)
|
|
|
+ , s = n.dataToRect([r.time], !1);
|
|
|
+ o[2 * r.day] = s.tl,
|
|
|
+ o[2 * r.day + 1] = s["horizontal" === i ? "bl" : "tr"]
|
|
|
+ }
|
|
|
+ return o
|
|
|
+ },
|
|
|
+ _formatterLabel: function(t, e) {
|
|
|
+ return "string" == typeof t && t ? uu(t, e) : "function" == typeof t ? t(e) : e.nameMap
|
|
|
+ },
|
|
|
+ _yearTextPositionControl: function(t, e, i, n, o) {
|
|
|
+ e = e.slice();
|
|
|
+ var a = ["center", "bottom"];
|
|
|
+ "bottom" === n ? (e[1] += o,
|
|
|
+ a = ["center", "top"]) : "left" === n ? e[0] -= o : "right" === n ? (e[0] += o,
|
|
|
+ a = ["center", "top"]) : e[1] -= o;
|
|
|
+ var r = 0;
|
|
|
+ return "left" !== n && "right" !== n || (r = Math.PI / 2),
|
|
|
+ {
|
|
|
+ rotation: r,
|
|
|
+ position: e,
|
|
|
+ style: {
|
|
|
+ textAlign: a[0],
|
|
|
+ textVerticalAlign: a[1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderYearText: function(t, e, i, n) {
|
|
|
+ var o = t.getModel("yearLabel");
|
|
|
+ if (o.get("show")) {
|
|
|
+ var a = o.get("margin")
|
|
|
+ , r = o.get("position");
|
|
|
+ r = r || ("horizontal" !== i ? "top" : "left");
|
|
|
+ var s = [this._tlpoints[this._tlpoints.length - 1], this._blpoints[0]]
|
|
|
+ , l = (s[0][0] + s[1][0]) / 2
|
|
|
+ , u = (s[0][1] + s[1][1]) / 2
|
|
|
+ , h = "horizontal" === i ? 0 : 1
|
|
|
+ , c = {
|
|
|
+ top: [l, s[h][1]],
|
|
|
+ bottom: [l, s[1 - h][1]],
|
|
|
+ left: [s[1 - h][0], u],
|
|
|
+ right: [s[h][0], u]
|
|
|
+ }
|
|
|
+ , d = e.start.y;
|
|
|
+ +e.end.y > +e.start.y && (d = d + "-" + e.end.y);
|
|
|
+ var f = o.get("formatter")
|
|
|
+ , p = {
|
|
|
+ start: e.start.y,
|
|
|
+ end: e.end.y,
|
|
|
+ nameMap: d
|
|
|
+ }
|
|
|
+ , g = this._formatterLabel(f, p)
|
|
|
+ , m = new Ur({
|
|
|
+ z2: 30
|
|
|
+ });
|
|
|
+ nl(m.style, o, {
|
|
|
+ text: g
|
|
|
+ }),
|
|
|
+ m.attr(this._yearTextPositionControl(m, c[r], i, r, a)),
|
|
|
+ n.add(m)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _monthTextPositionControl: function(t, e, i, n, o) {
|
|
|
+ var a = "left"
|
|
|
+ , r = "top"
|
|
|
+ , s = t[0]
|
|
|
+ , l = t[1];
|
|
|
+ return "horizontal" === i ? (l += o,
|
|
|
+ e && (a = "center"),
|
|
|
+ "start" === n && (r = "bottom")) : (s += o,
|
|
|
+ e && (r = "middle"),
|
|
|
+ "start" === n && (a = "right")),
|
|
|
+ {
|
|
|
+ x: s,
|
|
|
+ y: l,
|
|
|
+ textAlign: a,
|
|
|
+ textVerticalAlign: r
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderMonthText: function(t, e, i) {
|
|
|
+ var n = t.getModel("monthLabel");
|
|
|
+ if (n.get("show")) {
|
|
|
+ var o = n.get("nameMap")
|
|
|
+ , a = n.get("margin")
|
|
|
+ , r = n.get("position")
|
|
|
+ , s = n.get("align")
|
|
|
+ , l = [this._tlpoints, this._blpoints];
|
|
|
+ R(o) && (o = qT[o.toUpperCase()] || []);
|
|
|
+ var u = "start" === r ? 0 : 1
|
|
|
+ , h = "horizontal" === e ? 0 : 1;
|
|
|
+ a = "start" === r ? -a : a;
|
|
|
+ for (var c = "center" === s, d = 0; d < l[u].length - 1; d++) {
|
|
|
+ var f = l[u][d].slice()
|
|
|
+ , p = this._firstDayOfMonth[d];
|
|
|
+ if (c) {
|
|
|
+ var g = this._firstDayPoints[d];
|
|
|
+ f[h] = (g[h] + l[0][d + 1][h]) / 2
|
|
|
+ }
|
|
|
+ var m = n.get("formatter")
|
|
|
+ , v = o[+p.m - 1]
|
|
|
+ , y = {
|
|
|
+ yyyy: p.y,
|
|
|
+ yy: (p.y + "").slice(2),
|
|
|
+ MM: p.m,
|
|
|
+ M: +p.m,
|
|
|
+ nameMap: v
|
|
|
+ }
|
|
|
+ , x = this._formatterLabel(m, y)
|
|
|
+ , _ = new Ur({
|
|
|
+ z2: 30
|
|
|
+ });
|
|
|
+ P(nl(_.style, n, {
|
|
|
+ text: x
|
|
|
+ }), this._monthTextPositionControl(f, c, e, r, a)),
|
|
|
+ i.add(_)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _weekTextPositionControl: function(t, e, i, n, o) {
|
|
|
+ var a = "center"
|
|
|
+ , r = "middle"
|
|
|
+ , s = t[0]
|
|
|
+ , l = t[1]
|
|
|
+ , u = "start" === i;
|
|
|
+ return "horizontal" === e ? (s = s + n + (u ? 1 : -1) * o[0] / 2,
|
|
|
+ a = u ? "right" : "left") : (l = l + n + (u ? 1 : -1) * o[1] / 2,
|
|
|
+ r = u ? "bottom" : "top"),
|
|
|
+ {
|
|
|
+ x: s,
|
|
|
+ y: l,
|
|
|
+ textAlign: a,
|
|
|
+ textVerticalAlign: r
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderWeekText: function(t, e, i, n) {
|
|
|
+ var o = t.getModel("dayLabel");
|
|
|
+ if (o.get("show")) {
|
|
|
+ var a = t.coordinateSystem
|
|
|
+ , r = o.get("position")
|
|
|
+ , s = o.get("nameMap")
|
|
|
+ , l = o.get("margin")
|
|
|
+ , u = a.getFirstDayOfWeek();
|
|
|
+ R(s) && (s = KT[s.toUpperCase()] || []);
|
|
|
+ var h = a.getNextNDay(e.end.time, 7 - e.lweek).time
|
|
|
+ , c = [a.getCellWidth(), a.getCellHeight()];
|
|
|
+ l = Rl(l, c["horizontal" === i ? 0 : 1]),
|
|
|
+ "start" === r && (h = a.getNextNDay(e.start.time, -(7 + e.fweek)).time,
|
|
|
+ l = -l);
|
|
|
+ for (var d = 0; d < 7; d++) {
|
|
|
+ var f, p = a.getNextNDay(h, d), g = a.dataToRect([p.time], !1).center;
|
|
|
+ f = Math.abs((d + u) % 7);
|
|
|
+ var m = new Ur({
|
|
|
+ z2: 30
|
|
|
+ });
|
|
|
+ P(nl(m.style, o, {
|
|
|
+ text: s[f]
|
|
|
+ }), this._weekTextPositionControl(g, i, r, l, c)),
|
|
|
+ n.add(m)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var $T = {
|
|
|
+ path: null,
|
|
|
+ compoundPath: null,
|
|
|
+ group: Ci,
|
|
|
+ image: Qn,
|
|
|
+ text: Ur
|
|
|
+ };
|
|
|
+ yf(function(t) {
|
|
|
+ var e = t.graphic;
|
|
|
+ L(e) ? e[0] && e[0].elements ? t.graphic = [t.graphic[0]] : t.graphic = [{
|
|
|
+ elements: e
|
|
|
+ }] : e && !e.elements && (t.graphic = [{
|
|
|
+ elements: [e]
|
|
|
+ }])
|
|
|
+ });
|
|
|
+ var JT = Tf({
|
|
|
+ type: "graphic",
|
|
|
+ defaultOption: {
|
|
|
+ elements: [],
|
|
|
+ parentId: null
|
|
|
+ },
|
|
|
+ _elOptionsToUpdate: null,
|
|
|
+ mergeOption: function(t) {
|
|
|
+ var e = this.option.elements;
|
|
|
+ this.option.elements = null,
|
|
|
+ JT.superApply(this, "mergeOption", arguments),
|
|
|
+ this.option.elements = e
|
|
|
+ },
|
|
|
+ optionUpdated: function(t, e) {
|
|
|
+ var i = this.option
|
|
|
+ , n = (e ? i : t).elements
|
|
|
+ , o = i.elements = e ? [] : i.elements
|
|
|
+ , a = [];
|
|
|
+ this._flatten(n, a);
|
|
|
+ var r = Ho(o, a);
|
|
|
+ Zo(r);
|
|
|
+ var s = this._elOptionsToUpdate = [];
|
|
|
+ E(r, function(t, e) {
|
|
|
+ var i = t.option;
|
|
|
+ i && (s.push(i),
|
|
|
+ function(t, e) {
|
|
|
+ var i = t.exist;
|
|
|
+ if (e.id = t.keyInfo.id,
|
|
|
+ !e.type && i && (e.type = i.type),
|
|
|
+ null == e.parentId) {
|
|
|
+ var n = e.parentOption;
|
|
|
+ n ? e.parentId = n.id : i && (e.parentId = i.parentId)
|
|
|
+ }
|
|
|
+ e.parentOption = null
|
|
|
+ }(t, i),
|
|
|
+ function(t, e, i) {
|
|
|
+ var n = P({}, i)
|
|
|
+ , o = t[e]
|
|
|
+ , a = i.$action || "merge";
|
|
|
+ "merge" === a ? o ? (m(o, n, !0),
|
|
|
+ Mu(o, n, {
|
|
|
+ ignoreSize: !0
|
|
|
+ }),
|
|
|
+ Tu(i, o)) : t[e] = n : "replace" === a ? t[e] = n : "remove" === a && o && (t[e] = null)
|
|
|
+ }(o, e, i),
|
|
|
+ function(t, e) {
|
|
|
+ if (!t)
|
|
|
+ return;
|
|
|
+ t.hv = e.hv = [eA(e, ["left", "right"]), eA(e, ["top", "bottom"])],
|
|
|
+ "group" === t.type && (null == t.width && (t.width = e.width = 0),
|
|
|
+ null == t.height && (t.height = e.height = 0))
|
|
|
+ }(o[e], i))
|
|
|
+ }, this);
|
|
|
+ for (var l = o.length - 1; 0 <= l; l--)
|
|
|
+ null == o[l] ? o.splice(l, 1) : delete o[l].$action
|
|
|
+ },
|
|
|
+ _flatten: function(t, i, n) {
|
|
|
+ E(t, function(t) {
|
|
|
+ if (t) {
|
|
|
+ n && (t.parentOption = n),
|
|
|
+ i.push(t);
|
|
|
+ var e = t.children;
|
|
|
+ "group" === t.type && e && this._flatten(e, i, t),
|
|
|
+ delete t.children
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ useElOptionsToUpdate: function() {
|
|
|
+ var t = this._elOptionsToUpdate;
|
|
|
+ return this._elOptionsToUpdate = null,
|
|
|
+ t
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function QT(t, e, i, n) {
|
|
|
+ var o = i.type
|
|
|
+ , a = new ($T.hasOwnProperty(o) ? $T[o] : ks(o))(i);
|
|
|
+ e.add(a),
|
|
|
+ n.set(t, a),
|
|
|
+ a.__ecGraphicId = t
|
|
|
+ }
|
|
|
+ function tA(t, e) {
|
|
|
+ var i = t && t.parent;
|
|
|
+ i && ("group" === t.type && t.traverse(function(t) {
|
|
|
+ tA(t, e)
|
|
|
+ }),
|
|
|
+ e.removeKey(t.__ecGraphicId),
|
|
|
+ i.remove(t))
|
|
|
+ }
|
|
|
+ function eA(e, t) {
|
|
|
+ var i;
|
|
|
+ return E(t, function(t) {
|
|
|
+ null != e[t] && "auto" !== e[t] && (i = !0)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ Af({
|
|
|
+ type: "graphic",
|
|
|
+ init: function(t, e) {
|
|
|
+ this._elMap = Q(),
|
|
|
+ this._lastGraphicModel
|
|
|
+ },
|
|
|
+ render: function(t, e, i) {
|
|
|
+ t !== this._lastGraphicModel && this._clear(),
|
|
|
+ this._lastGraphicModel = t,
|
|
|
+ this._updateElements(t),
|
|
|
+ this._relocate(t, i)
|
|
|
+ },
|
|
|
+ _updateElements: function(u) {
|
|
|
+ var t = u.useElOptionsToUpdate();
|
|
|
+ if (t) {
|
|
|
+ var h = this._elMap
|
|
|
+ , c = this.group;
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = t.$action
|
|
|
+ , i = t.id
|
|
|
+ , n = h.get(i)
|
|
|
+ , o = t.parentId
|
|
|
+ , a = null != o ? h.get(o) : c
|
|
|
+ , r = t.style;
|
|
|
+ "text" === t.type && r && (t.hv && t.hv[1] && (r.textVerticalAlign = r.textBaseline = null),
|
|
|
+ !r.hasOwnProperty("textFill") && r.fill && (r.textFill = r.fill),
|
|
|
+ !r.hasOwnProperty("textStroke") && r.stroke && (r.textStroke = r.stroke));
|
|
|
+ var s = function(e) {
|
|
|
+ return e = P({}, e),
|
|
|
+ E(["id", "parentId", "$action", "hv", "bounding"].concat(yu), function(t) {
|
|
|
+ delete e[t]
|
|
|
+ }),
|
|
|
+ e
|
|
|
+ }(t);
|
|
|
+ e && "merge" !== e ? "replace" === e ? (tA(n, h),
|
|
|
+ QT(i, a, s, h)) : "remove" === e && tA(n, h) : n ? n.attr(s) : QT(i, a, s, h);
|
|
|
+ var l = h.get(i);
|
|
|
+ l && (l.__ecGraphicWidthOption = t.width,
|
|
|
+ l.__ecGraphicHeightOption = t.height,
|
|
|
+ function(t, e) {
|
|
|
+ var i = t.eventData;
|
|
|
+ t.silent || t.ignore || i || (i = t.eventData = {
|
|
|
+ componentType: "graphic",
|
|
|
+ componentIndex: e.componentIndex,
|
|
|
+ name: t.name
|
|
|
+ });
|
|
|
+ i && (i.info = t.info)
|
|
|
+ }(l, u))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _relocate: function(t, e) {
|
|
|
+ for (var i = t.option.elements, n = this.group, o = this._elMap, a = e.getWidth(), r = e.getHeight(), s = 0; s < i.length; s++) {
|
|
|
+ var l = i[s];
|
|
|
+ if ((h = o.get(l.id)) && h.isGroup) {
|
|
|
+ var u = (c = h.parent) === n;
|
|
|
+ h.__ecGraphicWidth = Rl(h.__ecGraphicWidthOption, u ? a : c.__ecGraphicWidth) || 0,
|
|
|
+ h.__ecGraphicHeight = Rl(h.__ecGraphicHeightOption, u ? r : c.__ecGraphicHeight) || 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (s = i.length - 1; 0 <= s; s--) {
|
|
|
+ var h, c;
|
|
|
+ l = i[s];
|
|
|
+ if (h = o.get(l.id))
|
|
|
+ Su(h, l, (c = h.parent) === n ? {
|
|
|
+ width: a,
|
|
|
+ height: r
|
|
|
+ } : {
|
|
|
+ width: c.__ecGraphicWidth,
|
|
|
+ height: c.__ecGraphicHeight
|
|
|
+ }, null, {
|
|
|
+ hv: l.hv,
|
|
|
+ boundingMode: l.bounding
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _clear: function() {
|
|
|
+ var e = this._elMap;
|
|
|
+ e.each(function(t) {
|
|
|
+ tA(t, e)
|
|
|
+ }),
|
|
|
+ this._elMap = Q()
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._clear()
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var iA = {};
|
|
|
+ function nA(t, e) {
|
|
|
+ iA[t] = e
|
|
|
+ }
|
|
|
+ function oA(t) {
|
|
|
+ return iA[t]
|
|
|
+ }
|
|
|
+ var aA = Tf({
|
|
|
+ type: "toolbox",
|
|
|
+ layoutMode: {
|
|
|
+ type: "box",
|
|
|
+ ignoreSize: !0
|
|
|
+ },
|
|
|
+ optionUpdated: function() {
|
|
|
+ aA.superApply(this, "optionUpdated", arguments),
|
|
|
+ E(this.option.feature, function(t, e) {
|
|
|
+ var i = oA(e);
|
|
|
+ i && m(t, i.defaultOption)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ show: !0,
|
|
|
+ z: 6,
|
|
|
+ zlevel: 0,
|
|
|
+ orient: "horizontal",
|
|
|
+ left: "right",
|
|
|
+ top: "top",
|
|
|
+ backgroundColor: "transparent",
|
|
|
+ borderColor: "#ccc",
|
|
|
+ borderRadius: 0,
|
|
|
+ borderWidth: 0,
|
|
|
+ padding: 5,
|
|
|
+ itemSize: 15,
|
|
|
+ itemGap: 8,
|
|
|
+ showTitle: !0,
|
|
|
+ iconStyle: {
|
|
|
+ borderColor: "#666",
|
|
|
+ color: "none"
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ iconStyle: {
|
|
|
+ borderColor: "#3E98C5"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ tooltip: {
|
|
|
+ show: !1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function rA(t, e) {
|
|
|
+ var i = iu(e.get("padding"))
|
|
|
+ , n = e.getItemStyle(["color", "opacity"]);
|
|
|
+ return n.fill = e.get("backgroundColor"),
|
|
|
+ t = new rs({
|
|
|
+ shape: {
|
|
|
+ x: t.x - i[3],
|
|
|
+ y: t.y - i[0],
|
|
|
+ width: t.width + i[1] + i[3],
|
|
|
+ height: t.height + i[0] + i[2],
|
|
|
+ r: e.get("borderRadius")
|
|
|
+ },
|
|
|
+ style: n,
|
|
|
+ silent: !0,
|
|
|
+ z2: -1
|
|
|
+ })
|
|
|
+ }
|
|
|
+ Af({
|
|
|
+ type: "toolbox",
|
|
|
+ render: function(h, c, d, l) {
|
|
|
+ var f = this.group;
|
|
|
+ if (f.removeAll(),
|
|
|
+ h.get("show")) {
|
|
|
+ var p = +h.get("itemSize")
|
|
|
+ , u = h.get("feature") || {}
|
|
|
+ , g = this._features || (this._features = {})
|
|
|
+ , m = [];
|
|
|
+ E(u, function(t, e) {
|
|
|
+ m.push(e)
|
|
|
+ }),
|
|
|
+ new kf(this._featureNames || [],m).add(t).update(t).remove(T(t, null)).execute(),
|
|
|
+ this._featureNames = m,
|
|
|
+ function(t, e, i) {
|
|
|
+ var n = e.getBoxLayoutParams()
|
|
|
+ , o = e.get("padding")
|
|
|
+ , a = {
|
|
|
+ width: i.getWidth(),
|
|
|
+ height: i.getHeight()
|
|
|
+ }
|
|
|
+ , r = bu(n, a, o);
|
|
|
+ wu(e.get("orient"), t, e.get("itemGap"), r.width, r.height),
|
|
|
+ Su(t, n, a, o)
|
|
|
+ }(f, h, d),
|
|
|
+ f.add(rA(f.getBoundingRect(), h)),
|
|
|
+ f.eachChild(function(t) {
|
|
|
+ var e = t.__title
|
|
|
+ , i = t.hoverStyle;
|
|
|
+ if (i && e) {
|
|
|
+ var n = gn(e, An(i))
|
|
|
+ , o = t.position[0] + f.position[0]
|
|
|
+ , a = !1;
|
|
|
+ t.position[1] + f.position[1] + p + n.height > d.getHeight() && (i.textPosition = "top",
|
|
|
+ a = !0);
|
|
|
+ var r = a ? -5 - n.height : p + 8;
|
|
|
+ o + n.width / 2 > d.getWidth() ? (i.textPosition = ["100%", r],
|
|
|
+ i.textAlign = "right") : o - n.width / 2 < 0 && (i.textPosition = [0, r],
|
|
|
+ i.textAlign = "left")
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function t(t, e) {
|
|
|
+ var i, n = m[t], o = m[e], a = u[n], r = new Cl(a,h,h.ecModel);
|
|
|
+ if (l && null != l.newTitle && l.featureName === n && (a.title = l.newTitle),
|
|
|
+ n && !o) {
|
|
|
+ if (function(t) {
|
|
|
+ return 0 === t.indexOf("my")
|
|
|
+ }(n))
|
|
|
+ i = {
|
|
|
+ model: r,
|
|
|
+ onclick: r.option.onclick,
|
|
|
+ featureName: n
|
|
|
+ };
|
|
|
+ else {
|
|
|
+ var s = oA(n);
|
|
|
+ if (!s)
|
|
|
+ return;
|
|
|
+ i = new s(r,c,d)
|
|
|
+ }
|
|
|
+ g[n] = i
|
|
|
+ } else {
|
|
|
+ if (!(i = g[o]))
|
|
|
+ return;
|
|
|
+ i.model = r,
|
|
|
+ i.ecModel = c,
|
|
|
+ i.api = d
|
|
|
+ }
|
|
|
+ n || !o ? r.get("show") && !i.unusable ? (function(o, a, t) {
|
|
|
+ var r = o.getModel("iconStyle")
|
|
|
+ , s = o.getModel("emphasis.iconStyle")
|
|
|
+ , e = a.getIcons ? a.getIcons() : o.get("icon")
|
|
|
+ , l = o.get("title") || {};
|
|
|
+ if ("string" == typeof e) {
|
|
|
+ var i = e
|
|
|
+ , n = l;
|
|
|
+ l = {},
|
|
|
+ (e = {})[t] = i,
|
|
|
+ l[t] = n
|
|
|
+ }
|
|
|
+ var u = o.iconPaths = {};
|
|
|
+ E(e, function(t, e) {
|
|
|
+ var i = yl(t, {}, {
|
|
|
+ x: -p / 2,
|
|
|
+ y: -p / 2,
|
|
|
+ width: p,
|
|
|
+ height: p
|
|
|
+ });
|
|
|
+ i.setStyle(r.getItemStyle()),
|
|
|
+ i.hoverStyle = s.getItemStyle(),
|
|
|
+ i.setStyle({
|
|
|
+ text: l[e],
|
|
|
+ textAlign: s.get("textAlign"),
|
|
|
+ textBorderRadius: s.get("textBorderRadius"),
|
|
|
+ textPadding: s.get("textPadding"),
|
|
|
+ textFill: null
|
|
|
+ });
|
|
|
+ var n = h.getModel("tooltip");
|
|
|
+ n && n.get("show") && i.attr("tooltip", P({
|
|
|
+ content: l[e],
|
|
|
+ formatter: n.get("formatter", !0) || function() {
|
|
|
+ return l[e]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ formatterParams: {
|
|
|
+ componentType: "toolbox",
|
|
|
+ name: e,
|
|
|
+ title: l[e],
|
|
|
+ $vars: ["name", "title"]
|
|
|
+ },
|
|
|
+ position: n.get("position", !0) || "bottom"
|
|
|
+ }, n.option)),
|
|
|
+ $s(i),
|
|
|
+ h.get("showTitle") && (i.__title = l[e],
|
|
|
+ i.on("mouseover", function() {
|
|
|
+ var t = s.getItemStyle()
|
|
|
+ , e = "vertical" === h.get("orient") ? null == h.get("right") ? "right" : "left" : null == h.get("bottom") ? "bottom" : "top";
|
|
|
+ i.setStyle({
|
|
|
+ textFill: s.get("textFill") || t.fill || t.stroke || "#000",
|
|
|
+ textBackgroundColor: s.get("textBackgroundColor"),
|
|
|
+ textPosition: s.get("textPosition") || e
|
|
|
+ })
|
|
|
+ }).on("mouseout", function() {
|
|
|
+ i.setStyle({
|
|
|
+ textFill: null,
|
|
|
+ textBackgroundColor: null
|
|
|
+ })
|
|
|
+ })),
|
|
|
+ i.trigger(o.get("iconStatus." + e) || "normal"),
|
|
|
+ f.add(i),
|
|
|
+ i.on("click", A(a.onclick, a, c, d, e)),
|
|
|
+ u[e] = i
|
|
|
+ })
|
|
|
+ }(r, i, n),
|
|
|
+ r.setIconStatus = function(t, e) {
|
|
|
+ var i = this.option
|
|
|
+ , n = this.iconPaths;
|
|
|
+ i.iconStatus = i.iconStatus || {},
|
|
|
+ i.iconStatus[t] = e,
|
|
|
+ n[t] && n[t].trigger(e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ i.render && i.render(r, c, d, l)) : i.remove && i.remove(c, d) : i.dispose && i.dispose(c, d)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ updateView: function(t, e, i, n) {
|
|
|
+ E(this._features, function(t) {
|
|
|
+ t.updateView && t.updateView(t.model, e, i, n)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ remove: function(e, i) {
|
|
|
+ E(this._features, function(t) {
|
|
|
+ t.remove && t.remove(e, i)
|
|
|
+ }),
|
|
|
+ this.group.removeAll()
|
|
|
+ },
|
|
|
+ dispose: function(e, i) {
|
|
|
+ E(this._features, function(t) {
|
|
|
+ t.dispose && t.dispose(e, i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var sA = Oc.toolbox.saveAsImage;
|
|
|
+ function lA(t) {
|
|
|
+ this.model = t
|
|
|
+ }
|
|
|
+ lA.defaultOption = {
|
|
|
+ show: !0,
|
|
|
+ icon: "M4.7,22.9L29.3,45.5L54.7,23.4M4.6,43.6L4.6,58L53.8,58L53.8,43.6M29.2,45.1L29.2,0",
|
|
|
+ title: sA.title,
|
|
|
+ type: "png",
|
|
|
+ connectedBackgroundColor: "#fff",
|
|
|
+ name: "",
|
|
|
+ excludeComponents: ["toolbox"],
|
|
|
+ pixelRatio: 1,
|
|
|
+ lang: sA.lang.slice()
|
|
|
+ },
|
|
|
+ lA.prototype.unusable = !v.canvasSupported,
|
|
|
+ lA.prototype.onclick = function(t, e) {
|
|
|
+ var i = this.model
|
|
|
+ , n = i.get("name") || t.get("title.0.text") || "echarts"
|
|
|
+ , o = "svg" === e.getZr().painter.getType() ? "svg" : i.get("type", !0) || "png"
|
|
|
+ , a = e.getConnectedDataURL({
|
|
|
+ type: o,
|
|
|
+ backgroundColor: i.get("backgroundColor", !0) || t.get("backgroundColor") || "#fff",
|
|
|
+ connectedBackgroundColor: i.get("connectedBackgroundColor"),
|
|
|
+ excludeComponents: i.get("excludeComponents"),
|
|
|
+ pixelRatio: i.get("pixelRatio")
|
|
|
+ });
|
|
|
+ if ("function" != typeof MouseEvent || v.browser.ie || v.browser.edge)
|
|
|
+ if (window.navigator.msSaveOrOpenBlob) {
|
|
|
+ for (var r = atob(a.split(",")[1]), s = r.length, l = new Uint8Array(s); s--; )
|
|
|
+ l[s] = r.charCodeAt(s);
|
|
|
+ var u = new Blob([l]);
|
|
|
+ window.navigator.msSaveOrOpenBlob(u, n + "." + o)
|
|
|
+ } else {
|
|
|
+ var h = i.get("lang")
|
|
|
+ , c = '<body style="margin:0;"><img src="' + a + '" style="max-width:100%;" title="' + (h && h[0] || "") + '" /></body>';
|
|
|
+ window.open().document.write(c)
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ var d = document.createElement("a");
|
|
|
+ d.download = n + "." + o,
|
|
|
+ d.target = "_blank",
|
|
|
+ d.href = a;
|
|
|
+ var f = new MouseEvent("click",{
|
|
|
+ view: window,
|
|
|
+ bubbles: !0,
|
|
|
+ cancelable: !1
|
|
|
+ });
|
|
|
+ d.dispatchEvent(f)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nA("saveAsImage", lA);
|
|
|
+ var uA = Oc.toolbox.magicType
|
|
|
+ , hA = "__ec_magicType_stack__";
|
|
|
+ function cA(t) {
|
|
|
+ this.model = t
|
|
|
+ }
|
|
|
+ cA.defaultOption = {
|
|
|
+ show: !0,
|
|
|
+ type: [],
|
|
|
+ icon: {
|
|
|
+ line: "M4.1,28.9h7.1l9.3-22l7.4,38l9.7-19.7l3,12.8h14.9M4.1,58h51.4",
|
|
|
+ bar: "M6.7,22.9h10V48h-10V22.9zM24.9,13h10v35h-10V13zM43.2,2h10v46h-10V2zM3.1,58h53.7",
|
|
|
+ stack: "M8.2,38.4l-8.4,4.1l30.6,15.3L60,42.5l-8.1-4.1l-21.5,11L8.2,38.4z M51.9,30l-8.1,4.2l-13.4,6.9l-13.9-6.9L8.2,30l-8.4,4.2l8.4,4.2l22.2,11l21.5-11l8.1-4.2L51.9,30z M51.9,21.7l-8.1,4.2L35.7,30l-5.3,2.8L24.9,30l-8.4-4.1l-8.3-4.2l-8.4,4.2L8.2,30l8.3,4.2l13.9,6.9l13.4-6.9l8.1-4.2l8.1-4.1L51.9,21.7zM30.4,2.2L-0.2,17.5l8.4,4.1l8.3,4.2l8.4,4.2l5.5,2.7l5.3-2.7l8.1-4.2l8.1-4.2l8.1-4.1L30.4,2.2z"
|
|
|
+ },
|
|
|
+ title: k(uA.title),
|
|
|
+ option: {},
|
|
|
+ seriesIndex: {}
|
|
|
+ };
|
|
|
+ var dA = cA.prototype;
|
|
|
+ dA.getIcons = function() {
|
|
|
+ var t = this.model
|
|
|
+ , e = t.get("icon")
|
|
|
+ , i = {};
|
|
|
+ return E(t.get("type"), function(t) {
|
|
|
+ e[t] && (i[t] = e[t])
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var fA = {
|
|
|
+ line: function(t, e, i, n) {
|
|
|
+ if ("bar" === t)
|
|
|
+ return m({
|
|
|
+ id: e,
|
|
|
+ type: "line",
|
|
|
+ data: i.get("data"),
|
|
|
+ stack: i.get("stack"),
|
|
|
+ markPoint: i.get("markPoint"),
|
|
|
+ markLine: i.get("markLine")
|
|
|
+ }, n.get("option.line") || {}, !0)
|
|
|
+ },
|
|
|
+ bar: function(t, e, i, n) {
|
|
|
+ if ("line" === t)
|
|
|
+ return m({
|
|
|
+ id: e,
|
|
|
+ type: "bar",
|
|
|
+ data: i.get("data"),
|
|
|
+ stack: i.get("stack"),
|
|
|
+ markPoint: i.get("markPoint"),
|
|
|
+ markLine: i.get("markLine")
|
|
|
+ }, n.get("option.bar") || {}, !0)
|
|
|
+ },
|
|
|
+ stack: function(t, e, i, n) {
|
|
|
+ var o = i.get("stack") === hA;
|
|
|
+ if ("line" === t || "bar" === t)
|
|
|
+ return n.setIconStatus("stack", o ? "normal" : "emphasis"),
|
|
|
+ m({
|
|
|
+ id: e,
|
|
|
+ stack: o ? "" : hA
|
|
|
+ }, n.get("option.stack") || {}, !0)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , pA = [["line", "bar"], ["stack"]];
|
|
|
+ dA.onclick = function(u, t, h) {
|
|
|
+ var c = this.model
|
|
|
+ , e = c.get("seriesIndex." + h);
|
|
|
+ if (fA[h]) {
|
|
|
+ var i, d = {
|
|
|
+ series: []
|
|
|
+ };
|
|
|
+ if (E(pA, function(t) {
|
|
|
+ 0 <= _(t, h) && E(t, function(t) {
|
|
|
+ c.setIconStatus(t, "normal")
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ c.setIconStatus(h, "emphasis"),
|
|
|
+ u.eachComponent({
|
|
|
+ mainType: "series",
|
|
|
+ query: null == e ? null : {
|
|
|
+ seriesIndex: e
|
|
|
+ }
|
|
|
+ }, function(t) {
|
|
|
+ var e = t.subType
|
|
|
+ , i = t.id
|
|
|
+ , n = fA[h](e, i, t, c);
|
|
|
+ n && (D(n, t.option),
|
|
|
+ d.series.push(n));
|
|
|
+ var o = t.coordinateSystem;
|
|
|
+ if (o && "cartesian2d" === o.type && ("line" === h || "bar" === h)) {
|
|
|
+ var a = o.getAxesByScale("ordinal")[0];
|
|
|
+ if (a) {
|
|
|
+ var r = a.dim + "Axis"
|
|
|
+ , s = u.queryComponents({
|
|
|
+ mainType: r,
|
|
|
+ index: t.get(name + "Index"),
|
|
|
+ id: t.get(name + "Id")
|
|
|
+ })[0].componentIndex;
|
|
|
+ d[r] = d[r] || [];
|
|
|
+ for (var l = 0; l <= s; l++)
|
|
|
+ d[r][s] = d[r][s] || {};
|
|
|
+ d[r][s].boundaryGap = "bar" === h
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ "stack" === h)
|
|
|
+ i = d.series && d.series[0] && d.series[0].stack === hA ? m({
|
|
|
+ stack: uA.title.tiled
|
|
|
+ }, uA.title) : k(uA.title);
|
|
|
+ t.dispatchAction({
|
|
|
+ type: "changeMagicType",
|
|
|
+ currentType: h,
|
|
|
+ newOption: d,
|
|
|
+ newTitle: i,
|
|
|
+ featureName: "magicType"
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ _f({
|
|
|
+ type: "changeMagicType",
|
|
|
+ event: "magicTypeChanged",
|
|
|
+ update: "prepareAndUpdate"
|
|
|
+ }, function(t, e) {
|
|
|
+ e.mergeOption(t.newOption)
|
|
|
+ }),
|
|
|
+ nA("magicType", cA);
|
|
|
+ var gA = Oc.toolbox.dataView
|
|
|
+ , mA = new Array(60).join("-")
|
|
|
+ , vA = "\t";
|
|
|
+ function yA(t) {
|
|
|
+ var e = function(t) {
|
|
|
+ var o = {}
|
|
|
+ , a = []
|
|
|
+ , r = [];
|
|
|
+ return t.eachRawSeries(function(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ if (!e || "cartesian2d" !== e.type && "polar" !== e.type)
|
|
|
+ a.push(t);
|
|
|
+ else {
|
|
|
+ var i = e.getBaseAxis();
|
|
|
+ if ("category" === i.type) {
|
|
|
+ var n = i.dim + "_" + i.index;
|
|
|
+ o[n] || (o[n] = {
|
|
|
+ categoryAxis: i,
|
|
|
+ valueAxis: e.getOtherAxis(i),
|
|
|
+ series: []
|
|
|
+ },
|
|
|
+ r.push({
|
|
|
+ axisDim: i.dim,
|
|
|
+ axisIndex: i.index
|
|
|
+ })),
|
|
|
+ o[n].series.push(t)
|
|
|
+ } else
|
|
|
+ a.push(t)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ seriesGroupByCategoryAxis: o,
|
|
|
+ other: a,
|
|
|
+ meta: r
|
|
|
+ }
|
|
|
+ }(t);
|
|
|
+ return {
|
|
|
+ value: M([function(t) {
|
|
|
+ var h = [];
|
|
|
+ return E(t, function(t, e) {
|
|
|
+ var i = t.categoryAxis
|
|
|
+ , n = t.valueAxis.dim
|
|
|
+ , o = [" "].concat(O(t.series, function(t) {
|
|
|
+ return t.name
|
|
|
+ }))
|
|
|
+ , a = [i.model.getCategories()];
|
|
|
+ E(t.series, function(t) {
|
|
|
+ a.push(t.getRawData().mapArray(n, function(t) {
|
|
|
+ return t
|
|
|
+ }))
|
|
|
+ });
|
|
|
+ for (var r = [o.join(vA)], s = 0; s < a[0].length; s++) {
|
|
|
+ for (var l = [], u = 0; u < a.length; u++)
|
|
|
+ l.push(a[u][s]);
|
|
|
+ r.push(l.join(vA))
|
|
|
+ }
|
|
|
+ h.push(r.join("\n"))
|
|
|
+ }),
|
|
|
+ h.join("\n\n" + mA + "\n\n")
|
|
|
+ }(e.seriesGroupByCategoryAxis), function(t) {
|
|
|
+ return O(t, function(t) {
|
|
|
+ var o = t.getRawData()
|
|
|
+ , a = [t.name]
|
|
|
+ , r = [];
|
|
|
+ return o.each(o.dimensions, function() {
|
|
|
+ for (var t = arguments.length, e = arguments[t - 1], i = o.getName(e), n = 0; n < t - 1; n++)
|
|
|
+ r[n] = arguments[n];
|
|
|
+ a.push((i ? i + vA : "") + r.join(vA))
|
|
|
+ }),
|
|
|
+ a.join("\n")
|
|
|
+ }).join("\n\n" + mA + "\n\n")
|
|
|
+ }(e.other)], function(t) {
|
|
|
+ return t.replace(/[\n\t\s]/g, "")
|
|
|
+ }).join("\n\n" + mA + "\n\n"),
|
|
|
+ meta: e.meta
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function xA(t) {
|
|
|
+ return t.replace(/^\s\s*/, "").replace(/\s\s*$/, "")
|
|
|
+ }
|
|
|
+ var _A = new RegExp("[" + vA + "]+","g");
|
|
|
+ function wA(t, a) {
|
|
|
+ var e = t.split(new RegExp("\n*" + mA + "\n*","g"))
|
|
|
+ , r = {
|
|
|
+ series: []
|
|
|
+ };
|
|
|
+ return E(e, function(t, e) {
|
|
|
+ if (function(t) {
|
|
|
+ if (0 <= t.slice(0, t.indexOf("\n")).indexOf(vA))
|
|
|
+ return !0
|
|
|
+ }(t)) {
|
|
|
+ var i = function(t) {
|
|
|
+ for (var e = t.split(/\n+/g), i = [], n = O(xA(e.shift()).split(_A), function(t) {
|
|
|
+ return {
|
|
|
+ name: t,
|
|
|
+ data: []
|
|
|
+ }
|
|
|
+ }), o = 0; o < e.length; o++) {
|
|
|
+ var a = xA(e[o]).split(_A);
|
|
|
+ i.push(a.shift());
|
|
|
+ for (var r = 0; r < a.length; r++)
|
|
|
+ n[r] && (n[r].data[o] = a[r])
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ series: n,
|
|
|
+ categories: i
|
|
|
+ }
|
|
|
+ }(t)
|
|
|
+ , n = a[e]
|
|
|
+ , o = n.axisDim + "Axis";
|
|
|
+ n && (r[o] = r[o] || [],
|
|
|
+ r[o][n.axisIndex] = {
|
|
|
+ data: i.categories
|
|
|
+ },
|
|
|
+ r.series = r.series.concat(i.series))
|
|
|
+ } else {
|
|
|
+ i = function(t) {
|
|
|
+ for (var e = t.split(/\n+/g), i = xA(e.shift()), n = [], o = 0; o < e.length; o++) {
|
|
|
+ var a, r = xA(e[o]).split(_A), s = "", l = !1;
|
|
|
+ a = isNaN(r[0]) ? (l = !0,
|
|
|
+ s = r[0],
|
|
|
+ r = r.slice(1),
|
|
|
+ n[o] = {
|
|
|
+ name: s,
|
|
|
+ value: []
|
|
|
+ },
|
|
|
+ n[o].value) : n[o] = [];
|
|
|
+ for (var u = 0; u < r.length; u++)
|
|
|
+ a.push(+r[u]);
|
|
|
+ 1 === a.length && (l ? n[o].value = a[0] : n[o] = a[0])
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ name: i,
|
|
|
+ data: n
|
|
|
+ }
|
|
|
+ }(t);
|
|
|
+ r.series.push(i)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ r
|
|
|
+ }
|
|
|
+ function bA(t) {
|
|
|
+ this._dom = null,
|
|
|
+ this.model = t
|
|
|
+ }
|
|
|
+ bA.defaultOption = {
|
|
|
+ show: !0,
|
|
|
+ readOnly: !1,
|
|
|
+ optionToContent: null,
|
|
|
+ contentToOption: null,
|
|
|
+ icon: "M17.5,17.3H33 M17.5,17.3H33 M45.4,29.5h-28 M11.5,2v56H51V14.8L38.4,2H11.5z M38.4,2.2v12.7H51 M45.4,41.7h-28",
|
|
|
+ title: k(gA.title),
|
|
|
+ lang: k(gA.lang),
|
|
|
+ backgroundColor: "#fff",
|
|
|
+ textColor: "#000",
|
|
|
+ textareaColor: "#fff",
|
|
|
+ textareaBorderColor: "#333",
|
|
|
+ buttonColor: "#c23531",
|
|
|
+ buttonTextColor: "#fff"
|
|
|
+ },
|
|
|
+ bA.prototype.onclick = function(t, e) {
|
|
|
+ var i = e.getDom()
|
|
|
+ , n = this.model;
|
|
|
+ this._dom && i.removeChild(this._dom);
|
|
|
+ var o = document.createElement("div");
|
|
|
+ o.style.cssText = "position:absolute;left:5px;top:5px;bottom:5px;right:5px;",
|
|
|
+ o.style.backgroundColor = n.get("backgroundColor") || "#fff";
|
|
|
+ var a = document.createElement("h4")
|
|
|
+ , r = n.get("lang") || [];
|
|
|
+ a.innerHTML = r[0] || n.get("title"),
|
|
|
+ a.style.cssText = "margin: 10px 20px;",
|
|
|
+ a.style.color = n.get("textColor");
|
|
|
+ var s = document.createElement("div")
|
|
|
+ , l = document.createElement("textarea");
|
|
|
+ s.style.cssText = "display:block;width:100%;overflow:auto;";
|
|
|
+ var u = n.get("optionToContent")
|
|
|
+ , h = n.get("contentToOption")
|
|
|
+ , c = yA(t);
|
|
|
+ if ("function" == typeof u) {
|
|
|
+ var d = u(e.getOption());
|
|
|
+ "string" == typeof d ? s.innerHTML = d : G(d) && s.appendChild(d)
|
|
|
+ } else
|
|
|
+ s.appendChild(l),
|
|
|
+ l.readOnly = n.get("readOnly"),
|
|
|
+ l.style.cssText = "width:100%;height:100%;font-family:monospace;font-size:14px;line-height:1.6rem;",
|
|
|
+ l.style.color = n.get("textColor"),
|
|
|
+ l.style.borderColor = n.get("textareaBorderColor"),
|
|
|
+ l.style.backgroundColor = n.get("textareaColor"),
|
|
|
+ l.value = c.value;
|
|
|
+ var f = c.meta
|
|
|
+ , p = document.createElement("div");
|
|
|
+ p.style.cssText = "position:absolute;bottom:0;left:0;right:0;";
|
|
|
+ var g = "float:right;margin-right:20px;border:none;cursor:pointer;padding:2px 5px;font-size:12px;border-radius:3px"
|
|
|
+ , m = document.createElement("div")
|
|
|
+ , v = document.createElement("div");
|
|
|
+ g += ";background-color:" + n.get("buttonColor"),
|
|
|
+ g += ";color:" + n.get("buttonTextColor");
|
|
|
+ var y = this;
|
|
|
+ function x() {
|
|
|
+ i.removeChild(o),
|
|
|
+ y._dom = null
|
|
|
+ }
|
|
|
+ Ut(m, "click", x),
|
|
|
+ Ut(v, "click", function() {
|
|
|
+ var t;
|
|
|
+ try {
|
|
|
+ t = "function" == typeof h ? h(s, e.getOption()) : wA(l.value, f)
|
|
|
+ } catch (t) {
|
|
|
+ throw x(),
|
|
|
+ new Error("Data view format error " + t)
|
|
|
+ }
|
|
|
+ t && e.dispatchAction({
|
|
|
+ type: "changeDataView",
|
|
|
+ newOption: t
|
|
|
+ }),
|
|
|
+ x()
|
|
|
+ }),
|
|
|
+ m.innerHTML = r[1],
|
|
|
+ v.innerHTML = r[2],
|
|
|
+ v.style.cssText = g,
|
|
|
+ m.style.cssText = g,
|
|
|
+ n.get("readOnly") || p.appendChild(v),
|
|
|
+ p.appendChild(m),
|
|
|
+ o.appendChild(a),
|
|
|
+ o.appendChild(s),
|
|
|
+ o.appendChild(p),
|
|
|
+ s.style.height = i.clientHeight - 80 + "px",
|
|
|
+ i.appendChild(o),
|
|
|
+ this._dom = o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ bA.prototype.remove = function(t, e) {
|
|
|
+ this._dom && e.getDom().removeChild(this._dom)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ bA.prototype.dispose = function(t, e) {
|
|
|
+ this.remove(t, e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nA("dataView", bA),
|
|
|
+ _f({
|
|
|
+ type: "changeDataView",
|
|
|
+ event: "dataViewChanged",
|
|
|
+ update: "prepareAndUpdate"
|
|
|
+ }, function(t, n) {
|
|
|
+ var o = [];
|
|
|
+ E(t.newOption.series, function(t) {
|
|
|
+ var e = n.getSeriesByName(t.name)[0];
|
|
|
+ if (e) {
|
|
|
+ var i = e.get("data");
|
|
|
+ o.push({
|
|
|
+ name: t.name,
|
|
|
+ data: function(t, n) {
|
|
|
+ return O(t, function(t, e) {
|
|
|
+ var i = n && n[e];
|
|
|
+ return z(i) && !L(i) ? (z(t) && !L(t) && (t = t.value),
|
|
|
+ D({
|
|
|
+ value: t
|
|
|
+ }, i)) : t
|
|
|
+ })
|
|
|
+ }(t.data, i)
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ o.push(P({
|
|
|
+ type: "scatter"
|
|
|
+ }, t))
|
|
|
+ }),
|
|
|
+ n.mergeOption(D({
|
|
|
+ series: o
|
|
|
+ }, t.newOption))
|
|
|
+ });
|
|
|
+ var SA = E
|
|
|
+ , MA = _
|
|
|
+ , IA = T
|
|
|
+ , TA = ["dataToPoint", "pointToData"]
|
|
|
+ , AA = ["grid", "xAxis", "yAxis", "geo", "graph", "polar", "radiusAxis", "angleAxis", "bmap"];
|
|
|
+ function DA(t, e, i) {
|
|
|
+ var n = this._targetInfoList = []
|
|
|
+ , o = {}
|
|
|
+ , a = kA(e, t);
|
|
|
+ SA(PA, function(t, e) {
|
|
|
+ i && i.include && !(0 <= MA(i.include, e)) || t(a, n, o)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var CA = DA.prototype;
|
|
|
+ function LA(t) {
|
|
|
+ return t[0] > t[1] && t.reverse(),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ function kA(t, e) {
|
|
|
+ return Ko(t, e, {
|
|
|
+ includeMainTypes: AA
|
|
|
+ })
|
|
|
+ }
|
|
|
+ CA.setOutputRanges = function(t, e) {
|
|
|
+ this.matchOutputRanges(t, e, function(t, e, i) {
|
|
|
+ if ((t.coordRanges || (t.coordRanges = [])).push(e),
|
|
|
+ !t.coordRange) {
|
|
|
+ t.coordRange = e;
|
|
|
+ var n = EA[t.brushType](0, i, e);
|
|
|
+ t.__rangeOffset = {
|
|
|
+ offset: zA[t.brushType](n.values, t.range, [1, 1]),
|
|
|
+ xyMinMax: n.xyMinMax
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ CA.matchOutputRanges = function(t, n, o) {
|
|
|
+ SA(t, function(i) {
|
|
|
+ var t = this.findTargetInfo(i, n);
|
|
|
+ t && !0 !== t && E(t.coordSyses, function(t) {
|
|
|
+ var e = EA[i.brushType](1, t, i.range);
|
|
|
+ o(i, e.values, t, n)
|
|
|
+ })
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ CA.setInputRanges = function(t, o) {
|
|
|
+ SA(t, function(t) {
|
|
|
+ var e = this.findTargetInfo(t, o);
|
|
|
+ if (t.range = t.range || [],
|
|
|
+ e && !0 !== e) {
|
|
|
+ t.panelId = e.panelId;
|
|
|
+ var i = EA[t.brushType](0, e.coordSys, t.coordRange)
|
|
|
+ , n = t.__rangeOffset;
|
|
|
+ t.range = n ? zA[t.brushType](i.values, n.offset, function(t, e) {
|
|
|
+ var i = VA(t)
|
|
|
+ , n = VA(e)
|
|
|
+ , o = [i[0] / n[0], i[1] / n[1]];
|
|
|
+ return isNaN(o[0]) && (o[0] = 1),
|
|
|
+ isNaN(o[1]) && (o[1] = 1),
|
|
|
+ o
|
|
|
+ }(i.xyMinMax, n.xyMinMax)) : i.values
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ CA.makePanelOpts = function(i, n) {
|
|
|
+ return O(this._targetInfoList, function(t) {
|
|
|
+ var e = t.getPanelRect();
|
|
|
+ return {
|
|
|
+ panelId: t.panelId,
|
|
|
+ defaultBrushType: n && n(t),
|
|
|
+ clipPath: eS(e),
|
|
|
+ isTargetByCursor: nS(e, i, t.coordSysModel),
|
|
|
+ getLinearBrushOtherExtent: iS(e)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ CA.controlSeries = function(t, e, i) {
|
|
|
+ var n = this.findTargetInfo(t, i);
|
|
|
+ return !0 === n || n && 0 <= MA(n.coordSyses, e.coordinateSystem)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ CA.findTargetInfo = function(t, e) {
|
|
|
+ for (var i = this._targetInfoList, n = kA(e, t), o = 0; o < i.length; o++) {
|
|
|
+ var a = i[o]
|
|
|
+ , r = t.panelId;
|
|
|
+ if (r) {
|
|
|
+ if (a.panelId === r)
|
|
|
+ return a
|
|
|
+ } else
|
|
|
+ for (o = 0; o < NA.length; o++)
|
|
|
+ if (NA[o](n, a))
|
|
|
+ return a
|
|
|
+ }
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var PA = {
|
|
|
+ grid: function(t, n) {
|
|
|
+ var o = t.xAxisModels
|
|
|
+ , a = t.yAxisModels
|
|
|
+ , e = t.gridModels
|
|
|
+ , i = Q()
|
|
|
+ , r = {}
|
|
|
+ , s = {};
|
|
|
+ (o || a || e) && (SA(o, function(t) {
|
|
|
+ var e = t.axis.grid.model;
|
|
|
+ i.set(e.id, e),
|
|
|
+ r[e.id] = !0
|
|
|
+ }),
|
|
|
+ SA(a, function(t) {
|
|
|
+ var e = t.axis.grid.model;
|
|
|
+ i.set(e.id, e),
|
|
|
+ s[e.id] = !0
|
|
|
+ }),
|
|
|
+ SA(e, function(t) {
|
|
|
+ i.set(t.id, t),
|
|
|
+ r[t.id] = !0,
|
|
|
+ s[t.id] = !0
|
|
|
+ }),
|
|
|
+ i.each(function(t) {
|
|
|
+ var e = t.coordinateSystem
|
|
|
+ , i = [];
|
|
|
+ SA(e.getCartesians(), function(t, e) {
|
|
|
+ (0 <= MA(o, t.getAxis("x").model) || 0 <= MA(a, t.getAxis("y").model)) && i.push(t)
|
|
|
+ }),
|
|
|
+ n.push({
|
|
|
+ panelId: "grid--" + t.id,
|
|
|
+ gridModel: t,
|
|
|
+ coordSysModel: t,
|
|
|
+ coordSys: i[0],
|
|
|
+ coordSyses: i,
|
|
|
+ getPanelRect: OA.grid,
|
|
|
+ xAxisDeclared: r[t.id],
|
|
|
+ yAxisDeclared: s[t.id]
|
|
|
+ })
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ geo: function(t, i) {
|
|
|
+ SA(t.geoModels, function(t) {
|
|
|
+ var e = t.coordinateSystem;
|
|
|
+ i.push({
|
|
|
+ panelId: "geo--" + t.id,
|
|
|
+ geoModel: t,
|
|
|
+ coordSysModel: t,
|
|
|
+ coordSys: e,
|
|
|
+ coordSyses: [e],
|
|
|
+ getPanelRect: OA.geo
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , NA = [function(t, e) {
|
|
|
+ var i = t.xAxisModel
|
|
|
+ , n = t.yAxisModel
|
|
|
+ , o = t.gridModel;
|
|
|
+ return !o && i && (o = i.axis.grid.model),
|
|
|
+ !o && n && (o = n.axis.grid.model),
|
|
|
+ o && o === e.gridModel
|
|
|
+ }
|
|
|
+ , function(t, e) {
|
|
|
+ var i = t.geoModel;
|
|
|
+ return i && i === e.geoModel
|
|
|
+ }
|
|
|
+ ]
|
|
|
+ , OA = {
|
|
|
+ grid: function() {
|
|
|
+ return this.coordSys.grid.getRect().clone()
|
|
|
+ },
|
|
|
+ geo: function() {
|
|
|
+ var t = this.coordSys
|
|
|
+ , e = t.getBoundingRect().clone();
|
|
|
+ return e.applyTransform(fl(t)),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , EA = {
|
|
|
+ lineX: IA(RA, 0),
|
|
|
+ lineY: IA(RA, 1),
|
|
|
+ rect: function(t, e, i) {
|
|
|
+ var n = e[TA[t]]([i[0][0], i[1][0]])
|
|
|
+ , o = e[TA[t]]([i[0][1], i[1][1]])
|
|
|
+ , a = [LA([n[0], o[0]]), LA([n[1], o[1]])];
|
|
|
+ return {
|
|
|
+ values: a,
|
|
|
+ xyMinMax: a
|
|
|
+ }
|
|
|
+ },
|
|
|
+ polygon: function(i, n, t) {
|
|
|
+ var o = [[1 / 0, -1 / 0], [1 / 0, -1 / 0]];
|
|
|
+ return {
|
|
|
+ values: O(t, function(t) {
|
|
|
+ var e = n[TA[i]](t);
|
|
|
+ return o[0][0] = Math.min(o[0][0], e[0]),
|
|
|
+ o[1][0] = Math.min(o[1][0], e[1]),
|
|
|
+ o[0][1] = Math.max(o[0][1], e[0]),
|
|
|
+ o[1][1] = Math.max(o[1][1], e[1]),
|
|
|
+ e
|
|
|
+ }),
|
|
|
+ xyMinMax: o
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function RA(t, e, i, n) {
|
|
|
+ var o = i.getAxis(["x", "y"][t])
|
|
|
+ , a = LA(O([0, 1], function(t) {
|
|
|
+ return e ? o.coordToData(o.toLocalCoord(n[t])) : o.toGlobalCoord(o.dataToCoord(n[t]))
|
|
|
+ }))
|
|
|
+ , r = [];
|
|
|
+ return r[t] = a,
|
|
|
+ r[1 - t] = [NaN, NaN],
|
|
|
+ {
|
|
|
+ values: a,
|
|
|
+ xyMinMax: r
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var zA = {
|
|
|
+ lineX: IA(BA, 0),
|
|
|
+ lineY: IA(BA, 1),
|
|
|
+ rect: function(t, e, i) {
|
|
|
+ return [[t[0][0] - i[0] * e[0][0], t[0][1] - i[0] * e[0][1]], [t[1][0] - i[1] * e[1][0], t[1][1] - i[1] * e[1][1]]]
|
|
|
+ },
|
|
|
+ polygon: function(t, i, n) {
|
|
|
+ return O(t, function(t, e) {
|
|
|
+ return [t[0] - n[0] * i[e][0], t[1] - n[1] * i[e][1]]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function BA(t, e, i, n) {
|
|
|
+ return [e[0] - n[t] * i[0], e[1] - n[t] * i[1]]
|
|
|
+ }
|
|
|
+ function VA(t) {
|
|
|
+ return t ? [t[0][1] - t[0][0], t[1][1] - t[1][0]] : [NaN, NaN]
|
|
|
+ }
|
|
|
+ var GA = E
|
|
|
+ , FA = "\0_ec_hist_store";
|
|
|
+ function WA(t) {
|
|
|
+ var e = t[FA];
|
|
|
+ return e = e || (t[FA] = [{}])
|
|
|
+ }
|
|
|
+ ku.registerSubTypeDefaulter("dataZoom", function() {
|
|
|
+ return "slider"
|
|
|
+ });
|
|
|
+ var HA = ["cartesian2d", "polar", "singleAxis"];
|
|
|
+ var ZA, UA, XA, YA, jA = (UA = ["axisIndex", "axis", "index", "id"],
|
|
|
+ XA = O(ZA = (ZA = ["x", "y", "z", "radius", "angle", "single"]).slice(), fu),
|
|
|
+ YA = O(UA = (UA || []).slice(), fu),
|
|
|
+ function(o, a) {
|
|
|
+ E(ZA, function(t, e) {
|
|
|
+ for (var i = {
|
|
|
+ name: t,
|
|
|
+ capital: XA[e]
|
|
|
+ }, n = 0; n < UA.length; n++)
|
|
|
+ i[UA[n]] = t + YA[n];
|
|
|
+ o.call(a, i)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ );
|
|
|
+ function qA(o, a, r) {
|
|
|
+ return function(t) {
|
|
|
+ var e, i = {
|
|
|
+ nodes: [],
|
|
|
+ records: {}
|
|
|
+ };
|
|
|
+ if (a(function(t) {
|
|
|
+ i.records[t.name] = {}
|
|
|
+ }),
|
|
|
+ !t)
|
|
|
+ return i;
|
|
|
+ for (s(t, i); e = !1,
|
|
|
+ o(n),
|
|
|
+ e; )
|
|
|
+ ;
|
|
|
+ function n(t) {
|
|
|
+ !function(t, e) {
|
|
|
+ return 0 <= _(e.nodes, t)
|
|
|
+ }(t, i) && function(t, i) {
|
|
|
+ var n = !1;
|
|
|
+ return a(function(e) {
|
|
|
+ E(r(t, e) || [], function(t) {
|
|
|
+ i.records[e.name][t] && (n = !0)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }(t, i) && (s(t, i),
|
|
|
+ e = !0)
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function s(t, i) {
|
|
|
+ i.nodes.push(t),
|
|
|
+ a(function(e) {
|
|
|
+ E(r(t, e) || [], function(t) {
|
|
|
+ i.records[e.name][t] = !0
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function KA(t, e, i, n) {
|
|
|
+ this._dimName = t,
|
|
|
+ this._axisIndex = e,
|
|
|
+ this._valueWindow,
|
|
|
+ this._percentWindow,
|
|
|
+ this._dataExtent,
|
|
|
+ this._minMaxSpan,
|
|
|
+ this.ecModel = n,
|
|
|
+ this._dataZoomModel = i
|
|
|
+ }
|
|
|
+ var $A = E
|
|
|
+ , JA = Bl;
|
|
|
+ function QA(t, e) {
|
|
|
+ var i = t.getAxisModel()
|
|
|
+ , n = t._percentWindow
|
|
|
+ , o = t._valueWindow;
|
|
|
+ if (n) {
|
|
|
+ var a = Fl(o, [0, 500]);
|
|
|
+ a = Math.min(a, 20);
|
|
|
+ var r = e || 0 === n[0] && 100 === n[1];
|
|
|
+ i.setRange(r ? null : +o[0].toFixed(a), r ? null : +o[1].toFixed(a))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ KA.prototype = {
|
|
|
+ constructor: KA,
|
|
|
+ hostedBy: function(t) {
|
|
|
+ return this._dataZoomModel === t
|
|
|
+ },
|
|
|
+ getDataValueWindow: function() {
|
|
|
+ return this._valueWindow.slice()
|
|
|
+ },
|
|
|
+ getDataPercentWindow: function() {
|
|
|
+ return this._percentWindow.slice()
|
|
|
+ },
|
|
|
+ getTargetSeriesModels: function() {
|
|
|
+ var n = []
|
|
|
+ , o = this.ecModel;
|
|
|
+ return o.eachSeries(function(t) {
|
|
|
+ if (function(t) {
|
|
|
+ return 0 <= _(HA, t)
|
|
|
+ }(t.get("coordinateSystem"))) {
|
|
|
+ var e = this._dimName
|
|
|
+ , i = o.queryComponents({
|
|
|
+ mainType: e + "Axis",
|
|
|
+ index: t.get(e + "AxisIndex"),
|
|
|
+ id: t.get(e + "AxisId")
|
|
|
+ })[0];
|
|
|
+ this._axisIndex === (i && i.componentIndex) && n.push(t)
|
|
|
+ }
|
|
|
+ }, this),
|
|
|
+ n
|
|
|
+ },
|
|
|
+ getAxisModel: function() {
|
|
|
+ return this.ecModel.getComponent(this._dimName + "Axis", this._axisIndex)
|
|
|
+ },
|
|
|
+ getOtherAxisModel: function() {
|
|
|
+ var t, e, i, n = this._dimName, o = this.ecModel, a = this.getAxisModel();
|
|
|
+ return t = "x" === n || "y" === n ? (e = "gridIndex",
|
|
|
+ "x" === n ? "y" : "x") : (e = "polarIndex",
|
|
|
+ "angle" === n ? "radius" : "angle"),
|
|
|
+ o.eachComponent(t + "Axis", function(t) {
|
|
|
+ (t.get(e) || 0) === (a.get(e) || 0) && (i = t)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ getMinMaxSpan: function() {
|
|
|
+ return k(this._minMaxSpan)
|
|
|
+ },
|
|
|
+ calculateDataWindow: function(o) {
|
|
|
+ var a, r = this._dataExtent, s = this.getAxisModel().axis.scale, l = this._dataZoomModel.getRangePropMode(), u = [0, 100], h = [], c = [];
|
|
|
+ $A(["start", "end"], function(t, e) {
|
|
|
+ var i = o[t]
|
|
|
+ , n = o[t + "Value"];
|
|
|
+ "percent" === l[e] ? (null == i && (i = u[e]),
|
|
|
+ n = s.parse(El(i, u, r))) : (a = !0,
|
|
|
+ i = El(n = null == n ? r[e] : s.parse(n), r, u)),
|
|
|
+ c[e] = n,
|
|
|
+ h[e] = i
|
|
|
+ }),
|
|
|
+ JA(c),
|
|
|
+ JA(h);
|
|
|
+ var d = this._minMaxSpan;
|
|
|
+ function t(t, e, i, n, o) {
|
|
|
+ var a = o ? "Span" : "ValueSpan";
|
|
|
+ Jw(0, t, i, "all", d["min" + a], d["max" + a]);
|
|
|
+ for (var r = 0; r < 2; r++)
|
|
|
+ e[r] = El(t[r], i, n, !0),
|
|
|
+ o && (e[r] = s.parse(e[r]))
|
|
|
+ }
|
|
|
+ return a ? t(c, h, r, u, !1) : t(h, c, u, r, !0),
|
|
|
+ {
|
|
|
+ valueWindow: c,
|
|
|
+ percentWindow: h
|
|
|
+ }
|
|
|
+ },
|
|
|
+ reset: function(t) {
|
|
|
+ if (t === this._dataZoomModel) {
|
|
|
+ var e = this.getTargetSeriesModels();
|
|
|
+ this._dataExtent = function(t, e, i) {
|
|
|
+ var n = [1 / 0, -1 / 0];
|
|
|
+ $A(i, function(t) {
|
|
|
+ var i = t.getData();
|
|
|
+ i && $A(i.mapDimension(e, !0), function(t) {
|
|
|
+ var e = i.getApproximateExtent(t);
|
|
|
+ e[0] < n[0] && (n[0] = e[0]),
|
|
|
+ e[1] > n[1] && (n[1] = e[1])
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ n[1] < n[0] && (n = [NaN, NaN]);
|
|
|
+ return function(t, e) {
|
|
|
+ var i = t.getAxisModel()
|
|
|
+ , n = i.getMin(!0)
|
|
|
+ , o = "category" === i.get("type")
|
|
|
+ , a = o && i.getCategories().length;
|
|
|
+ null != n && "dataMin" !== n && "function" != typeof n ? e[0] = n : o && (e[0] = 0 < a ? 0 : NaN);
|
|
|
+ var r = i.getMax(!0);
|
|
|
+ null != r && "dataMax" !== r && "function" != typeof r ? e[1] = r : o && (e[1] = 0 < a ? a - 1 : NaN);
|
|
|
+ i.get("scale", !0) || (0 < e[0] && (e[0] = 0),
|
|
|
+ e[1] < 0 && (e[1] = 0))
|
|
|
+ }(t, n),
|
|
|
+ n
|
|
|
+ }(this, this._dimName, e),
|
|
|
+ function(n) {
|
|
|
+ var o = n._minMaxSpan = {}
|
|
|
+ , a = n._dataZoomModel
|
|
|
+ , r = n._dataExtent;
|
|
|
+ $A(["min", "max"], function(t) {
|
|
|
+ var e = a.get(t + "Span")
|
|
|
+ , i = a.get(t + "ValueSpan");
|
|
|
+ null != i && (i = n.getAxisModel().axis.scale.parse(i)),
|
|
|
+ null != i ? e = El(r[0] + i, r, [0, 100], !0) : null != e && (i = El(e, [0, 100], r, !0) - r[0]),
|
|
|
+ o[t + "Span"] = e,
|
|
|
+ o[t + "ValueSpan"] = i
|
|
|
+ })
|
|
|
+ }(this);
|
|
|
+ var i = this.calculateDataWindow(t.settledOption);
|
|
|
+ this._valueWindow = i.valueWindow,
|
|
|
+ this._percentWindow = i.percentWindow,
|
|
|
+ QA(this)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ restore: function(t) {
|
|
|
+ t === this._dataZoomModel && (this._valueWindow = this._percentWindow = null,
|
|
|
+ QA(this, !0))
|
|
|
+ },
|
|
|
+ filterData: function(t, e) {
|
|
|
+ if (t === this._dataZoomModel) {
|
|
|
+ var n = this._dimName
|
|
|
+ , i = this.getTargetSeriesModels()
|
|
|
+ , o = t.get("filterMode")
|
|
|
+ , c = this._valueWindow;
|
|
|
+ "none" !== o && $A(i, function(i) {
|
|
|
+ var u = i.getData()
|
|
|
+ , h = u.mapDimension(n, !0);
|
|
|
+ h.length && ("weakFilter" === o ? u.filterSelf(function(t) {
|
|
|
+ for (var e, i, n, o = 0; o < h.length; o++) {
|
|
|
+ var a = u.get(h[o], t)
|
|
|
+ , r = !isNaN(a)
|
|
|
+ , s = a < c[0]
|
|
|
+ , l = a > c[1];
|
|
|
+ if (r && !s && !l)
|
|
|
+ return !0;
|
|
|
+ r && (n = !0),
|
|
|
+ s && (e = !0),
|
|
|
+ l && (i = !0)
|
|
|
+ }
|
|
|
+ return n && e && i
|
|
|
+ }) : $A(h, function(t) {
|
|
|
+ if ("empty" === o)
|
|
|
+ i.setData(u = u.map(t, function(t) {
|
|
|
+ return function(t) {
|
|
|
+ return t >= c[0] && t <= c[1]
|
|
|
+ }(t) ? t : NaN
|
|
|
+ }));
|
|
|
+ else {
|
|
|
+ var e = {};
|
|
|
+ e[t] = c,
|
|
|
+ u.selectRange(e)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ $A(h, function(t) {
|
|
|
+ u.setApproximateExtent(c, t)
|
|
|
+ }))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var tD = E
|
|
|
+ , eD = jA
|
|
|
+ , iD = Tf({
|
|
|
+ type: "dataZoom",
|
|
|
+ dependencies: ["xAxis", "yAxis", "zAxis", "radiusAxis", "angleAxis", "singleAxis", "series"],
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 4,
|
|
|
+ orient: null,
|
|
|
+ xAxisIndex: null,
|
|
|
+ yAxisIndex: null,
|
|
|
+ filterMode: "filter",
|
|
|
+ throttle: null,
|
|
|
+ start: 0,
|
|
|
+ end: 100,
|
|
|
+ startValue: null,
|
|
|
+ endValue: null,
|
|
|
+ minSpan: null,
|
|
|
+ maxSpan: null,
|
|
|
+ minValueSpan: null,
|
|
|
+ maxValueSpan: null,
|
|
|
+ rangeMode: null
|
|
|
+ },
|
|
|
+ init: function(t, e, i) {
|
|
|
+ this._dataIntervalByAxis = {},
|
|
|
+ this._dataInfo = {},
|
|
|
+ this._axisProxies = {},
|
|
|
+ this.textStyleModel,
|
|
|
+ this._autoThrottle = !0,
|
|
|
+ this._rangePropMode = ["percent", "percent"];
|
|
|
+ var n = nD(t);
|
|
|
+ this.settledOption = n,
|
|
|
+ this.mergeDefaultAndTheme(t, i),
|
|
|
+ this.doInit(n)
|
|
|
+ },
|
|
|
+ mergeOption: function(t) {
|
|
|
+ var e = nD(t);
|
|
|
+ m(this.option, t, !0),
|
|
|
+ m(this.settledOption, e, !0),
|
|
|
+ this.doInit(e)
|
|
|
+ },
|
|
|
+ doInit: function(t) {
|
|
|
+ var i = this.option;
|
|
|
+ v.canvasSupported || (i.realtime = !1),
|
|
|
+ this._setDefaultThrottle(t),
|
|
|
+ oD(this, t);
|
|
|
+ var n = this.settledOption;
|
|
|
+ tD([["start", "startValue"], ["end", "endValue"]], function(t, e) {
|
|
|
+ "value" === this._rangePropMode[e] && (i[t[0]] = n[t[0]] = null)
|
|
|
+ }, this),
|
|
|
+ this.textStyleModel = this.getModel("textStyle"),
|
|
|
+ this._resetTarget(),
|
|
|
+ this._giveAxisProxies()
|
|
|
+ },
|
|
|
+ _giveAxisProxies: function() {
|
|
|
+ var r = this._axisProxies;
|
|
|
+ this.eachTargetAxis(function(t, e, i, n) {
|
|
|
+ var o = this.dependentModels[t.axis][e]
|
|
|
+ , a = o.__dzAxisProxy || (o.__dzAxisProxy = new KA(t.name,e,this,n));
|
|
|
+ r[t.name + "_" + e] = a
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _resetTarget: function() {
|
|
|
+ var i = this.option
|
|
|
+ , t = this._judgeAutoMode();
|
|
|
+ eD(function(t) {
|
|
|
+ var e = t.axisIndex;
|
|
|
+ i[e] = Vo(i[e])
|
|
|
+ }, this),
|
|
|
+ "axisIndex" === t ? this._autoSetAxisIndex() : "orient" === t && this._autoSetOrient()
|
|
|
+ },
|
|
|
+ _judgeAutoMode: function() {
|
|
|
+ var e = this.option
|
|
|
+ , i = !1;
|
|
|
+ eD(function(t) {
|
|
|
+ null != e[t.axisIndex] && (i = !0)
|
|
|
+ }, this);
|
|
|
+ var t = e.orient;
|
|
|
+ return null == t && i ? "orient" : i ? void 0 : (null == t && (e.orient = "horizontal"),
|
|
|
+ "axisIndex")
|
|
|
+ },
|
|
|
+ _autoSetAxisIndex: function() {
|
|
|
+ var a = !0
|
|
|
+ , e = this.get("orient", !0)
|
|
|
+ , r = this.option
|
|
|
+ , t = this.dependentModels;
|
|
|
+ if (a) {
|
|
|
+ var i = "vertical" === e ? "y" : "x";
|
|
|
+ t[i + "Axis"].length ? (r[i + "AxisIndex"] = [0],
|
|
|
+ a = !1) : tD(t.singleAxis, function(t) {
|
|
|
+ a && t.get("orient", !0) === e && (r.singleAxisIndex = [t.componentIndex],
|
|
|
+ a = !1)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ a && eD(function(t) {
|
|
|
+ if (a) {
|
|
|
+ var e = []
|
|
|
+ , i = this.dependentModels[t.axis];
|
|
|
+ if (i.length && !e.length)
|
|
|
+ for (var n = 0, o = i.length; n < o; n++)
|
|
|
+ "category" === i[n].get("type") && e.push(n);
|
|
|
+ (r[t.axisIndex] = e).length && (a = !1)
|
|
|
+ }
|
|
|
+ }, this),
|
|
|
+ a && this.ecModel.eachSeries(function(o) {
|
|
|
+ this._isSeriesHasAllAxesTypeOf(o, "value") && eD(function(t) {
|
|
|
+ var e = r[t.axisIndex]
|
|
|
+ , i = o.get(t.axisIndex)
|
|
|
+ , n = o.get(t.axisId);
|
|
|
+ _(e, i = o.ecModel.queryComponents({
|
|
|
+ mainType: t.axis,
|
|
|
+ index: i,
|
|
|
+ id: n
|
|
|
+ })[0].componentIndex) < 0 && e.push(i)
|
|
|
+ })
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _autoSetOrient: function() {
|
|
|
+ var e;
|
|
|
+ this.eachTargetAxis(function(t) {
|
|
|
+ e = e || t.name
|
|
|
+ }, this),
|
|
|
+ this.option.orient = "y" === e ? "vertical" : "horizontal"
|
|
|
+ },
|
|
|
+ _isSeriesHasAllAxesTypeOf: function(n, o) {
|
|
|
+ var a = !0;
|
|
|
+ return eD(function(t) {
|
|
|
+ var e = n.get(t.axisIndex)
|
|
|
+ , i = this.dependentModels[t.axis][e];
|
|
|
+ i && i.get("type") === o || (a = !1)
|
|
|
+ }, this),
|
|
|
+ a
|
|
|
+ },
|
|
|
+ _setDefaultThrottle: function(t) {
|
|
|
+ if (t.hasOwnProperty("throttle") && (this._autoThrottle = !1),
|
|
|
+ this._autoThrottle) {
|
|
|
+ var e = this.ecModel.option;
|
|
|
+ this.option.throttle = e.animation && 0 < e.animationDurationUpdate ? 100 : 20
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getFirstTargetAxisModel: function() {
|
|
|
+ var i;
|
|
|
+ return eD(function(t) {
|
|
|
+ if (null == i) {
|
|
|
+ var e = this.get(t.axisIndex);
|
|
|
+ e.length && (i = this.dependentModels[t.axis][e[0]])
|
|
|
+ }
|
|
|
+ }, this),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ eachTargetAxis: function(i, n) {
|
|
|
+ var o = this.ecModel;
|
|
|
+ eD(function(e) {
|
|
|
+ tD(this.get(e.axisIndex), function(t) {
|
|
|
+ i.call(n, e, t, this, o)
|
|
|
+ }, this)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ getAxisProxy: function(t, e) {
|
|
|
+ return this._axisProxies[t + "_" + e]
|
|
|
+ },
|
|
|
+ getAxisModel: function(t, e) {
|
|
|
+ var i = this.getAxisProxy(t, e);
|
|
|
+ return i && i.getAxisModel()
|
|
|
+ },
|
|
|
+ setRawRange: function(e) {
|
|
|
+ var i = this.option
|
|
|
+ , n = this.settledOption;
|
|
|
+ tD([["start", "startValue"], ["end", "endValue"]], function(t) {
|
|
|
+ null == e[t[0]] && null == e[t[1]] || (i[t[0]] = n[t[0]] = e[t[0]],
|
|
|
+ i[t[1]] = n[t[1]] = e[t[1]])
|
|
|
+ }, this),
|
|
|
+ oD(this, e)
|
|
|
+ },
|
|
|
+ setCalculatedRange: function(e) {
|
|
|
+ var i = this.option;
|
|
|
+ tD(["start", "startValue", "end", "endValue"], function(t) {
|
|
|
+ i[t] = e[t]
|
|
|
+ })
|
|
|
+ },
|
|
|
+ getPercentRange: function() {
|
|
|
+ var t = this.findRepresentativeAxisProxy();
|
|
|
+ if (t)
|
|
|
+ return t.getDataPercentWindow()
|
|
|
+ },
|
|
|
+ getValueRange: function(t, e) {
|
|
|
+ if (null != t || null != e)
|
|
|
+ return this.getAxisProxy(t, e).getDataValueWindow();
|
|
|
+ var i = this.findRepresentativeAxisProxy();
|
|
|
+ return i ? i.getDataValueWindow() : void 0
|
|
|
+ },
|
|
|
+ findRepresentativeAxisProxy: function(t) {
|
|
|
+ if (t)
|
|
|
+ return t.__dzAxisProxy;
|
|
|
+ var e = this._axisProxies;
|
|
|
+ for (var i in e)
|
|
|
+ if (e.hasOwnProperty(i) && e[i].hostedBy(this))
|
|
|
+ return e[i];
|
|
|
+ for (var i in e)
|
|
|
+ if (e.hasOwnProperty(i) && !e[i].hostedBy(this))
|
|
|
+ return e[i]
|
|
|
+ },
|
|
|
+ getRangePropMode: function() {
|
|
|
+ return this._rangePropMode.slice()
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function nD(e) {
|
|
|
+ var i = {};
|
|
|
+ return tD(["start", "end", "startValue", "endValue", "throttle"], function(t) {
|
|
|
+ e.hasOwnProperty(t) && (i[t] = e[t])
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function oD(t, o) {
|
|
|
+ var a = t._rangePropMode
|
|
|
+ , r = t.get("rangeMode");
|
|
|
+ tD([["start", "startValue"], ["end", "endValue"]], function(t, e) {
|
|
|
+ var i = null != o[t[0]]
|
|
|
+ , n = null != o[t[1]];
|
|
|
+ i && !n ? a[e] = "percent" : !i && n ? a[e] = "value" : r ? a[e] = r[e] : i && (a[e] = "percent")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var aD = gc.extend({
|
|
|
+ type: "dataZoom",
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ this.dataZoomModel = t,
|
|
|
+ this.ecModel = e,
|
|
|
+ this.api = i
|
|
|
+ },
|
|
|
+ getTargetCoordInfo: function() {
|
|
|
+ var t = this.dataZoomModel
|
|
|
+ , o = this.ecModel
|
|
|
+ , a = {};
|
|
|
+ return t.eachTargetAxis(function(t, e) {
|
|
|
+ var i = o.getComponent(t.axis, e);
|
|
|
+ if (i) {
|
|
|
+ var n = i.getCoordSysModel();
|
|
|
+ n && function(t, e, i, n) {
|
|
|
+ for (var o, a = 0; a < i.length; a++)
|
|
|
+ if (i[a].model === t) {
|
|
|
+ o = i[a];
|
|
|
+ break
|
|
|
+ }
|
|
|
+ o || i.push(o = {
|
|
|
+ model: t,
|
|
|
+ axisModels: [],
|
|
|
+ coordIndex: n
|
|
|
+ });
|
|
|
+ o.axisModels.push(e)
|
|
|
+ }(n, i, a[n.mainType] || (a[n.mainType] = []), n.componentIndex)
|
|
|
+ }
|
|
|
+ }, this),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ });
|
|
|
+ iD.extend({
|
|
|
+ type: "dataZoom.select"
|
|
|
+ }),
|
|
|
+ aD.extend({
|
|
|
+ type: "dataZoom.select"
|
|
|
+ }),
|
|
|
+ xf({
|
|
|
+ getTargetSeries: function(t) {
|
|
|
+ var n = Q();
|
|
|
+ return t.eachComponent("dataZoom", function(t) {
|
|
|
+ t.eachTargetAxis(function(t, e, i) {
|
|
|
+ E(i.getAxisProxy(t.name, e).getTargetSeriesModels(), function(t) {
|
|
|
+ n.set(t.uid, t)
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ },
|
|
|
+ modifyOutputEnd: !0,
|
|
|
+ overallReset: function(t, n) {
|
|
|
+ t.eachComponent("dataZoom", function(t) {
|
|
|
+ t.eachTargetAxis(function(t, e, i) {
|
|
|
+ i.getAxisProxy(t.name, e).reset(i, n)
|
|
|
+ }),
|
|
|
+ t.eachTargetAxis(function(t, e, i) {
|
|
|
+ i.getAxisProxy(t.name, e).filterData(i, n)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ t.eachComponent("dataZoom", function(t) {
|
|
|
+ var e = t.findRepresentativeAxisProxy()
|
|
|
+ , i = e.getDataPercentWindow()
|
|
|
+ , n = e.getDataValueWindow();
|
|
|
+ t.setCalculatedRange({
|
|
|
+ start: i[0],
|
|
|
+ end: i[1],
|
|
|
+ startValue: n[0],
|
|
|
+ endValue: n[1]
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _f("dataZoom", function(i, t) {
|
|
|
+ var n = qA(A(t.eachComponent, t, "dataZoom"), jA, function(t, e) {
|
|
|
+ return t.get(e.axisIndex)
|
|
|
+ })
|
|
|
+ , o = [];
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "dataZoom",
|
|
|
+ query: i
|
|
|
+ }, function(t, e) {
|
|
|
+ o.push.apply(o, n(t).nodes)
|
|
|
+ }),
|
|
|
+ E(o, function(t, e) {
|
|
|
+ t.setRawRange({
|
|
|
+ start: i.start,
|
|
|
+ end: i.end,
|
|
|
+ startValue: i.startValue,
|
|
|
+ endValue: i.endValue
|
|
|
+ })
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var rD = Oc.toolbox.dataZoom
|
|
|
+ , sD = E;
|
|
|
+ function lD(t, e, i) {
|
|
|
+ (this._brushController = new Ib(i.getZr())).on("brush", A(this._onBrush, this)).mount(),
|
|
|
+ this._isZoomActive
|
|
|
+ }
|
|
|
+ lD.defaultOption = {
|
|
|
+ show: !0,
|
|
|
+ filterMode: "filter",
|
|
|
+ icon: {
|
|
|
+ zoom: "M0,13.5h26.9 M13.5,26.9V0 M32.1,13.5H58V58H13.5 V32.1",
|
|
|
+ back: "M22,1.4L9.9,13.5l12.3,12.3 M10.3,13.5H54.9v44.6 H10.3v-26"
|
|
|
+ },
|
|
|
+ title: k(rD.title)
|
|
|
+ };
|
|
|
+ var uD = lD.prototype;
|
|
|
+ uD.render = function(t, e, i, n) {
|
|
|
+ this.model = t,
|
|
|
+ this.ecModel = e,
|
|
|
+ this.api = i,
|
|
|
+ function(t, e, i, n, o) {
|
|
|
+ var a = i._isZoomActive;
|
|
|
+ n && "takeGlobalCursor" === n.type && (a = "dataZoomSelect" === n.key && n.dataZoomSelectActive);
|
|
|
+ i._isZoomActive = a,
|
|
|
+ t.setIconStatus("zoom", a ? "emphasis" : "normal");
|
|
|
+ var r = new DA(cD(t.option),e,{
|
|
|
+ include: ["grid"]
|
|
|
+ });
|
|
|
+ i._brushController.setPanels(r.makePanelOpts(o, function(t) {
|
|
|
+ return t.xAxisDeclared && !t.yAxisDeclared ? "lineX" : !t.xAxisDeclared && t.yAxisDeclared ? "lineY" : "rect"
|
|
|
+ })).enableBrush(!!a && {
|
|
|
+ brushType: "auto",
|
|
|
+ brushStyle: {
|
|
|
+ lineWidth: 0,
|
|
|
+ fill: "rgba(0,0,0,0.2)"
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }(t, e, this, n, i),
|
|
|
+ function(t, e) {
|
|
|
+ t.setIconStatus("back", 1 < function(t) {
|
|
|
+ return WA(t).length
|
|
|
+ }(e) ? "emphasis" : "normal")
|
|
|
+ }(t, e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ uD.onclick = function(t, e, i) {
|
|
|
+ hD[i].call(this)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ uD.remove = function(t, e) {
|
|
|
+ this._brushController.unmount()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ uD.dispose = function(t, e) {
|
|
|
+ this._brushController.dispose()
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var hD = {
|
|
|
+ zoom: function() {
|
|
|
+ var t = !this._isZoomActive;
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "takeGlobalCursor",
|
|
|
+ key: "dataZoomSelect",
|
|
|
+ dataZoomSelectActive: t
|
|
|
+ })
|
|
|
+ },
|
|
|
+ back: function() {
|
|
|
+ this._dispatchZoomAction(function(t) {
|
|
|
+ var n = WA(t)
|
|
|
+ , e = n[n.length - 1];
|
|
|
+ 1 < n.length && n.pop();
|
|
|
+ var o = {};
|
|
|
+ return GA(e, function(t, e) {
|
|
|
+ for (var i = n.length - 1; 0 <= i; i--) {
|
|
|
+ if (t = n[i][e]) {
|
|
|
+ o[e] = t;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ o
|
|
|
+ }(this.ecModel))
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function cD(e) {
|
|
|
+ var i = {};
|
|
|
+ return E(["xAxisIndex", "yAxisIndex"], function(t) {
|
|
|
+ i[t] = e[t],
|
|
|
+ null == i[t] && (i[t] = "all"),
|
|
|
+ !1 !== i[t] && "none" !== i[t] || (i[t] = [])
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ uD._onBrush = function(t, e) {
|
|
|
+ if (e.isEnd && t.length) {
|
|
|
+ var s = {}
|
|
|
+ , l = this.ecModel;
|
|
|
+ this._brushController.updateCovers([]),
|
|
|
+ new DA(cD(this.model.option),l,{
|
|
|
+ include: ["grid"]
|
|
|
+ }).matchOutputRanges(t, l, function(t, e, i) {
|
|
|
+ if ("cartesian2d" === i.type) {
|
|
|
+ var n = t.brushType;
|
|
|
+ "rect" === n ? (o("x", i, e[0]),
|
|
|
+ o("y", i, e[1])) : o({
|
|
|
+ lineX: "x",
|
|
|
+ lineY: "y"
|
|
|
+ }[n], i, e)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ function(a, t) {
|
|
|
+ var r = WA(a);
|
|
|
+ GA(t, function(t, e) {
|
|
|
+ for (var i = r.length - 1; 0 <= i; i--) {
|
|
|
+ if (r[i][e])
|
|
|
+ break
|
|
|
+ }
|
|
|
+ if (i < 0) {
|
|
|
+ var n = a.queryComponents({
|
|
|
+ mainType: "dataZoom",
|
|
|
+ subType: "select",
|
|
|
+ id: e
|
|
|
+ })[0];
|
|
|
+ if (n) {
|
|
|
+ var o = n.getPercentRange();
|
|
|
+ r[0][e] = {
|
|
|
+ dataZoomId: e,
|
|
|
+ start: o[0],
|
|
|
+ end: o[1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ r.push(t)
|
|
|
+ }(l, s),
|
|
|
+ this._dispatchZoomAction(s)
|
|
|
+ }
|
|
|
+ function o(t, e, i) {
|
|
|
+ var n = e.getAxis(t)
|
|
|
+ , o = n.model
|
|
|
+ , a = function(e, i, t) {
|
|
|
+ var n;
|
|
|
+ return t.eachComponent({
|
|
|
+ mainType: "dataZoom",
|
|
|
+ subType: "select"
|
|
|
+ }, function(t) {
|
|
|
+ t.getAxisModel(e, i.componentIndex) && (n = t)
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }(t, o, l)
|
|
|
+ , r = a.findRepresentativeAxisProxy(o).getMinMaxSpan();
|
|
|
+ null == r.minValueSpan && null == r.maxValueSpan || (i = Jw(0, i.slice(), n.scale.getExtent(), 0, r.minValueSpan, r.maxValueSpan)),
|
|
|
+ a && (s[a.id] = {
|
|
|
+ dataZoomId: a.id,
|
|
|
+ startValue: i[0],
|
|
|
+ endValue: i[1]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ uD._dispatchZoomAction = function(t) {
|
|
|
+ var i = [];
|
|
|
+ sD(t, function(t, e) {
|
|
|
+ i.push(k(t))
|
|
|
+ }),
|
|
|
+ i.length && this.api.dispatchAction({
|
|
|
+ type: "dataZoom",
|
|
|
+ from: this.uid,
|
|
|
+ batch: i
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nA("dataZoom", lD),
|
|
|
+ yf(function(s) {
|
|
|
+ if (s) {
|
|
|
+ var l = s.dataZoom || (s.dataZoom = []);
|
|
|
+ L(l) || (s.dataZoom = l = [l]);
|
|
|
+ var t = s.toolbox;
|
|
|
+ if (t && (L(t) && (t = t[0]),
|
|
|
+ t && t.feature)) {
|
|
|
+ var e = t.feature.dataZoom;
|
|
|
+ i("xAxis", e),
|
|
|
+ i("yAxis", e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function i(n, o) {
|
|
|
+ if (o) {
|
|
|
+ var a = n + "Index"
|
|
|
+ , r = o[a];
|
|
|
+ null == r || "all" === r || L(r) || (r = !1 === r || "none" === r ? [] : [r]),
|
|
|
+ function(t, e) {
|
|
|
+ var i = s[t];
|
|
|
+ L(i) || (i = i ? [i] : []);
|
|
|
+ sD(i, e)
|
|
|
+ }(n, function(t, e) {
|
|
|
+ if (null == r || "all" === r || -1 !== _(r, e)) {
|
|
|
+ var i = {
|
|
|
+ type: "select",
|
|
|
+ $fromToolbox: !0,
|
|
|
+ filterMode: o.filterMode || "filter",
|
|
|
+ id: "\0_ec_\0toolbox-dataZoom_" + n + e
|
|
|
+ };
|
|
|
+ i[a] = e,
|
|
|
+ l.push(i)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var dD = Oc.toolbox.restore;
|
|
|
+ function fD(t) {
|
|
|
+ this.model = t
|
|
|
+ }
|
|
|
+ fD.defaultOption = {
|
|
|
+ show: !0,
|
|
|
+ icon: "M3.8,33.4 M47,18.9h9.8V8.7 M56.3,20.1 C52.1,9,40.5,0.6,26.8,2.1C12.6,3.7,1.6,16.2,2.1,30.6 M13,41.1H3.1v10.2 M3.7,39.9c4.2,11.1,15.8,19.5,29.5,18 c14.2-1.6,25.2-14.1,24.7-28.5",
|
|
|
+ title: dD.title
|
|
|
+ },
|
|
|
+ fD.prototype.onclick = function(t, e, i) {
|
|
|
+ !function(t) {
|
|
|
+ t[FA] = null
|
|
|
+ }(t),
|
|
|
+ e.dispatchAction({
|
|
|
+ type: "restore",
|
|
|
+ from: this.uid
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nA("restore", fD),
|
|
|
+ _f({
|
|
|
+ type: "restore",
|
|
|
+ event: "restore",
|
|
|
+ update: "prepareAndUpdate"
|
|
|
+ }, function(t, e) {
|
|
|
+ e.resetOption("recreate")
|
|
|
+ }),
|
|
|
+ Tf({
|
|
|
+ type: "tooltip",
|
|
|
+ dependencies: ["axisPointer"],
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 60,
|
|
|
+ show: !0,
|
|
|
+ showContent: !0,
|
|
|
+ trigger: "item",
|
|
|
+ triggerOn: "mousemove|click",
|
|
|
+ alwaysShowContent: !1,
|
|
|
+ displayMode: "single",
|
|
|
+ renderMode: "auto",
|
|
|
+ confine: !1,
|
|
|
+ showDelay: 0,
|
|
|
+ hideDelay: 100,
|
|
|
+ transitionDuration: .4,
|
|
|
+ enterable: !1,
|
|
|
+ backgroundColor: "rgba(50,50,50,0.7)",
|
|
|
+ borderColor: "#333",
|
|
|
+ borderRadius: 4,
|
|
|
+ borderWidth: 0,
|
|
|
+ padding: 5,
|
|
|
+ extraCssText: "",
|
|
|
+ axisPointer: {
|
|
|
+ type: "line",
|
|
|
+ axis: "auto",
|
|
|
+ animation: "auto",
|
|
|
+ animationDurationUpdate: 200,
|
|
|
+ animationEasingUpdate: "exponentialOut",
|
|
|
+ crossStyle: {
|
|
|
+ color: "#999",
|
|
|
+ width: 1,
|
|
|
+ type: "dashed",
|
|
|
+ textStyle: {}
|
|
|
+ }
|
|
|
+ },
|
|
|
+ textStyle: {
|
|
|
+ color: "#fff",
|
|
|
+ fontSize: 14
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var pD = E
|
|
|
+ , gD = eu
|
|
|
+ , mD = ["", "-webkit-", "-moz-", "-o-"];
|
|
|
+ function vD(o) {
|
|
|
+ var a = []
|
|
|
+ , t = o.get("transitionDuration")
|
|
|
+ , e = o.get("backgroundColor")
|
|
|
+ , i = o.getModel("textStyle")
|
|
|
+ , n = o.get("padding");
|
|
|
+ return t && a.push(function(t) {
|
|
|
+ var e = "cubic-bezier(0.23, 1, 0.32, 1)"
|
|
|
+ , i = "left " + t + "s " + e + ",top " + t + "s " + e;
|
|
|
+ return O(mD, function(t) {
|
|
|
+ return t + "transition:" + i
|
|
|
+ }).join(";")
|
|
|
+ }(t)),
|
|
|
+ e && (v.canvasSupported ? a.push("background-Color:" + e) : (a.push("background-Color:#" + Ze(e)),
|
|
|
+ a.push("filter:alpha(opacity=70)"))),
|
|
|
+ pD(["width", "color", "radius"], function(t) {
|
|
|
+ var e = "border-" + t
|
|
|
+ , i = gD(e)
|
|
|
+ , n = o.get(i);
|
|
|
+ null != n && a.push(e + ":" + n + ("color" === t ? "" : "px"))
|
|
|
+ }),
|
|
|
+ a.push(function(i) {
|
|
|
+ var n = []
|
|
|
+ , t = i.get("fontSize")
|
|
|
+ , e = i.getTextColor();
|
|
|
+ return e && n.push("color:" + e),
|
|
|
+ n.push("font:" + i.getFont()),
|
|
|
+ t && n.push("line-height:" + Math.round(3 * t / 2) + "px"),
|
|
|
+ pD(["decoration", "align"], function(t) {
|
|
|
+ var e = i.get(t);
|
|
|
+ e && n.push("text-" + t + ":" + e)
|
|
|
+ }),
|
|
|
+ n.join(";")
|
|
|
+ }(i)),
|
|
|
+ null != n && a.push("padding:" + iu(n).join("px ") + "px"),
|
|
|
+ a.join(";") + ";"
|
|
|
+ }
|
|
|
+ function yD(t, e, i, n, o) {
|
|
|
+ var a = e && e.painter;
|
|
|
+ if (i) {
|
|
|
+ var r = a && a.getViewportRoot();
|
|
|
+ r && function(t, e, i, n, o) {
|
|
|
+ Rt(Et, e, n, o, !0) && Rt(t, i, Et[0], Et[1])
|
|
|
+ }(t, r, document.body, n, o)
|
|
|
+ } else {
|
|
|
+ t[0] = n,
|
|
|
+ t[1] = o;
|
|
|
+ var s = a && a.getViewportRootOffset();
|
|
|
+ s && (t[0] += s.offsetLeft,
|
|
|
+ t[1] += s.offsetTop)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function xD(t, e, i) {
|
|
|
+ if (v.wxa)
|
|
|
+ return null;
|
|
|
+ var n = document.createElement("div");
|
|
|
+ n.domBelongToZr = !0,
|
|
|
+ this.el = n;
|
|
|
+ var o = this._zr = e.getZr()
|
|
|
+ , a = this._appendToBody = i && i.appendToBody;
|
|
|
+ this._styleCoord = [0, 0],
|
|
|
+ yD(this._styleCoord, o, a, e.getWidth() / 2, e.getHeight() / 2),
|
|
|
+ a ? document.body.appendChild(n) : t.appendChild(n),
|
|
|
+ this._container = t,
|
|
|
+ this._show = !1,
|
|
|
+ this._hideTimeout;
|
|
|
+ var r = this;
|
|
|
+ n.onmouseenter = function() {
|
|
|
+ r._enterable && (clearTimeout(r._hideTimeout),
|
|
|
+ r._show = !0),
|
|
|
+ r._inContent = !0
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ n.onmousemove = function(t) {
|
|
|
+ if (t = t || window.event,
|
|
|
+ !r._enterable) {
|
|
|
+ var e = o.handler;
|
|
|
+ Zt(o.painter.getViewportRoot(), t, !0),
|
|
|
+ e.dispatch("mousemove", t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ n.onmouseleave = function() {
|
|
|
+ r._enterable && r._show && r.hideLater(r._hideDelay),
|
|
|
+ r._inContent = !1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function _D(t) {
|
|
|
+ this._zr = t.getZr(),
|
|
|
+ this._show = !1,
|
|
|
+ this._hideTimeout
|
|
|
+ }
|
|
|
+ xD.prototype = {
|
|
|
+ constructor: xD,
|
|
|
+ _enterable: !0,
|
|
|
+ update: function() {
|
|
|
+ var t = this._container
|
|
|
+ , e = t.currentStyle || document.defaultView.getComputedStyle(t)
|
|
|
+ , i = t.style;
|
|
|
+ "absolute" !== i.position && "absolute" !== e.position && (i.position = "relative")
|
|
|
+ },
|
|
|
+ show: function(t) {
|
|
|
+ clearTimeout(this._hideTimeout);
|
|
|
+ var e = this.el
|
|
|
+ , i = this._styleCoord;
|
|
|
+ e.style.cssText = "position:absolute;display:block;border-style:solid;white-space:nowrap;z-index:9999999;" + vD(t) + ";left:" + i[0] + "px;top:" + i[1] + "px;" + (t.get("extraCssText") || ""),
|
|
|
+ e.style.display = e.innerHTML ? "block" : "none",
|
|
|
+ e.style.pointerEvents = this._enterable ? "auto" : "none",
|
|
|
+ this._show = !0
|
|
|
+ },
|
|
|
+ setContent: function(t) {
|
|
|
+ this.el.innerHTML = null == t ? "" : t
|
|
|
+ },
|
|
|
+ setEnterable: function(t) {
|
|
|
+ this._enterable = t
|
|
|
+ },
|
|
|
+ getSize: function() {
|
|
|
+ var t = this.el;
|
|
|
+ return [t.clientWidth, t.clientHeight]
|
|
|
+ },
|
|
|
+ moveTo: function(t, e) {
|
|
|
+ var i = this._styleCoord;
|
|
|
+ yD(i, this._zr, this._appendToBody, t, e);
|
|
|
+ var n = this.el.style;
|
|
|
+ n.left = i[0] + "px",
|
|
|
+ n.top = i[1] + "px"
|
|
|
+ },
|
|
|
+ hide: function() {
|
|
|
+ this.el.style.display = "none",
|
|
|
+ this._show = !1
|
|
|
+ },
|
|
|
+ hideLater: function(t) {
|
|
|
+ !this._show || this._inContent && this._enterable || (t ? (this._hideDelay = t,
|
|
|
+ this._show = !1,
|
|
|
+ this._hideTimeout = setTimeout(A(this.hide, this), t)) : this.hide())
|
|
|
+ },
|
|
|
+ isShow: function() {
|
|
|
+ return this._show
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this.el.parentNode.removeChild(this.el)
|
|
|
+ },
|
|
|
+ getOuterSize: function() {
|
|
|
+ var t = this.el.clientWidth
|
|
|
+ , e = this.el.clientHeight;
|
|
|
+ if (document.defaultView && document.defaultView.getComputedStyle) {
|
|
|
+ var i = document.defaultView.getComputedStyle(this.el);
|
|
|
+ i && (t += parseInt(i.borderLeftWidth, 10) + parseInt(i.borderRightWidth, 10),
|
|
|
+ e += parseInt(i.borderTopWidth, 10) + parseInt(i.borderBottomWidth, 10))
|
|
|
+ }
|
|
|
+ return {
|
|
|
+ width: t,
|
|
|
+ height: e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _D.prototype = {
|
|
|
+ constructor: _D,
|
|
|
+ _enterable: !0,
|
|
|
+ update: function() {},
|
|
|
+ show: function(t) {
|
|
|
+ this._hideTimeout && clearTimeout(this._hideTimeout),
|
|
|
+ this.el.attr("show", !0),
|
|
|
+ this._show = !0
|
|
|
+ },
|
|
|
+ setContent: function(t, e, i) {
|
|
|
+ this.el && this._zr.remove(this.el);
|
|
|
+ for (var n = {}, o = t, a = "{marker", r = o.indexOf(a); 0 <= r; ) {
|
|
|
+ var s = o.indexOf("|}")
|
|
|
+ , l = o.substr(r + a.length, s - r - a.length);
|
|
|
+ -1 < l.indexOf("sub") ? n["marker" + l] = {
|
|
|
+ textWidth: 4,
|
|
|
+ textHeight: 4,
|
|
|
+ textBorderRadius: 2,
|
|
|
+ textBackgroundColor: e[l],
|
|
|
+ textOffset: [3, 0]
|
|
|
+ } : n["marker" + l] = {
|
|
|
+ textWidth: 10,
|
|
|
+ textHeight: 10,
|
|
|
+ textBorderRadius: 5,
|
|
|
+ textBackgroundColor: e[l]
|
|
|
+ },
|
|
|
+ r = (o = o.substr(s + 1)).indexOf("{marker")
|
|
|
+ }
|
|
|
+ this.el = new Ur({
|
|
|
+ style: {
|
|
|
+ rich: n,
|
|
|
+ text: t,
|
|
|
+ textLineHeight: 20,
|
|
|
+ textBackgroundColor: i.get("backgroundColor"),
|
|
|
+ textBorderRadius: i.get("borderRadius"),
|
|
|
+ textFill: i.get("textStyle.color"),
|
|
|
+ textPadding: i.get("padding")
|
|
|
+ },
|
|
|
+ z: i.get("z")
|
|
|
+ }),
|
|
|
+ this._zr.add(this.el);
|
|
|
+ var u = this;
|
|
|
+ this.el.on("mouseover", function() {
|
|
|
+ u._enterable && (clearTimeout(u._hideTimeout),
|
|
|
+ u._show = !0),
|
|
|
+ u._inContent = !0
|
|
|
+ }),
|
|
|
+ this.el.on("mouseout", function() {
|
|
|
+ u._enterable && u._show && u.hideLater(u._hideDelay),
|
|
|
+ u._inContent = !1
|
|
|
+ })
|
|
|
+ },
|
|
|
+ setEnterable: function(t) {
|
|
|
+ this._enterable = t
|
|
|
+ },
|
|
|
+ getSize: function() {
|
|
|
+ var t = this.el.getBoundingRect();
|
|
|
+ return [t.width, t.height]
|
|
|
+ },
|
|
|
+ moveTo: function(t, e) {
|
|
|
+ this.el && this.el.attr("position", [t, e])
|
|
|
+ },
|
|
|
+ hide: function() {
|
|
|
+ this.el && this.el.hide(),
|
|
|
+ this._show = !1
|
|
|
+ },
|
|
|
+ hideLater: function(t) {
|
|
|
+ !this._show || this._inContent && this._enterable || (t ? (this._hideDelay = t,
|
|
|
+ this._show = !1,
|
|
|
+ this._hideTimeout = setTimeout(A(this.hide, this), t)) : this.hide())
|
|
|
+ },
|
|
|
+ isShow: function() {
|
|
|
+ return this._show
|
|
|
+ },
|
|
|
+ getOuterSize: function() {
|
|
|
+ var t = this.getSize();
|
|
|
+ return {
|
|
|
+ width: t[0],
|
|
|
+ height: t[1]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var wD = A
|
|
|
+ , bD = E
|
|
|
+ , SD = Rl
|
|
|
+ , MD = new rs({
|
|
|
+ shape: {
|
|
|
+ x: -1,
|
|
|
+ y: -1,
|
|
|
+ width: 2,
|
|
|
+ height: 2
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function ID(t) {
|
|
|
+ for (var e = t.pop(); t.length; ) {
|
|
|
+ var i = t.pop();
|
|
|
+ i && (Cl.isInstance(i) && (i = i.get("tooltip", !0)),
|
|
|
+ "string" == typeof i && (i = {
|
|
|
+ formatter: i
|
|
|
+ }),
|
|
|
+ e = new Cl(i,e,e.ecModel))
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ function TD(t, e) {
|
|
|
+ return t.dispatchAction || A(e.dispatchAction, e)
|
|
|
+ }
|
|
|
+ function AD(t) {
|
|
|
+ return "center" === t || "middle" === t
|
|
|
+ }
|
|
|
+ Af({
|
|
|
+ type: "tooltip",
|
|
|
+ init: function(t, e) {
|
|
|
+ if (!v.node) {
|
|
|
+ var i, n = t.getComponent("tooltip"), o = n.get("renderMode");
|
|
|
+ this._renderMode = Qo(o),
|
|
|
+ "html" === this._renderMode ? (i = new xD(e.getDom(),e,{
|
|
|
+ appendToBody: n.get("appendToBody", !0)
|
|
|
+ }),
|
|
|
+ this._newLine = "<br/>") : (i = new _D(e),
|
|
|
+ this._newLine = "\n"),
|
|
|
+ this._tooltipContent = i
|
|
|
+ }
|
|
|
+ },
|
|
|
+ render: function(t, e, i) {
|
|
|
+ if (!v.node) {
|
|
|
+ this.group.removeAll(),
|
|
|
+ this._tooltipModel = t,
|
|
|
+ this._ecModel = e,
|
|
|
+ this._api = i,
|
|
|
+ this._lastDataByCoordSys = null,
|
|
|
+ this._alwaysShowContent = t.get("alwaysShowContent");
|
|
|
+ var n = this._tooltipContent;
|
|
|
+ n.update(),
|
|
|
+ n.setEnterable(t.get("enterable")),
|
|
|
+ this._initGlobalListener(),
|
|
|
+ this._keepShow()
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _initGlobalListener: function() {
|
|
|
+ var n = this._tooltipModel.get("triggerOn");
|
|
|
+ fI("itemTooltip", this._api, wD(function(t, e, i) {
|
|
|
+ "none" !== n && (0 <= n.indexOf(t) ? this._tryShow(e, i) : "leave" === t && this._hide(i))
|
|
|
+ }, this))
|
|
|
+ },
|
|
|
+ _keepShow: function() {
|
|
|
+ var t = this._tooltipModel
|
|
|
+ , e = this._ecModel
|
|
|
+ , i = this._api;
|
|
|
+ if (null != this._lastX && null != this._lastY && "none" !== t.get("triggerOn")) {
|
|
|
+ var n = this;
|
|
|
+ clearTimeout(this._refreshUpdateTimeout),
|
|
|
+ this._refreshUpdateTimeout = setTimeout(function() {
|
|
|
+ i.isDisposed() || n.manuallyShowTip(t, e, i, {
|
|
|
+ x: n._lastX,
|
|
|
+ y: n._lastY
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ manuallyShowTip: function(t, e, i, n) {
|
|
|
+ if (n.from !== this.uid && !v.node) {
|
|
|
+ var o = TD(n, i);
|
|
|
+ this._ticket = "";
|
|
|
+ var a = n.dataByCoordSys;
|
|
|
+ if (n.tooltip && null != n.x && null != n.y) {
|
|
|
+ var r = MD;
|
|
|
+ r.position = [n.x, n.y],
|
|
|
+ r.update(),
|
|
|
+ r.tooltip = n.tooltip,
|
|
|
+ this._tryShow({
|
|
|
+ offsetX: n.x,
|
|
|
+ offsetY: n.y,
|
|
|
+ target: r
|
|
|
+ }, o)
|
|
|
+ } else if (a)
|
|
|
+ this._tryShow({
|
|
|
+ offsetX: n.x,
|
|
|
+ offsetY: n.y,
|
|
|
+ position: n.position,
|
|
|
+ dataByCoordSys: n.dataByCoordSys,
|
|
|
+ tooltipOption: n.tooltipOption
|
|
|
+ }, o);
|
|
|
+ else if (null != n.seriesIndex) {
|
|
|
+ if (this._manuallyAxisShowTip(t, e, i, n))
|
|
|
+ return;
|
|
|
+ var s = iI(n, e)
|
|
|
+ , l = s.point[0]
|
|
|
+ , u = s.point[1];
|
|
|
+ null != l && null != u && this._tryShow({
|
|
|
+ offsetX: l,
|
|
|
+ offsetY: u,
|
|
|
+ position: n.position,
|
|
|
+ target: s.el
|
|
|
+ }, o)
|
|
|
+ } else
|
|
|
+ null != n.x && null != n.y && (i.dispatchAction({
|
|
|
+ type: "updateAxisPointer",
|
|
|
+ x: n.x,
|
|
|
+ y: n.y
|
|
|
+ }),
|
|
|
+ this._tryShow({
|
|
|
+ offsetX: n.x,
|
|
|
+ offsetY: n.y,
|
|
|
+ position: n.position,
|
|
|
+ target: i.getZr().findHover(n.x, n.y).target
|
|
|
+ }, o))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ manuallyHideTip: function(t, e, i, n) {
|
|
|
+ var o = this._tooltipContent;
|
|
|
+ !this._alwaysShowContent && this._tooltipModel && o.hideLater(this._tooltipModel.get("hideDelay")),
|
|
|
+ this._lastX = this._lastY = null,
|
|
|
+ n.from !== this.uid && this._hide(TD(n, i))
|
|
|
+ },
|
|
|
+ _manuallyAxisShowTip: function(t, e, i, n) {
|
|
|
+ var o = n.seriesIndex
|
|
|
+ , a = n.dataIndex
|
|
|
+ , r = e.getComponent("axisPointer").coordSysAxesInfo;
|
|
|
+ if (null != o && null != a && null != r) {
|
|
|
+ var s = e.getSeriesByIndex(o);
|
|
|
+ if (s)
|
|
|
+ if ("axis" === (t = ID([s.getData().getItemModel(a), s, (s.coordinateSystem || {}).model, t])).get("trigger"))
|
|
|
+ return i.dispatchAction({
|
|
|
+ type: "updateAxisPointer",
|
|
|
+ seriesIndex: o,
|
|
|
+ dataIndex: a,
|
|
|
+ position: n.position
|
|
|
+ }),
|
|
|
+ !0
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _tryShow: function(t, e) {
|
|
|
+ var i = t.target;
|
|
|
+ if (this._tooltipModel) {
|
|
|
+ this._lastX = t.offsetX,
|
|
|
+ this._lastY = t.offsetY;
|
|
|
+ var n = t.dataByCoordSys;
|
|
|
+ n && n.length ? this._showAxisTooltip(n, t) : i && null != i.dataIndex ? (this._lastDataByCoordSys = null,
|
|
|
+ this._showSeriesItemTooltip(t, i, e)) : i && i.tooltip ? (this._lastDataByCoordSys = null,
|
|
|
+ this._showComponentItemTooltip(t, i, e)) : (this._lastDataByCoordSys = null,
|
|
|
+ this._hide(e))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _showOrMove: function(t, e) {
|
|
|
+ var i = t.get("showDelay");
|
|
|
+ e = A(e, this),
|
|
|
+ clearTimeout(this._showTimout),
|
|
|
+ 0 < i ? this._showTimout = setTimeout(e, i) : e()
|
|
|
+ },
|
|
|
+ _showAxisTooltip: function(t, e) {
|
|
|
+ var d = this._ecModel
|
|
|
+ , i = this._tooltipModel
|
|
|
+ , n = [e.offsetX, e.offsetY]
|
|
|
+ , o = []
|
|
|
+ , f = []
|
|
|
+ , a = ID([e.tooltipOption, i])
|
|
|
+ , p = this._renderMode
|
|
|
+ , r = this._newLine
|
|
|
+ , g = {};
|
|
|
+ bD(t, function(t) {
|
|
|
+ bD(t.dataByAxis, function(s) {
|
|
|
+ var l = d.getComponent(s.axisDim + "Axis", s.axisIndex)
|
|
|
+ , u = s.value
|
|
|
+ , h = [];
|
|
|
+ if (l && null != u) {
|
|
|
+ var c = DI(u, l.axis, d, s.seriesDataIndices, s.valueLabelOpt);
|
|
|
+ E(s.seriesDataIndices, function(t) {
|
|
|
+ var e = d.getSeriesByIndex(t.seriesIndex)
|
|
|
+ , i = t.dataIndexInside
|
|
|
+ , n = e && e.getDataParams(i);
|
|
|
+ if (n.axisDim = s.axisDim,
|
|
|
+ n.axisIndex = s.axisIndex,
|
|
|
+ n.axisType = s.axisType,
|
|
|
+ n.axisId = s.axisId,
|
|
|
+ n.axisValue = ug(l.axis, u),
|
|
|
+ n.axisValueLabel = c,
|
|
|
+ n) {
|
|
|
+ f.push(n);
|
|
|
+ var o, a = e.formatTooltip(i, !0, null, p);
|
|
|
+ if (z(a)) {
|
|
|
+ o = a.html;
|
|
|
+ var r = a.markers;
|
|
|
+ m(g, r)
|
|
|
+ } else
|
|
|
+ o = a;
|
|
|
+ h.push(o)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var t = c;
|
|
|
+ "html" !== p ? o.push(h.join(r)) : o.push((t ? au(t) + r : "") + h.join(r))
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }, this),
|
|
|
+ o.reverse(),
|
|
|
+ o = o.join(this._newLine + this._newLine);
|
|
|
+ var s = e.position;
|
|
|
+ this._showOrMove(a, function() {
|
|
|
+ this._updateContentNotChangedOnAxis(t) ? this._updatePosition(a, s, n[0], n[1], this._tooltipContent, f) : this._showTooltipContent(a, o, f, Math.random(), n[0], n[1], s, void 0, g)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _showSeriesItemTooltip: function(t, e, i) {
|
|
|
+ var n = this._ecModel
|
|
|
+ , o = e.seriesIndex
|
|
|
+ , a = n.getSeriesByIndex(o)
|
|
|
+ , r = e.dataModel || a
|
|
|
+ , s = e.dataIndex
|
|
|
+ , l = e.dataType
|
|
|
+ , u = r.getData(l)
|
|
|
+ , h = ID([u.getItemModel(s), r, a && (a.coordinateSystem || {}).model, this._tooltipModel])
|
|
|
+ , c = h.get("trigger");
|
|
|
+ if (null == c || "item" === c) {
|
|
|
+ var d, f, p = r.getDataParams(s, l), g = r.formatTooltip(s, !1, l, this._renderMode);
|
|
|
+ f = z(g) ? (d = g.html,
|
|
|
+ g.markers) : (d = g,
|
|
|
+ null);
|
|
|
+ var m = "item_" + r.name + "_" + s;
|
|
|
+ this._showOrMove(h, function() {
|
|
|
+ this._showTooltipContent(h, d, p, m, t.offsetX, t.offsetY, t.position, t.target, f)
|
|
|
+ }),
|
|
|
+ i({
|
|
|
+ type: "showTip",
|
|
|
+ dataIndexInside: s,
|
|
|
+ dataIndex: u.getRawIndex(s),
|
|
|
+ seriesIndex: o,
|
|
|
+ from: this.uid
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _showComponentItemTooltip: function(t, e, i) {
|
|
|
+ var n = e.tooltip;
|
|
|
+ if ("string" == typeof n) {
|
|
|
+ n = {
|
|
|
+ content: n,
|
|
|
+ formatter: n
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var o = new Cl(n,this._tooltipModel,this._ecModel)
|
|
|
+ , a = o.get("content")
|
|
|
+ , r = Math.random();
|
|
|
+ this._showOrMove(o, function() {
|
|
|
+ this._showTooltipContent(o, a, o.get("formatterParams") || {}, r, t.offsetX, t.offsetY, t.position, e)
|
|
|
+ }),
|
|
|
+ i({
|
|
|
+ type: "showTip",
|
|
|
+ from: this.uid
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _showTooltipContent: function(i, t, n, e, o, a, r, s, l) {
|
|
|
+ if (this._ticket = "",
|
|
|
+ i.get("showContent") && i.get("show")) {
|
|
|
+ var u = this._tooltipContent
|
|
|
+ , h = i.get("formatter");
|
|
|
+ r = r || i.get("position");
|
|
|
+ var c = t;
|
|
|
+ if (h && "string" == typeof h)
|
|
|
+ c = lu(h, n, !0);
|
|
|
+ else if ("function" == typeof h) {
|
|
|
+ var d = wD(function(t, e) {
|
|
|
+ t === this._ticket && (u.setContent(e, l, i),
|
|
|
+ this._updatePosition(i, r, o, a, u, n, s))
|
|
|
+ }, this);
|
|
|
+ this._ticket = e,
|
|
|
+ c = h(n, e, d)
|
|
|
+ }
|
|
|
+ u.setContent(c, l, i),
|
|
|
+ u.show(i),
|
|
|
+ this._updatePosition(i, r, o, a, u, n, s)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _updatePosition: function(t, e, i, n, o, a, r) {
|
|
|
+ var s = this._api.getWidth()
|
|
|
+ , l = this._api.getHeight();
|
|
|
+ e = e || t.get("position");
|
|
|
+ var u = o.getSize()
|
|
|
+ , h = t.get("align")
|
|
|
+ , c = t.get("verticalAlign")
|
|
|
+ , d = r && r.getBoundingRect().clone();
|
|
|
+ if (r && d.applyTransform(r.transform),
|
|
|
+ "function" == typeof e && (e = e([i, n], a, o.el, d, {
|
|
|
+ viewSize: [s, l],
|
|
|
+ contentSize: u.slice()
|
|
|
+ })),
|
|
|
+ L(e))
|
|
|
+ i = SD(e[0], s),
|
|
|
+ n = SD(e[1], l);
|
|
|
+ else if (z(e)) {
|
|
|
+ e.width = u[0],
|
|
|
+ e.height = u[1];
|
|
|
+ var f = bu(e, {
|
|
|
+ width: s,
|
|
|
+ height: l
|
|
|
+ });
|
|
|
+ i = f.x,
|
|
|
+ n = f.y,
|
|
|
+ c = h = null
|
|
|
+ } else if ("string" == typeof e && r) {
|
|
|
+ i = (p = function(t, e, i) {
|
|
|
+ var n = i[0]
|
|
|
+ , o = i[1]
|
|
|
+ , a = 0
|
|
|
+ , r = 0
|
|
|
+ , s = e.width
|
|
|
+ , l = e.height;
|
|
|
+ switch (t) {
|
|
|
+ case "inside":
|
|
|
+ a = e.x + s / 2 - n / 2,
|
|
|
+ r = e.y + l / 2 - o / 2;
|
|
|
+ break;
|
|
|
+ case "top":
|
|
|
+ a = e.x + s / 2 - n / 2,
|
|
|
+ r = e.y - o - 5;
|
|
|
+ break;
|
|
|
+ case "bottom":
|
|
|
+ a = e.x + s / 2 - n / 2,
|
|
|
+ r = e.y + l + 5;
|
|
|
+ break;
|
|
|
+ case "left":
|
|
|
+ a = e.x - n - 5,
|
|
|
+ r = e.y + l / 2 - o / 2;
|
|
|
+ break;
|
|
|
+ case "right":
|
|
|
+ a = e.x + s + 5,
|
|
|
+ r = e.y + l / 2 - o / 2
|
|
|
+ }
|
|
|
+ return [a, r]
|
|
|
+ }(e, d, u))[0],
|
|
|
+ n = p[1]
|
|
|
+ } else {
|
|
|
+ var p;
|
|
|
+ i = (p = function(t, e, i, n, o, a, r) {
|
|
|
+ var s = i.getOuterSize()
|
|
|
+ , l = s.width
|
|
|
+ , u = s.height;
|
|
|
+ null != a && (n < t + l + a ? t -= l + a : t += a);
|
|
|
+ null != r && (o < e + u + r ? e -= u + r : e += r);
|
|
|
+ return [t, e]
|
|
|
+ }(i, n, o, s, l, h ? null : 20, c ? null : 20))[0],
|
|
|
+ n = p[1]
|
|
|
+ }
|
|
|
+ h && (i -= AD(h) ? u[0] / 2 : "right" === h ? u[0] : 0),
|
|
|
+ c && (n -= AD(c) ? u[1] / 2 : "bottom" === c ? u[1] : 0),
|
|
|
+ t.get("confine") && (i = (p = function(t, e, i, n, o) {
|
|
|
+ var a = i.getOuterSize()
|
|
|
+ , r = a.width
|
|
|
+ , s = a.height;
|
|
|
+ return t = Math.min(t + r, n) - r,
|
|
|
+ e = Math.min(e + s, o) - s,
|
|
|
+ t = Math.max(t, 0),
|
|
|
+ e = Math.max(e, 0),
|
|
|
+ [t, e]
|
|
|
+ }(i, n, o, s, l))[0],
|
|
|
+ n = p[1]);
|
|
|
+ o.moveTo(i, n)
|
|
|
+ },
|
|
|
+ _updateContentNotChangedOnAxis: function(n) {
|
|
|
+ var t = this._lastDataByCoordSys
|
|
|
+ , r = !!t && t.length === n.length;
|
|
|
+ return r && bD(t, function(t, e) {
|
|
|
+ var i = t.dataByAxis || {}
|
|
|
+ , a = (n[e] || {}).dataByAxis || [];
|
|
|
+ (r &= i.length === a.length) && bD(i, function(t, e) {
|
|
|
+ var i = a[e] || {}
|
|
|
+ , n = t.seriesDataIndices || []
|
|
|
+ , o = i.seriesDataIndices || [];
|
|
|
+ (r &= t.value === i.value && t.axisType === i.axisType && t.axisId === i.axisId && n.length === o.length) && bD(n, function(t, e) {
|
|
|
+ var i = o[e];
|
|
|
+ r &= t.seriesIndex === i.seriesIndex && t.dataIndex === i.dataIndex
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ this._lastDataByCoordSys = n,
|
|
|
+ !!r
|
|
|
+ },
|
|
|
+ _hide: function(t) {
|
|
|
+ this._lastDataByCoordSys = null,
|
|
|
+ t({
|
|
|
+ type: "hideTip",
|
|
|
+ from: this.uid
|
|
|
+ })
|
|
|
+ },
|
|
|
+ dispose: function(t, e) {
|
|
|
+ v.node || (this._tooltipContent.dispose(),
|
|
|
+ mI("itemTooltip", e))
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "showTip",
|
|
|
+ event: "showTip",
|
|
|
+ update: "tooltip:manuallyShowTip"
|
|
|
+ }, function() {}),
|
|
|
+ _f({
|
|
|
+ type: "hideTip",
|
|
|
+ event: "hideTip",
|
|
|
+ update: "tooltip:manuallyHideTip"
|
|
|
+ }, function() {});
|
|
|
+ var DD = ["rect", "polygon", "keep", "clear"];
|
|
|
+ var CD = E;
|
|
|
+ function LD(t) {
|
|
|
+ if (t)
|
|
|
+ for (var e in t)
|
|
|
+ if (t.hasOwnProperty(e))
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ function kD(t, e, a) {
|
|
|
+ var i = {};
|
|
|
+ return CD(e, function(n) {
|
|
|
+ var o = i[n] = function() {
|
|
|
+ function t() {}
|
|
|
+ return t.prototype.__hidden = t.prototype,
|
|
|
+ new t
|
|
|
+ }();
|
|
|
+ CD(t[n], function(t, e) {
|
|
|
+ if (g_.isValidType(e)) {
|
|
|
+ var i = {
|
|
|
+ type: e,
|
|
|
+ visual: t
|
|
|
+ };
|
|
|
+ a && a(i, n),
|
|
|
+ o[e] = new g_(i),
|
|
|
+ "opacity" === e && ((i = k(i)).type = "colorAlpha",
|
|
|
+ o.__hidden.__alphaForOpacity = new g_(i))
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ function PD(e, i, t) {
|
|
|
+ var n;
|
|
|
+ E(t, function(t) {
|
|
|
+ i.hasOwnProperty(t) && LD(i[t]) && (n = !0)
|
|
|
+ }),
|
|
|
+ n && E(t, function(t) {
|
|
|
+ i.hasOwnProperty(t) && LD(i[t]) ? e[t] = k(i[t]) : delete e[t]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var ND = {
|
|
|
+ lineX: OD(0),
|
|
|
+ lineY: OD(1),
|
|
|
+ rect: {
|
|
|
+ point: function(t, e, i) {
|
|
|
+ return t && i.boundingRect.contain(t[0], t[1])
|
|
|
+ },
|
|
|
+ rect: function(t, e, i) {
|
|
|
+ return t && i.boundingRect.intersect(t)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ polygon: {
|
|
|
+ point: function(t, e, i) {
|
|
|
+ return t && i.boundingRect.contain(t[0], t[1]) && Tg(i.range, t[0], t[1])
|
|
|
+ },
|
|
|
+ rect: function(t, e, i) {
|
|
|
+ var n = i.range;
|
|
|
+ if (!t || n.length <= 1)
|
|
|
+ return !1;
|
|
|
+ var o = t.x
|
|
|
+ , a = t.y
|
|
|
+ , r = t.width
|
|
|
+ , s = t.height
|
|
|
+ , l = n[0];
|
|
|
+ return !!(Tg(n, o, a) || Tg(n, o + r, a) || Tg(n, o, a + s) || Tg(n, o + r, a + s) || Di.create(t).contain(l[0], l[1]) || xl(o, a, o + r, a, n) || xl(o, a, o, a + s, n) || xl(o + r, a, o + r, a + s, n) || xl(o, a + s, o + r, a + s, n)) || void 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function OD(a) {
|
|
|
+ var r = ["x", "y"]
|
|
|
+ , s = ["width", "height"];
|
|
|
+ return {
|
|
|
+ point: function(t, e, i) {
|
|
|
+ if (t) {
|
|
|
+ var n = i.range;
|
|
|
+ return ED(t[a], n)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ rect: function(t, e, i) {
|
|
|
+ if (t) {
|
|
|
+ var n = i.range
|
|
|
+ , o = [t[r[a]], t[r[a]] + t[s[a]]];
|
|
|
+ return o[1] < o[0] && o.reverse(),
|
|
|
+ ED(o[0], n) || ED(o[1], n) || ED(n[0], o) || ED(n[1], o)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function ED(t, e) {
|
|
|
+ return e[0] <= t && t <= e[1]
|
|
|
+ }
|
|
|
+ var RD = ["inBrush", "outOfBrush"]
|
|
|
+ , zD = "__ecBrushSelect"
|
|
|
+ , BD = "__ecInBrushSelectEvent"
|
|
|
+ , VD = Ld.VISUAL.BRUSH;
|
|
|
+ function GD(e) {
|
|
|
+ e.eachComponent({
|
|
|
+ mainType: "brush"
|
|
|
+ }, function(t) {
|
|
|
+ (t.brushTargetManager = new DA(t.option,e)).setInputRanges(t.areas, e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function FD(t, e) {
|
|
|
+ if (!t.isDisposed()) {
|
|
|
+ var i = t.getZr();
|
|
|
+ i[BD] = !0,
|
|
|
+ t.dispatchAction({
|
|
|
+ type: "brushSelect",
|
|
|
+ batch: e
|
|
|
+ }),
|
|
|
+ i[BD] = !1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function WD(t, e, i, n) {
|
|
|
+ for (var o = 0, a = e.length; o < a; o++) {
|
|
|
+ var r = e[o];
|
|
|
+ if (t[r.brushType](n, i, r.selectors, r))
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function HD(t) {
|
|
|
+ var r = t.brushSelector;
|
|
|
+ if (R(r)) {
|
|
|
+ var e = [];
|
|
|
+ return E(ND, function(a, t) {
|
|
|
+ e[t] = function(t, e, i, n) {
|
|
|
+ var o = e.getItemLayout(t);
|
|
|
+ return a[r](o, i, n)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ if (C(r)) {
|
|
|
+ var i = {};
|
|
|
+ return E(ND, function(t, e) {
|
|
|
+ i[e] = r
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ bf(VD, function(t, e, i) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "brush"
|
|
|
+ }, function(t) {
|
|
|
+ i && "takeGlobalCursor" === i.type && t.setBrushOption("brush" === i.key ? i.brushOption : {
|
|
|
+ brushType: !1
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ GD(t)
|
|
|
+ }),
|
|
|
+ Sf(VD, function(p, t, e) {
|
|
|
+ var o, g, m = [];
|
|
|
+ p.eachComponent({
|
|
|
+ mainType: "brush"
|
|
|
+ }, function(a, t) {
|
|
|
+ var s = {
|
|
|
+ brushId: a.id,
|
|
|
+ brushIndex: t,
|
|
|
+ brushName: a.name,
|
|
|
+ areas: k(a.areas),
|
|
|
+ selected: []
|
|
|
+ };
|
|
|
+ m.push(s);
|
|
|
+ var e = a.option
|
|
|
+ , i = e.brushLink
|
|
|
+ , n = []
|
|
|
+ , l = []
|
|
|
+ , u = []
|
|
|
+ , h = 0;
|
|
|
+ t || (o = e.throttleType,
|
|
|
+ g = e.throttleDelay);
|
|
|
+ var r = O(a.areas, function(t) {
|
|
|
+ return function(i) {
|
|
|
+ var n = i.selectors = {};
|
|
|
+ return E(ND[i.brushType], function(e, t) {
|
|
|
+ n[t] = function(t) {
|
|
|
+ return e(t, n, i)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }(D({
|
|
|
+ boundingRect: ZD[t.brushType](t)
|
|
|
+ }, t))
|
|
|
+ })
|
|
|
+ , c = kD(a.option, RD, function(t) {
|
|
|
+ t.mappingMethod = "fixed"
|
|
|
+ });
|
|
|
+ function d(t) {
|
|
|
+ return "all" === i || n[t]
|
|
|
+ }
|
|
|
+ function f(t) {
|
|
|
+ return !!t.length
|
|
|
+ }
|
|
|
+ L(i) && E(i, function(t) {
|
|
|
+ n[t] = 1
|
|
|
+ }),
|
|
|
+ p.eachSeries(function(t, e) {
|
|
|
+ var i = u[e] = [];
|
|
|
+ "parallel" === t.subType ? function(t, e) {
|
|
|
+ var i = t.coordinateSystem;
|
|
|
+ h |= i.hasAxisBrushed(),
|
|
|
+ d(e) && i.eachActiveState(t.getData(), function(t, e) {
|
|
|
+ "active" === t && (l[e] = 1)
|
|
|
+ })
|
|
|
+ }(t, e) : function(e, t, i) {
|
|
|
+ var n = HD(e);
|
|
|
+ if (!n || function(t, e) {
|
|
|
+ var i = t.option.seriesIndex;
|
|
|
+ return null != i && "all" !== i && (L(i) ? _(i, e) < 0 : e !== i)
|
|
|
+ }(a, t))
|
|
|
+ return;
|
|
|
+ if (E(r, function(t) {
|
|
|
+ n[t.brushType] && a.brushTargetManager.controlSeries(t, e, p) && i.push(t),
|
|
|
+ h |= f(i)
|
|
|
+ }),
|
|
|
+ d(t) && f(i)) {
|
|
|
+ var o = e.getData();
|
|
|
+ o.each(function(t) {
|
|
|
+ WD(n, i, o, t) && (l[t] = 1)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }(t, e, i)
|
|
|
+ }),
|
|
|
+ p.eachSeries(function(t, e) {
|
|
|
+ var i = {
|
|
|
+ seriesId: t.id,
|
|
|
+ seriesIndex: e,
|
|
|
+ seriesName: t.name,
|
|
|
+ dataIndex: []
|
|
|
+ };
|
|
|
+ s.selected.push(i);
|
|
|
+ var n = HD(t)
|
|
|
+ , o = u[e]
|
|
|
+ , a = t.getData()
|
|
|
+ , r = d(e) ? function(t) {
|
|
|
+ return l[t] ? (i.dataIndex.push(a.getRawIndex(t)),
|
|
|
+ "inBrush") : "outOfBrush"
|
|
|
+ }
|
|
|
+ : function(t) {
|
|
|
+ return WD(n, o, a, t) ? (i.dataIndex.push(a.getRawIndex(t)),
|
|
|
+ "inBrush") : "outOfBrush"
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ (d(e) ? h : f(o)) && function(t, u, h, c, d, f) {
|
|
|
+ var p, g = {};
|
|
|
+ function m(t) {
|
|
|
+ return h.getItemVisual(p, t)
|
|
|
+ }
|
|
|
+ function v(t, e) {
|
|
|
+ h.setItemVisual(p, t, e)
|
|
|
+ }
|
|
|
+ function e(t, e) {
|
|
|
+ p = null == f ? t : e;
|
|
|
+ var i = h.getRawDataItem(p);
|
|
|
+ if (!i || !1 !== i.visualMap)
|
|
|
+ for (var n = c.call(d, t), o = u[n], a = g[n], r = 0, s = a.length; r < s; r++) {
|
|
|
+ var l = a[r];
|
|
|
+ o[l] && o[l].applyVisual(t, m, v)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = g_.prepareVisualTypes(u[t]);
|
|
|
+ g[t] = e
|
|
|
+ }),
|
|
|
+ null == f ? h.each(e) : h.each([f], e)
|
|
|
+ }(RD, c, a, r)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ function(t, e, i, n, o) {
|
|
|
+ if (!o)
|
|
|
+ return;
|
|
|
+ var a = t.getZr();
|
|
|
+ if (a[BD])
|
|
|
+ return;
|
|
|
+ a[zD] || (a[zD] = FD);
|
|
|
+ kc(a, zD, i, e)(t, n)
|
|
|
+ }(t, o, g, m, e)
|
|
|
+ });
|
|
|
+ var ZD = {
|
|
|
+ lineX: et,
|
|
|
+ lineY: et,
|
|
|
+ rect: function(t) {
|
|
|
+ return UD(t.range)
|
|
|
+ },
|
|
|
+ polygon: function(t) {
|
|
|
+ for (var e, i = t.range, n = 0, o = i.length; n < o; n++) {
|
|
|
+ e = e || [[1 / 0, -1 / 0], [1 / 0, -1 / 0]];
|
|
|
+ var a = i[n];
|
|
|
+ a[0] < e[0][0] && (e[0][0] = a[0]),
|
|
|
+ a[0] > e[0][1] && (e[0][1] = a[0]),
|
|
|
+ a[1] < e[1][0] && (e[1][0] = a[1]),
|
|
|
+ a[1] > e[1][1] && (e[1][1] = a[1])
|
|
|
+ }
|
|
|
+ return e && UD(e)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function UD(t) {
|
|
|
+ return new Di(t[0][0],t[1][0],t[0][1] - t[0][0],t[1][1] - t[1][0])
|
|
|
+ }
|
|
|
+ var XD = ["#ddd"];
|
|
|
+ Tf({
|
|
|
+ type: "brush",
|
|
|
+ dependencies: ["geo", "grid", "xAxis", "yAxis", "parallel", "series"],
|
|
|
+ defaultOption: {
|
|
|
+ toolbox: null,
|
|
|
+ brushLink: null,
|
|
|
+ seriesIndex: "all",
|
|
|
+ geoIndex: null,
|
|
|
+ xAxisIndex: null,
|
|
|
+ yAxisIndex: null,
|
|
|
+ brushType: "rect",
|
|
|
+ brushMode: "single",
|
|
|
+ transformable: !0,
|
|
|
+ brushStyle: {
|
|
|
+ borderWidth: 1,
|
|
|
+ color: "rgba(120,140,180,0.3)",
|
|
|
+ borderColor: "rgba(120,140,180,0.8)"
|
|
|
+ },
|
|
|
+ throttleType: "fixRate",
|
|
|
+ throttleDelay: 0,
|
|
|
+ removeOnClick: !0,
|
|
|
+ z: 1e4
|
|
|
+ },
|
|
|
+ areas: [],
|
|
|
+ brushType: null,
|
|
|
+ brushOption: {},
|
|
|
+ coordInfoList: [],
|
|
|
+ optionUpdated: function(t, e) {
|
|
|
+ var i = this.option;
|
|
|
+ e || PD(i, t, ["inBrush", "outOfBrush"]);
|
|
|
+ var n = i.inBrush = i.inBrush || {};
|
|
|
+ i.outOfBrush = i.outOfBrush || {
|
|
|
+ color: XD
|
|
|
+ },
|
|
|
+ n.hasOwnProperty("liftZ") || (n.liftZ = 5)
|
|
|
+ },
|
|
|
+ setAreas: function(t) {
|
|
|
+ t && (this.areas = O(t, function(t) {
|
|
|
+ return YD(this.option, t)
|
|
|
+ }, this))
|
|
|
+ },
|
|
|
+ setBrushOption: function(t) {
|
|
|
+ this.brushOption = YD(this.option, t),
|
|
|
+ this.brushType = this.brushOption.brushType
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function YD(t, e) {
|
|
|
+ return m({
|
|
|
+ brushType: t.brushType,
|
|
|
+ brushMode: t.brushMode,
|
|
|
+ transformable: t.transformable,
|
|
|
+ brushStyle: new Cl(t.brushStyle).getItemStyle(),
|
|
|
+ removeOnClick: t.removeOnClick,
|
|
|
+ z: t.z
|
|
|
+ }, e, !0)
|
|
|
+ }
|
|
|
+ function jD(t, e, i, n) {
|
|
|
+ n && n.$from === t.id || this._brushController.setPanels(t.brushTargetManager.makePanelOpts(i)).enableBrush(t.brushOption).updateCovers(t.areas.slice())
|
|
|
+ }
|
|
|
+ Af({
|
|
|
+ type: "brush",
|
|
|
+ init: function(t, e) {
|
|
|
+ this.ecModel = t,
|
|
|
+ this.api = e,
|
|
|
+ this.model,
|
|
|
+ (this._brushController = new Ib(e.getZr())).on("brush", A(this._onBrush, this)).mount()
|
|
|
+ },
|
|
|
+ render: function(t) {
|
|
|
+ return this.model = t,
|
|
|
+ jD.apply(this, arguments)
|
|
|
+ },
|
|
|
+ updateTransform: function(t, e) {
|
|
|
+ return GD(e),
|
|
|
+ jD.apply(this, arguments)
|
|
|
+ },
|
|
|
+ updateView: jD,
|
|
|
+ dispose: function() {
|
|
|
+ this._brushController.dispose()
|
|
|
+ },
|
|
|
+ _onBrush: function(t, e) {
|
|
|
+ var i = this.model.id;
|
|
|
+ this.model.brushTargetManager.setOutputRanges(t, this.ecModel),
|
|
|
+ e.isEnd && !e.removeOnClick || this.api.dispatchAction({
|
|
|
+ type: "brush",
|
|
|
+ brushId: i,
|
|
|
+ areas: k(t),
|
|
|
+ $from: i
|
|
|
+ }),
|
|
|
+ e.isEnd && this.api.dispatchAction({
|
|
|
+ type: "brushEnd",
|
|
|
+ brushId: i,
|
|
|
+ areas: k(t),
|
|
|
+ $from: i
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "brush",
|
|
|
+ event: "brush"
|
|
|
+ }, function(e, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "brush",
|
|
|
+ query: e
|
|
|
+ }, function(t) {
|
|
|
+ t.setAreas(e.areas)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "brushSelect",
|
|
|
+ event: "brushSelected",
|
|
|
+ update: "none"
|
|
|
+ }, function() {}),
|
|
|
+ _f({
|
|
|
+ type: "brushEnd",
|
|
|
+ event: "brushEnd",
|
|
|
+ update: "none"
|
|
|
+ }, function() {});
|
|
|
+ var qD = Oc.toolbox.brush;
|
|
|
+ function KD(t, e, i) {
|
|
|
+ this.model = t,
|
|
|
+ this.ecModel = e,
|
|
|
+ this.api = i,
|
|
|
+ this._brushType,
|
|
|
+ this._brushMode
|
|
|
+ }
|
|
|
+ KD.defaultOption = {
|
|
|
+ show: !0,
|
|
|
+ type: ["rect", "polygon", "lineX", "lineY", "keep", "clear"],
|
|
|
+ icon: {
|
|
|
+ rect: "M7.3,34.7 M0.4,10V-0.2h9.8 M89.6,10V-0.2h-9.8 M0.4,60v10.2h9.8 M89.6,60v10.2h-9.8 M12.3,22.4V10.5h13.1 M33.6,10.5h7.8 M49.1,10.5h7.8 M77.5,22.4V10.5h-13 M12.3,31.1v8.2 M77.7,31.1v8.2 M12.3,47.6v11.9h13.1 M33.6,59.5h7.6 M49.1,59.5 h7.7 M77.5,47.6v11.9h-13",
|
|
|
+ polygon: "M55.2,34.9c1.7,0,3.1,1.4,3.1,3.1s-1.4,3.1-3.1,3.1 s-3.1-1.4-3.1-3.1S53.5,34.9,55.2,34.9z M50.4,51c1.7,0,3.1,1.4,3.1,3.1c0,1.7-1.4,3.1-3.1,3.1c-1.7,0-3.1-1.4-3.1-3.1 C47.3,52.4,48.7,51,50.4,51z M55.6,37.1l1.5-7.8 M60.1,13.5l1.6-8.7l-7.8,4 M59,19l-1,5.3 M24,16.1l6.4,4.9l6.4-3.3 M48.5,11.6 l-5.9,3.1 M19.1,12.8L9.7,5.1l1.1,7.7 M13.4,29.8l1,7.3l6.6,1.6 M11.6,18.4l1,6.1 M32.8,41.9 M26.6,40.4 M27.3,40.2l6.1,1.6 M49.9,52.1l-5.6-7.6l-4.9-1.2",
|
|
|
+ lineX: "M15.2,30 M19.7,15.6V1.9H29 M34.8,1.9H40.4 M55.3,15.6V1.9H45.9 M19.7,44.4V58.1H29 M34.8,58.1H40.4 M55.3,44.4 V58.1H45.9 M12.5,20.3l-9.4,9.6l9.6,9.8 M3.1,29.9h16.5 M62.5,20.3l9.4,9.6L62.3,39.7 M71.9,29.9H55.4",
|
|
|
+ lineY: "M38.8,7.7 M52.7,12h13.2v9 M65.9,26.6V32 M52.7,46.3h13.2v-9 M24.9,12H11.8v9 M11.8,26.6V32 M24.9,46.3H11.8v-9 M48.2,5.1l-9.3-9l-9.4,9.2 M38.9-3.9V12 M48.2,53.3l-9.3,9l-9.4-9.2 M38.9,62.3V46.4",
|
|
|
+ keep: "M4,10.5V1h10.3 M20.7,1h6.1 M33,1h6.1 M55.4,10.5V1H45.2 M4,17.3v6.6 M55.6,17.3v6.6 M4,30.5V40h10.3 M20.7,40 h6.1 M33,40h6.1 M55.4,30.5V40H45.2 M21,18.9h62.9v48.6H21V18.9z",
|
|
|
+ clear: "M22,14.7l30.9,31 M52.9,14.7L22,45.7 M4.7,16.8V4.2h13.1 M26,4.2h7.8 M41.6,4.2h7.8 M70.3,16.8V4.2H57.2 M4.7,25.9v8.6 M70.3,25.9v8.6 M4.7,43.2v12.6h13.1 M26,55.8h7.8 M41.6,55.8h7.8 M70.3,43.2v12.6H57.2"
|
|
|
+ },
|
|
|
+ title: k(qD.title)
|
|
|
+ };
|
|
|
+ var $D = KD.prototype;
|
|
|
+ $D.render = $D.updateView = function(e, t, i) {
|
|
|
+ var n, o, a;
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "brush"
|
|
|
+ }, function(t) {
|
|
|
+ n = t.brushType,
|
|
|
+ o = t.brushOption.brushMode || "single",
|
|
|
+ a |= t.areas.length
|
|
|
+ }),
|
|
|
+ this._brushType = n,
|
|
|
+ this._brushMode = o,
|
|
|
+ E(e.get("type", !0), function(t) {
|
|
|
+ e.setIconStatus(t, ("keep" === t ? "multiple" === o : "clear" === t ? a : t === n) ? "emphasis" : "normal")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ $D.getIcons = function() {
|
|
|
+ var t = this.model
|
|
|
+ , e = t.get("icon", !0)
|
|
|
+ , i = {};
|
|
|
+ return E(t.get("type", !0), function(t) {
|
|
|
+ e[t] && (i[t] = e[t])
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ $D.onclick = function(t, e, i) {
|
|
|
+ var n = this._brushType
|
|
|
+ , o = this._brushMode;
|
|
|
+ "clear" === i ? (e.dispatchAction({
|
|
|
+ type: "axisAreaSelect",
|
|
|
+ intervals: []
|
|
|
+ }),
|
|
|
+ e.dispatchAction({
|
|
|
+ type: "brush",
|
|
|
+ command: "clear",
|
|
|
+ areas: []
|
|
|
+ })) : e.dispatchAction({
|
|
|
+ type: "takeGlobalCursor",
|
|
|
+ key: "brush",
|
|
|
+ brushOption: {
|
|
|
+ brushType: "keep" === i ? n : n !== i && i,
|
|
|
+ brushMode: "keep" === i ? "multiple" === o ? "single" : "multiple" : o
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ nA("brush", KD),
|
|
|
+ yf(function(t, e) {
|
|
|
+ var i = t && t.brush;
|
|
|
+ if (L(i) || (i = i ? [i] : []),
|
|
|
+ i.length) {
|
|
|
+ var n = [];
|
|
|
+ E(i, function(t) {
|
|
|
+ var e = t.hasOwnProperty("toolbox") ? t.toolbox : [];
|
|
|
+ e instanceof Array && (n = n.concat(e))
|
|
|
+ });
|
|
|
+ var o = t && t.toolbox;
|
|
|
+ L(o) && (o = o[0]),
|
|
|
+ o || (o = {
|
|
|
+ feature: {}
|
|
|
+ },
|
|
|
+ t.toolbox = [o]);
|
|
|
+ var a = o.feature || (o.feature = {})
|
|
|
+ , r = a.brush || (a.brush = {})
|
|
|
+ , s = r.type || (r.type = []);
|
|
|
+ s.push.apply(s, n),
|
|
|
+ function(i) {
|
|
|
+ var e = {};
|
|
|
+ E(i, function(t) {
|
|
|
+ e[t] = 1
|
|
|
+ }),
|
|
|
+ i.length = 0,
|
|
|
+ E(e, function(t, e) {
|
|
|
+ i.push(e)
|
|
|
+ })
|
|
|
+ }(s),
|
|
|
+ e && !s.length && s.push.apply(s, DD)
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ Tf({
|
|
|
+ type: "title",
|
|
|
+ layoutMode: {
|
|
|
+ type: "box",
|
|
|
+ ignoreSize: !0
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 6,
|
|
|
+ show: !0,
|
|
|
+ text: "",
|
|
|
+ target: "blank",
|
|
|
+ subtext: "",
|
|
|
+ subtarget: "blank",
|
|
|
+ left: 0,
|
|
|
+ top: 0,
|
|
|
+ backgroundColor: "rgba(0,0,0,0)",
|
|
|
+ borderColor: "#ccc",
|
|
|
+ borderWidth: 0,
|
|
|
+ padding: 5,
|
|
|
+ itemGap: 10,
|
|
|
+ textStyle: {
|
|
|
+ fontSize: 18,
|
|
|
+ fontWeight: "bolder",
|
|
|
+ color: "#333"
|
|
|
+ },
|
|
|
+ subtextStyle: {
|
|
|
+ color: "#aaa"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ Af({
|
|
|
+ type: "title",
|
|
|
+ render: function(t, e, i) {
|
|
|
+ if (this.group.removeAll(),
|
|
|
+ t.get("show")) {
|
|
|
+ var n = this.group
|
|
|
+ , o = t.getModel("textStyle")
|
|
|
+ , a = t.getModel("subtextStyle")
|
|
|
+ , r = t.get("textAlign")
|
|
|
+ , s = H(t.get("textBaseline"), t.get("textVerticalAlign"))
|
|
|
+ , l = new Ur({
|
|
|
+ style: nl({}, o, {
|
|
|
+ text: t.get("text"),
|
|
|
+ textFill: o.getTextColor()
|
|
|
+ }, {
|
|
|
+ disableBox: !0
|
|
|
+ }),
|
|
|
+ z2: 10
|
|
|
+ })
|
|
|
+ , u = l.getBoundingRect()
|
|
|
+ , h = t.get("subtext")
|
|
|
+ , c = new Ur({
|
|
|
+ style: nl({}, a, {
|
|
|
+ text: h,
|
|
|
+ textFill: a.getTextColor(),
|
|
|
+ y: u.height + t.get("itemGap"),
|
|
|
+ textVerticalAlign: "top"
|
|
|
+ }, {
|
|
|
+ disableBox: !0
|
|
|
+ }),
|
|
|
+ z2: 10
|
|
|
+ })
|
|
|
+ , d = t.get("link")
|
|
|
+ , f = t.get("sublink")
|
|
|
+ , p = t.get("triggerEvent", !0);
|
|
|
+ l.silent = !d && !p,
|
|
|
+ c.silent = !f && !p,
|
|
|
+ d && l.on("click", function() {
|
|
|
+ gu(d, "_" + t.get("target"))
|
|
|
+ }),
|
|
|
+ f && c.on("click", function() {
|
|
|
+ gu(d, "_" + t.get("subtarget"))
|
|
|
+ }),
|
|
|
+ l.eventData = c.eventData = p ? {
|
|
|
+ componentType: "title",
|
|
|
+ componentIndex: t.componentIndex
|
|
|
+ } : null,
|
|
|
+ n.add(l),
|
|
|
+ h && n.add(c);
|
|
|
+ var g = n.getBoundingRect()
|
|
|
+ , m = t.getBoxLayoutParams();
|
|
|
+ m.width = g.width,
|
|
|
+ m.height = g.height;
|
|
|
+ var v = bu(m, {
|
|
|
+ width: i.getWidth(),
|
|
|
+ height: i.getHeight()
|
|
|
+ }, t.get("padding"));
|
|
|
+ r || ("middle" === (r = t.get("left") || t.get("right")) && (r = "center"),
|
|
|
+ "right" === r ? v.x += v.width : "center" === r && (v.x += v.width / 2)),
|
|
|
+ s || ("center" === (s = t.get("top") || t.get("bottom")) && (s = "middle"),
|
|
|
+ "bottom" === s ? v.y += v.height : "middle" === s && (v.y += v.height / 2),
|
|
|
+ s = s || "top"),
|
|
|
+ n.attr("position", [v.x, v.y]);
|
|
|
+ var y = {
|
|
|
+ textAlign: r,
|
|
|
+ textVerticalAlign: s
|
|
|
+ };
|
|
|
+ l.setStyle(y),
|
|
|
+ c.setStyle(y),
|
|
|
+ g = n.getBoundingRect();
|
|
|
+ var x = v.margin
|
|
|
+ , _ = t.getItemStyle(["color", "opacity"]);
|
|
|
+ _.fill = t.get("backgroundColor");
|
|
|
+ var w = new rs({
|
|
|
+ shape: {
|
|
|
+ x: g.x - x[3],
|
|
|
+ y: g.y - x[0],
|
|
|
+ width: g.width + x[1] + x[3],
|
|
|
+ height: g.height + x[0] + x[2],
|
|
|
+ r: t.get("borderRadius")
|
|
|
+ },
|
|
|
+ style: _,
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ silent: !0
|
|
|
+ });
|
|
|
+ n.add(w)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function JD(t) {
|
|
|
+ var e = t.itemStyle || (t.itemStyle = {})
|
|
|
+ , i = e.emphasis || (e.emphasis = {})
|
|
|
+ , n = t.label || t.label || {}
|
|
|
+ , o = n.normal || (n.normal = {})
|
|
|
+ , a = {
|
|
|
+ normal: 1,
|
|
|
+ emphasis: 1
|
|
|
+ };
|
|
|
+ E(n, function(t, e) {
|
|
|
+ a[e] || QD(o, e) || (o[e] = t)
|
|
|
+ }),
|
|
|
+ i.label && !QD(n, "emphasis") && (n.emphasis = i.label,
|
|
|
+ delete i.label)
|
|
|
+ }
|
|
|
+ function QD(t, e) {
|
|
|
+ return t.hasOwnProperty(e)
|
|
|
+ }
|
|
|
+ ku.registerSubTypeDefaulter("timeline", function() {
|
|
|
+ return "slider"
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "timelineChange",
|
|
|
+ event: "timelineChanged",
|
|
|
+ update: "prepareAndUpdate"
|
|
|
+ }, function(t, e) {
|
|
|
+ var i = e.getComponent("timeline");
|
|
|
+ return i && null != t.currentIndex && (i.setCurrentIndex(t.currentIndex),
|
|
|
+ !i.get("loop", !0) && i.isIndexMax() && i.setPlayState(!1)),
|
|
|
+ e.resetOption("timeline"),
|
|
|
+ D({
|
|
|
+ currentIndex: i.option.currentIndex
|
|
|
+ }, t)
|
|
|
+ }),
|
|
|
+ _f({
|
|
|
+ type: "timelinePlayChange",
|
|
|
+ event: "timelinePlayChanged",
|
|
|
+ update: "update"
|
|
|
+ }, function(t, e) {
|
|
|
+ var i = e.getComponent("timeline");
|
|
|
+ i && null != t.playState && i.setPlayState(t.playState)
|
|
|
+ });
|
|
|
+ var tC = ku.extend({
|
|
|
+ type: "timeline",
|
|
|
+ layoutMode: "box",
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 4,
|
|
|
+ show: !0,
|
|
|
+ axisType: "time",
|
|
|
+ realtime: !0,
|
|
|
+ left: "20%",
|
|
|
+ top: null,
|
|
|
+ right: "20%",
|
|
|
+ bottom: 0,
|
|
|
+ width: null,
|
|
|
+ height: 40,
|
|
|
+ padding: 5,
|
|
|
+ controlPosition: "left",
|
|
|
+ autoPlay: !1,
|
|
|
+ rewind: !1,
|
|
|
+ loop: !0,
|
|
|
+ playInterval: 2e3,
|
|
|
+ currentIndex: 0,
|
|
|
+ itemStyle: {},
|
|
|
+ label: {
|
|
|
+ color: "#000"
|
|
|
+ },
|
|
|
+ data: []
|
|
|
+ },
|
|
|
+ init: function(t, e, i) {
|
|
|
+ this._data,
|
|
|
+ this._names,
|
|
|
+ this.mergeDefaultAndTheme(t, i),
|
|
|
+ this._initData()
|
|
|
+ },
|
|
|
+ mergeOption: function(t) {
|
|
|
+ tC.superApply(this, "mergeOption", arguments),
|
|
|
+ this._initData()
|
|
|
+ },
|
|
|
+ setCurrentIndex: function(t) {
|
|
|
+ null == t && (t = this.option.currentIndex);
|
|
|
+ var e = this._data.count();
|
|
|
+ this.option.loop ? t = (t % e + e) % e : (e <= t && (t = e - 1),
|
|
|
+ t < 0 && (t = 0)),
|
|
|
+ this.option.currentIndex = t
|
|
|
+ },
|
|
|
+ getCurrentIndex: function() {
|
|
|
+ return this.option.currentIndex
|
|
|
+ },
|
|
|
+ isIndexMax: function() {
|
|
|
+ return this.getCurrentIndex() >= this._data.count() - 1
|
|
|
+ },
|
|
|
+ setPlayState: function(t) {
|
|
|
+ this.option.autoPlay = !!t
|
|
|
+ },
|
|
|
+ getPlayState: function() {
|
|
|
+ return !!this.option.autoPlay
|
|
|
+ },
|
|
|
+ _initData: function() {
|
|
|
+ var t = this.option
|
|
|
+ , e = t.data || []
|
|
|
+ , i = t.axisType
|
|
|
+ , o = this._names = [];
|
|
|
+ if ("category" === i) {
|
|
|
+ var a = [];
|
|
|
+ E(e, function(t, e) {
|
|
|
+ var i, n = Wo(t);
|
|
|
+ z(t) ? (i = k(t)).value = e : i = e,
|
|
|
+ a.push(i),
|
|
|
+ R(n) || null != n && !isNaN(n) || (n = ""),
|
|
|
+ o.push(n + "")
|
|
|
+ }),
|
|
|
+ e = a
|
|
|
+ }
|
|
|
+ var n = {
|
|
|
+ category: "ordinal",
|
|
|
+ time: "time"
|
|
|
+ }[i] || "number";
|
|
|
+ (this._data = new Yf([{
|
|
|
+ name: "value",
|
|
|
+ type: n
|
|
|
+ }],this)).initData(e, o)
|
|
|
+ },
|
|
|
+ getData: function() {
|
|
|
+ return this._data
|
|
|
+ },
|
|
|
+ getCategories: function() {
|
|
|
+ if ("category" === this.get("axisType"))
|
|
|
+ return this._names.slice()
|
|
|
+ }
|
|
|
+ });
|
|
|
+ b(tC.extend({
|
|
|
+ type: "timeline.slider",
|
|
|
+ defaultOption: {
|
|
|
+ backgroundColor: "rgba(0,0,0,0)",
|
|
|
+ borderColor: "#ccc",
|
|
|
+ borderWidth: 0,
|
|
|
+ orient: "horizontal",
|
|
|
+ inverse: !1,
|
|
|
+ tooltip: {
|
|
|
+ trigger: "item"
|
|
|
+ },
|
|
|
+ symbol: "emptyCircle",
|
|
|
+ symbolSize: 10,
|
|
|
+ lineStyle: {
|
|
|
+ show: !0,
|
|
|
+ width: 2,
|
|
|
+ color: "#304654"
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ position: "auto",
|
|
|
+ show: !0,
|
|
|
+ interval: "auto",
|
|
|
+ rotate: 0,
|
|
|
+ color: "#304654"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ color: "#304654",
|
|
|
+ borderWidth: 1
|
|
|
+ },
|
|
|
+ checkpointStyle: {
|
|
|
+ symbol: "circle",
|
|
|
+ symbolSize: 13,
|
|
|
+ color: "#c23531",
|
|
|
+ borderWidth: 5,
|
|
|
+ borderColor: "rgba(194,53,49, 0.5)",
|
|
|
+ animation: !0,
|
|
|
+ animationDuration: 300,
|
|
|
+ animationEasing: "quinticInOut"
|
|
|
+ },
|
|
|
+ controlStyle: {
|
|
|
+ show: !0,
|
|
|
+ showPlayBtn: !0,
|
|
|
+ showPrevBtn: !0,
|
|
|
+ showNextBtn: !0,
|
|
|
+ itemSize: 22,
|
|
|
+ itemGap: 12,
|
|
|
+ position: "left",
|
|
|
+ playIcon: "path://M31.6,53C17.5,53,6,41.5,6,27.4S17.5,1.8,31.6,1.8C45.7,1.8,57.2,13.3,57.2,27.4S45.7,53,31.6,53z M31.6,3.3 C18.4,3.3,7.5,14.1,7.5,27.4c0,13.3,10.8,24.1,24.1,24.1C44.9,51.5,55.7,40.7,55.7,27.4C55.7,14.1,44.9,3.3,31.6,3.3z M24.9,21.3 c0-2.2,1.6-3.1,3.5-2l10.5,6.1c1.899,1.1,1.899,2.9,0,4l-10.5,6.1c-1.9,1.1-3.5,0.2-3.5-2V21.3z",
|
|
|
+ stopIcon: "path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z",
|
|
|
+ nextIcon: "path://M18.6,50.8l22.5-22.5c0.2-0.2,0.3-0.4,0.3-0.7c0-0.3-0.1-0.5-0.3-0.7L18.7,4.4c-0.1-0.1-0.2-0.3-0.2-0.5 c0-0.4,0.3-0.8,0.8-0.8c0.2,0,0.5,0.1,0.6,0.3l23.5,23.5l0,0c0.2,0.2,0.3,0.4,0.3,0.7c0,0.3-0.1,0.5-0.3,0.7l-0.1,0.1L19.7,52 c-0.1,0.1-0.3,0.2-0.5,0.2c-0.4,0-0.8-0.3-0.8-0.8C18.4,51.2,18.5,51,18.6,50.8z",
|
|
|
+ prevIcon: "path://M43,52.8L20.4,30.3c-0.2-0.2-0.3-0.4-0.3-0.7c0-0.3,0.1-0.5,0.3-0.7L42.9,6.4c0.1-0.1,0.2-0.3,0.2-0.5 c0-0.4-0.3-0.8-0.8-0.8c-0.2,0-0.5,0.1-0.6,0.3L18.3,28.8l0,0c-0.2,0.2-0.3,0.4-0.3,0.7c0,0.3,0.1,0.5,0.3,0.7l0.1,0.1L41.9,54 c0.1,0.1,0.3,0.2,0.5,0.2c0.4,0,0.8-0.3,0.8-0.8C43.2,53.2,43.1,53,43,52.8z",
|
|
|
+ color: "#304654",
|
|
|
+ borderColor: "#304654",
|
|
|
+ borderWidth: 1
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ color: "#c23531"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ color: "#c23531"
|
|
|
+ },
|
|
|
+ controlStyle: {
|
|
|
+ color: "#c23531",
|
|
|
+ borderColor: "#c23531",
|
|
|
+ borderWidth: 2
|
|
|
+ }
|
|
|
+ },
|
|
|
+ data: []
|
|
|
+ }
|
|
|
+ }), Xh);
|
|
|
+ function eC(t, e, i, n) {
|
|
|
+ Gg.call(this, t, e, i),
|
|
|
+ this.type = n || "value",
|
|
|
+ this.model = null
|
|
|
+ }
|
|
|
+ var iC = gc.extend({
|
|
|
+ type: "timeline"
|
|
|
+ });
|
|
|
+ eC.prototype = {
|
|
|
+ constructor: eC,
|
|
|
+ getLabelModel: function() {
|
|
|
+ return this.model.getModel("label")
|
|
|
+ },
|
|
|
+ isHorizontal: function() {
|
|
|
+ return "horizontal" === this.model.get("orient")
|
|
|
+ }
|
|
|
+ },
|
|
|
+ w(eC, Gg);
|
|
|
+ var nC = A
|
|
|
+ , oC = E
|
|
|
+ , aC = Math.PI;
|
|
|
+ function rC(t, e, i, n, o, a) {
|
|
|
+ var r = e.get("color");
|
|
|
+ o ? (o.setColor(r),
|
|
|
+ i.add(o),
|
|
|
+ a && a.onUpdate(o)) : ((o = wg(t.get("symbol"), -1, -1, 2, 2, r)).setStyle("strokeNoScale", !0),
|
|
|
+ i.add(o),
|
|
|
+ a && a.onCreate(o));
|
|
|
+ var s = e.getItemStyle(["color", "symbol", "symbolSize"]);
|
|
|
+ o.setStyle(s),
|
|
|
+ n = m({
|
|
|
+ rectHover: !0,
|
|
|
+ z2: 100
|
|
|
+ }, n, !0);
|
|
|
+ var l = t.get("symbolSize");
|
|
|
+ (l = l instanceof Array ? l.slice() : [+l, +l])[0] /= 2,
|
|
|
+ l[1] /= 2,
|
|
|
+ n.scale = l;
|
|
|
+ var u = t.get("symbolOffset");
|
|
|
+ if (u) {
|
|
|
+ var h = n.position = n.position || [0, 0];
|
|
|
+ h[0] += Rl(u[0], l[0]),
|
|
|
+ h[1] += Rl(u[1], l[1])
|
|
|
+ }
|
|
|
+ var c = t.get("symbolRotate");
|
|
|
+ return n.rotation = (c || 0) * Math.PI / 180 || 0,
|
|
|
+ o.attr(n),
|
|
|
+ o.updateTransform(),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ function sC(t, e, i, n, o) {
|
|
|
+ if (!t.dragging) {
|
|
|
+ var a = n.getModel("checkpointStyle")
|
|
|
+ , r = i.dataToCoord(n.getData().get(["value"], e));
|
|
|
+ o || !a.get("animation", !0) ? t.attr({
|
|
|
+ position: [r, 0]
|
|
|
+ }) : (t.stopAnimation(!0),
|
|
|
+ t.animateTo({
|
|
|
+ position: [r, 0]
|
|
|
+ }, a.get("animationDuration", !0), a.get("animationEasing", !0)))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ iC.extend({
|
|
|
+ type: "timeline.slider",
|
|
|
+ init: function(t, e) {
|
|
|
+ this.api = e,
|
|
|
+ this._axis,
|
|
|
+ this._viewRect,
|
|
|
+ this._timer,
|
|
|
+ this._currentPointer,
|
|
|
+ this._mainGroup,
|
|
|
+ this._labelGroup
|
|
|
+ },
|
|
|
+ render: function(e, t, i, n) {
|
|
|
+ if (this.model = e,
|
|
|
+ this.api = i,
|
|
|
+ this.ecModel = t,
|
|
|
+ this.group.removeAll(),
|
|
|
+ e.get("show", !0)) {
|
|
|
+ var o = this._layout(e, i)
|
|
|
+ , a = this._createGroup("mainGroup")
|
|
|
+ , r = this._createGroup("labelGroup")
|
|
|
+ , s = this._axis = this._createAxis(o, e);
|
|
|
+ e.formatTooltip = function(t) {
|
|
|
+ return au(s.scale.getLabel(t))
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ oC(["AxisLine", "AxisTick", "Control", "CurrentPointer"], function(t) {
|
|
|
+ this["_render" + t](o, a, s, e)
|
|
|
+ }, this),
|
|
|
+ this._renderAxisLabel(o, r, s, e),
|
|
|
+ this._position(o, e)
|
|
|
+ }
|
|
|
+ this._doPlayStop()
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this._clearTimer(),
|
|
|
+ this.group.removeAll()
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._clearTimer()
|
|
|
+ },
|
|
|
+ _layout: function(t, e) {
|
|
|
+ var i = t.get("label.position")
|
|
|
+ , n = t.get("orient")
|
|
|
+ , o = function(t, e) {
|
|
|
+ return bu(t.getBoxLayoutParams(), {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ }, t.get("padding"))
|
|
|
+ }(t, e);
|
|
|
+ null == i || "auto" === i ? i = "horizontal" === n ? o.y + o.height / 2 < e.getHeight() / 2 ? "-" : "+" : o.x + o.width / 2 < e.getWidth() / 2 ? "+" : "-" : isNaN(i) && (i = {
|
|
|
+ horizontal: {
|
|
|
+ top: "-",
|
|
|
+ bottom: "+"
|
|
|
+ },
|
|
|
+ vertical: {
|
|
|
+ left: "-",
|
|
|
+ right: "+"
|
|
|
+ }
|
|
|
+ }[n][i]);
|
|
|
+ var a, r, s, l, u = {
|
|
|
+ horizontal: "center",
|
|
|
+ vertical: 0 <= i || "+" === i ? "left" : "right"
|
|
|
+ }, h = {
|
|
|
+ horizontal: 0 <= i || "+" === i ? "top" : "bottom",
|
|
|
+ vertical: "middle"
|
|
|
+ }, c = {
|
|
|
+ horizontal: 0,
|
|
|
+ vertical: aC / 2
|
|
|
+ }, d = "vertical" === n ? o.height : o.width, f = t.getModel("controlStyle"), p = f.get("show", !0), g = p ? f.get("itemSize") : 0, m = p ? f.get("itemGap") : 0, v = g + m, y = t.get("label.rotate") || 0;
|
|
|
+ y = y * aC / 180;
|
|
|
+ var x = f.get("position", !0)
|
|
|
+ , _ = p && f.get("showPlayBtn", !0)
|
|
|
+ , w = p && f.get("showPrevBtn", !0)
|
|
|
+ , b = p && f.get("showNextBtn", !0)
|
|
|
+ , S = 0
|
|
|
+ , M = d;
|
|
|
+ return "left" === x || "bottom" === x ? (_ && (a = [0, 0],
|
|
|
+ S += v),
|
|
|
+ w && (r = [S, 0],
|
|
|
+ S += v)) : (_ && (a = [M - g, 0],
|
|
|
+ M -= v),
|
|
|
+ w && (r = [0, 0],
|
|
|
+ S += v)),
|
|
|
+ b && (s = [M - g, 0],
|
|
|
+ M -= v),
|
|
|
+ l = [S, M],
|
|
|
+ t.get("inverse") && l.reverse(),
|
|
|
+ {
|
|
|
+ viewRect: o,
|
|
|
+ mainLength: d,
|
|
|
+ orient: n,
|
|
|
+ rotation: c[n],
|
|
|
+ labelRotation: y,
|
|
|
+ labelPosOpt: i,
|
|
|
+ labelAlign: t.get("label.align") || u[n],
|
|
|
+ labelBaseline: t.get("label.verticalAlign") || t.get("label.baseline") || h[n],
|
|
|
+ playPosition: a,
|
|
|
+ prevBtnPosition: r,
|
|
|
+ nextBtnPosition: s,
|
|
|
+ axisExtent: l,
|
|
|
+ controlSize: g,
|
|
|
+ controlGap: m
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _position: function(t, e) {
|
|
|
+ var i = this._mainGroup
|
|
|
+ , n = this._labelGroup
|
|
|
+ , o = t.viewRect;
|
|
|
+ if ("vertical" === t.orient) {
|
|
|
+ var a = ae()
|
|
|
+ , r = o.x
|
|
|
+ , s = o.y + o.height;
|
|
|
+ ue(a, a, [-r, -s]),
|
|
|
+ he(a, a, -aC / 2),
|
|
|
+ ue(a, a, [r, s]),
|
|
|
+ (o = o.clone()).applyTransform(a)
|
|
|
+ }
|
|
|
+ var l = m(o)
|
|
|
+ , u = m(i.getBoundingRect())
|
|
|
+ , h = m(n.getBoundingRect())
|
|
|
+ , c = i.position
|
|
|
+ , d = n.position;
|
|
|
+ d[0] = c[0] = l[0][0];
|
|
|
+ var f, p = t.labelPosOpt;
|
|
|
+ isNaN(p) ? (v(c, u, l, 1, f = "+" === p ? 0 : 1),
|
|
|
+ v(d, h, l, 1, 1 - f)) : (v(c, u, l, 1, f = 0 <= p ? 0 : 1),
|
|
|
+ d[1] = c[1] + p);
|
|
|
+ function g(t) {
|
|
|
+ var e = t.position;
|
|
|
+ t.origin = [l[0][0] - e[0], l[1][0] - e[1]]
|
|
|
+ }
|
|
|
+ function m(t) {
|
|
|
+ return [[t.x, t.x + t.width], [t.y, t.y + t.height]]
|
|
|
+ }
|
|
|
+ function v(t, e, i, n, o) {
|
|
|
+ t[n] += i[n][o] - e[n][o]
|
|
|
+ }
|
|
|
+ i.attr("position", c),
|
|
|
+ n.attr("position", d),
|
|
|
+ i.rotation = n.rotation = t.rotation,
|
|
|
+ g(i),
|
|
|
+ g(n)
|
|
|
+ },
|
|
|
+ _createAxis: function(t, e) {
|
|
|
+ var i = e.getData()
|
|
|
+ , n = e.get("axisType")
|
|
|
+ , o = sg(e, n);
|
|
|
+ o.getTicks = function() {
|
|
|
+ return i.mapArray(["value"], function(t) {
|
|
|
+ return t
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var a = i.getDataExtent("value");
|
|
|
+ o.setExtent(a[0], a[1]),
|
|
|
+ o.niceTicks();
|
|
|
+ var r = new eC("value",o,t.axisExtent,n);
|
|
|
+ return r.model = e,
|
|
|
+ r
|
|
|
+ },
|
|
|
+ _createGroup: function(t) {
|
|
|
+ var e = this["_" + t] = new Ci;
|
|
|
+ return this.group.add(e),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ _renderAxisLine: function(t, e, i, n) {
|
|
|
+ var o = i.getExtent();
|
|
|
+ n.get("lineStyle.show") && e.add(new ls({
|
|
|
+ shape: {
|
|
|
+ x1: o[0],
|
|
|
+ y1: 0,
|
|
|
+ x2: o[1],
|
|
|
+ y2: 0
|
|
|
+ },
|
|
|
+ style: P({
|
|
|
+ lineCap: "round"
|
|
|
+ }, n.getModel("lineStyle").getLineStyle()),
|
|
|
+ silent: !0,
|
|
|
+ z2: 1
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ _renderAxisTick: function(t, s, l, u) {
|
|
|
+ var h = u.getData()
|
|
|
+ , e = l.scale.getTicks();
|
|
|
+ oC(e, function(t) {
|
|
|
+ var e = l.dataToCoord(t)
|
|
|
+ , i = h.getItemModel(t)
|
|
|
+ , n = i.getModel("itemStyle")
|
|
|
+ , o = i.getModel("emphasis.itemStyle")
|
|
|
+ , a = {
|
|
|
+ position: [e, 0],
|
|
|
+ onclick: nC(this._changeTimeline, this, t)
|
|
|
+ }
|
|
|
+ , r = rC(i, n, s, a);
|
|
|
+ $s(r, o.getItemStyle()),
|
|
|
+ i.get("tooltip") ? (r.dataIndex = t,
|
|
|
+ r.dataModel = u) : r.dataIndex = r.dataModel = null
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _renderAxisLabel: function(s, l, u, t) {
|
|
|
+ if (u.getLabelModel().get("show")) {
|
|
|
+ var h = t.getData()
|
|
|
+ , e = u.getViewLabels();
|
|
|
+ oC(e, function(t) {
|
|
|
+ var e = t.tickValue
|
|
|
+ , i = h.getItemModel(e)
|
|
|
+ , n = i.getModel("label")
|
|
|
+ , o = i.getModel("emphasis.label")
|
|
|
+ , a = u.dataToCoord(t.tickValue)
|
|
|
+ , r = new Ur({
|
|
|
+ position: [a, 0],
|
|
|
+ rotation: s.labelRotation - s.rotation,
|
|
|
+ onclick: nC(this._changeTimeline, this, e),
|
|
|
+ silent: !1
|
|
|
+ });
|
|
|
+ nl(r.style, n, {
|
|
|
+ text: t.formattedLabel,
|
|
|
+ textAlign: s.labelAlign,
|
|
|
+ textVerticalAlign: s.labelBaseline
|
|
|
+ }),
|
|
|
+ l.add(r),
|
|
|
+ $s(r, nl({}, o))
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderControl: function(t, a, e, r) {
|
|
|
+ var s = t.controlSize
|
|
|
+ , l = t.rotation
|
|
|
+ , u = r.getModel("controlStyle").getItemStyle()
|
|
|
+ , h = r.getModel("emphasis.controlStyle").getItemStyle()
|
|
|
+ , c = [0, -s / 2, s, s]
|
|
|
+ , i = r.getPlayState()
|
|
|
+ , n = r.get("inverse", !0);
|
|
|
+ function o(t, e, i, n) {
|
|
|
+ if (t) {
|
|
|
+ var o = function(t, e, i, n) {
|
|
|
+ return Ps(t.get(e).replace(/^path:\/\//, ""), k(n || {}), new Di(i[0],i[1],i[2],i[3]), "center")
|
|
|
+ }(r, e, c, {
|
|
|
+ position: t,
|
|
|
+ origin: [s / 2, 0],
|
|
|
+ rotation: n ? -l : 0,
|
|
|
+ rectHover: !0,
|
|
|
+ style: u,
|
|
|
+ onclick: i
|
|
|
+ });
|
|
|
+ a.add(o),
|
|
|
+ $s(o, h)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ o(t.nextBtnPosition, "controlStyle.nextIcon", nC(this._changeTimeline, this, n ? "-" : "+")),
|
|
|
+ o(t.prevBtnPosition, "controlStyle.prevIcon", nC(this._changeTimeline, this, n ? "+" : "-")),
|
|
|
+ o(t.playPosition, "controlStyle." + (i ? "stopIcon" : "playIcon"), nC(this._handlePlayClick, this, !i), !0)
|
|
|
+ },
|
|
|
+ _renderCurrentPointer: function(t, e, i, n) {
|
|
|
+ var o = n.getData()
|
|
|
+ , a = n.getCurrentIndex()
|
|
|
+ , r = o.getItemModel(a).getModel("checkpointStyle")
|
|
|
+ , s = this
|
|
|
+ , l = {
|
|
|
+ onCreate: function(t) {
|
|
|
+ t.draggable = !0,
|
|
|
+ t.drift = nC(s._handlePointerDrag, s),
|
|
|
+ t.ondragend = nC(s._handlePointerDragend, s),
|
|
|
+ sC(t, a, i, n, !0)
|
|
|
+ },
|
|
|
+ onUpdate: function(t) {
|
|
|
+ sC(t, a, i, n)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ this._currentPointer = rC(r, r, this._mainGroup, {}, this._currentPointer, l)
|
|
|
+ },
|
|
|
+ _handlePlayClick: function(t) {
|
|
|
+ this._clearTimer(),
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "timelinePlayChange",
|
|
|
+ playState: t,
|
|
|
+ from: this.uid
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _handlePointerDrag: function(t, e, i) {
|
|
|
+ this._clearTimer(),
|
|
|
+ this._pointerChangeTimeline([i.offsetX, i.offsetY])
|
|
|
+ },
|
|
|
+ _handlePointerDragend: function(t) {
|
|
|
+ this._pointerChangeTimeline([t.offsetX, t.offsetY], !0)
|
|
|
+ },
|
|
|
+ _pointerChangeTimeline: function(t, e) {
|
|
|
+ var i = this._toAxisCoord(t)[0]
|
|
|
+ , n = Bl(this._axis.getExtent().slice());
|
|
|
+ i > n[1] && (i = n[1]),
|
|
|
+ i < n[0] && (i = n[0]),
|
|
|
+ this._currentPointer.position[0] = i,
|
|
|
+ this._currentPointer.dirty();
|
|
|
+ var o = this._findNearestTick(i)
|
|
|
+ , a = this.model;
|
|
|
+ (e || o !== a.getCurrentIndex() && a.get("realtime")) && this._changeTimeline(o)
|
|
|
+ },
|
|
|
+ _doPlayStop: function() {
|
|
|
+ this._clearTimer(),
|
|
|
+ this.model.getPlayState() && (this._timer = setTimeout(nC(function() {
|
|
|
+ var t = this.model;
|
|
|
+ this._changeTimeline(t.getCurrentIndex() + (t.get("rewind", !0) ? -1 : 1))
|
|
|
+ }, this), this.model.get("playInterval")))
|
|
|
+ },
|
|
|
+ _toAxisCoord: function(t) {
|
|
|
+ return pl(t, this._mainGroup.getLocalTransform(), !0)
|
|
|
+ },
|
|
|
+ _findNearestTick: function(o) {
|
|
|
+ var a, t = this.model.getData(), r = 1 / 0, s = this._axis;
|
|
|
+ return t.each(["value"], function(t, e) {
|
|
|
+ var i = s.dataToCoord(t)
|
|
|
+ , n = Math.abs(i - o);
|
|
|
+ n < r && (r = n,
|
|
|
+ a = e)
|
|
|
+ }),
|
|
|
+ a
|
|
|
+ },
|
|
|
+ _clearTimer: function() {
|
|
|
+ this._timer && (clearTimeout(this._timer),
|
|
|
+ this._timer = null)
|
|
|
+ },
|
|
|
+ _changeTimeline: function(t) {
|
|
|
+ var e = this.model.getCurrentIndex();
|
|
|
+ "+" === t ? t = e + 1 : "-" === t && (t = e - 1),
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "timelineChange",
|
|
|
+ currentIndex: t,
|
|
|
+ from: this.uid
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ yf(function(t) {
|
|
|
+ var e = t && t.timeline;
|
|
|
+ L(e) || (e = e ? [e] : []),
|
|
|
+ E(e, function(t) {
|
|
|
+ t && function(t) {
|
|
|
+ var e = t.type
|
|
|
+ , i = {
|
|
|
+ number: "value",
|
|
|
+ time: "time"
|
|
|
+ };
|
|
|
+ i[e] && (t.axisType = i[e],
|
|
|
+ delete t.type);
|
|
|
+ if (JD(t),
|
|
|
+ QD(t, "controlPosition")) {
|
|
|
+ var n = t.controlStyle || (t.controlStyle = {});
|
|
|
+ QD(n, "position") || (n.position = t.controlPosition),
|
|
|
+ "none" !== n.position || QD(n, "show") || (n.show = !1,
|
|
|
+ delete n.position),
|
|
|
+ delete t.controlPosition
|
|
|
+ }
|
|
|
+ E(t.data || [], function(t) {
|
|
|
+ z(t) && !L(t) && (!QD(t, "value") && QD(t, "name") && (t.value = t.name),
|
|
|
+ JD(t))
|
|
|
+ })
|
|
|
+ }(t)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var lC = tu
|
|
|
+ , uC = au;
|
|
|
+ function hC(t) {
|
|
|
+ Go(t, "label", ["show"])
|
|
|
+ }
|
|
|
+ var cC = Tf({
|
|
|
+ type: "marker",
|
|
|
+ dependencies: ["series", "grid", "polar", "geo"],
|
|
|
+ init: function(t, e, i) {
|
|
|
+ this.mergeDefaultAndTheme(t, i),
|
|
|
+ this._mergeOption(t, i, !1, !0)
|
|
|
+ },
|
|
|
+ isAnimationEnabled: function() {
|
|
|
+ if (v.node)
|
|
|
+ return !1;
|
|
|
+ var t = this.__hostSeries;
|
|
|
+ return this.getShallow("animation") && t && t.isAnimationEnabled()
|
|
|
+ },
|
|
|
+ mergeOption: function(t, e) {
|
|
|
+ this._mergeOption(t, e, !1, !1)
|
|
|
+ },
|
|
|
+ _mergeOption: function(t, n, e, o) {
|
|
|
+ var a = this.constructor
|
|
|
+ , r = this.mainType + "Model";
|
|
|
+ e || n.eachSeries(function(t) {
|
|
|
+ var e = t.get(this.mainType, !0)
|
|
|
+ , i = t[r];
|
|
|
+ e && e.data ? (i ? i._mergeOption(e, n, !0) : (o && hC(e),
|
|
|
+ E(e.data, function(t) {
|
|
|
+ t instanceof Array ? (hC(t[0]),
|
|
|
+ hC(t[1])) : hC(t)
|
|
|
+ }),
|
|
|
+ P(i = new a(e,this,n), {
|
|
|
+ mainType: this.mainType,
|
|
|
+ seriesIndex: t.seriesIndex,
|
|
|
+ name: t.name,
|
|
|
+ createdBySelf: !0
|
|
|
+ }),
|
|
|
+ i.__hostSeries = t),
|
|
|
+ t[r] = i) : t[r] = null
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ formatTooltip: function(t) {
|
|
|
+ var e = this.getData()
|
|
|
+ , i = this.getRawValue(t)
|
|
|
+ , n = L(i) ? O(i, lC).join(", ") : lC(i)
|
|
|
+ , o = e.getName(t)
|
|
|
+ , a = uC(this.name);
|
|
|
+ return null == i && !o || (a += "<br />"),
|
|
|
+ o && (a += uC(o),
|
|
|
+ null != i && (a += " : ")),
|
|
|
+ null != i && (a += uC(n)),
|
|
|
+ a
|
|
|
+ },
|
|
|
+ getData: function() {
|
|
|
+ return this._data
|
|
|
+ },
|
|
|
+ setData: function(t) {
|
|
|
+ this._data = t
|
|
|
+ }
|
|
|
+ });
|
|
|
+ b(cC, Xh),
|
|
|
+ cC.extend({
|
|
|
+ type: "markPoint",
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 5,
|
|
|
+ symbol: "pin",
|
|
|
+ symbolSize: 50,
|
|
|
+ tooltip: {
|
|
|
+ trigger: "item"
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ position: "inside"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: 2
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var dC = _;
|
|
|
+ function fC(t, e, i, n, o, a) {
|
|
|
+ var r = []
|
|
|
+ , s = fp(e, n) ? e.getCalculationInfo("stackResultDimension") : n
|
|
|
+ , l = _C(e, s, t)
|
|
|
+ , u = e.indicesOfNearest(s, l)[0];
|
|
|
+ r[o] = e.get(i, u),
|
|
|
+ r[a] = e.get(s, u);
|
|
|
+ var h = e.get(n, u)
|
|
|
+ , c = Vl(e.get(n, u));
|
|
|
+ return 0 <= (c = Math.min(c, 20)) && (r[a] = +r[a].toFixed(c)),
|
|
|
+ [r, h]
|
|
|
+ }
|
|
|
+ var pC = T
|
|
|
+ , gC = {
|
|
|
+ min: pC(fC, "min"),
|
|
|
+ max: pC(fC, "max"),
|
|
|
+ average: pC(fC, "average")
|
|
|
+ };
|
|
|
+ function mC(t, e) {
|
|
|
+ var i = t.getData()
|
|
|
+ , n = t.coordinateSystem;
|
|
|
+ if (e && !function(t) {
|
|
|
+ return !isNaN(parseFloat(t.x)) && !isNaN(parseFloat(t.y))
|
|
|
+ }(e) && !L(e.coord) && n) {
|
|
|
+ var o = n.dimensions
|
|
|
+ , a = vC(e, i, n, t);
|
|
|
+ if ((e = k(e)).type && gC[e.type] && a.baseAxis && a.valueAxis) {
|
|
|
+ var r = dC(o, a.baseAxis.dim)
|
|
|
+ , s = dC(o, a.valueAxis.dim)
|
|
|
+ , l = gC[e.type](i, a.baseDataDim, a.valueDataDim, r, s);
|
|
|
+ e.coord = l[0],
|
|
|
+ e.value = l[1]
|
|
|
+ } else {
|
|
|
+ for (var u = [null != e.xAxis ? e.xAxis : e.radiusAxis, null != e.yAxis ? e.yAxis : e.angleAxis], h = 0; h < 2; h++)
|
|
|
+ gC[u[h]] && (u[h] = _C(i, i.mapDimension(o[h]), u[h]));
|
|
|
+ e.coord = u
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ function vC(t, e, i, n) {
|
|
|
+ var o = {};
|
|
|
+ return null != t.valueIndex || null != t.valueDim ? (o.valueDataDim = null != t.valueIndex ? e.getDimension(t.valueIndex) : t.valueDim,
|
|
|
+ o.valueAxis = i.getAxis(function(t, e) {
|
|
|
+ var i = t.getData()
|
|
|
+ , n = i.dimensions;
|
|
|
+ e = i.getDimension(e);
|
|
|
+ for (var o = 0; o < n.length; o++) {
|
|
|
+ var a = i.getDimensionInfo(n[o]);
|
|
|
+ if (a.name === e)
|
|
|
+ return a.coordDim
|
|
|
+ }
|
|
|
+ }(n, o.valueDataDim)),
|
|
|
+ o.baseAxis = i.getOtherAxis(o.valueAxis),
|
|
|
+ o.baseDataDim = e.mapDimension(o.baseAxis.dim)) : (o.baseAxis = n.getBaseAxis(),
|
|
|
+ o.valueAxis = i.getOtherAxis(o.baseAxis),
|
|
|
+ o.baseDataDim = e.mapDimension(o.baseAxis.dim),
|
|
|
+ o.valueDataDim = e.mapDimension(o.valueAxis.dim)),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ function yC(t, e) {
|
|
|
+ return !(t && t.containData && e.coord && !function(t) {
|
|
|
+ return !(isNaN(parseFloat(t.x)) && isNaN(parseFloat(t.y)))
|
|
|
+ }(e)) || t.containData(e.coord)
|
|
|
+ }
|
|
|
+ function xC(t, e, i, n) {
|
|
|
+ return n < 2 ? t.coord && t.coord[n] : t.value
|
|
|
+ }
|
|
|
+ function _C(t, e, i) {
|
|
|
+ if ("average" !== i)
|
|
|
+ return "median" === i ? t.getMedian(e) : t.getDataExtent(e, !0)["max" === i ? 1 : 0];
|
|
|
+ var n = 0
|
|
|
+ , o = 0;
|
|
|
+ return t.each(e, function(t, e) {
|
|
|
+ isNaN(t) || (n += t,
|
|
|
+ o++)
|
|
|
+ }),
|
|
|
+ n / o
|
|
|
+ }
|
|
|
+ var wC = Af({
|
|
|
+ type: "marker",
|
|
|
+ init: function() {
|
|
|
+ this.markerGroupMap = Q()
|
|
|
+ },
|
|
|
+ render: function(t, i, n) {
|
|
|
+ var e = this.markerGroupMap;
|
|
|
+ e.each(function(t) {
|
|
|
+ t.__keep = !1
|
|
|
+ });
|
|
|
+ var o = this.type + "Model";
|
|
|
+ i.eachSeries(function(t) {
|
|
|
+ var e = t[o];
|
|
|
+ e && this.renderSeries(t, e, i, n)
|
|
|
+ }, this),
|
|
|
+ e.each(function(t) {
|
|
|
+ t.__keep || this.group.remove(t.group)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ renderSeries: function() {}
|
|
|
+ });
|
|
|
+ function bC(s, l, u) {
|
|
|
+ var h = l.coordinateSystem;
|
|
|
+ s.each(function(t) {
|
|
|
+ var e, i = s.getItemModel(t), n = Rl(i.get("x"), u.getWidth()), o = Rl(i.get("y"), u.getHeight());
|
|
|
+ if (isNaN(n) || isNaN(o)) {
|
|
|
+ if (l.getMarkerPosition)
|
|
|
+ e = l.getMarkerPosition(s.getValues(s.dimensions, t));
|
|
|
+ else if (h) {
|
|
|
+ var a = s.get(h.dimensions[0], t)
|
|
|
+ , r = s.get(h.dimensions[1], t);
|
|
|
+ e = h.dataToPoint([a, r])
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ e = [n, o];
|
|
|
+ isNaN(n) || (e[0] = n),
|
|
|
+ isNaN(o) || (e[1] = o),
|
|
|
+ s.setItemLayout(t, e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ wC.extend({
|
|
|
+ type: "markPoint",
|
|
|
+ updateTransform: function(t, e, i) {
|
|
|
+ e.eachSeries(function(t) {
|
|
|
+ var e = t.markPointModel;
|
|
|
+ e && (bC(e.getData(), t, i),
|
|
|
+ this.markerGroupMap.get(t.id).updateLayout(e))
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ renderSeries: function(t, l, e, i) {
|
|
|
+ var n = t.coordinateSystem
|
|
|
+ , o = t.id
|
|
|
+ , u = t.getData()
|
|
|
+ , a = this.markerGroupMap
|
|
|
+ , r = a.get(o) || a.set(o, new im)
|
|
|
+ , h = function(t, e, i) {
|
|
|
+ var n;
|
|
|
+ n = t ? O(t && t.dimensions, function(t) {
|
|
|
+ return D({
|
|
|
+ name: t
|
|
|
+ }, e.getData().getDimensionInfo(e.getData().mapDimension(t)) || {})
|
|
|
+ }) : [{
|
|
|
+ name: "value",
|
|
|
+ type: "float"
|
|
|
+ }];
|
|
|
+ var o = new Yf(n,i)
|
|
|
+ , a = O(i.get("data"), T(mC, e));
|
|
|
+ t && (a = M(a, T(yC, t)));
|
|
|
+ return o.initData(a, null, t ? xC : function(t) {
|
|
|
+ return t.value
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ o
|
|
|
+ }(n, t, l);
|
|
|
+ l.setData(h),
|
|
|
+ bC(l.getData(), t, i),
|
|
|
+ h.each(function(t) {
|
|
|
+ var e = h.getItemModel(t)
|
|
|
+ , i = e.getShallow("symbol")
|
|
|
+ , n = e.getShallow("symbolSize")
|
|
|
+ , o = C(i)
|
|
|
+ , a = C(n);
|
|
|
+ if (o || a) {
|
|
|
+ var r = l.getRawValue(t)
|
|
|
+ , s = l.getDataParams(t);
|
|
|
+ o && (i = i(r, s)),
|
|
|
+ a && (n = n(r, s))
|
|
|
+ }
|
|
|
+ h.setItemVisual(t, {
|
|
|
+ symbol: i,
|
|
|
+ symbolSize: n,
|
|
|
+ color: e.get("itemStyle.color") || u.getVisual("color")
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ r.updateData(h),
|
|
|
+ this.group.add(r.group),
|
|
|
+ h.eachItemGraphicEl(function(t) {
|
|
|
+ t.traverse(function(t) {
|
|
|
+ t.dataModel = l
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ r.__keep = !0,
|
|
|
+ r.group.silent = l.get("silent") || t.get("silent")
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ yf(function(t) {
|
|
|
+ t.markPoint = t.markPoint || {}
|
|
|
+ }),
|
|
|
+ cC.extend({
|
|
|
+ type: "markLine",
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 5,
|
|
|
+ symbol: ["circle", "arrow"],
|
|
|
+ symbolSize: [8, 16],
|
|
|
+ precision: 2,
|
|
|
+ tooltip: {
|
|
|
+ trigger: "item"
|
|
|
+ },
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ position: "end",
|
|
|
+ distance: 5
|
|
|
+ },
|
|
|
+ lineStyle: {
|
|
|
+ type: "dashed"
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0
|
|
|
+ },
|
|
|
+ lineStyle: {
|
|
|
+ width: 3
|
|
|
+ }
|
|
|
+ },
|
|
|
+ animationEasing: "linear"
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function SC(t, e, i, n) {
|
|
|
+ var o = t.getData()
|
|
|
+ , a = n.type;
|
|
|
+ if (!L(n) && ("min" === a || "max" === a || "average" === a || "median" === a || null != n.xAxis || null != n.yAxis)) {
|
|
|
+ var r, s;
|
|
|
+ if (null != n.yAxis || null != n.xAxis)
|
|
|
+ r = e.getAxis(null != n.yAxis ? "y" : "x"),
|
|
|
+ s = W(n.yAxis, n.xAxis);
|
|
|
+ else {
|
|
|
+ var l = vC(n, o, e, t);
|
|
|
+ r = l.valueAxis,
|
|
|
+ s = _C(o, pp(o, l.valueDataDim), a)
|
|
|
+ }
|
|
|
+ var u = "x" === r.dim ? 0 : 1
|
|
|
+ , h = 1 - u
|
|
|
+ , c = k(n)
|
|
|
+ , d = {};
|
|
|
+ c.type = null,
|
|
|
+ c.coord = [],
|
|
|
+ d.coord = [],
|
|
|
+ c.coord[h] = -1 / 0,
|
|
|
+ d.coord[h] = 1 / 0;
|
|
|
+ var f = i.get("precision");
|
|
|
+ 0 <= f && "number" == typeof s && (s = +s.toFixed(Math.min(f, 20))),
|
|
|
+ c.coord[u] = d.coord[u] = s,
|
|
|
+ n = [c, d, {
|
|
|
+ type: a,
|
|
|
+ valueIndex: n.valueIndex,
|
|
|
+ value: s
|
|
|
+ }]
|
|
|
+ }
|
|
|
+ return (n = [mC(t, n[0]), mC(t, n[1]), P({}, n[2])])[2].type = n[2].type || "",
|
|
|
+ m(n[2], n[0]),
|
|
|
+ m(n[2], n[1]),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ function MC(t) {
|
|
|
+ return !isNaN(t) && !isFinite(t)
|
|
|
+ }
|
|
|
+ function IC(t, e, i, n) {
|
|
|
+ var o = 1 - t
|
|
|
+ , a = n.dimensions[t];
|
|
|
+ return MC(e[o]) && MC(i[o]) && e[t] === i[t] && n.getAxis(a).containData(e[t])
|
|
|
+ }
|
|
|
+ function TC(t, e) {
|
|
|
+ if ("cartesian2d" === t.type) {
|
|
|
+ var i = e[0].coord
|
|
|
+ , n = e[1].coord;
|
|
|
+ if (i && n && (IC(1, i, n, t) || IC(0, i, n, t)))
|
|
|
+ return !0
|
|
|
+ }
|
|
|
+ return yC(t, e[0]) && yC(t, e[1])
|
|
|
+ }
|
|
|
+ function AC(t, e, i, n, o) {
|
|
|
+ var a, r = n.coordinateSystem, s = t.getItemModel(e), l = Rl(s.get("x"), o.getWidth()), u = Rl(s.get("y"), o.getHeight());
|
|
|
+ if (isNaN(l) || isNaN(u)) {
|
|
|
+ if (n.getMarkerPosition)
|
|
|
+ a = n.getMarkerPosition(t.getValues(t.dimensions, e));
|
|
|
+ else {
|
|
|
+ var h = r.dimensions
|
|
|
+ , c = t.get(h[0], e)
|
|
|
+ , d = t.get(h[1], e);
|
|
|
+ a = r.dataToPoint([c, d])
|
|
|
+ }
|
|
|
+ if ("cartesian2d" === r.type) {
|
|
|
+ var f = r.getAxis("x")
|
|
|
+ , p = r.getAxis("y");
|
|
|
+ h = r.dimensions;
|
|
|
+ MC(t.get(h[0], e)) ? a[0] = f.toGlobalCoord(f.getExtent()[i ? 0 : 1]) : MC(t.get(h[1], e)) && (a[1] = p.toGlobalCoord(p.getExtent()[i ? 0 : 1]))
|
|
|
+ }
|
|
|
+ isNaN(l) || (a[0] = l),
|
|
|
+ isNaN(u) || (a[1] = u)
|
|
|
+ } else
|
|
|
+ a = [l, u];
|
|
|
+ t.setItemLayout(e, a)
|
|
|
+ }
|
|
|
+ wC.extend({
|
|
|
+ type: "markLine",
|
|
|
+ updateTransform: function(t, e, a) {
|
|
|
+ e.eachSeries(function(e) {
|
|
|
+ var t = e.markLineModel;
|
|
|
+ if (t) {
|
|
|
+ var i = t.getData()
|
|
|
+ , n = t.__from
|
|
|
+ , o = t.__to;
|
|
|
+ n.each(function(t) {
|
|
|
+ AC(n, t, !0, e, a),
|
|
|
+ AC(o, t, !1, e, a)
|
|
|
+ }),
|
|
|
+ i.each(function(t) {
|
|
|
+ i.setItemLayout(t, [n.getItemLayout(t), o.getItemLayout(t)])
|
|
|
+ }),
|
|
|
+ this.markerGroupMap.get(e.id).updateLayout()
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ renderSeries: function(o, i, t, a) {
|
|
|
+ var e = o.coordinateSystem
|
|
|
+ , n = o.id
|
|
|
+ , r = o.getData()
|
|
|
+ , s = this.markerGroupMap
|
|
|
+ , l = s.get(n) || s.set(n, new pw);
|
|
|
+ this.group.add(l.group);
|
|
|
+ var u = function(t, e, i) {
|
|
|
+ var n;
|
|
|
+ n = t ? O(t && t.dimensions, function(t) {
|
|
|
+ return D({
|
|
|
+ name: t
|
|
|
+ }, e.getData().getDimensionInfo(e.getData().mapDimension(t)) || {})
|
|
|
+ }) : [{
|
|
|
+ name: "value",
|
|
|
+ type: "float"
|
|
|
+ }];
|
|
|
+ var o = new Yf(n,i)
|
|
|
+ , a = new Yf(n,i)
|
|
|
+ , r = new Yf([],i)
|
|
|
+ , s = O(i.get("data"), T(SC, e, t, i));
|
|
|
+ t && (s = M(s, T(TC, t)));
|
|
|
+ var l = t ? xC : function(t) {
|
|
|
+ return t.value
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ return o.initData(O(s, function(t) {
|
|
|
+ return t[0]
|
|
|
+ }), null, l),
|
|
|
+ a.initData(O(s, function(t) {
|
|
|
+ return t[1]
|
|
|
+ }), null, l),
|
|
|
+ r.initData(O(s, function(t) {
|
|
|
+ return t[2]
|
|
|
+ })),
|
|
|
+ r.hasItemOption = !0,
|
|
|
+ {
|
|
|
+ from: o,
|
|
|
+ to: a,
|
|
|
+ line: r
|
|
|
+ }
|
|
|
+ }(e, o, i)
|
|
|
+ , h = u.from
|
|
|
+ , c = u.to
|
|
|
+ , d = u.line;
|
|
|
+ i.__from = h,
|
|
|
+ i.__to = c,
|
|
|
+ i.setData(d);
|
|
|
+ var f = i.get("symbol")
|
|
|
+ , p = i.get("symbolSize");
|
|
|
+ function g(t, e, i) {
|
|
|
+ var n = t.getItemModel(e);
|
|
|
+ AC(t, e, i, o, a),
|
|
|
+ t.setItemVisual(e, {
|
|
|
+ symbolSize: n.get("symbolSize") || p[i ? 0 : 1],
|
|
|
+ symbol: n.get("symbol", !0) || f[i ? 0 : 1],
|
|
|
+ color: n.get("itemStyle.color") || r.getVisual("color")
|
|
|
+ })
|
|
|
+ }
|
|
|
+ L(f) || (f = [f, f]),
|
|
|
+ "number" == typeof p && (p = [p, p]),
|
|
|
+ u.from.each(function(t) {
|
|
|
+ g(h, t, !0),
|
|
|
+ g(c, t, !1)
|
|
|
+ }),
|
|
|
+ d.each(function(t) {
|
|
|
+ var e = d.getItemModel(t).get("lineStyle.color");
|
|
|
+ d.setItemVisual(t, {
|
|
|
+ color: e || h.getItemVisual(t, "color")
|
|
|
+ }),
|
|
|
+ d.setItemLayout(t, [h.getItemLayout(t), c.getItemLayout(t)]),
|
|
|
+ d.setItemVisual(t, {
|
|
|
+ fromSymbolSize: h.getItemVisual(t, "symbolSize"),
|
|
|
+ fromSymbol: h.getItemVisual(t, "symbol"),
|
|
|
+ toSymbolSize: c.getItemVisual(t, "symbolSize"),
|
|
|
+ toSymbol: c.getItemVisual(t, "symbol")
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ l.updateData(d),
|
|
|
+ u.line.eachItemGraphicEl(function(t, e) {
|
|
|
+ t.traverse(function(t) {
|
|
|
+ t.dataModel = i
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ l.__keep = !0,
|
|
|
+ l.group.silent = i.get("silent") || o.get("silent")
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ yf(function(t) {
|
|
|
+ t.markLine = t.markLine || {}
|
|
|
+ }),
|
|
|
+ cC.extend({
|
|
|
+ type: "markArea",
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 1,
|
|
|
+ tooltip: {
|
|
|
+ trigger: "item"
|
|
|
+ },
|
|
|
+ animation: !1,
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ position: "top"
|
|
|
+ },
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: 0
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ label: {
|
|
|
+ show: !0,
|
|
|
+ position: "top"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function DC(t, e, i, n) {
|
|
|
+ var o = mC(t, n[0])
|
|
|
+ , a = mC(t, n[1])
|
|
|
+ , r = W
|
|
|
+ , s = o.coord
|
|
|
+ , l = a.coord;
|
|
|
+ s[0] = r(s[0], -1 / 0),
|
|
|
+ s[1] = r(s[1], -1 / 0),
|
|
|
+ l[0] = r(l[0], 1 / 0),
|
|
|
+ l[1] = r(l[1], 1 / 0);
|
|
|
+ var u = p([{}, o, a]);
|
|
|
+ return u.coord = [o.coord, a.coord],
|
|
|
+ u.x0 = o.x,
|
|
|
+ u.y0 = o.y,
|
|
|
+ u.x1 = a.x,
|
|
|
+ u.y1 = a.y,
|
|
|
+ u
|
|
|
+ }
|
|
|
+ function CC(t) {
|
|
|
+ return !isNaN(t) && !isFinite(t)
|
|
|
+ }
|
|
|
+ function LC(t, e, i) {
|
|
|
+ var n = 1 - t;
|
|
|
+ return CC(e[n]) && CC(i[n])
|
|
|
+ }
|
|
|
+ function kC(t, e) {
|
|
|
+ var i = e.coord[0]
|
|
|
+ , n = e.coord[1];
|
|
|
+ return !("cartesian2d" !== t.type || !i || !n || !LC(1, i, n) && !LC(0, i, n)) || (yC(t, {
|
|
|
+ coord: i,
|
|
|
+ x: e.x0,
|
|
|
+ y: e.y0
|
|
|
+ }) || yC(t, {
|
|
|
+ coord: n,
|
|
|
+ x: e.x1,
|
|
|
+ y: e.y1
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ function PC(t, e, i, n, o) {
|
|
|
+ var a, r = n.coordinateSystem, s = t.getItemModel(e), l = Rl(s.get(i[0]), o.getWidth()), u = Rl(s.get(i[1]), o.getHeight());
|
|
|
+ if (isNaN(l) || isNaN(u)) {
|
|
|
+ if (n.getMarkerPosition)
|
|
|
+ a = n.getMarkerPosition(t.getValues(i, e));
|
|
|
+ else {
|
|
|
+ var h = [f = t.get(i[0], e), p = t.get(i[1], e)];
|
|
|
+ r.clampData && r.clampData(h, h),
|
|
|
+ a = r.dataToPoint(h, !0)
|
|
|
+ }
|
|
|
+ if ("cartesian2d" === r.type) {
|
|
|
+ var c = r.getAxis("x")
|
|
|
+ , d = r.getAxis("y")
|
|
|
+ , f = t.get(i[0], e)
|
|
|
+ , p = t.get(i[1], e);
|
|
|
+ CC(f) ? a[0] = c.toGlobalCoord(c.getExtent()["x0" === i[0] ? 0 : 1]) : CC(p) && (a[1] = d.toGlobalCoord(d.getExtent()["y0" === i[1] ? 0 : 1]))
|
|
|
+ }
|
|
|
+ isNaN(l) || (a[0] = l),
|
|
|
+ isNaN(u) || (a[1] = u)
|
|
|
+ } else
|
|
|
+ a = [l, u];
|
|
|
+ return a
|
|
|
+ }
|
|
|
+ var NC = [["x0", "y0"], ["x1", "y0"], ["x1", "y1"], ["x0", "y1"]];
|
|
|
+ wC.extend({
|
|
|
+ type: "markArea",
|
|
|
+ updateTransform: function(t, e, o) {
|
|
|
+ e.eachSeries(function(i) {
|
|
|
+ var t = i.markAreaModel;
|
|
|
+ if (t) {
|
|
|
+ var n = t.getData();
|
|
|
+ n.each(function(e) {
|
|
|
+ var t = O(NC, function(t) {
|
|
|
+ return PC(n, e, t, i, o)
|
|
|
+ });
|
|
|
+ n.setItemLayout(e, t),
|
|
|
+ n.getItemGraphicEl(e).setShape("points", t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ renderSeries: function(i, r, t, n) {
|
|
|
+ var e = i.coordinateSystem
|
|
|
+ , o = i.id
|
|
|
+ , a = i.getData()
|
|
|
+ , s = this.markerGroupMap
|
|
|
+ , l = s.get(o) || s.set(o, {
|
|
|
+ group: new Ci
|
|
|
+ });
|
|
|
+ this.group.add(l.group),
|
|
|
+ l.__keep = !0;
|
|
|
+ var u = function(t, i, e) {
|
|
|
+ var n, o;
|
|
|
+ o = t ? (n = O(t && t.dimensions, function(t) {
|
|
|
+ var e = i.getData();
|
|
|
+ return D({
|
|
|
+ name: t
|
|
|
+ }, e.getDimensionInfo(e.mapDimension(t)) || {})
|
|
|
+ }),
|
|
|
+ new Yf(O(["x0", "y0", "x1", "y1"], function(t, e) {
|
|
|
+ return {
|
|
|
+ name: t,
|
|
|
+ type: n[e % 2].type
|
|
|
+ }
|
|
|
+ }),e)) : new Yf(n = [{
|
|
|
+ name: "value",
|
|
|
+ type: "float"
|
|
|
+ }],e);
|
|
|
+ var a = O(e.get("data"), T(DC, i, t, e));
|
|
|
+ t && (a = M(a, T(kC, t)));
|
|
|
+ var r = t ? function(t, e, i, n) {
|
|
|
+ return t.coord[Math.floor(n / 2)][n % 2]
|
|
|
+ }
|
|
|
+ : function(t) {
|
|
|
+ return t.value
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ return o.initData(a, null, r),
|
|
|
+ o.hasItemOption = !0,
|
|
|
+ o
|
|
|
+ }(e, i, r);
|
|
|
+ r.setData(u),
|
|
|
+ u.each(function(e) {
|
|
|
+ u.setItemLayout(e, O(NC, function(t) {
|
|
|
+ return PC(u, e, t, i, n)
|
|
|
+ })),
|
|
|
+ u.setItemVisual(e, {
|
|
|
+ color: a.getVisual("color")
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ u.diff(l.__data).add(function(t) {
|
|
|
+ var e = new Qr({
|
|
|
+ shape: {
|
|
|
+ points: u.getItemLayout(t)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ u.setItemGraphicEl(t, e),
|
|
|
+ l.group.add(e)
|
|
|
+ }).update(function(t, e) {
|
|
|
+ var i = l.__data.getItemGraphicEl(e);
|
|
|
+ cl(i, {
|
|
|
+ shape: {
|
|
|
+ points: u.getItemLayout(t)
|
|
|
+ }
|
|
|
+ }, r, t),
|
|
|
+ l.group.add(i),
|
|
|
+ u.setItemGraphicEl(t, i)
|
|
|
+ }).remove(function(t) {
|
|
|
+ var e = l.__data.getItemGraphicEl(t);
|
|
|
+ l.group.remove(e)
|
|
|
+ }).execute(),
|
|
|
+ u.eachItemGraphicEl(function(t, e) {
|
|
|
+ var i = u.getItemModel(e)
|
|
|
+ , n = i.getModel("label")
|
|
|
+ , o = i.getModel("emphasis.label")
|
|
|
+ , a = u.getItemVisual(e, "color");
|
|
|
+ t.useStyle(D(i.getModel("itemStyle").getItemStyle(), {
|
|
|
+ fill: Ke(a, .4),
|
|
|
+ stroke: a
|
|
|
+ })),
|
|
|
+ t.hoverStyle = i.getModel("emphasis.itemStyle").getItemStyle(),
|
|
|
+ el(t.style, t.hoverStyle, n, o, {
|
|
|
+ labelFetcher: r,
|
|
|
+ labelDataIndex: e,
|
|
|
+ defaultText: u.getName(e) || "",
|
|
|
+ isRectText: !0,
|
|
|
+ autoColor: a
|
|
|
+ }),
|
|
|
+ $s(t, {}),
|
|
|
+ t.dataModel = r
|
|
|
+ }),
|
|
|
+ l.__data = u,
|
|
|
+ l.group.silent = r.get("silent") || i.get("silent")
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ yf(function(t) {
|
|
|
+ t.markArea = t.markArea || {}
|
|
|
+ });
|
|
|
+ var OC = Oc.legend.selector
|
|
|
+ , EC = {
|
|
|
+ all: {
|
|
|
+ type: "all",
|
|
|
+ title: k(OC.all)
|
|
|
+ },
|
|
|
+ inverse: {
|
|
|
+ type: "inverse",
|
|
|
+ title: k(OC.inverse)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , RC = Tf({
|
|
|
+ type: "legend.plain",
|
|
|
+ dependencies: ["series"],
|
|
|
+ layoutMode: {
|
|
|
+ type: "box",
|
|
|
+ ignoreSize: !0
|
|
|
+ },
|
|
|
+ init: function(t, e, i) {
|
|
|
+ this.mergeDefaultAndTheme(t, i),
|
|
|
+ t.selected = t.selected || {},
|
|
|
+ this._updateSelector(t)
|
|
|
+ },
|
|
|
+ mergeOption: function(t) {
|
|
|
+ RC.superCall(this, "mergeOption", t),
|
|
|
+ this._updateSelector(t)
|
|
|
+ },
|
|
|
+ _updateSelector: function(t) {
|
|
|
+ var i = t.selector;
|
|
|
+ !0 === i && (i = t.selector = ["all", "inverse"]),
|
|
|
+ L(i) && E(i, function(t, e) {
|
|
|
+ R(t) && (t = {
|
|
|
+ type: t
|
|
|
+ }),
|
|
|
+ i[e] = m(t, EC[t.type])
|
|
|
+ })
|
|
|
+ },
|
|
|
+ optionUpdated: function() {
|
|
|
+ this._updateData(this.ecModel);
|
|
|
+ var t = this._data;
|
|
|
+ if (t[0] && "single" === this.get("selectedMode")) {
|
|
|
+ for (var e = !1, i = 0; i < t.length; i++) {
|
|
|
+ var n = t[i].get("name");
|
|
|
+ if (this.isSelected(n)) {
|
|
|
+ this.select(n),
|
|
|
+ e = !0;
|
|
|
+ break
|
|
|
+ }
|
|
|
+ }
|
|
|
+ e || this.select(t[0].get("name"))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _updateData: function(o) {
|
|
|
+ var a = []
|
|
|
+ , r = [];
|
|
|
+ o.eachRawSeries(function(t) {
|
|
|
+ var e, i = t.name;
|
|
|
+ if (r.push(i),
|
|
|
+ t.legendVisualProvider) {
|
|
|
+ var n = t.legendVisualProvider.getAllNames();
|
|
|
+ o.isSeriesFiltered(t) || (r = r.concat(n)),
|
|
|
+ n.length ? a = a.concat(n) : e = !0
|
|
|
+ } else
|
|
|
+ e = !0;
|
|
|
+ e && Uo(t) && a.push(t.name)
|
|
|
+ }),
|
|
|
+ this._availableNames = r;
|
|
|
+ var t = O(this.get("data") || a, function(t) {
|
|
|
+ return "string" != typeof t && "number" != typeof t || (t = {
|
|
|
+ name: t
|
|
|
+ }),
|
|
|
+ new Cl(t,this,this.ecModel)
|
|
|
+ }, this);
|
|
|
+ this._data = t
|
|
|
+ },
|
|
|
+ getData: function() {
|
|
|
+ return this._data
|
|
|
+ },
|
|
|
+ select: function(t) {
|
|
|
+ var e = this.option.selected;
|
|
|
+ "single" === this.get("selectedMode") && E(this._data, function(t) {
|
|
|
+ e[t.get("name")] = !1
|
|
|
+ });
|
|
|
+ e[t] = !0
|
|
|
+ },
|
|
|
+ unSelect: function(t) {
|
|
|
+ "single" !== this.get("selectedMode") && (this.option.selected[t] = !1)
|
|
|
+ },
|
|
|
+ toggleSelected: function(t) {
|
|
|
+ var e = this.option.selected;
|
|
|
+ e.hasOwnProperty(t) || (e[t] = !0),
|
|
|
+ this[e[t] ? "unSelect" : "select"](t)
|
|
|
+ },
|
|
|
+ allSelect: function() {
|
|
|
+ var t = this._data
|
|
|
+ , e = this.option.selected;
|
|
|
+ E(t, function(t) {
|
|
|
+ e[t.get("name", !0)] = !0
|
|
|
+ })
|
|
|
+ },
|
|
|
+ inverseSelect: function() {
|
|
|
+ var t = this._data
|
|
|
+ , i = this.option.selected;
|
|
|
+ E(t, function(t) {
|
|
|
+ var e = t.get("name", !0);
|
|
|
+ i.hasOwnProperty(e) || (i[e] = !0),
|
|
|
+ i[e] = !i[e]
|
|
|
+ })
|
|
|
+ },
|
|
|
+ isSelected: function(t) {
|
|
|
+ var e = this.option.selected;
|
|
|
+ return !(e.hasOwnProperty(t) && !e[t]) && 0 <= _(this._availableNames, t)
|
|
|
+ },
|
|
|
+ getOrient: function() {
|
|
|
+ return "vertical" === this.get("orient") ? {
|
|
|
+ index: 1,
|
|
|
+ name: "vertical"
|
|
|
+ } : {
|
|
|
+ index: 0,
|
|
|
+ name: "horizontal"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ zlevel: 0,
|
|
|
+ z: 4,
|
|
|
+ show: !0,
|
|
|
+ orient: "horizontal",
|
|
|
+ left: "center",
|
|
|
+ top: 0,
|
|
|
+ align: "auto",
|
|
|
+ backgroundColor: "rgba(0,0,0,0)",
|
|
|
+ borderColor: "#ccc",
|
|
|
+ borderRadius: 0,
|
|
|
+ borderWidth: 0,
|
|
|
+ padding: 5,
|
|
|
+ itemGap: 10,
|
|
|
+ itemWidth: 25,
|
|
|
+ itemHeight: 14,
|
|
|
+ inactiveColor: "#ccc",
|
|
|
+ inactiveBorderColor: "#ccc",
|
|
|
+ itemStyle: {
|
|
|
+ borderWidth: 0
|
|
|
+ },
|
|
|
+ textStyle: {
|
|
|
+ color: "#333"
|
|
|
+ },
|
|
|
+ selectedMode: !0,
|
|
|
+ selector: !1,
|
|
|
+ selectorLabel: {
|
|
|
+ show: !0,
|
|
|
+ borderRadius: 10,
|
|
|
+ padding: [3, 5, 3, 5],
|
|
|
+ fontSize: 12,
|
|
|
+ fontFamily: " sans-serif",
|
|
|
+ color: "#666",
|
|
|
+ borderWidth: 1,
|
|
|
+ borderColor: "#666"
|
|
|
+ },
|
|
|
+ emphasis: {
|
|
|
+ selectorLabel: {
|
|
|
+ show: !0,
|
|
|
+ color: "#eee",
|
|
|
+ backgroundColor: "#666"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ selectorPosition: "auto",
|
|
|
+ selectorItemGap: 7,
|
|
|
+ selectorButtonGap: 10,
|
|
|
+ tooltip: {
|
|
|
+ show: !1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function zC(t, e, i) {
|
|
|
+ var o, a = {}, r = "toggleSelected" === t;
|
|
|
+ return i.eachComponent("legend", function(n) {
|
|
|
+ r && null != o ? n[o ? "select" : "unSelect"](e.name) : "allSelect" === t || "inverseSelect" === t ? n[t]() : (n[t](e.name),
|
|
|
+ o = n.isSelected(e.name)),
|
|
|
+ E(n.getData(), function(t) {
|
|
|
+ var e = t.get("name");
|
|
|
+ if ("\n" !== e && "" !== e) {
|
|
|
+ var i = n.isSelected(e);
|
|
|
+ a.hasOwnProperty(e) ? a[e] = a[e] && i : a[e] = i
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ "allSelect" === t || "inverseSelect" === t ? {
|
|
|
+ selected: a
|
|
|
+ } : {
|
|
|
+ name: e.name,
|
|
|
+ selected: a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _f("legendToggleSelect", "legendselectchanged", T(zC, "toggleSelected")),
|
|
|
+ _f("legendAllSelect", "legendselectall", T(zC, "allSelect")),
|
|
|
+ _f("legendInverseSelect", "legendinverseselect", T(zC, "inverseSelect")),
|
|
|
+ _f("legendSelect", "legendselected", T(zC, "select")),
|
|
|
+ _f("legendUnSelect", "legendunselected", T(zC, "unSelect"));
|
|
|
+ var BC = T
|
|
|
+ , VC = E
|
|
|
+ , GC = Ci
|
|
|
+ , FC = Af({
|
|
|
+ type: "legend.plain",
|
|
|
+ newlineDisabled: !1,
|
|
|
+ init: function() {
|
|
|
+ this.group.add(this._contentGroup = new GC),
|
|
|
+ this._backgroundEl,
|
|
|
+ this.group.add(this._selectorGroup = new GC),
|
|
|
+ this._isFirstRender = !0
|
|
|
+ },
|
|
|
+ getContentGroup: function() {
|
|
|
+ return this._contentGroup
|
|
|
+ },
|
|
|
+ getSelectorGroup: function() {
|
|
|
+ return this._selectorGroup
|
|
|
+ },
|
|
|
+ render: function(t, e, i) {
|
|
|
+ var n = this._isFirstRender;
|
|
|
+ if (this._isFirstRender = !1,
|
|
|
+ this.resetInner(),
|
|
|
+ t.get("show", !0)) {
|
|
|
+ var o = t.get("align")
|
|
|
+ , a = t.get("orient");
|
|
|
+ o && "auto" !== o || (o = "right" === t.get("left") && "vertical" === a ? "right" : "left");
|
|
|
+ var r = t.get("selector", !0)
|
|
|
+ , s = t.get("selectorPosition", !0);
|
|
|
+ !r || s && "auto" !== s || (s = "horizontal" === a ? "end" : "start"),
|
|
|
+ this.renderInner(o, t, e, i, r, a, s);
|
|
|
+ var l = t.getBoxLayoutParams()
|
|
|
+ , u = {
|
|
|
+ width: i.getWidth(),
|
|
|
+ height: i.getHeight()
|
|
|
+ }
|
|
|
+ , h = t.get("padding")
|
|
|
+ , c = bu(l, u, h)
|
|
|
+ , d = this.layoutInner(t, o, c, n, r, s)
|
|
|
+ , f = bu(D({
|
|
|
+ width: d.width,
|
|
|
+ height: d.height
|
|
|
+ }, l), u, h);
|
|
|
+ this.group.attr("position", [f.x - d.x, f.y - d.y]),
|
|
|
+ this.group.add(this._backgroundEl = rA(d, t))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ resetInner: function() {
|
|
|
+ this.getContentGroup().removeAll(),
|
|
|
+ this._backgroundEl && this.group.remove(this._backgroundEl),
|
|
|
+ this.getSelectorGroup().removeAll()
|
|
|
+ },
|
|
|
+ renderInner: function(u, h, c, d, t, e, i) {
|
|
|
+ var f = this.getContentGroup()
|
|
|
+ , p = Q()
|
|
|
+ , g = h.get("selectedMode")
|
|
|
+ , m = [];
|
|
|
+ c.eachRawSeries(function(t) {
|
|
|
+ t.get("legendHoverLink") || m.push(t.id)
|
|
|
+ }),
|
|
|
+ VC(h.getData(), function(a, r) {
|
|
|
+ var s = a.get("name");
|
|
|
+ if (this.newlineDisabled || "" !== s && "\n" !== s) {
|
|
|
+ var t = c.getSeriesByName(s)[0];
|
|
|
+ if (!p.get(s))
|
|
|
+ if (t) {
|
|
|
+ var e = t.getData()
|
|
|
+ , i = e.getVisual("color")
|
|
|
+ , n = e.getVisual("borderColor");
|
|
|
+ "function" == typeof i && (i = i(t.getDataParams(0))),
|
|
|
+ "function" == typeof n && (n = n(t.getDataParams(0)));
|
|
|
+ var o = e.getVisual("legendSymbol") || "roundRect"
|
|
|
+ , l = e.getVisual("symbol");
|
|
|
+ this._createItem(s, r, a, h, o, l, u, i, n, g).on("click", BC(HC, s, null, d, m)).on("mouseover", BC(ZC, t.name, null, d, m)).on("mouseout", BC(UC, t.name, null, d, m)),
|
|
|
+ p.set(s, !0)
|
|
|
+ } else
|
|
|
+ c.eachRawSeries(function(t) {
|
|
|
+ if (!p.get(s) && t.legendVisualProvider) {
|
|
|
+ var e = t.legendVisualProvider;
|
|
|
+ if (!e.containName(s))
|
|
|
+ return;
|
|
|
+ var i = e.indexOfName(s)
|
|
|
+ , n = e.getItemVisual(i, "color")
|
|
|
+ , o = e.getItemVisual(i, "borderColor");
|
|
|
+ this._createItem(s, r, a, h, "roundRect", null, u, n, o, g).on("click", BC(HC, null, s, d, m)).on("mouseover", BC(ZC, null, s, d, m)).on("mouseout", BC(UC, null, s, d, m)),
|
|
|
+ p.set(s, !0)
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ } else
|
|
|
+ f.add(new GC({
|
|
|
+ newline: !0
|
|
|
+ }))
|
|
|
+ }, this),
|
|
|
+ t && this._createSelector(t, h, d, e, i)
|
|
|
+ },
|
|
|
+ _createSelector: function(t, a, r, e, i) {
|
|
|
+ var s = this.getSelectorGroup();
|
|
|
+ VC(t, function(t) {
|
|
|
+ !function(t) {
|
|
|
+ var e = t.type
|
|
|
+ , i = new Ur({
|
|
|
+ style: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ align: "center",
|
|
|
+ verticalAlign: "middle"
|
|
|
+ },
|
|
|
+ onclick: function() {
|
|
|
+ r.dispatchAction({
|
|
|
+ type: "all" === e ? "legendAllSelect" : "legendInverseSelect"
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ s.add(i);
|
|
|
+ var n = a.getModel("selectorLabel")
|
|
|
+ , o = a.getModel("emphasis.selectorLabel");
|
|
|
+ el(i.style, i.hoverStyle = {}, n, o, {
|
|
|
+ defaultText: t.title,
|
|
|
+ isRectText: !1
|
|
|
+ }),
|
|
|
+ $s(i)
|
|
|
+ }(t)
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _createItem: function(t, e, i, n, o, a, r, s, l, u) {
|
|
|
+ var h = n.get("itemWidth")
|
|
|
+ , c = n.get("itemHeight")
|
|
|
+ , d = n.get("inactiveColor")
|
|
|
+ , f = n.get("inactiveBorderColor")
|
|
|
+ , p = n.get("symbolKeepAspect")
|
|
|
+ , g = n.getModel("itemStyle")
|
|
|
+ , m = n.isSelected(t)
|
|
|
+ , v = new GC
|
|
|
+ , y = i.getModel("textStyle")
|
|
|
+ , x = i.get("icon")
|
|
|
+ , _ = i.getModel("tooltip")
|
|
|
+ , w = _.parentModel
|
|
|
+ , b = wg(o = x || o, 0, 0, h, c, m ? s : d, null == p || p);
|
|
|
+ if (v.add(WC(b, o, g, l, f, m)),
|
|
|
+ !x && a && (a !== o || "none" === a)) {
|
|
|
+ var S = .8 * c;
|
|
|
+ "none" === a && (a = "circle");
|
|
|
+ var M = wg(a, (h - S) / 2, (c - S) / 2, S, S, m ? s : d, null == p || p);
|
|
|
+ v.add(WC(M, a, g, l, f, m))
|
|
|
+ }
|
|
|
+ var I = "left" === r ? h + 5 : -5
|
|
|
+ , T = r
|
|
|
+ , A = n.get("formatter")
|
|
|
+ , D = t;
|
|
|
+ "string" == typeof A && A ? D = A.replace("{name}", null != t ? t : "") : "function" == typeof A && (D = A(t)),
|
|
|
+ v.add(new Ur({
|
|
|
+ style: nl({}, y, {
|
|
|
+ text: D,
|
|
|
+ x: I,
|
|
|
+ y: c / 2,
|
|
|
+ textFill: m ? y.getTextColor() : d,
|
|
|
+ textAlign: T,
|
|
|
+ textVerticalAlign: "middle"
|
|
|
+ })
|
|
|
+ }));
|
|
|
+ var C = new rs({
|
|
|
+ shape: v.getBoundingRect(),
|
|
|
+ invisible: !0,
|
|
|
+ tooltip: _.get("show") ? P({
|
|
|
+ content: t,
|
|
|
+ formatter: w.get("formatter", !0) || function() {
|
|
|
+ return t
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ formatterParams: {
|
|
|
+ componentType: "legend",
|
|
|
+ legendIndex: n.componentIndex,
|
|
|
+ name: t,
|
|
|
+ $vars: ["name"]
|
|
|
+ }
|
|
|
+ }, _.option) : null
|
|
|
+ });
|
|
|
+ return v.add(C),
|
|
|
+ v.eachChild(function(t) {
|
|
|
+ t.silent = !0
|
|
|
+ }),
|
|
|
+ C.silent = !u,
|
|
|
+ this.getContentGroup().add(v),
|
|
|
+ $s(v),
|
|
|
+ v.__legendDataIndex = e,
|
|
|
+ v
|
|
|
+ },
|
|
|
+ layoutInner: function(t, e, i, n, o, a) {
|
|
|
+ var r = this.getContentGroup()
|
|
|
+ , s = this.getSelectorGroup();
|
|
|
+ wu(t.get("orient"), r, t.get("itemGap"), i.width, i.height);
|
|
|
+ var l = r.getBoundingRect()
|
|
|
+ , u = [-l.x, -l.y];
|
|
|
+ if (o) {
|
|
|
+ wu("horizontal", s, t.get("selectorItemGap", !0));
|
|
|
+ var h = s.getBoundingRect()
|
|
|
+ , c = [-h.x, -h.y]
|
|
|
+ , d = t.get("selectorButtonGap", !0)
|
|
|
+ , f = t.getOrient().index
|
|
|
+ , p = 0 === f ? "width" : "height"
|
|
|
+ , g = 0 === f ? "height" : "width"
|
|
|
+ , m = 0 === f ? "y" : "x";
|
|
|
+ "end" === a ? c[f] += l[p] + d : u[f] += h[p] + d,
|
|
|
+ c[1 - f] += l[g] / 2 - h[g] / 2,
|
|
|
+ s.attr("position", c),
|
|
|
+ r.attr("position", u);
|
|
|
+ var v = {
|
|
|
+ x: 0,
|
|
|
+ y: 0
|
|
|
+ };
|
|
|
+ return v[p] = l[p] + d + h[p],
|
|
|
+ v[g] = Math.max(l[g], h[g]),
|
|
|
+ v[m] = Math.min(0, h[m] + c[1 - f]),
|
|
|
+ v
|
|
|
+ }
|
|
|
+ return r.attr("position", u),
|
|
|
+ this.group.getBoundingRect()
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this.getContentGroup().removeAll(),
|
|
|
+ this._isFirstRender = !0
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function WC(t, e, i, n, o, a) {
|
|
|
+ var r;
|
|
|
+ return "line" !== e && e.indexOf("empty") < 0 ? (r = i.getItemStyle(),
|
|
|
+ t.style.stroke = n,
|
|
|
+ a || (r.stroke = o)) : r = i.getItemStyle(["borderWidth", "borderColor"]),
|
|
|
+ t.setStyle(r)
|
|
|
+ }
|
|
|
+ function HC(t, e, i, n) {
|
|
|
+ UC(t, e, i, n),
|
|
|
+ i.dispatchAction({
|
|
|
+ type: "legendToggleSelect",
|
|
|
+ name: null != t ? t : e
|
|
|
+ }),
|
|
|
+ ZC(t, e, i, n)
|
|
|
+ }
|
|
|
+ function ZC(t, e, i, n) {
|
|
|
+ var o = i.getZr().storage.getDisplayList()[0];
|
|
|
+ o && o.useHoverLayer || i.dispatchAction({
|
|
|
+ type: "highlight",
|
|
|
+ seriesName: t,
|
|
|
+ name: e,
|
|
|
+ excludeSeriesId: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function UC(t, e, i, n) {
|
|
|
+ var o = i.getZr().storage.getDisplayList()[0];
|
|
|
+ o && o.useHoverLayer || i.dispatchAction({
|
|
|
+ type: "downplay",
|
|
|
+ seriesName: t,
|
|
|
+ name: e,
|
|
|
+ excludeSeriesId: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ xf(Ld.PROCESSOR.SERIES_FILTER, function(t) {
|
|
|
+ var i = t.findComponents({
|
|
|
+ mainType: "legend"
|
|
|
+ });
|
|
|
+ i && i.length && t.filterSeries(function(t) {
|
|
|
+ for (var e = 0; e < i.length; e++)
|
|
|
+ if (!i[e].isSelected(t.name))
|
|
|
+ return !1;
|
|
|
+ return !0
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ ku.registerSubTypeDefaulter("legend", function() {
|
|
|
+ return "plain"
|
|
|
+ });
|
|
|
+ var XC = RC.extend({
|
|
|
+ type: "legend.scroll",
|
|
|
+ setScrollDataIndex: function(t) {
|
|
|
+ this.option.scrollDataIndex = t
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ scrollDataIndex: 0,
|
|
|
+ pageButtonItemGap: 5,
|
|
|
+ pageButtonGap: null,
|
|
|
+ pageButtonPosition: "end",
|
|
|
+ pageFormatter: "{current}/{total}",
|
|
|
+ pageIcons: {
|
|
|
+ horizontal: ["M0,0L12,-10L12,10z", "M0,0L-12,-10L-12,10z"],
|
|
|
+ vertical: ["M0,0L20,0L10,-20z", "M0,0L20,0L10,20z"]
|
|
|
+ },
|
|
|
+ pageIconColor: "#2f4554",
|
|
|
+ pageIconInactiveColor: "#aaa",
|
|
|
+ pageIconSize: 15,
|
|
|
+ pageTextStyle: {
|
|
|
+ color: "#333"
|
|
|
+ },
|
|
|
+ animationDurationUpdate: 800
|
|
|
+ },
|
|
|
+ init: function(t, e, i, n) {
|
|
|
+ var o = Iu(t);
|
|
|
+ XC.superCall(this, "init", t, e, i, n),
|
|
|
+ YC(this, t, o)
|
|
|
+ },
|
|
|
+ mergeOption: function(t, e) {
|
|
|
+ XC.superCall(this, "mergeOption", t, e),
|
|
|
+ YC(this, this.option, t)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function YC(t, e, i) {
|
|
|
+ var n = [1, 1];
|
|
|
+ n[t.getOrient().index] = 0,
|
|
|
+ Mu(e, i, {
|
|
|
+ type: "box",
|
|
|
+ ignoreSize: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var jC = Ci
|
|
|
+ , qC = ["width", "height"]
|
|
|
+ , KC = ["x", "y"]
|
|
|
+ , $C = FC.extend({
|
|
|
+ type: "legend.scroll",
|
|
|
+ newlineDisabled: !0,
|
|
|
+ init: function() {
|
|
|
+ $C.superCall(this, "init"),
|
|
|
+ this._currentIndex = 0,
|
|
|
+ this.group.add(this._containerGroup = new jC),
|
|
|
+ this._containerGroup.add(this.getContentGroup()),
|
|
|
+ this.group.add(this._controllerGroup = new jC),
|
|
|
+ this._showController
|
|
|
+ },
|
|
|
+ resetInner: function() {
|
|
|
+ $C.superCall(this, "resetInner"),
|
|
|
+ this._controllerGroup.removeAll(),
|
|
|
+ this._containerGroup.removeClipPath(),
|
|
|
+ this._containerGroup.__rectSize = null
|
|
|
+ },
|
|
|
+ renderInner: function(t, o, e, a, i, n, r) {
|
|
|
+ var s = this;
|
|
|
+ $C.superCall(this, "renderInner", t, o, e, a, i, n, r);
|
|
|
+ var l = this._controllerGroup
|
|
|
+ , u = o.get("pageIconSize", !0);
|
|
|
+ L(u) || (u = [u, u]),
|
|
|
+ c("pagePrev", 0);
|
|
|
+ var h = o.getModel("pageTextStyle");
|
|
|
+ function c(t, e) {
|
|
|
+ var i = t + "DataIndex"
|
|
|
+ , n = yl(o.get("pageIcons", !0)[o.getOrient().name][e], {
|
|
|
+ onclick: A(s._pageGo, s, i, o, a)
|
|
|
+ }, {
|
|
|
+ x: -u[0] / 2,
|
|
|
+ y: -u[1] / 2,
|
|
|
+ width: u[0],
|
|
|
+ height: u[1]
|
|
|
+ });
|
|
|
+ n.name = t,
|
|
|
+ l.add(n)
|
|
|
+ }
|
|
|
+ l.add(new Ur({
|
|
|
+ name: "pageText",
|
|
|
+ style: {
|
|
|
+ textFill: h.getTextColor(),
|
|
|
+ font: h.getFont(),
|
|
|
+ textVerticalAlign: "middle",
|
|
|
+ textAlign: "center"
|
|
|
+ },
|
|
|
+ silent: !0
|
|
|
+ })),
|
|
|
+ c("pageNext", 1)
|
|
|
+ },
|
|
|
+ layoutInner: function(t, e, i, n, o, a) {
|
|
|
+ var r = this.getSelectorGroup()
|
|
|
+ , s = t.getOrient().index
|
|
|
+ , l = qC[s]
|
|
|
+ , u = KC[s]
|
|
|
+ , h = qC[1 - s]
|
|
|
+ , c = KC[1 - s];
|
|
|
+ o && wu("horizontal", r, t.get("selectorItemGap", !0));
|
|
|
+ var d = t.get("selectorButtonGap", !0)
|
|
|
+ , f = r.getBoundingRect()
|
|
|
+ , p = [-f.x, -f.y]
|
|
|
+ , g = k(i);
|
|
|
+ o && (g[l] = i[l] - f[l] - d);
|
|
|
+ var m = this._layoutContentAndController(t, n, g, s, l, h, c);
|
|
|
+ if (o) {
|
|
|
+ if ("end" === a)
|
|
|
+ p[s] += m[l] + d;
|
|
|
+ else {
|
|
|
+ var v = f[l] + d;
|
|
|
+ p[s] -= v,
|
|
|
+ m[u] -= v
|
|
|
+ }
|
|
|
+ m[l] += f[l] + d,
|
|
|
+ p[1 - s] += m[c] + m[h] / 2 - f[h] / 2,
|
|
|
+ m[h] = Math.max(m[h], f[h]),
|
|
|
+ m[c] = Math.min(m[c], f[c] + p[1 - s]),
|
|
|
+ r.attr("position", p)
|
|
|
+ }
|
|
|
+ return m
|
|
|
+ },
|
|
|
+ _layoutContentAndController: function(t, e, i, n, o, a, r) {
|
|
|
+ var s = this.getContentGroup()
|
|
|
+ , l = this._containerGroup
|
|
|
+ , u = this._controllerGroup;
|
|
|
+ wu(t.get("orient"), s, t.get("itemGap"), n ? i.width : null, n ? null : i.height),
|
|
|
+ wu("horizontal", u, t.get("pageButtonItemGap", !0));
|
|
|
+ var h = s.getBoundingRect()
|
|
|
+ , c = u.getBoundingRect()
|
|
|
+ , d = this._showController = h[o] > i[o]
|
|
|
+ , f = [-h.x, -h.y];
|
|
|
+ e || (f[n] = s.position[n]);
|
|
|
+ var p = [0, 0]
|
|
|
+ , g = [-c.x, -c.y]
|
|
|
+ , m = H(t.get("pageButtonGap", !0), t.get("itemGap", !0));
|
|
|
+ d && ("end" === t.get("pageButtonPosition", !0) ? g[n] += i[o] - c[o] : p[n] += c[o] + m);
|
|
|
+ g[1 - n] += h[a] / 2 - c[a] / 2,
|
|
|
+ s.attr("position", f),
|
|
|
+ l.attr("position", p),
|
|
|
+ u.attr("position", g);
|
|
|
+ var v = {
|
|
|
+ x: 0,
|
|
|
+ y: 0
|
|
|
+ };
|
|
|
+ if (v[o] = d ? i[o] : h[o],
|
|
|
+ v[a] = Math.max(h[a], c[a]),
|
|
|
+ v[r] = Math.min(0, c[r] + g[1 - n]),
|
|
|
+ l.__rectSize = i[o],
|
|
|
+ d) {
|
|
|
+ var y = {
|
|
|
+ x: 0,
|
|
|
+ y: 0
|
|
|
+ };
|
|
|
+ y[o] = Math.max(i[o] - c[o] - m, 0),
|
|
|
+ y[a] = v[a],
|
|
|
+ l.setClipPath(new rs({
|
|
|
+ shape: y
|
|
|
+ })),
|
|
|
+ l.__rectSize = y[o]
|
|
|
+ } else
|
|
|
+ u.eachChild(function(t) {
|
|
|
+ t.attr({
|
|
|
+ invisible: !0,
|
|
|
+ silent: !0
|
|
|
+ })
|
|
|
+ });
|
|
|
+ var x = this._getPageInfo(t);
|
|
|
+ return null != x.pageIndex && cl(s, {
|
|
|
+ position: x.contentPosition
|
|
|
+ }, d && t),
|
|
|
+ this._updatePageInfoView(t, x),
|
|
|
+ v
|
|
|
+ },
|
|
|
+ _pageGo: function(t, e, i) {
|
|
|
+ var n = this._getPageInfo(e)[t];
|
|
|
+ null != n && i.dispatchAction({
|
|
|
+ type: "legendScroll",
|
|
|
+ scrollDataIndex: n,
|
|
|
+ legendId: e.id
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _updatePageInfoView: function(n, o) {
|
|
|
+ var a = this._controllerGroup;
|
|
|
+ E(["pagePrev", "pageNext"], function(t) {
|
|
|
+ var e = null != o[t + "DataIndex"]
|
|
|
+ , i = a.childOfName(t);
|
|
|
+ i && (i.setStyle("fill", e ? n.get("pageIconColor", !0) : n.get("pageIconInactiveColor", !0)),
|
|
|
+ i.cursor = e ? "pointer" : "default")
|
|
|
+ });
|
|
|
+ var t = a.childOfName("pageText")
|
|
|
+ , e = n.get("pageFormatter")
|
|
|
+ , i = o.pageIndex
|
|
|
+ , r = null != i ? i + 1 : 0
|
|
|
+ , s = o.pageCount;
|
|
|
+ t && e && t.setStyle("text", R(e) ? e.replace("{current}", r).replace("{total}", s) : e({
|
|
|
+ current: r,
|
|
|
+ total: s
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ _getPageInfo: function(t) {
|
|
|
+ var e = t.get("scrollDataIndex", !0)
|
|
|
+ , i = this.getContentGroup()
|
|
|
+ , n = this._containerGroup.__rectSize
|
|
|
+ , o = t.getOrient().index
|
|
|
+ , a = qC[o]
|
|
|
+ , r = KC[o]
|
|
|
+ , s = this._findTargetItemIndex(e)
|
|
|
+ , l = i.children()
|
|
|
+ , u = l[s]
|
|
|
+ , h = l.length
|
|
|
+ , c = h ? 1 : 0
|
|
|
+ , d = {
|
|
|
+ contentPosition: i.position.slice(),
|
|
|
+ pageCount: c,
|
|
|
+ pageIndex: c - 1,
|
|
|
+ pagePrevDataIndex: null,
|
|
|
+ pageNextDataIndex: null
|
|
|
+ };
|
|
|
+ if (!u)
|
|
|
+ return d;
|
|
|
+ var f = y(u);
|
|
|
+ d.contentPosition[o] = -f.s;
|
|
|
+ for (var p = s + 1, g = f, m = f, v = null; p <= h; ++p)
|
|
|
+ (!(v = y(l[p])) && m.e > g.s + n || v && !x(v, g.s)) && (g = m.i > g.i ? m : v) && (null == d.pageNextDataIndex && (d.pageNextDataIndex = g.i),
|
|
|
+ ++d.pageCount),
|
|
|
+ m = v;
|
|
|
+ for (p = s - 1,
|
|
|
+ g = f,
|
|
|
+ m = f,
|
|
|
+ v = null; -1 <= p; --p)
|
|
|
+ (v = y(l[p])) && x(m, v.s) || !(g.i < m.i) || (m = g,
|
|
|
+ null == d.pagePrevDataIndex && (d.pagePrevDataIndex = g.i),
|
|
|
+ ++d.pageCount,
|
|
|
+ ++d.pageIndex),
|
|
|
+ g = v;
|
|
|
+ return d;
|
|
|
+ function y(t) {
|
|
|
+ if (t) {
|
|
|
+ var e = t.getBoundingRect()
|
|
|
+ , i = e[r] + t.position[o];
|
|
|
+ return {
|
|
|
+ s: i,
|
|
|
+ e: i + e[a],
|
|
|
+ i: t.__legendDataIndex
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function x(t, e) {
|
|
|
+ return t.e >= e && t.s <= e + n
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _findTargetItemIndex: function(n) {
|
|
|
+ return this._showController ? (this.getContentGroup().eachChild(function(t, e) {
|
|
|
+ var i = t.__legendDataIndex;
|
|
|
+ null == a && null != i && (a = e),
|
|
|
+ i === n && (o = e)
|
|
|
+ }),
|
|
|
+ null != o ? o : a) : 0;
|
|
|
+ var o, a
|
|
|
+ }
|
|
|
+ });
|
|
|
+ _f("legendScroll", "legendscroll", function(t, e) {
|
|
|
+ var i = t.scrollDataIndex;
|
|
|
+ null != i && e.eachComponent({
|
|
|
+ mainType: "legend",
|
|
|
+ subType: "scroll",
|
|
|
+ query: t
|
|
|
+ }, function(t) {
|
|
|
+ t.setScrollDataIndex(i)
|
|
|
+ })
|
|
|
+ });
|
|
|
+ iD.extend({
|
|
|
+ type: "dataZoom.slider",
|
|
|
+ layoutMode: "box",
|
|
|
+ defaultOption: {
|
|
|
+ show: !0,
|
|
|
+ right: "ph",
|
|
|
+ top: "ph",
|
|
|
+ width: "ph",
|
|
|
+ height: "ph",
|
|
|
+ left: null,
|
|
|
+ bottom: null,
|
|
|
+ backgroundColor: "rgba(47,69,84,0)",
|
|
|
+ dataBackground: {
|
|
|
+ lineStyle: {
|
|
|
+ color: "#2f4554",
|
|
|
+ width: .5,
|
|
|
+ opacity: .3
|
|
|
+ },
|
|
|
+ areaStyle: {
|
|
|
+ color: "rgba(47,69,84,0.3)",
|
|
|
+ opacity: .3
|
|
|
+ }
|
|
|
+ },
|
|
|
+ borderColor: "#ddd",
|
|
|
+ fillerColor: "rgba(167,183,204,0.4)",
|
|
|
+ handleIcon: "M8.2,13.6V3.9H6.3v9.7H3.1v14.9h3.3v9.7h1.8v-9.7h3.3V13.6H8.2z M9.7,24.4H4.8v-1.4h4.9V24.4z M9.7,19.1H4.8v-1.4h4.9V19.1z",
|
|
|
+ handleSize: "100%",
|
|
|
+ handleStyle: {
|
|
|
+ color: "#a7b7cc"
|
|
|
+ },
|
|
|
+ labelPrecision: null,
|
|
|
+ labelFormatter: null,
|
|
|
+ showDetail: !0,
|
|
|
+ showDataShadow: "auto",
|
|
|
+ realtime: !0,
|
|
|
+ zoomLock: !1,
|
|
|
+ textStyle: {
|
|
|
+ color: "#333"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var JC = rs
|
|
|
+ , QC = El
|
|
|
+ , tL = Bl
|
|
|
+ , eL = A
|
|
|
+ , iL = E
|
|
|
+ , nL = "horizontal"
|
|
|
+ , oL = "vertical"
|
|
|
+ , aL = ["line", "bar", "candlestick", "scatter"]
|
|
|
+ , rL = aD.extend({
|
|
|
+ type: "dataZoom.slider",
|
|
|
+ init: function(t, e) {
|
|
|
+ this._displayables = {},
|
|
|
+ this._orient,
|
|
|
+ this._range,
|
|
|
+ this._handleEnds,
|
|
|
+ this._size,
|
|
|
+ this._handleWidth,
|
|
|
+ this._handleHeight,
|
|
|
+ this._location,
|
|
|
+ this._dragging,
|
|
|
+ this._dataShadowInfo,
|
|
|
+ this.api = e
|
|
|
+ },
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ rL.superApply(this, "render", arguments),
|
|
|
+ kc(this, "_dispatchZoomAction", this.dataZoomModel.get("throttle"), "fixRate"),
|
|
|
+ this._orient = t.get("orient"),
|
|
|
+ !1 !== this.dataZoomModel.get("show") ? (n && "dataZoom" === n.type && n.from === this.uid || this._buildView(),
|
|
|
+ this._updateView()) : this.group.removeAll()
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ rL.superApply(this, "remove", arguments),
|
|
|
+ Pc(this, "_dispatchZoomAction")
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ rL.superApply(this, "dispose", arguments),
|
|
|
+ Pc(this, "_dispatchZoomAction")
|
|
|
+ },
|
|
|
+ _buildView: function() {
|
|
|
+ var t = this.group;
|
|
|
+ t.removeAll(),
|
|
|
+ this._resetLocation(),
|
|
|
+ this._resetInterval();
|
|
|
+ var e = this._displayables.barGroup = new Ci;
|
|
|
+ this._renderBackground(),
|
|
|
+ this._renderHandle(),
|
|
|
+ this._renderDataShadow(),
|
|
|
+ t.add(e),
|
|
|
+ this._positionGroup()
|
|
|
+ },
|
|
|
+ _resetLocation: function() {
|
|
|
+ var t = this.dataZoomModel
|
|
|
+ , e = this.api
|
|
|
+ , i = this._findCoordRect()
|
|
|
+ , n = {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ }
|
|
|
+ , o = this._orient === nL ? {
|
|
|
+ right: n.width - i.x - i.width,
|
|
|
+ top: n.height - 30 - 7,
|
|
|
+ width: i.width,
|
|
|
+ height: 30
|
|
|
+ } : {
|
|
|
+ right: 7,
|
|
|
+ top: i.y,
|
|
|
+ width: 30,
|
|
|
+ height: i.height
|
|
|
+ }
|
|
|
+ , a = Iu(t.option);
|
|
|
+ E(["right", "top", "width", "height"], function(t) {
|
|
|
+ "ph" === a[t] && (a[t] = o[t])
|
|
|
+ });
|
|
|
+ var r = bu(a, n, t.padding);
|
|
|
+ this._location = {
|
|
|
+ x: r.x,
|
|
|
+ y: r.y
|
|
|
+ },
|
|
|
+ this._size = [r.width, r.height],
|
|
|
+ this._orient === oL && this._size.reverse()
|
|
|
+ },
|
|
|
+ _positionGroup: function() {
|
|
|
+ var t = this.group
|
|
|
+ , e = this._location
|
|
|
+ , i = this._orient
|
|
|
+ , n = this.dataZoomModel.getFirstTargetAxisModel()
|
|
|
+ , o = n && n.get("inverse")
|
|
|
+ , a = this._displayables.barGroup
|
|
|
+ , r = (this._dataShadowInfo || {}).otherAxisInverse;
|
|
|
+ a.attr(i !== nL || o ? i === nL && o ? {
|
|
|
+ scale: r ? [-1, 1] : [-1, -1]
|
|
|
+ } : i !== oL || o ? {
|
|
|
+ scale: r ? [-1, -1] : [-1, 1],
|
|
|
+ rotation: Math.PI / 2
|
|
|
+ } : {
|
|
|
+ scale: r ? [1, -1] : [1, 1],
|
|
|
+ rotation: Math.PI / 2
|
|
|
+ } : {
|
|
|
+ scale: r ? [1, 1] : [1, -1]
|
|
|
+ });
|
|
|
+ var s = t.getBoundingRect([a]);
|
|
|
+ t.attr("position", [e.x - s.x, e.y - s.y])
|
|
|
+ },
|
|
|
+ _getViewExtent: function() {
|
|
|
+ return [0, this._size[0]]
|
|
|
+ },
|
|
|
+ _renderBackground: function() {
|
|
|
+ var t = this.dataZoomModel
|
|
|
+ , e = this._size
|
|
|
+ , i = this._displayables.barGroup;
|
|
|
+ i.add(new JC({
|
|
|
+ silent: !0,
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: e[0],
|
|
|
+ height: e[1]
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ fill: t.get("backgroundColor")
|
|
|
+ },
|
|
|
+ z2: -40
|
|
|
+ })),
|
|
|
+ i.add(new JC({
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: e[0],
|
|
|
+ height: e[1]
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ fill: "transparent"
|
|
|
+ },
|
|
|
+ z2: 0,
|
|
|
+ onclick: A(this._onClickPanelClick, this)
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ _renderDataShadow: function() {
|
|
|
+ var t = this._dataShadowInfo = this._prepareDataShadowInfo();
|
|
|
+ if (t) {
|
|
|
+ var e = this._size
|
|
|
+ , i = t.series
|
|
|
+ , n = i.getRawData()
|
|
|
+ , o = i.getShadowDim ? i.getShadowDim() : t.otherDim;
|
|
|
+ if (null != o) {
|
|
|
+ var a = n.getDataExtent(o)
|
|
|
+ , r = .3 * (a[1] - a[0]);
|
|
|
+ a = [a[0] - r, a[1] + r];
|
|
|
+ var s, l = [0, e[1]], u = [0, e[0]], h = [[e[0], 0], [0, 0]], c = [], d = u[1] / (n.count() - 1), f = 0, p = Math.round(n.count() / e[0]);
|
|
|
+ n.each([o], function(t, e) {
|
|
|
+ if (0 < p && e % p)
|
|
|
+ f += d;
|
|
|
+ else {
|
|
|
+ var i = null == t || isNaN(t) || "" === t
|
|
|
+ , n = i ? 0 : QC(t, a, l, !0);
|
|
|
+ i && !s && e ? (h.push([h[h.length - 1][0], 0]),
|
|
|
+ c.push([c[c.length - 1][0], 0])) : !i && s && (h.push([f, 0]),
|
|
|
+ c.push([f, 0])),
|
|
|
+ h.push([f, n]),
|
|
|
+ c.push([f, n]),
|
|
|
+ f += d,
|
|
|
+ s = i
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var g = this.dataZoomModel;
|
|
|
+ this._displayables.barGroup.add(new Qr({
|
|
|
+ shape: {
|
|
|
+ points: h
|
|
|
+ },
|
|
|
+ style: D({
|
|
|
+ fill: g.get("dataBackgroundColor")
|
|
|
+ }, g.getModel("dataBackground.areaStyle").getAreaStyle()),
|
|
|
+ silent: !0,
|
|
|
+ z2: -20
|
|
|
+ })),
|
|
|
+ this._displayables.barGroup.add(new ts({
|
|
|
+ shape: {
|
|
|
+ points: c
|
|
|
+ },
|
|
|
+ style: g.getModel("dataBackground.lineStyle").getLineStyle(),
|
|
|
+ silent: !0,
|
|
|
+ z2: -19
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _prepareDataShadowInfo: function() {
|
|
|
+ var t = this.dataZoomModel
|
|
|
+ , s = t.get("showDataShadow");
|
|
|
+ if (!1 !== s) {
|
|
|
+ var l, u = this.ecModel;
|
|
|
+ return t.eachTargetAxis(function(a, r) {
|
|
|
+ E(t.getAxisProxy(a.name, r).getTargetSeriesModels(), function(t) {
|
|
|
+ if (!(l || !0 !== s && _(aL, t.get("type")) < 0)) {
|
|
|
+ var e, i = u.getComponent(a.axis, r).axis, n = function(t) {
|
|
|
+ return {
|
|
|
+ x: "y",
|
|
|
+ y: "x",
|
|
|
+ radius: "angle",
|
|
|
+ angle: "radius"
|
|
|
+ }[t]
|
|
|
+ }(a.name), o = t.coordinateSystem;
|
|
|
+ null != n && o.getOtherAxis && (e = o.getOtherAxis(i).inverse),
|
|
|
+ n = t.getData().mapDimension(n),
|
|
|
+ l = {
|
|
|
+ thisAxis: i,
|
|
|
+ series: t,
|
|
|
+ thisDim: a.name,
|
|
|
+ otherDim: n,
|
|
|
+ otherAxisInverse: e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }, this),
|
|
|
+ l
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderHandle: function() {
|
|
|
+ var t = this._displayables
|
|
|
+ , a = t.handles = []
|
|
|
+ , r = t.handleLabels = []
|
|
|
+ , s = this._displayables.barGroup
|
|
|
+ , e = this._size
|
|
|
+ , l = this.dataZoomModel;
|
|
|
+ s.add(t.filler = new JC({
|
|
|
+ draggable: !0,
|
|
|
+ cursor: sL(this._orient),
|
|
|
+ drift: eL(this._onDragMove, this, "all"),
|
|
|
+ ondragstart: eL(this._showDataInfo, this, !0),
|
|
|
+ ondragend: eL(this._onDragEnd, this),
|
|
|
+ onmouseover: eL(this._showDataInfo, this, !0),
|
|
|
+ onmouseout: eL(this._showDataInfo, this, !1),
|
|
|
+ style: {
|
|
|
+ fill: l.get("fillerColor"),
|
|
|
+ textPosition: "inside"
|
|
|
+ }
|
|
|
+ })),
|
|
|
+ s.add(new JC({
|
|
|
+ silent: !0,
|
|
|
+ subPixelOptimize: !0,
|
|
|
+ shape: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ width: e[0],
|
|
|
+ height: e[1]
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ stroke: l.get("dataBackgroundColor") || l.get("borderColor"),
|
|
|
+ lineWidth: 1,
|
|
|
+ fill: "rgba(0,0,0,0)"
|
|
|
+ }
|
|
|
+ })),
|
|
|
+ iL([0, 1], function(t) {
|
|
|
+ var e = yl(l.get("handleIcon"), {
|
|
|
+ cursor: sL(this._orient),
|
|
|
+ draggable: !0,
|
|
|
+ drift: eL(this._onDragMove, this, t),
|
|
|
+ ondragend: eL(this._onDragEnd, this),
|
|
|
+ onmouseover: eL(this._showDataInfo, this, !0),
|
|
|
+ onmouseout: eL(this._showDataInfo, this, !1)
|
|
|
+ }, {
|
|
|
+ x: -1,
|
|
|
+ y: 0,
|
|
|
+ width: 2,
|
|
|
+ height: 2
|
|
|
+ })
|
|
|
+ , i = e.getBoundingRect();
|
|
|
+ this._handleHeight = Rl(l.get("handleSize"), this._size[1]),
|
|
|
+ this._handleWidth = i.width / i.height * this._handleHeight,
|
|
|
+ e.setStyle(l.getModel("handleStyle").getItemStyle());
|
|
|
+ var n = l.get("handleColor");
|
|
|
+ null != n && (e.style.fill = n),
|
|
|
+ s.add(a[t] = e);
|
|
|
+ var o = l.textStyleModel;
|
|
|
+ this.group.add(r[t] = new Ur({
|
|
|
+ silent: !0,
|
|
|
+ invisible: !0,
|
|
|
+ style: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ text: "",
|
|
|
+ textVerticalAlign: "middle",
|
|
|
+ textAlign: "center",
|
|
|
+ textFill: o.getTextColor(),
|
|
|
+ textFont: o.getFont()
|
|
|
+ },
|
|
|
+ z2: 10
|
|
|
+ }))
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ _resetInterval: function() {
|
|
|
+ var t = this._range = this.dataZoomModel.getPercentRange()
|
|
|
+ , e = this._getViewExtent();
|
|
|
+ this._handleEnds = [QC(t[0], [0, 100], e, !0), QC(t[1], [0, 100], e, !0)]
|
|
|
+ },
|
|
|
+ _updateInterval: function(t, e) {
|
|
|
+ var i = this.dataZoomModel
|
|
|
+ , n = this._handleEnds
|
|
|
+ , o = this._getViewExtent()
|
|
|
+ , a = i.findRepresentativeAxisProxy().getMinMaxSpan()
|
|
|
+ , r = [0, 100];
|
|
|
+ Jw(e, n, o, i.get("zoomLock") ? "all" : t, null != a.minSpan ? QC(a.minSpan, r, o, !0) : null, null != a.maxSpan ? QC(a.maxSpan, r, o, !0) : null);
|
|
|
+ var s = this._range
|
|
|
+ , l = this._range = tL([QC(n[0], o, r, !0), QC(n[1], o, r, !0)]);
|
|
|
+ return !s || s[0] !== l[0] || s[1] !== l[1]
|
|
|
+ },
|
|
|
+ _updateView: function(t) {
|
|
|
+ var n = this._displayables
|
|
|
+ , o = this._handleEnds
|
|
|
+ , e = tL(o.slice())
|
|
|
+ , a = this._size;
|
|
|
+ iL([0, 1], function(t) {
|
|
|
+ var e = n.handles[t]
|
|
|
+ , i = this._handleHeight;
|
|
|
+ e.attr({
|
|
|
+ scale: [i / 2, i / 2],
|
|
|
+ position: [o[t], a[1] / 2 - i / 2]
|
|
|
+ })
|
|
|
+ }, this),
|
|
|
+ n.filler.setShape({
|
|
|
+ x: e[0],
|
|
|
+ y: 0,
|
|
|
+ width: e[1] - e[0],
|
|
|
+ height: a[1]
|
|
|
+ }),
|
|
|
+ this._updateDataInfo(t)
|
|
|
+ },
|
|
|
+ _updateDataInfo: function(t) {
|
|
|
+ var e = this.dataZoomModel
|
|
|
+ , a = this._displayables
|
|
|
+ , r = a.handleLabels
|
|
|
+ , s = this._orient
|
|
|
+ , l = ["", ""];
|
|
|
+ if (e.get("showDetail")) {
|
|
|
+ var i = e.findRepresentativeAxisProxy();
|
|
|
+ if (i) {
|
|
|
+ var n = i.getAxisModel().axis
|
|
|
+ , o = this._range
|
|
|
+ , u = t ? i.calculateDataWindow({
|
|
|
+ start: o[0],
|
|
|
+ end: o[1]
|
|
|
+ }).valueWindow : i.getDataValueWindow();
|
|
|
+ l = [this._formatLabel(u[0], n), this._formatLabel(u[1], n)]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var h = tL(this._handleEnds.slice());
|
|
|
+ function c(t) {
|
|
|
+ var e = fl(a.handles[t].parent, this.group)
|
|
|
+ , i = gl(0 === t ? "right" : "left", e)
|
|
|
+ , n = this._handleWidth / 2 + 5
|
|
|
+ , o = pl([h[t] + (0 === t ? -n : n), this._size[1] / 2], e);
|
|
|
+ r[t].setStyle({
|
|
|
+ x: o[0],
|
|
|
+ y: o[1],
|
|
|
+ textVerticalAlign: s === nL ? "middle" : i,
|
|
|
+ textAlign: s === nL ? i : "center",
|
|
|
+ text: l[t]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ c.call(this, 0),
|
|
|
+ c.call(this, 1)
|
|
|
+ },
|
|
|
+ _formatLabel: function(t, e) {
|
|
|
+ var i = this.dataZoomModel
|
|
|
+ , n = i.get("labelFormatter")
|
|
|
+ , o = i.get("labelPrecision");
|
|
|
+ null != o && "auto" !== o || (o = e.getPixelPrecision());
|
|
|
+ var a = null == t || isNaN(t) ? "" : "category" === e.type || "time" === e.type ? e.scale.getLabel(Math.round(t)) : t.toFixed(Math.min(o, 20));
|
|
|
+ return C(n) ? n(t, a) : R(n) ? n.replace("{value}", a) : a
|
|
|
+ },
|
|
|
+ _showDataInfo: function(t) {
|
|
|
+ t = this._dragging || t;
|
|
|
+ var e = this._displayables.handleLabels;
|
|
|
+ e[0].attr("invisible", !t),
|
|
|
+ e[1].attr("invisible", !t)
|
|
|
+ },
|
|
|
+ _onDragMove: function(t, e, i, n) {
|
|
|
+ this._dragging = !0,
|
|
|
+ Xt(n.event);
|
|
|
+ var o = pl([e, i], this._displayables.barGroup.getLocalTransform(), !0)
|
|
|
+ , a = this._updateInterval(t, o[0])
|
|
|
+ , r = this.dataZoomModel.get("realtime");
|
|
|
+ this._updateView(!r),
|
|
|
+ a && r && this._dispatchZoomAction()
|
|
|
+ },
|
|
|
+ _onDragEnd: function() {
|
|
|
+ this._dragging = !1,
|
|
|
+ this._showDataInfo(!1),
|
|
|
+ this.dataZoomModel.get("realtime") || this._dispatchZoomAction()
|
|
|
+ },
|
|
|
+ _onClickPanelClick: function(t) {
|
|
|
+ var e = this._size
|
|
|
+ , i = this._displayables.barGroup.transformCoordToLocal(t.offsetX, t.offsetY);
|
|
|
+ if (!(i[0] < 0 || i[0] > e[0] || i[1] < 0 || i[1] > e[1])) {
|
|
|
+ var n = this._handleEnds
|
|
|
+ , o = (n[0] + n[1]) / 2
|
|
|
+ , a = this._updateInterval("all", i[0] - o);
|
|
|
+ this._updateView(),
|
|
|
+ a && this._dispatchZoomAction()
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _dispatchZoomAction: function() {
|
|
|
+ var t = this._range;
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "dataZoom",
|
|
|
+ from: this.uid,
|
|
|
+ dataZoomId: this.dataZoomModel.id,
|
|
|
+ start: t[0],
|
|
|
+ end: t[1]
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _findCoordRect: function() {
|
|
|
+ var i;
|
|
|
+ if (iL(this.getTargetCoordInfo(), function(t) {
|
|
|
+ if (!i && t.length) {
|
|
|
+ var e = t[0].model.coordinateSystem;
|
|
|
+ i = e.getRect && e.getRect()
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ !i) {
|
|
|
+ var t = this.api.getWidth()
|
|
|
+ , e = this.api.getHeight();
|
|
|
+ i = {
|
|
|
+ x: .2 * t,
|
|
|
+ y: .2 * e,
|
|
|
+ width: .6 * t,
|
|
|
+ height: .6 * e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function sL(t) {
|
|
|
+ return "vertical" === t ? "ns-resize" : "ew-resize"
|
|
|
+ }
|
|
|
+ iD.extend({
|
|
|
+ type: "dataZoom.inside",
|
|
|
+ defaultOption: {
|
|
|
+ disabled: !1,
|
|
|
+ zoomLock: !1,
|
|
|
+ zoomOnMouseWheel: !0,
|
|
|
+ moveOnMouseMove: !0,
|
|
|
+ moveOnMouseWheel: !1,
|
|
|
+ preventDefaultMouseMove: !0
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var lL = "\0_ec_dataZoom_roams";
|
|
|
+ function uL(t, n) {
|
|
|
+ var e = cL(t)
|
|
|
+ , o = n.dataZoomId
|
|
|
+ , a = n.coordId;
|
|
|
+ E(e, function(t, e) {
|
|
|
+ var i = t.dataZoomInfos;
|
|
|
+ i[o] && _(n.allCoordIds, a) < 0 && (delete i[o],
|
|
|
+ t.count--)
|
|
|
+ }),
|
|
|
+ dL(e);
|
|
|
+ var i = e[a];
|
|
|
+ i || ((i = e[a] = {
|
|
|
+ coordId: a,
|
|
|
+ dataZoomInfos: {},
|
|
|
+ count: 0
|
|
|
+ }).controller = function(t, r) {
|
|
|
+ var e = new Vy(t.getZr());
|
|
|
+ return E(["pan", "zoom", "scrollMove"], function(a) {
|
|
|
+ e.on(a, function(n) {
|
|
|
+ var o = [];
|
|
|
+ E(r.dataZoomInfos, function(t) {
|
|
|
+ if (n.isAvailableBehavior(t.dataZoomModel.option)) {
|
|
|
+ var e = (t.getRange || {})[a]
|
|
|
+ , i = e && e(r.controller, n);
|
|
|
+ !t.dataZoomModel.get("disabled", !0) && i && o.push({
|
|
|
+ dataZoomId: t.dataZoomId,
|
|
|
+ start: i[0],
|
|
|
+ end: i[1]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ o.length && r.dispatchAction(o)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ e
|
|
|
+ }(t, i),
|
|
|
+ i.dispatchAction = T(fL, t)),
|
|
|
+ i.dataZoomInfos[o] || i.count++,
|
|
|
+ i.dataZoomInfos[o] = n;
|
|
|
+ var r = function(t) {
|
|
|
+ var n, o = {
|
|
|
+ type_true: 2,
|
|
|
+ type_move: 1,
|
|
|
+ type_false: 0,
|
|
|
+ type_undefined: -1
|
|
|
+ }, a = !0;
|
|
|
+ return E(t, function(t) {
|
|
|
+ var e = t.dataZoomModel
|
|
|
+ , i = !e.get("disabled", !0) && (!e.get("zoomLock", !0) || "move");
|
|
|
+ o["type_" + n] < o["type_" + i] && (n = i),
|
|
|
+ a &= e.get("preventDefaultMouseMove", !0)
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ controlType: n,
|
|
|
+ opt: {
|
|
|
+ zoomOnMouseWheel: !0,
|
|
|
+ moveOnMouseMove: !0,
|
|
|
+ moveOnMouseWheel: !0,
|
|
|
+ preventDefaultMouseMove: !!a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }(i.dataZoomInfos);
|
|
|
+ i.controller.enable(r.controlType, r.opt),
|
|
|
+ i.controller.setPointerChecker(n.containsPoint),
|
|
|
+ kc(i, "dispatchAction", n.dataZoomModel.get("throttle", !0), "fixRate")
|
|
|
+ }
|
|
|
+ function hL(t) {
|
|
|
+ return t.type + "\0_" + t.id
|
|
|
+ }
|
|
|
+ function cL(t) {
|
|
|
+ var e = t.getZr();
|
|
|
+ return e[lL] || (e[lL] = {})
|
|
|
+ }
|
|
|
+ function dL(i) {
|
|
|
+ E(i, function(t, e) {
|
|
|
+ t.count || (t.controller.dispose(),
|
|
|
+ delete i[e])
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function fL(t, e) {
|
|
|
+ t.dispatchAction({
|
|
|
+ type: "dataZoom",
|
|
|
+ batch: e
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var pL = A
|
|
|
+ , gL = aD.extend({
|
|
|
+ type: "dataZoom.inside",
|
|
|
+ init: function(t, e) {
|
|
|
+ this._range
|
|
|
+ },
|
|
|
+ render: function(r, t, s, e) {
|
|
|
+ gL.superApply(this, "render", arguments),
|
|
|
+ this._range = r.getPercentRange(),
|
|
|
+ E(this.getTargetCoordInfo(), function(t, o) {
|
|
|
+ var a = O(t, function(t) {
|
|
|
+ return hL(t.model)
|
|
|
+ });
|
|
|
+ E(t, function(e) {
|
|
|
+ var n = e.model
|
|
|
+ , i = {};
|
|
|
+ E(["pan", "zoom", "scrollMove"], function(t) {
|
|
|
+ i[t] = pL(mL[t], this, e, o)
|
|
|
+ }, this),
|
|
|
+ uL(s, {
|
|
|
+ coordId: hL(n),
|
|
|
+ allCoordIds: a,
|
|
|
+ containsPoint: function(t, e, i) {
|
|
|
+ return n.coordinateSystem.containPoint([e, i])
|
|
|
+ },
|
|
|
+ dataZoomId: r.id,
|
|
|
+ dataZoomModel: r,
|
|
|
+ getRange: i
|
|
|
+ })
|
|
|
+ }, this)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ !function(t, i) {
|
|
|
+ var e = cL(t);
|
|
|
+ E(e, function(t) {
|
|
|
+ t.controller.dispose();
|
|
|
+ var e = t.dataZoomInfos;
|
|
|
+ e[i] && (delete e[i],
|
|
|
+ t.count--)
|
|
|
+ }),
|
|
|
+ dL(e)
|
|
|
+ }(this.api, this.dataZoomModel.id),
|
|
|
+ gL.superApply(this, "dispose", arguments),
|
|
|
+ this._range = null
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , mL = {
|
|
|
+ zoom: function(t, e, i, n) {
|
|
|
+ var o = this._range
|
|
|
+ , a = o.slice()
|
|
|
+ , r = t.axisModels[0];
|
|
|
+ if (r) {
|
|
|
+ var s = xL[e](null, [n.originX, n.originY], r, i, t)
|
|
|
+ , l = (0 < s.signal ? s.pixelStart + s.pixelLength - s.pixel : s.pixel - s.pixelStart) / s.pixelLength * (a[1] - a[0]) + a[0]
|
|
|
+ , u = Math.max(1 / n.scale, 0);
|
|
|
+ a[0] = (a[0] - l) * u + l,
|
|
|
+ a[1] = (a[1] - l) * u + l;
|
|
|
+ var h = this.dataZoomModel.findRepresentativeAxisProxy().getMinMaxSpan();
|
|
|
+ return Jw(0, a, [0, 100], 0, h.minSpan, h.maxSpan),
|
|
|
+ this._range = a,
|
|
|
+ o[0] !== a[0] || o[1] !== a[1] ? a : void 0
|
|
|
+ }
|
|
|
+ },
|
|
|
+ pan: vL(function(t, e, i, n, o, a) {
|
|
|
+ var r = xL[n]([a.oldX, a.oldY], [a.newX, a.newY], e, o, i);
|
|
|
+ return r.signal * (t[1] - t[0]) * r.pixel / r.pixelLength
|
|
|
+ }),
|
|
|
+ scrollMove: vL(function(t, e, i, n, o, a) {
|
|
|
+ return xL[n]([0, 0], [a.scrollDelta, a.scrollDelta], e, o, i).signal * (t[1] - t[0]) * a.scrollDelta
|
|
|
+ })
|
|
|
+ };
|
|
|
+ function vL(l) {
|
|
|
+ return function(t, e, i, n) {
|
|
|
+ var o = this._range
|
|
|
+ , a = o.slice()
|
|
|
+ , r = t.axisModels[0];
|
|
|
+ if (r) {
|
|
|
+ var s = l(a, r, t, e, i, n);
|
|
|
+ return Jw(s, a, [0, 100], "all"),
|
|
|
+ this._range = a,
|
|
|
+ o[0] !== a[0] || o[1] !== a[1] ? a : void 0
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function yL(t) {
|
|
|
+ var e = t && t.visualMap;
|
|
|
+ L(e) || (e = e ? [e] : []),
|
|
|
+ _L(e, function(t) {
|
|
|
+ if (t) {
|
|
|
+ wL(t, "splitList") && !wL(t, "pieces") && (t.pieces = t.splitList,
|
|
|
+ delete t.splitList);
|
|
|
+ var e = t.pieces;
|
|
|
+ e && L(e) && _L(e, function(t) {
|
|
|
+ z(t) && (wL(t, "start") && !wL(t, "min") && (t.min = t.start),
|
|
|
+ wL(t, "end") && !wL(t, "max") && (t.max = t.end))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ var xL = {
|
|
|
+ grid: function(t, e, i, n, o) {
|
|
|
+ var a = i.axis
|
|
|
+ , r = {}
|
|
|
+ , s = o.model.coordinateSystem.getRect();
|
|
|
+ return t = t || [0, 0],
|
|
|
+ "x" === a.dim ? (r.pixel = e[0] - t[0],
|
|
|
+ r.pixelLength = s.width,
|
|
|
+ r.pixelStart = s.x,
|
|
|
+ r.signal = a.inverse ? 1 : -1) : (r.pixel = e[1] - t[1],
|
|
|
+ r.pixelLength = s.height,
|
|
|
+ r.pixelStart = s.y,
|
|
|
+ r.signal = a.inverse ? -1 : 1),
|
|
|
+ r
|
|
|
+ },
|
|
|
+ polar: function(t, e, i, n, o) {
|
|
|
+ var a = i.axis
|
|
|
+ , r = {}
|
|
|
+ , s = o.model.coordinateSystem
|
|
|
+ , l = s.getRadiusAxis().getExtent()
|
|
|
+ , u = s.getAngleAxis().getExtent();
|
|
|
+ return t = t ? s.pointToCoord(t) : [0, 0],
|
|
|
+ e = s.pointToCoord(e),
|
|
|
+ "radiusAxis" === i.mainType ? (r.pixel = e[0] - t[0],
|
|
|
+ r.pixelLength = l[1] - l[0],
|
|
|
+ r.pixelStart = l[0],
|
|
|
+ r.signal = a.inverse ? 1 : -1) : (r.pixel = e[1] - t[1],
|
|
|
+ r.pixelLength = u[1] - u[0],
|
|
|
+ r.pixelStart = u[0],
|
|
|
+ r.signal = a.inverse ? -1 : 1),
|
|
|
+ r
|
|
|
+ },
|
|
|
+ singleAxis: function(t, e, i, n, o) {
|
|
|
+ var a = i.axis
|
|
|
+ , r = o.model.coordinateSystem.getRect()
|
|
|
+ , s = {};
|
|
|
+ return t = t || [0, 0],
|
|
|
+ "horizontal" === a.orient ? (s.pixel = e[0] - t[0],
|
|
|
+ s.pixelLength = r.width,
|
|
|
+ s.pixelStart = r.x,
|
|
|
+ s.signal = a.inverse ? 1 : -1) : (s.pixel = e[1] - t[1],
|
|
|
+ s.pixelLength = r.height,
|
|
|
+ s.pixelStart = r.y,
|
|
|
+ s.signal = a.inverse ? -1 : 1),
|
|
|
+ s
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , _L = E;
|
|
|
+ function wL(t, e) {
|
|
|
+ return t && t.hasOwnProperty && t.hasOwnProperty(e)
|
|
|
+ }
|
|
|
+ ku.registerSubTypeDefaulter("visualMap", function(t) {
|
|
|
+ return t.categories || (t.pieces ? 0 < t.pieces.length : 0 < t.splitNumber) && !t.calculable ? "piecewise" : "continuous"
|
|
|
+ });
|
|
|
+ var bL = Ld.VISUAL.COMPONENT;
|
|
|
+ function SL(t, e, i, n) {
|
|
|
+ for (var o = e.targetVisuals[n], a = g_.prepareVisualTypes(o), r = {
|
|
|
+ color: t.getData().getVisual("color")
|
|
|
+ }, s = 0, l = a.length; s < l; s++) {
|
|
|
+ var u = a[s]
|
|
|
+ , h = o["opacity" === u ? "__alphaForOpacity" : u];
|
|
|
+ h && h.applyVisual(i, c, d)
|
|
|
+ }
|
|
|
+ return r.color;
|
|
|
+ function c(t) {
|
|
|
+ return r[t]
|
|
|
+ }
|
|
|
+ function d(t, e) {
|
|
|
+ r[t] = e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Sf(bL, {
|
|
|
+ createOnAllSeries: !0,
|
|
|
+ reset: function(i, t) {
|
|
|
+ var n = [];
|
|
|
+ return t.eachComponent("visualMap", function(t) {
|
|
|
+ var e = i.pipelineContext;
|
|
|
+ !t.isTargetSeries(i) || e && e.large || n.push(function(t, f, p, g) {
|
|
|
+ var m = {};
|
|
|
+ return E(t, function(t) {
|
|
|
+ var e = g_.prepareVisualTypes(f[t]);
|
|
|
+ m[t] = e
|
|
|
+ }),
|
|
|
+ {
|
|
|
+ progress: function(t, i) {
|
|
|
+ function e(t) {
|
|
|
+ return i.getItemVisual(o, t)
|
|
|
+ }
|
|
|
+ function n(t, e) {
|
|
|
+ i.setItemVisual(o, t, e)
|
|
|
+ }
|
|
|
+ var o;
|
|
|
+ for (null != g && (g = i.getDimension(g)); null != (o = t.next()); ) {
|
|
|
+ var a = i.getRawDataItem(o);
|
|
|
+ if (!a || !1 !== a.visualMap)
|
|
|
+ for (var r = null != g ? i.get(g, o, !0) : o, s = p(r), l = f[s], u = m[s], h = 0, c = u.length; h < c; h++) {
|
|
|
+ var d = u[h];
|
|
|
+ l[d] && l[d].applyVisual(r, e, n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }(t.stateList, t.targetVisuals, A(t.getValueState, t), t.getDataDimension(i.getData())))
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ Sf(bL, {
|
|
|
+ createOnAllSeries: !0,
|
|
|
+ reset: function(o, t) {
|
|
|
+ var a = o.getData()
|
|
|
+ , r = [];
|
|
|
+ t.eachComponent("visualMap", function(t) {
|
|
|
+ if (t.isTargetSeries(o)) {
|
|
|
+ var e = t.getVisualMeta(A(SL, null, o, t)) || {
|
|
|
+ stops: [],
|
|
|
+ outerColors: []
|
|
|
+ }
|
|
|
+ , i = t.getDataDimension(a)
|
|
|
+ , n = a.getDimensionInfo(i);
|
|
|
+ null != n && (e.dimension = n.index,
|
|
|
+ r.push(e))
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ o.getData().setVisual("visualMeta", r)
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var ML = function(t, e, i) {
|
|
|
+ var n = k((IL[t] || {})[e]);
|
|
|
+ return i && L(n) ? n[n.length - 1] : n
|
|
|
+ }
|
|
|
+ , IL = {
|
|
|
+ color: {
|
|
|
+ active: ["#006edd", "#e0ffff"],
|
|
|
+ inactive: ["rgba(0,0,0,0)"]
|
|
|
+ },
|
|
|
+ colorHue: {
|
|
|
+ active: [0, 360],
|
|
|
+ inactive: [0, 0]
|
|
|
+ },
|
|
|
+ colorSaturation: {
|
|
|
+ active: [.3, 1],
|
|
|
+ inactive: [0, 0]
|
|
|
+ },
|
|
|
+ colorLightness: {
|
|
|
+ active: [.9, .5],
|
|
|
+ inactive: [0, 0]
|
|
|
+ },
|
|
|
+ colorAlpha: {
|
|
|
+ active: [.3, 1],
|
|
|
+ inactive: [0, 0]
|
|
|
+ },
|
|
|
+ opacity: {
|
|
|
+ active: [.3, 1],
|
|
|
+ inactive: [0, 0]
|
|
|
+ },
|
|
|
+ symbol: {
|
|
|
+ active: ["circle", "roundRect", "diamond"],
|
|
|
+ inactive: ["none"]
|
|
|
+ },
|
|
|
+ symbolSize: {
|
|
|
+ active: [10, 50],
|
|
|
+ inactive: [0, 0]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , TL = g_.mapVisual
|
|
|
+ , AL = g_.eachVisual
|
|
|
+ , DL = L
|
|
|
+ , CL = E
|
|
|
+ , LL = Bl
|
|
|
+ , kL = El
|
|
|
+ , PL = Tf({
|
|
|
+ type: "visualMap",
|
|
|
+ dependencies: ["series"],
|
|
|
+ stateList: ["inRange", "outOfRange"],
|
|
|
+ replacableOptionKeys: ["inRange", "outOfRange", "target", "controller", "color"],
|
|
|
+ dataBound: [-1 / 0, 1 / 0],
|
|
|
+ layoutMode: {
|
|
|
+ type: "box",
|
|
|
+ ignoreSize: !0
|
|
|
+ },
|
|
|
+ defaultOption: {
|
|
|
+ show: !0,
|
|
|
+ zlevel: 0,
|
|
|
+ z: 4,
|
|
|
+ seriesIndex: "all",
|
|
|
+ min: 0,
|
|
|
+ max: 200,
|
|
|
+ dimension: null,
|
|
|
+ inRange: null,
|
|
|
+ outOfRange: null,
|
|
|
+ left: 0,
|
|
|
+ right: null,
|
|
|
+ top: null,
|
|
|
+ bottom: 0,
|
|
|
+ itemWidth: null,
|
|
|
+ itemHeight: null,
|
|
|
+ inverse: !1,
|
|
|
+ orient: "vertical",
|
|
|
+ backgroundColor: "rgba(0,0,0,0)",
|
|
|
+ borderColor: "#ccc",
|
|
|
+ contentColor: "#5793f3",
|
|
|
+ inactiveColor: "#aaa",
|
|
|
+ borderWidth: 0,
|
|
|
+ padding: 5,
|
|
|
+ textGap: 10,
|
|
|
+ precision: 0,
|
|
|
+ color: null,
|
|
|
+ formatter: null,
|
|
|
+ text: null,
|
|
|
+ textStyle: {
|
|
|
+ color: "#333"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ init: function(t, e, i) {
|
|
|
+ this._dataExtent,
|
|
|
+ this.targetVisuals = {},
|
|
|
+ this.controllerVisuals = {},
|
|
|
+ this.textStyleModel,
|
|
|
+ this.itemSize,
|
|
|
+ this.mergeDefaultAndTheme(t, i)
|
|
|
+ },
|
|
|
+ optionUpdated: function(t, e) {
|
|
|
+ var i = this.option;
|
|
|
+ v.canvasSupported || (i.realtime = !1),
|
|
|
+ e || PD(i, t, this.replacableOptionKeys),
|
|
|
+ this.textStyleModel = this.getModel("textStyle"),
|
|
|
+ this.resetItemSize(),
|
|
|
+ this.completeVisualOption()
|
|
|
+ },
|
|
|
+ resetVisual: function(t) {
|
|
|
+ var e = this.stateList;
|
|
|
+ t = A(t, this),
|
|
|
+ this.controllerVisuals = kD(this.option.controller, e, t),
|
|
|
+ this.targetVisuals = kD(this.option.target, e, t)
|
|
|
+ },
|
|
|
+ getTargetSeriesIndices: function() {
|
|
|
+ var t = this.option.seriesIndex
|
|
|
+ , i = [];
|
|
|
+ return null == t || "all" === t ? this.ecModel.eachSeries(function(t, e) {
|
|
|
+ i.push(e)
|
|
|
+ }) : i = Vo(t),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ eachTargetSeries: function(e, i) {
|
|
|
+ E(this.getTargetSeriesIndices(), function(t) {
|
|
|
+ e.call(i, this.ecModel.getSeriesByIndex(t))
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ isTargetSeries: function(e) {
|
|
|
+ var i = !1;
|
|
|
+ return this.eachTargetSeries(function(t) {
|
|
|
+ t === e && (i = !0)
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ formatValueText: function(t, e, i) {
|
|
|
+ var n, o, a = this.option, r = a.precision, s = this.dataBound, l = a.formatter;
|
|
|
+ return i = i || ["<", ">"],
|
|
|
+ L(t) && (t = t.slice(),
|
|
|
+ n = !0),
|
|
|
+ o = e ? t : n ? [u(t[0]), u(t[1])] : u(t),
|
|
|
+ R(l) ? l.replace("{value}", n ? o[0] : o).replace("{value2}", n ? o[1] : o) : C(l) ? n ? l(t[0], t[1]) : l(t) : n ? t[0] === s[0] ? i[0] + " " + o[1] : t[1] === s[1] ? i[1] + " " + o[0] : o[0] + " - " + o[1] : o;
|
|
|
+ function u(t) {
|
|
|
+ return t === s[0] ? "min" : t === s[1] ? "max" : (+t).toFixed(Math.min(r, 20))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ resetExtent: function() {
|
|
|
+ var t = this.option
|
|
|
+ , e = LL([t.min, t.max]);
|
|
|
+ this._dataExtent = e
|
|
|
+ },
|
|
|
+ getDataDimension: function(t) {
|
|
|
+ var e = this.option.dimension
|
|
|
+ , i = t.dimensions;
|
|
|
+ if (null != e || i.length) {
|
|
|
+ if (null != e)
|
|
|
+ return t.getDimension(e);
|
|
|
+ for (var n = t.dimensions, o = n.length - 1; 0 <= o; o--) {
|
|
|
+ var a = n[o];
|
|
|
+ if (!t.getDimensionInfo(a).isCalculationCoord)
|
|
|
+ return a
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getExtent: function() {
|
|
|
+ return this._dataExtent.slice()
|
|
|
+ },
|
|
|
+ completeVisualOption: function() {
|
|
|
+ var t = this.ecModel
|
|
|
+ , e = this.option
|
|
|
+ , i = {
|
|
|
+ inRange: e.inRange,
|
|
|
+ outOfRange: e.outOfRange
|
|
|
+ }
|
|
|
+ , n = e.target || (e.target = {})
|
|
|
+ , o = e.controller || (e.controller = {});
|
|
|
+ m(n, i),
|
|
|
+ m(o, i);
|
|
|
+ var u = this.isCategory();
|
|
|
+ function a(n) {
|
|
|
+ DL(e.color) && !n.inRange && (n.inRange = {
|
|
|
+ color: e.color.slice().reverse()
|
|
|
+ }),
|
|
|
+ n.inRange = n.inRange || {
|
|
|
+ color: t.get("gradientColor")
|
|
|
+ },
|
|
|
+ CL(this.stateList, function(t) {
|
|
|
+ var e = n[t];
|
|
|
+ if (R(e)) {
|
|
|
+ var i = ML(e, "active", u);
|
|
|
+ i ? (n[t] = {},
|
|
|
+ n[t][e] = i) : delete n[t]
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ a.call(this, n),
|
|
|
+ a.call(this, o),
|
|
|
+ function(t, e, i) {
|
|
|
+ var n = t[e]
|
|
|
+ , o = t[i];
|
|
|
+ n && !o && (o = t[i] = {},
|
|
|
+ CL(n, function(t, e) {
|
|
|
+ if (g_.isValidType(e)) {
|
|
|
+ var i = ML(e, "inactive", u);
|
|
|
+ null != i && (o[e] = i,
|
|
|
+ "color" !== e || o.hasOwnProperty("opacity") || o.hasOwnProperty("colorAlpha") || (o.opacity = [0, 0]))
|
|
|
+ }
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ .call(this, n, "inRange", "outOfRange"),
|
|
|
+ function(a) {
|
|
|
+ var r = (a.inRange || {}).symbol || (a.outOfRange || {}).symbol
|
|
|
+ , s = (a.inRange || {}).symbolSize || (a.outOfRange || {}).symbolSize
|
|
|
+ , l = this.get("inactiveColor");
|
|
|
+ CL(this.stateList, function(t) {
|
|
|
+ var e = this.itemSize
|
|
|
+ , i = a[t];
|
|
|
+ null == (i = i || (a[t] = {
|
|
|
+ color: u ? l : [l]
|
|
|
+ })).symbol && (i.symbol = r && k(r) || (u ? "roundRect" : ["roundRect"])),
|
|
|
+ null == i.symbolSize && (i.symbolSize = s && k(s) || (u ? e[0] : [e[0], e[0]])),
|
|
|
+ i.symbol = TL(i.symbol, function(t) {
|
|
|
+ return "none" === t || "square" === t ? "roundRect" : t
|
|
|
+ });
|
|
|
+ var n = i.symbolSize;
|
|
|
+ if (null != n) {
|
|
|
+ var o = -1 / 0;
|
|
|
+ AL(n, function(t) {
|
|
|
+ o < t && (o = t)
|
|
|
+ }),
|
|
|
+ i.symbolSize = TL(n, function(t) {
|
|
|
+ return kL(t, [0, o], [0, e[0]], !0)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ .call(this, o)
|
|
|
+ },
|
|
|
+ resetItemSize: function() {
|
|
|
+ this.itemSize = [parseFloat(this.get("itemWidth")), parseFloat(this.get("itemHeight"))]
|
|
|
+ },
|
|
|
+ isCategory: function() {
|
|
|
+ return !!this.option.categories
|
|
|
+ },
|
|
|
+ setSelected: et,
|
|
|
+ getValueState: et,
|
|
|
+ getVisualMeta: et
|
|
|
+ })
|
|
|
+ , NL = [20, 140]
|
|
|
+ , OL = PL.extend({
|
|
|
+ type: "visualMap.continuous",
|
|
|
+ defaultOption: {
|
|
|
+ align: "auto",
|
|
|
+ calculable: !1,
|
|
|
+ range: null,
|
|
|
+ realtime: !0,
|
|
|
+ itemHeight: null,
|
|
|
+ itemWidth: null,
|
|
|
+ hoverLink: !0,
|
|
|
+ hoverLinkDataSize: null,
|
|
|
+ hoverLinkOnHandle: null
|
|
|
+ },
|
|
|
+ optionUpdated: function(t, e) {
|
|
|
+ OL.superApply(this, "optionUpdated", arguments),
|
|
|
+ this.resetExtent(),
|
|
|
+ this.resetVisual(function(t) {
|
|
|
+ t.mappingMethod = "linear",
|
|
|
+ t.dataExtent = this.getExtent()
|
|
|
+ }),
|
|
|
+ this._resetRange()
|
|
|
+ },
|
|
|
+ resetItemSize: function() {
|
|
|
+ OL.superApply(this, "resetItemSize", arguments);
|
|
|
+ var t = this.itemSize;
|
|
|
+ "horizontal" === this._orient && t.reverse(),
|
|
|
+ null != t[0] && !isNaN(t[0]) || (t[0] = NL[0]),
|
|
|
+ null != t[1] && !isNaN(t[1]) || (t[1] = NL[1])
|
|
|
+ },
|
|
|
+ _resetRange: function() {
|
|
|
+ var t = this.getExtent()
|
|
|
+ , e = this.option.range;
|
|
|
+ !e || e.auto ? (t.auto = 1,
|
|
|
+ this.option.range = t) : L(e) && (e[0] > e[1] && e.reverse(),
|
|
|
+ e[0] = Math.max(e[0], t[0]),
|
|
|
+ e[1] = Math.min(e[1], t[1]))
|
|
|
+ },
|
|
|
+ completeVisualOption: function() {
|
|
|
+ PL.prototype.completeVisualOption.apply(this, arguments),
|
|
|
+ E(this.stateList, function(t) {
|
|
|
+ var e = this.option.controller[t].symbolSize;
|
|
|
+ e && e[0] !== e[1] && (e[0] = 0)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ setSelected: function(t) {
|
|
|
+ this.option.range = t.slice(),
|
|
|
+ this._resetRange()
|
|
|
+ },
|
|
|
+ getSelected: function() {
|
|
|
+ var t = this.getExtent()
|
|
|
+ , e = Bl((this.get("range") || []).slice());
|
|
|
+ return e[0] > t[1] && (e[0] = t[1]),
|
|
|
+ e[1] > t[1] && (e[1] = t[1]),
|
|
|
+ e[0] < t[0] && (e[0] = t[0]),
|
|
|
+ e[1] < t[0] && (e[1] = t[0]),
|
|
|
+ e
|
|
|
+ },
|
|
|
+ getValueState: function(t) {
|
|
|
+ var e = this.option.range
|
|
|
+ , i = this.getExtent();
|
|
|
+ return (e[0] <= i[0] || e[0] <= t) && (e[1] >= i[1] || t <= e[1]) ? "inRange" : "outOfRange"
|
|
|
+ },
|
|
|
+ findTargetDataIndices: function(n) {
|
|
|
+ var o = [];
|
|
|
+ return this.eachTargetSeries(function(t) {
|
|
|
+ var i = []
|
|
|
+ , e = t.getData();
|
|
|
+ e.each(this.getDataDimension(e), function(t, e) {
|
|
|
+ n[0] <= t && t <= n[1] && i.push(e)
|
|
|
+ }, this),
|
|
|
+ o.push({
|
|
|
+ seriesId: t.id,
|
|
|
+ dataIndex: i
|
|
|
+ })
|
|
|
+ }, this),
|
|
|
+ o
|
|
|
+ },
|
|
|
+ getVisualMeta: function(i) {
|
|
|
+ var t = EL(this, "outOfRange", this.getExtent())
|
|
|
+ , e = EL(this, "inRange", this.option.range.slice())
|
|
|
+ , n = [];
|
|
|
+ function o(t, e) {
|
|
|
+ n.push({
|
|
|
+ value: t,
|
|
|
+ color: i(t, e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ for (var a = 0, r = 0, s = e.length, l = t.length; r < l && (!e.length || t[r] <= e[0]); r++)
|
|
|
+ t[r] < e[a] && o(t[r], "outOfRange");
|
|
|
+ for (var u = 1; a < s; a++,
|
|
|
+ u = 0)
|
|
|
+ u && n.length && o(e[a], "outOfRange"),
|
|
|
+ o(e[a], "inRange");
|
|
|
+ for (u = 1; r < l; r++)
|
|
|
+ (!e.length || e[e.length - 1] < t[r]) && (u && (n.length && o(n[n.length - 1].value, "outOfRange"),
|
|
|
+ u = 0),
|
|
|
+ o(t[r], "outOfRange"));
|
|
|
+ var h = n.length;
|
|
|
+ return {
|
|
|
+ stops: n,
|
|
|
+ outerColors: [h ? n[0].color : "transparent", h ? n[h - 1].color : "transparent"]
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function EL(t, e, i) {
|
|
|
+ if (i[0] === i[1])
|
|
|
+ return i.slice();
|
|
|
+ for (var n = (i[1] - i[0]) / 200, o = i[0], a = [], r = 0; r <= 200 && o < i[1]; r++)
|
|
|
+ a.push(o),
|
|
|
+ o += n;
|
|
|
+ return a.push(i[1]),
|
|
|
+ a
|
|
|
+ }
|
|
|
+ var RL = Af({
|
|
|
+ type: "visualMap",
|
|
|
+ autoPositionValues: {
|
|
|
+ left: 1,
|
|
|
+ right: 1,
|
|
|
+ top: 1,
|
|
|
+ bottom: 1
|
|
|
+ },
|
|
|
+ init: function(t, e) {
|
|
|
+ this.ecModel = t,
|
|
|
+ this.api = e,
|
|
|
+ this.visualMapModel
|
|
|
+ },
|
|
|
+ render: function(t, e, i, n) {
|
|
|
+ !1 !== (this.visualMapModel = t).get("show") ? this.doRender.apply(this, arguments) : this.group.removeAll()
|
|
|
+ },
|
|
|
+ renderBackground: function(t) {
|
|
|
+ var e = this.visualMapModel
|
|
|
+ , i = iu(e.get("padding") || 0)
|
|
|
+ , n = t.getBoundingRect();
|
|
|
+ t.add(new rs({
|
|
|
+ z2: -1,
|
|
|
+ silent: !0,
|
|
|
+ shape: {
|
|
|
+ x: n.x - i[3],
|
|
|
+ y: n.y - i[0],
|
|
|
+ width: n.width + i[3] + i[1],
|
|
|
+ height: n.height + i[0] + i[2]
|
|
|
+ },
|
|
|
+ style: {
|
|
|
+ fill: e.get("backgroundColor"),
|
|
|
+ stroke: e.get("borderColor"),
|
|
|
+ lineWidth: e.get("borderWidth")
|
|
|
+ }
|
|
|
+ }))
|
|
|
+ },
|
|
|
+ getControllerVisual: function(i, n, o) {
|
|
|
+ var t = (o = o || {}).forceState
|
|
|
+ , e = this.visualMapModel
|
|
|
+ , a = {};
|
|
|
+ if ("symbol" === n && (a.symbol = e.get("itemSymbol")),
|
|
|
+ "color" === n) {
|
|
|
+ var r = e.get("contentColor");
|
|
|
+ a.color = r
|
|
|
+ }
|
|
|
+ function s(t) {
|
|
|
+ return a[t]
|
|
|
+ }
|
|
|
+ function l(t, e) {
|
|
|
+ a[t] = e
|
|
|
+ }
|
|
|
+ var u = e.controllerVisuals[t || e.getValueState(i)];
|
|
|
+ return E(g_.prepareVisualTypes(u), function(t) {
|
|
|
+ var e = u[t];
|
|
|
+ o.convertOpacityToAlpha && "opacity" === t && (t = "colorAlpha",
|
|
|
+ e = u.__alphaForOpacity),
|
|
|
+ g_.dependsOn(t, n) && e && e.applyVisual(i, s, l)
|
|
|
+ }),
|
|
|
+ a[n]
|
|
|
+ },
|
|
|
+ positionGroup: function(t) {
|
|
|
+ var e = this.visualMapModel
|
|
|
+ , i = this.api;
|
|
|
+ Su(t, e.getBoxLayoutParams(), {
|
|
|
+ width: i.getWidth(),
|
|
|
+ height: i.getHeight()
|
|
|
+ })
|
|
|
+ },
|
|
|
+ doRender: et
|
|
|
+ });
|
|
|
+ function zL(t, e, i) {
|
|
|
+ var n = t.option
|
|
|
+ , o = n.align;
|
|
|
+ if (null != o && "auto" !== o)
|
|
|
+ return o;
|
|
|
+ for (var a = {
|
|
|
+ width: e.getWidth(),
|
|
|
+ height: e.getHeight()
|
|
|
+ }, r = "horizontal" === n.orient ? 1 : 0, s = [["left", "right", "width"], ["top", "bottom", "height"]], l = s[r], u = [0, null, 10], h = {}, c = 0; c < 3; c++)
|
|
|
+ h[s[1 - r][c]] = u[c],
|
|
|
+ h[l[c]] = 2 === c ? i[0] : n[l[c]];
|
|
|
+ var d = [["x", "width", 3], ["y", "height", 0]][r]
|
|
|
+ , f = bu(h, a, n.padding);
|
|
|
+ return l[(f.margin[d[2]] || 0) + f[d[0]] + .5 * f[d[1]] < .5 * a[d[1]] ? 0 : 1]
|
|
|
+ }
|
|
|
+ function BL(t, e) {
|
|
|
+ return E(t || [], function(t) {
|
|
|
+ null != t.dataIndex && (t.dataIndexInside = t.dataIndex,
|
|
|
+ t.dataIndex = null),
|
|
|
+ t.highlightKey = "visualMap" + (e ? e.componentIndex : "")
|
|
|
+ }),
|
|
|
+ t
|
|
|
+ }
|
|
|
+ var VL = El
|
|
|
+ , GL = E
|
|
|
+ , FL = Math.min
|
|
|
+ , WL = Math.max
|
|
|
+ , HL = RL.extend({
|
|
|
+ type: "visualMap.continuous",
|
|
|
+ init: function() {
|
|
|
+ HL.superApply(this, "init", arguments),
|
|
|
+ this._shapes = {},
|
|
|
+ this._dataInterval = [],
|
|
|
+ this._handleEnds = [],
|
|
|
+ this._orient,
|
|
|
+ this._useHandle,
|
|
|
+ this._hoverLinkDataIndices = [],
|
|
|
+ this._dragging,
|
|
|
+ this._hovering
|
|
|
+ },
|
|
|
+ doRender: function(t, e, i, n) {
|
|
|
+ n && "selectDataRange" === n.type && n.from === this.uid || this._buildView()
|
|
|
+ },
|
|
|
+ _buildView: function() {
|
|
|
+ this.group.removeAll();
|
|
|
+ var t = this.visualMapModel
|
|
|
+ , e = this.group;
|
|
|
+ this._orient = t.get("orient"),
|
|
|
+ this._useHandle = t.get("calculable"),
|
|
|
+ this._resetInterval(),
|
|
|
+ this._renderBar(e);
|
|
|
+ var i = t.get("text");
|
|
|
+ this._renderEndsText(e, i, 0),
|
|
|
+ this._renderEndsText(e, i, 1),
|
|
|
+ this._updateView(!0),
|
|
|
+ this.renderBackground(e),
|
|
|
+ this._updateView(),
|
|
|
+ this._enableHoverLinkToSeries(),
|
|
|
+ this._enableHoverLinkFromSeries(),
|
|
|
+ this.positionGroup(e)
|
|
|
+ },
|
|
|
+ _renderEndsText: function(t, e, i) {
|
|
|
+ if (e) {
|
|
|
+ var n = e[1 - i];
|
|
|
+ n = null != n ? n + "" : "";
|
|
|
+ var o = this.visualMapModel
|
|
|
+ , a = o.get("textGap")
|
|
|
+ , r = o.itemSize
|
|
|
+ , s = this._shapes.barGroup
|
|
|
+ , l = this._applyTransform([r[0] / 2, 0 === i ? -a : r[1] + a], s)
|
|
|
+ , u = this._applyTransform(0 === i ? "bottom" : "top", s)
|
|
|
+ , h = this._orient
|
|
|
+ , c = this.visualMapModel.textStyleModel;
|
|
|
+ this.group.add(new Ur({
|
|
|
+ style: {
|
|
|
+ x: l[0],
|
|
|
+ y: l[1],
|
|
|
+ textVerticalAlign: "horizontal" === h ? "middle" : u,
|
|
|
+ textAlign: "horizontal" === h ? u : "center",
|
|
|
+ text: n,
|
|
|
+ textFont: c.getFont(),
|
|
|
+ textFill: c.getTextColor()
|
|
|
+ }
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _renderBar: function(t) {
|
|
|
+ var e = this.visualMapModel
|
|
|
+ , i = this._shapes
|
|
|
+ , n = e.itemSize
|
|
|
+ , o = this._orient
|
|
|
+ , a = this._useHandle
|
|
|
+ , r = zL(e, this.api, n)
|
|
|
+ , s = i.barGroup = this._createBarGroup(r);
|
|
|
+ s.add(i.outOfRange = ZL()),
|
|
|
+ s.add(i.inRange = ZL(null, a ? XL(this._orient) : null, A(this._dragHandle, this, "all", !1), A(this._dragHandle, this, "all", !0)));
|
|
|
+ var l = e.textStyleModel.getTextRect("国")
|
|
|
+ , u = WL(l.width, l.height);
|
|
|
+ a && (i.handleThumbs = [],
|
|
|
+ i.handleLabels = [],
|
|
|
+ i.handleLabelPoints = [],
|
|
|
+ this._createHandle(s, 0, n, u, o, r),
|
|
|
+ this._createHandle(s, 1, n, u, o, r)),
|
|
|
+ this._createIndicator(s, n, u, o),
|
|
|
+ t.add(s)
|
|
|
+ },
|
|
|
+ _createHandle: function(t, e, i, n, o) {
|
|
|
+ var a = A(this._dragHandle, this, e, !1)
|
|
|
+ , r = A(this._dragHandle, this, e, !0)
|
|
|
+ , s = ZL(function(t, e) {
|
|
|
+ return 0 === t ? [[0, 0], [e, 0], [e, -e]] : [[0, 0], [e, 0], [e, e]]
|
|
|
+ }(e, n), XL(this._orient), a, r);
|
|
|
+ s.position[0] = i[0],
|
|
|
+ t.add(s);
|
|
|
+ var l = this.visualMapModel.textStyleModel
|
|
|
+ , u = new Ur({
|
|
|
+ draggable: !0,
|
|
|
+ drift: a,
|
|
|
+ onmousemove: function(t) {
|
|
|
+ Xt(t.event)
|
|
|
+ },
|
|
|
+ ondragend: r,
|
|
|
+ style: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ text: "",
|
|
|
+ textFont: l.getFont(),
|
|
|
+ textFill: l.getTextColor()
|
|
|
+ }
|
|
|
+ });
|
|
|
+ this.group.add(u);
|
|
|
+ var h = ["horizontal" === o ? n / 2 : 1.5 * n, "horizontal" === o ? 0 === e ? -1.5 * n : 1.5 * n : 0 === e ? -n / 2 : n / 2]
|
|
|
+ , c = this._shapes;
|
|
|
+ c.handleThumbs[e] = s,
|
|
|
+ c.handleLabelPoints[e] = h,
|
|
|
+ c.handleLabels[e] = u
|
|
|
+ },
|
|
|
+ _createIndicator: function(t, e, i, n) {
|
|
|
+ var o = ZL([[0, 0]], "move");
|
|
|
+ o.position[0] = e[0],
|
|
|
+ o.attr({
|
|
|
+ invisible: !0,
|
|
|
+ silent: !0
|
|
|
+ }),
|
|
|
+ t.add(o);
|
|
|
+ var a = this.visualMapModel.textStyleModel
|
|
|
+ , r = new Ur({
|
|
|
+ silent: !0,
|
|
|
+ invisible: !0,
|
|
|
+ style: {
|
|
|
+ x: 0,
|
|
|
+ y: 0,
|
|
|
+ text: "",
|
|
|
+ textFont: a.getFont(),
|
|
|
+ textFill: a.getTextColor()
|
|
|
+ }
|
|
|
+ });
|
|
|
+ this.group.add(r);
|
|
|
+ var s = ["horizontal" === n ? i / 2 : 9, 0]
|
|
|
+ , l = this._shapes;
|
|
|
+ l.indicator = o,
|
|
|
+ l.indicatorLabel = r,
|
|
|
+ l.indicatorLabelPoint = s
|
|
|
+ },
|
|
|
+ _dragHandle: function(t, e, i, n) {
|
|
|
+ if (this._useHandle) {
|
|
|
+ if (this._dragging = !e,
|
|
|
+ !e) {
|
|
|
+ var o = this._applyTransform([i, n], this._shapes.barGroup, !0);
|
|
|
+ this._updateInterval(t, o[1]),
|
|
|
+ this._updateView()
|
|
|
+ }
|
|
|
+ e === !this.visualMapModel.get("realtime") && this.api.dispatchAction({
|
|
|
+ type: "selectDataRange",
|
|
|
+ from: this.uid,
|
|
|
+ visualMapId: this.visualMapModel.id,
|
|
|
+ selected: this._dataInterval.slice()
|
|
|
+ }),
|
|
|
+ e ? this._hovering || this._clearHoverLinkToSeries() : UL(this.visualMapModel) && this._doHoverLinkToSeries(this._handleEnds[t], !1)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _resetInterval: function() {
|
|
|
+ var t = this.visualMapModel
|
|
|
+ , e = this._dataInterval = t.getSelected()
|
|
|
+ , i = t.getExtent()
|
|
|
+ , n = [0, t.itemSize[1]];
|
|
|
+ this._handleEnds = [VL(e[0], i, n, !0), VL(e[1], i, n, !0)]
|
|
|
+ },
|
|
|
+ _updateInterval: function(t, e) {
|
|
|
+ e = e || 0;
|
|
|
+ var i = this.visualMapModel
|
|
|
+ , n = this._handleEnds
|
|
|
+ , o = [0, i.itemSize[1]];
|
|
|
+ Jw(e, n, o, t, 0);
|
|
|
+ var a = i.getExtent();
|
|
|
+ this._dataInterval = [VL(n[0], o, a, !0), VL(n[1], o, a, !0)]
|
|
|
+ },
|
|
|
+ _updateView: function(t) {
|
|
|
+ var e = this.visualMapModel
|
|
|
+ , i = e.getExtent()
|
|
|
+ , n = this._shapes
|
|
|
+ , o = [0, e.itemSize[1]]
|
|
|
+ , a = t ? o : this._handleEnds
|
|
|
+ , r = this._createBarVisual(this._dataInterval, i, a, "inRange")
|
|
|
+ , s = this._createBarVisual(i, i, o, "outOfRange");
|
|
|
+ n.inRange.setStyle({
|
|
|
+ fill: r.barColor,
|
|
|
+ opacity: r.opacity
|
|
|
+ }).setShape("points", r.barPoints),
|
|
|
+ n.outOfRange.setStyle({
|
|
|
+ fill: s.barColor,
|
|
|
+ opacity: s.opacity
|
|
|
+ }).setShape("points", s.barPoints),
|
|
|
+ this._updateHandle(a, r)
|
|
|
+ },
|
|
|
+ _createBarVisual: function(t, e, i, n) {
|
|
|
+ var o = {
|
|
|
+ forceState: n,
|
|
|
+ convertOpacityToAlpha: !0
|
|
|
+ }
|
|
|
+ , a = this._makeColorGradient(t, o)
|
|
|
+ , r = [this.getControllerVisual(t[0], "symbolSize", o), this.getControllerVisual(t[1], "symbolSize", o)]
|
|
|
+ , s = this._createBarPoints(i, r);
|
|
|
+ return {
|
|
|
+ barColor: new gs(0,0,0,1,a),
|
|
|
+ barPoints: s,
|
|
|
+ handlesColor: [a[0].color, a[a.length - 1].color]
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _makeColorGradient: function(t, e) {
|
|
|
+ var i = []
|
|
|
+ , n = (t[1] - t[0]) / 100;
|
|
|
+ i.push({
|
|
|
+ color: this.getControllerVisual(t[0], "color", e),
|
|
|
+ offset: 0
|
|
|
+ });
|
|
|
+ for (var o = 1; o < 100; o++) {
|
|
|
+ var a = t[0] + n * o;
|
|
|
+ if (a > t[1])
|
|
|
+ break;
|
|
|
+ i.push({
|
|
|
+ color: this.getControllerVisual(a, "color", e),
|
|
|
+ offset: o / 100
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return i.push({
|
|
|
+ color: this.getControllerVisual(t[1], "color", e),
|
|
|
+ offset: 1
|
|
|
+ }),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ _createBarPoints: function(t, e) {
|
|
|
+ var i = this.visualMapModel.itemSize;
|
|
|
+ return [[i[0] - e[0], t[0]], [i[0], t[0]], [i[0], t[1]], [i[0] - e[1], t[1]]]
|
|
|
+ },
|
|
|
+ _createBarGroup: function(t) {
|
|
|
+ var e = this._orient
|
|
|
+ , i = this.visualMapModel.get("inverse");
|
|
|
+ return new Ci("horizontal" !== e || i ? "horizontal" === e && i ? {
|
|
|
+ scale: "bottom" === t ? [-1, 1] : [1, 1],
|
|
|
+ rotation: -Math.PI / 2
|
|
|
+ } : "vertical" !== e || i ? {
|
|
|
+ scale: "left" === t ? [1, 1] : [-1, 1]
|
|
|
+ } : {
|
|
|
+ scale: "left" === t ? [1, -1] : [-1, -1]
|
|
|
+ } : {
|
|
|
+ scale: "bottom" === t ? [1, 1] : [-1, 1],
|
|
|
+ rotation: Math.PI / 2
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _updateHandle: function(n, o) {
|
|
|
+ if (this._useHandle) {
|
|
|
+ var a = this._shapes
|
|
|
+ , r = this.visualMapModel
|
|
|
+ , s = a.handleThumbs
|
|
|
+ , l = a.handleLabels;
|
|
|
+ GL([0, 1], function(t) {
|
|
|
+ var e = s[t];
|
|
|
+ e.setStyle("fill", o.handlesColor[t]),
|
|
|
+ e.position[1] = n[t];
|
|
|
+ var i = pl(a.handleLabelPoints[t], fl(e, this.group));
|
|
|
+ l[t].setStyle({
|
|
|
+ x: i[0],
|
|
|
+ y: i[1],
|
|
|
+ text: r.formatValueText(this._dataInterval[t]),
|
|
|
+ textVerticalAlign: "middle",
|
|
|
+ textAlign: this._applyTransform("horizontal" === this._orient ? 0 === t ? "bottom" : "top" : "left", a.barGroup)
|
|
|
+ })
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _showIndicator: function(t, e, i, n) {
|
|
|
+ var o = this.visualMapModel
|
|
|
+ , a = o.getExtent()
|
|
|
+ , r = o.itemSize
|
|
|
+ , s = [0, r[1]]
|
|
|
+ , l = VL(t, a, s, !0)
|
|
|
+ , u = this._shapes
|
|
|
+ , h = u.indicator;
|
|
|
+ if (h) {
|
|
|
+ h.position[1] = l,
|
|
|
+ h.attr("invisible", !1),
|
|
|
+ h.setShape("points", function(t, e, i, n) {
|
|
|
+ return t ? [[0, -FL(e, WL(i, 0))], [6, 0], [0, FL(e, WL(n - i, 0))]] : [[0, 0], [5, -5], [5, 5]]
|
|
|
+ }(!!i, n, l, r[1]));
|
|
|
+ var c = this.getControllerVisual(t, "color", {
|
|
|
+ convertOpacityToAlpha: !0
|
|
|
+ });
|
|
|
+ h.setStyle("fill", c);
|
|
|
+ var d = pl(u.indicatorLabelPoint, fl(h, this.group))
|
|
|
+ , f = u.indicatorLabel;
|
|
|
+ f.attr("invisible", !1);
|
|
|
+ var p = this._applyTransform("left", u.barGroup)
|
|
|
+ , g = this._orient;
|
|
|
+ f.setStyle({
|
|
|
+ text: (i || "") + o.formatValueText(e),
|
|
|
+ textVerticalAlign: "horizontal" === g ? p : "middle",
|
|
|
+ textAlign: "horizontal" === g ? "center" : p,
|
|
|
+ x: d[0],
|
|
|
+ y: d[1]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _enableHoverLinkToSeries: function() {
|
|
|
+ var n = this;
|
|
|
+ this._shapes.barGroup.on("mousemove", function(t) {
|
|
|
+ if (n._hovering = !0,
|
|
|
+ !n._dragging) {
|
|
|
+ var e = n.visualMapModel.itemSize
|
|
|
+ , i = n._applyTransform([t.offsetX, t.offsetY], n._shapes.barGroup, !0, !0);
|
|
|
+ i[1] = FL(WL(0, i[1]), e[1]),
|
|
|
+ n._doHoverLinkToSeries(i[1], 0 <= i[0] && i[0] <= e[0])
|
|
|
+ }
|
|
|
+ }).on("mouseout", function() {
|
|
|
+ n._hovering = !1,
|
|
|
+ n._dragging || n._clearHoverLinkToSeries()
|
|
|
+ })
|
|
|
+ },
|
|
|
+ _enableHoverLinkFromSeries: function() {
|
|
|
+ var t = this.api.getZr();
|
|
|
+ this.visualMapModel.option.hoverLink ? (t.on("mouseover", this._hoverLinkFromSeriesMouseOver, this),
|
|
|
+ t.on("mouseout", this._hideIndicator, this)) : this._clearHoverLinkFromSeries()
|
|
|
+ },
|
|
|
+ _doHoverLinkToSeries: function(t, e) {
|
|
|
+ var i = this.visualMapModel
|
|
|
+ , n = i.itemSize;
|
|
|
+ if (i.option.hoverLink) {
|
|
|
+ var o = [0, n[1]]
|
|
|
+ , a = i.getExtent();
|
|
|
+ t = FL(WL(o[0], t), o[1]);
|
|
|
+ var r = function(t, e, i) {
|
|
|
+ var n = 6
|
|
|
+ , o = t.get("hoverLinkDataSize");
|
|
|
+ o && (n = VL(o, e, i, !0) / 2);
|
|
|
+ return n
|
|
|
+ }(i, a, o)
|
|
|
+ , s = [t - r, t + r]
|
|
|
+ , l = VL(t, o, a, !0)
|
|
|
+ , u = [VL(s[0], o, a, !0), VL(s[1], o, a, !0)];
|
|
|
+ s[0] < o[0] && (u[0] = -1 / 0),
|
|
|
+ o[1] < s[1] && (u[1] = 1 / 0),
|
|
|
+ e && (u[0] === -1 / 0 ? this._showIndicator(l, u[1], "< ", r) : u[1] === 1 / 0 ? this._showIndicator(l, u[0], "> ", r) : this._showIndicator(l, l, "≈ ", r));
|
|
|
+ var h = this._hoverLinkDataIndices
|
|
|
+ , c = [];
|
|
|
+ (e || UL(i)) && (c = this._hoverLinkDataIndices = i.findTargetDataIndices(u));
|
|
|
+ var d = function(t, e) {
|
|
|
+ var i = {}
|
|
|
+ , n = {};
|
|
|
+ return o(t || [], i),
|
|
|
+ o(e || [], n, i),
|
|
|
+ [a(i), a(n)];
|
|
|
+ function o(t, e, i) {
|
|
|
+ for (var n = 0, o = t.length; n < o; n++)
|
|
|
+ for (var a = t[n].seriesId, r = Vo(t[n].dataIndex), s = i && i[a], l = 0, u = r.length; l < u; l++) {
|
|
|
+ var h = r[l];
|
|
|
+ s && s[h] ? s[h] = null : (e[a] || (e[a] = {}))[h] = 1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function a(t, e) {
|
|
|
+ var i = [];
|
|
|
+ for (var n in t)
|
|
|
+ if (t.hasOwnProperty(n) && null != t[n])
|
|
|
+ if (e)
|
|
|
+ i.push(+n);
|
|
|
+ else {
|
|
|
+ var o = a(t[n], !0);
|
|
|
+ o.length && i.push({
|
|
|
+ seriesId: n,
|
|
|
+ dataIndex: o
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return i
|
|
|
+ }
|
|
|
+ }(h, c);
|
|
|
+ this._dispatchHighDown("downplay", BL(d[0], i)),
|
|
|
+ this._dispatchHighDown("highlight", BL(d[1], i))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _hoverLinkFromSeriesMouseOver: function(t) {
|
|
|
+ var e = t.target
|
|
|
+ , i = this.visualMapModel;
|
|
|
+ if (e && null != e.dataIndex) {
|
|
|
+ var n = this.ecModel.getSeriesByIndex(e.seriesIndex);
|
|
|
+ if (i.isTargetSeries(n)) {
|
|
|
+ var o = n.getData(e.dataType)
|
|
|
+ , a = o.get(i.getDataDimension(o), e.dataIndex, !0);
|
|
|
+ isNaN(a) || this._showIndicator(a, a)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _hideIndicator: function() {
|
|
|
+ var t = this._shapes;
|
|
|
+ t.indicator && t.indicator.attr("invisible", !0),
|
|
|
+ t.indicatorLabel && t.indicatorLabel.attr("invisible", !0)
|
|
|
+ },
|
|
|
+ _clearHoverLinkToSeries: function() {
|
|
|
+ this._hideIndicator();
|
|
|
+ var t = this._hoverLinkDataIndices;
|
|
|
+ this._dispatchHighDown("downplay", BL(t, this.visualMapModel)),
|
|
|
+ t.length = 0
|
|
|
+ },
|
|
|
+ _clearHoverLinkFromSeries: function() {
|
|
|
+ this._hideIndicator();
|
|
|
+ var t = this.api.getZr();
|
|
|
+ t.off("mouseover", this._hoverLinkFromSeriesMouseOver),
|
|
|
+ t.off("mouseout", this._hideIndicator)
|
|
|
+ },
|
|
|
+ _applyTransform: function(t, e, i, n) {
|
|
|
+ var o = fl(e, n ? null : this.group);
|
|
|
+ return bl[L(t) ? "applyTransform" : "transformDirection"](t, o, i)
|
|
|
+ },
|
|
|
+ _dispatchHighDown: function(t, e) {
|
|
|
+ e && e.length && this.api.dispatchAction({
|
|
|
+ type: t,
|
|
|
+ batch: e
|
|
|
+ })
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this._clearHoverLinkFromSeries(),
|
|
|
+ this._clearHoverLinkToSeries()
|
|
|
+ },
|
|
|
+ remove: function() {
|
|
|
+ this._clearHoverLinkFromSeries(),
|
|
|
+ this._clearHoverLinkToSeries()
|
|
|
+ }
|
|
|
+ });
|
|
|
+ function ZL(t, e, i, n) {
|
|
|
+ return new Qr({
|
|
|
+ shape: {
|
|
|
+ points: t
|
|
|
+ },
|
|
|
+ draggable: !!i,
|
|
|
+ cursor: e,
|
|
|
+ drift: i,
|
|
|
+ onmousemove: function(t) {
|
|
|
+ Xt(t.event)
|
|
|
+ },
|
|
|
+ ondragend: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ function UL(t) {
|
|
|
+ var e = t.get("hoverLinkOnHandle");
|
|
|
+ return !!(null == e ? t.get("realtime") : e)
|
|
|
+ }
|
|
|
+ function XL(t) {
|
|
|
+ return "vertical" === t ? "ns-resize" : "ew-resize"
|
|
|
+ }
|
|
|
+ _f({
|
|
|
+ type: "selectDataRange",
|
|
|
+ event: "dataRangeSelected",
|
|
|
+ update: "update"
|
|
|
+ }, function(e, t) {
|
|
|
+ t.eachComponent({
|
|
|
+ mainType: "visualMap",
|
|
|
+ query: e
|
|
|
+ }, function(t) {
|
|
|
+ t.setSelected(e.selected)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ yf(yL);
|
|
|
+ var YL = PL.extend({
|
|
|
+ type: "visualMap.piecewise",
|
|
|
+ defaultOption: {
|
|
|
+ selected: null,
|
|
|
+ minOpen: !1,
|
|
|
+ maxOpen: !1,
|
|
|
+ align: "auto",
|
|
|
+ itemWidth: 20,
|
|
|
+ itemHeight: 14,
|
|
|
+ itemSymbol: "roundRect",
|
|
|
+ pieceList: null,
|
|
|
+ categories: null,
|
|
|
+ splitNumber: 5,
|
|
|
+ selectedMode: "multiple",
|
|
|
+ itemGap: 10,
|
|
|
+ hoverLink: !0,
|
|
|
+ showLabel: null
|
|
|
+ },
|
|
|
+ optionUpdated: function(t, e) {
|
|
|
+ YL.superApply(this, "optionUpdated", arguments),
|
|
|
+ this._pieceList = [],
|
|
|
+ this.resetExtent();
|
|
|
+ var i = this._mode = this._determineMode();
|
|
|
+ jL[this._mode].call(this),
|
|
|
+ this._resetSelected(t, e);
|
|
|
+ var n = this.option.categories;
|
|
|
+ this.resetVisual(function(t, e) {
|
|
|
+ "categories" === i ? (t.mappingMethod = "category",
|
|
|
+ t.categories = k(n)) : (t.dataExtent = this.getExtent(),
|
|
|
+ t.mappingMethod = "piecewise",
|
|
|
+ t.pieceList = O(this._pieceList, function(t) {
|
|
|
+ t = k(t);
|
|
|
+ return "inRange" !== e && (t.visual = null),
|
|
|
+ t
|
|
|
+ }))
|
|
|
+ })
|
|
|
+ },
|
|
|
+ completeVisualOption: function() {
|
|
|
+ var n = this.option
|
|
|
+ , i = {}
|
|
|
+ , t = g_.listVisualTypes()
|
|
|
+ , o = this.isCategory();
|
|
|
+ function a(t, e, i) {
|
|
|
+ return t && t[e] && (z(t[e]) ? t[e].hasOwnProperty(i) : t[e] === i)
|
|
|
+ }
|
|
|
+ E(n.pieces, function(e) {
|
|
|
+ E(t, function(t) {
|
|
|
+ e.hasOwnProperty(t) && (i[t] = 1)
|
|
|
+ })
|
|
|
+ }),
|
|
|
+ E(i, function(t, e) {
|
|
|
+ var i = 0;
|
|
|
+ E(this.stateList, function(t) {
|
|
|
+ i |= a(n, t, e) || a(n.target, t, e)
|
|
|
+ }, this),
|
|
|
+ i || E(this.stateList, function(t) {
|
|
|
+ (n[t] || (n[t] = {}))[e] = ML(e, "inRange" === t ? "active" : "inactive", o)
|
|
|
+ })
|
|
|
+ }, this),
|
|
|
+ PL.prototype.completeVisualOption.apply(this, arguments)
|
|
|
+ },
|
|
|
+ _resetSelected: function(t, e) {
|
|
|
+ var i = this.option
|
|
|
+ , n = this._pieceList
|
|
|
+ , o = (e ? i : t).selected || {};
|
|
|
+ if (i.selected = o,
|
|
|
+ E(n, function(t, e) {
|
|
|
+ var i = this.getSelectedMapKey(t);
|
|
|
+ o.hasOwnProperty(i) || (o[i] = !0)
|
|
|
+ }, this),
|
|
|
+ "single" === i.selectedMode) {
|
|
|
+ var a = !1;
|
|
|
+ E(n, function(t, e) {
|
|
|
+ var i = this.getSelectedMapKey(t);
|
|
|
+ o[i] && (a ? o[i] = !1 : a = !0)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getSelectedMapKey: function(t) {
|
|
|
+ return "categories" === this._mode ? t.value + "" : t.index + ""
|
|
|
+ },
|
|
|
+ getPieceList: function() {
|
|
|
+ return this._pieceList
|
|
|
+ },
|
|
|
+ _determineMode: function() {
|
|
|
+ var t = this.option;
|
|
|
+ return t.pieces && 0 < t.pieces.length ? "pieces" : this.option.categories ? "categories" : "splitNumber"
|
|
|
+ },
|
|
|
+ setSelected: function(t) {
|
|
|
+ this.option.selected = k(t)
|
|
|
+ },
|
|
|
+ getValueState: function(t) {
|
|
|
+ var e = g_.findPieceIndex(t, this._pieceList);
|
|
|
+ return null != e && this.option.selected[this.getSelectedMapKey(this._pieceList[e])] ? "inRange" : "outOfRange"
|
|
|
+ },
|
|
|
+ findTargetDataIndices: function(n) {
|
|
|
+ var o = [];
|
|
|
+ return this.eachTargetSeries(function(t) {
|
|
|
+ var i = []
|
|
|
+ , e = t.getData();
|
|
|
+ e.each(this.getDataDimension(e), function(t, e) {
|
|
|
+ g_.findPieceIndex(t, this._pieceList) === n && i.push(e)
|
|
|
+ }, this),
|
|
|
+ o.push({
|
|
|
+ seriesId: t.id,
|
|
|
+ dataIndex: i
|
|
|
+ })
|
|
|
+ }, this),
|
|
|
+ o
|
|
|
+ },
|
|
|
+ getRepresentValue: function(t) {
|
|
|
+ var e;
|
|
|
+ if (this.isCategory())
|
|
|
+ e = t.value;
|
|
|
+ else if (null != t.value)
|
|
|
+ e = t.value;
|
|
|
+ else {
|
|
|
+ var i = t.interval || [];
|
|
|
+ e = i[0] === -1 / 0 && i[1] === 1 / 0 ? 0 : (i[0] + i[1]) / 2
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ },
|
|
|
+ getVisualMeta: function(o) {
|
|
|
+ if (!this.isCategory()) {
|
|
|
+ var a = []
|
|
|
+ , r = []
|
|
|
+ , s = this
|
|
|
+ , t = this._pieceList.slice();
|
|
|
+ if (t.length) {
|
|
|
+ var e = t[0].interval[0];
|
|
|
+ e !== -1 / 0 && t.unshift({
|
|
|
+ interval: [-1 / 0, e]
|
|
|
+ }),
|
|
|
+ (e = t[t.length - 1].interval[1]) !== 1 / 0 && t.push({
|
|
|
+ interval: [e, 1 / 0]
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ t.push({
|
|
|
+ interval: [-1 / 0, 1 / 0]
|
|
|
+ });
|
|
|
+ var i = -1 / 0;
|
|
|
+ return E(t, function(t) {
|
|
|
+ var e = t.interval;
|
|
|
+ e && (e[0] > i && n([i, e[0]], "outOfRange"),
|
|
|
+ n(e.slice()),
|
|
|
+ i = e[1])
|
|
|
+ }, this),
|
|
|
+ {
|
|
|
+ stops: a,
|
|
|
+ outerColors: r
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function n(t, e) {
|
|
|
+ var i = s.getRepresentValue({
|
|
|
+ interval: t
|
|
|
+ });
|
|
|
+ e = e || s.getValueState(i);
|
|
|
+ var n = o(i, e);
|
|
|
+ t[0] === -1 / 0 ? r[0] = n : t[1] === 1 / 0 ? r[1] = n : a.push({
|
|
|
+ value: t[0],
|
|
|
+ color: n
|
|
|
+ }, {
|
|
|
+ value: t[1],
|
|
|
+ color: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , jL = {
|
|
|
+ splitNumber: function() {
|
|
|
+ var t = this.option
|
|
|
+ , e = this._pieceList
|
|
|
+ , i = Math.min(t.precision, 20)
|
|
|
+ , n = this.getExtent()
|
|
|
+ , o = t.splitNumber;
|
|
|
+ o = Math.max(parseInt(o, 10), 1),
|
|
|
+ t.splitNumber = o;
|
|
|
+ for (var a = (n[1] - n[0]) / o; +a.toFixed(i) !== a && i < 5; )
|
|
|
+ i++;
|
|
|
+ t.precision = i,
|
|
|
+ a = +a.toFixed(i),
|
|
|
+ t.minOpen && e.push({
|
|
|
+ interval: [-1 / 0, n[0]],
|
|
|
+ close: [0, 0]
|
|
|
+ });
|
|
|
+ for (var r = 0, s = n[0]; r < o; s += a,
|
|
|
+ r++) {
|
|
|
+ var l = r === o - 1 ? n[1] : s + a;
|
|
|
+ e.push({
|
|
|
+ interval: [s, l],
|
|
|
+ close: [1, 1]
|
|
|
+ })
|
|
|
+ }
|
|
|
+ t.maxOpen && e.push({
|
|
|
+ interval: [n[1], 1 / 0],
|
|
|
+ close: [0, 0]
|
|
|
+ }),
|
|
|
+ $l(e),
|
|
|
+ E(e, function(t, e) {
|
|
|
+ t.index = e,
|
|
|
+ t.text = this.formatValueText(t.interval)
|
|
|
+ }, this)
|
|
|
+ },
|
|
|
+ categories: function() {
|
|
|
+ var t = this.option;
|
|
|
+ E(t.categories, function(t) {
|
|
|
+ this._pieceList.push({
|
|
|
+ text: this.formatValueText(t, !0),
|
|
|
+ value: t
|
|
|
+ })
|
|
|
+ }, this),
|
|
|
+ qL(t, this._pieceList)
|
|
|
+ },
|
|
|
+ pieces: function() {
|
|
|
+ var t = this.option
|
|
|
+ , d = this._pieceList;
|
|
|
+ E(t.pieces, function(t, e) {
|
|
|
+ z(t) || (t = {
|
|
|
+ value: t
|
|
|
+ });
|
|
|
+ var i = {
|
|
|
+ text: "",
|
|
|
+ index: e
|
|
|
+ };
|
|
|
+ if (null != t.label && (i.text = t.label),
|
|
|
+ t.hasOwnProperty("value")) {
|
|
|
+ var n = i.value = t.value;
|
|
|
+ i.interval = [n, n],
|
|
|
+ i.close = [1, 1]
|
|
|
+ } else {
|
|
|
+ for (var o = i.interval = [], a = i.close = [0, 0], r = [1, 0, 1], s = [-1 / 0, 1 / 0], l = [], u = 0; u < 2; u++) {
|
|
|
+ for (var h = [["gte", "gt", "min"], ["lte", "lt", "max"]][u], c = 0; c < 3 && null == o[u]; c++)
|
|
|
+ o[u] = t[h[c]],
|
|
|
+ a[u] = r[c],
|
|
|
+ l[u] = 2 === c;
|
|
|
+ null == o[u] && (o[u] = s[u])
|
|
|
+ }
|
|
|
+ l[0] && o[1] === 1 / 0 && (a[0] = 0),
|
|
|
+ l[1] && o[0] === -1 / 0 && (a[1] = 0),
|
|
|
+ o[0] === o[1] && a[0] && a[1] && (i.value = o[0])
|
|
|
+ }
|
|
|
+ i.visual = g_.retrieveVisuals(t),
|
|
|
+ d.push(i)
|
|
|
+ }, this),
|
|
|
+ qL(t, d),
|
|
|
+ $l(d),
|
|
|
+ E(d, function(t) {
|
|
|
+ var e = t.close
|
|
|
+ , i = [["<", "≤"][e[1]], [">", "≥"][e[0]]];
|
|
|
+ t.text = t.text || this.formatValueText(null != t.value ? t.value : t.interval, !1, i)
|
|
|
+ }, this)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function qL(t, e) {
|
|
|
+ var i = t.inverse;
|
|
|
+ ("vertical" === t.orient ? !i : i) && e.reverse()
|
|
|
+ }
|
|
|
+ RL.extend({
|
|
|
+ type: "visualMap.piecewise",
|
|
|
+ doRender: function() {
|
|
|
+ var a = this.group;
|
|
|
+ a.removeAll();
|
|
|
+ var r = this.visualMapModel
|
|
|
+ , s = r.get("textGap")
|
|
|
+ , t = r.textStyleModel
|
|
|
+ , l = t.getFont()
|
|
|
+ , u = t.getTextColor()
|
|
|
+ , h = this._getItemAlign()
|
|
|
+ , c = r.itemSize
|
|
|
+ , e = this._getViewData()
|
|
|
+ , i = e.endsText
|
|
|
+ , d = W(r.get("showLabel", !0), !i);
|
|
|
+ i && this._renderEndsText(a, i[0], c, d, h),
|
|
|
+ E(e.viewPieceList, function(t) {
|
|
|
+ var e = t.piece
|
|
|
+ , i = new Ci;
|
|
|
+ i.onclick = A(this._onItemClick, this, e),
|
|
|
+ this._enableHoverLink(i, t.indexInModelPieceList);
|
|
|
+ var n = r.getRepresentValue(e);
|
|
|
+ if (this._createItemSymbol(i, n, [0, 0, c[0], c[1]]),
|
|
|
+ d) {
|
|
|
+ var o = this.visualMapModel.getValueState(n);
|
|
|
+ i.add(new Ur({
|
|
|
+ style: {
|
|
|
+ x: "right" === h ? -s : c[0] + s,
|
|
|
+ y: c[1] / 2,
|
|
|
+ text: e.text,
|
|
|
+ textVerticalAlign: "middle",
|
|
|
+ textAlign: h,
|
|
|
+ textFont: l,
|
|
|
+ textFill: u,
|
|
|
+ opacity: "outOfRange" === o ? .5 : 1
|
|
|
+ }
|
|
|
+ }))
|
|
|
+ }
|
|
|
+ a.add(i)
|
|
|
+ }, this),
|
|
|
+ i && this._renderEndsText(a, i[1], c, d, h),
|
|
|
+ wu(r.get("orient"), a, r.get("itemGap")),
|
|
|
+ this.renderBackground(a),
|
|
|
+ this.positionGroup(a)
|
|
|
+ },
|
|
|
+ _enableHoverLink: function(t, i) {
|
|
|
+ function e(t) {
|
|
|
+ var e = this.visualMapModel;
|
|
|
+ e.option.hoverLink && this.api.dispatchAction({
|
|
|
+ type: t,
|
|
|
+ batch: BL(e.findTargetDataIndices(i), e)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ t.on("mouseover", A(e, this, "highlight")).on("mouseout", A(e, this, "downplay"))
|
|
|
+ },
|
|
|
+ _getItemAlign: function() {
|
|
|
+ var t = this.visualMapModel
|
|
|
+ , e = t.option;
|
|
|
+ if ("vertical" === e.orient)
|
|
|
+ return zL(t, this.api, t.itemSize);
|
|
|
+ var i = e.align;
|
|
|
+ return i && "auto" !== i || (i = "left"),
|
|
|
+ i
|
|
|
+ },
|
|
|
+ _renderEndsText: function(t, e, i, n, o) {
|
|
|
+ if (e) {
|
|
|
+ var a = new Ci
|
|
|
+ , r = this.visualMapModel.textStyleModel;
|
|
|
+ a.add(new Ur({
|
|
|
+ style: {
|
|
|
+ x: n ? "right" === o ? i[0] : 0 : i[0] / 2,
|
|
|
+ y: i[1] / 2,
|
|
|
+ textVerticalAlign: "middle",
|
|
|
+ textAlign: n ? o : "center",
|
|
|
+ text: e,
|
|
|
+ textFont: r.getFont(),
|
|
|
+ textFill: r.getTextColor()
|
|
|
+ }
|
|
|
+ })),
|
|
|
+ t.add(a)
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _getViewData: function() {
|
|
|
+ var t = this.visualMapModel
|
|
|
+ , e = O(t.getPieceList(), function(t, e) {
|
|
|
+ return {
|
|
|
+ piece: t,
|
|
|
+ indexInModelPieceList: e
|
|
|
+ }
|
|
|
+ })
|
|
|
+ , i = t.get("text")
|
|
|
+ , n = t.get("orient")
|
|
|
+ , o = t.get("inverse");
|
|
|
+ return ("horizontal" === n ? o : !o) ? e.reverse() : i = i && i.slice().reverse(),
|
|
|
+ {
|
|
|
+ viewPieceList: e,
|
|
|
+ endsText: i
|
|
|
+ }
|
|
|
+ },
|
|
|
+ _createItemSymbol: function(t, e, i) {
|
|
|
+ t.add(wg(this.getControllerVisual(e, "symbol"), i[0], i[1], i[2], i[3], this.getControllerVisual(e, "color")))
|
|
|
+ },
|
|
|
+ _onItemClick: function(t) {
|
|
|
+ var e = this.visualMapModel
|
|
|
+ , i = e.option
|
|
|
+ , n = k(i.selected)
|
|
|
+ , o = e.getSelectedMapKey(t);
|
|
|
+ "single" === i.selectedMode ? (n[o] = !0,
|
|
|
+ E(n, function(t, e) {
|
|
|
+ n[e] = e === o
|
|
|
+ })) : n[o] = !n[o],
|
|
|
+ this.api.dispatchAction({
|
|
|
+ type: "selectDataRange",
|
|
|
+ from: this.uid,
|
|
|
+ visualMapId: this.visualMapModel.id,
|
|
|
+ selected: n
|
|
|
+ })
|
|
|
+ }
|
|
|
+ });
|
|
|
+ yf(yL);
|
|
|
+ var KL, $L = "urn:schemas-microsoft-com:vml", JL = "undefined" == typeof window ? null : window, QL = !1, tk = JL && JL.document;
|
|
|
+ function ek(t) {
|
|
|
+ return KL(t)
|
|
|
+ }
|
|
|
+ if (tk && !v.canvasSupported)
|
|
|
+ try {
|
|
|
+ tk.namespaces.zrvml || tk.namespaces.add("zrvml", $L),
|
|
|
+ KL = function(t) {
|
|
|
+ return tk.createElement("<zrvml:" + t + ' class="zrvml">')
|
|
|
+ }
|
|
|
+ } catch (t) {
|
|
|
+ KL = function(t) {
|
|
|
+ return tk.createElement("<" + t + ' xmlns="' + $L + '" class="zrvml">')
|
|
|
+ }
|
|
|
+ }
|
|
|
+ var ik, nk = rr.CMD, ok = Math.round, ak = Math.sqrt, rk = Math.abs, sk = Math.cos, lk = Math.sin, uk = Math.max;
|
|
|
+ if (!v.canvasSupported) {
|
|
|
+ var hk = ","
|
|
|
+ , ck = "progid:DXImageTransform.Microsoft"
|
|
|
+ , dk = 21600
|
|
|
+ , fk = dk / 2
|
|
|
+ , pk = function(t) {
|
|
|
+ t.style.cssText = "position:absolute;left:0;top:0;width:1px;height:1px;",
|
|
|
+ t.coordsize = dk + "," + dk,
|
|
|
+ t.coordorigin = "0,0"
|
|
|
+ }
|
|
|
+ , gk = function(t, e, i) {
|
|
|
+ return "rgb(" + [t, e, i].join(",") + ")"
|
|
|
+ }
|
|
|
+ , mk = function(t, e) {
|
|
|
+ e && t && e.parentNode !== t && t.appendChild(e)
|
|
|
+ }
|
|
|
+ , vk = function(t, e) {
|
|
|
+ e && t && e.parentNode === t && t.removeChild(e)
|
|
|
+ }
|
|
|
+ , yk = function(t, e, i) {
|
|
|
+ return 1e5 * (parseFloat(t) || 0) + 1e3 * (parseFloat(e) || 0) + i
|
|
|
+ }
|
|
|
+ , xk = Yn
|
|
|
+ , _k = function(t, e, i) {
|
|
|
+ var n = Fe(e);
|
|
|
+ i = +i,
|
|
|
+ isNaN(i) && (i = 1),
|
|
|
+ n && (t.color = gk(n[0], n[1], n[2]),
|
|
|
+ t.opacity = i * n[3])
|
|
|
+ }
|
|
|
+ , wk = function(t, e, i, n) {
|
|
|
+ var o = "fill" === e
|
|
|
+ , a = t.getElementsByTagName(e)[0];
|
|
|
+ null != i[e] && "none" !== i[e] && (o || !o && i.lineWidth) ? (t[o ? "filled" : "stroked"] = "true",
|
|
|
+ i[e]instanceof cs && vk(t, a),
|
|
|
+ a = a || ek(e),
|
|
|
+ o ? function(t, e, i) {
|
|
|
+ var n, o, a = e.fill;
|
|
|
+ if (null != a)
|
|
|
+ if (a instanceof cs) {
|
|
|
+ var r, s = 0, l = [0, 0], u = 0, h = 1, c = i.getBoundingRect(), d = c.width, f = c.height;
|
|
|
+ if ("linear" === a.type) {
|
|
|
+ r = "gradient";
|
|
|
+ var p = i.transform
|
|
|
+ , g = [a.x * d, a.y * f]
|
|
|
+ , m = [a.x2 * d, a.y2 * f];
|
|
|
+ p && (bt(g, g, p),
|
|
|
+ bt(m, m, p));
|
|
|
+ var v = m[0] - g[0]
|
|
|
+ , y = m[1] - g[1];
|
|
|
+ (s = 180 * Math.atan2(v, y) / Math.PI) < 0 && (s += 360),
|
|
|
+ s < 1e-6 && (s = 0)
|
|
|
+ } else {
|
|
|
+ r = "gradientradial";
|
|
|
+ g = [a.x * d, a.y * f],
|
|
|
+ p = i.transform;
|
|
|
+ var x = i.scale
|
|
|
+ , _ = d
|
|
|
+ , w = f;
|
|
|
+ l = [(g[0] - c.x) / _, (g[1] - c.y) / w],
|
|
|
+ p && bt(g, g, p),
|
|
|
+ _ /= x[0] * dk,
|
|
|
+ w /= x[1] * dk;
|
|
|
+ var b = uk(_, w);
|
|
|
+ u = 0 / b,
|
|
|
+ h = 2 * a.r / b - u
|
|
|
+ }
|
|
|
+ var S = a.colorStops.slice();
|
|
|
+ S.sort(function(t, e) {
|
|
|
+ return t.offset - e.offset
|
|
|
+ });
|
|
|
+ for (var M = S.length, I = [], T = [], A = 0; A < M; A++) {
|
|
|
+ var D = S[A]
|
|
|
+ , C = (n = D.color,
|
|
|
+ void 0,
|
|
|
+ o = Fe(n),
|
|
|
+ [gk(o[0], o[1], o[2]), o[3]]);
|
|
|
+ T.push(D.offset * h + u + " " + C[0]),
|
|
|
+ 0 !== A && A !== M - 1 || I.push(C)
|
|
|
+ }
|
|
|
+ if (2 <= M) {
|
|
|
+ var L = I[0][0]
|
|
|
+ , k = I[1][0]
|
|
|
+ , P = I[0][1] * e.opacity
|
|
|
+ , N = I[1][1] * e.opacity;
|
|
|
+ t.type = r,
|
|
|
+ t.method = "none",
|
|
|
+ t.focus = "100%",
|
|
|
+ t.angle = s,
|
|
|
+ t.color = L,
|
|
|
+ t.color2 = k,
|
|
|
+ t.colors = T.join(","),
|
|
|
+ t.opacity = N,
|
|
|
+ t.opacity2 = P
|
|
|
+ }
|
|
|
+ "radial" === r && (t.focusposition = l.join(","))
|
|
|
+ } else
|
|
|
+ _k(t, a, e.opacity)
|
|
|
+ }(a, i, n) : function(t, e) {
|
|
|
+ e.lineDash && (t.dashstyle = e.lineDash.join(" ")),
|
|
|
+ null == e.stroke || e.stroke instanceof cs || _k(t, e.stroke, e.opacity)
|
|
|
+ }(a, i),
|
|
|
+ mk(t, a)) : (t[o ? "filled" : "stroked"] = "false",
|
|
|
+ vk(t, a))
|
|
|
+ }
|
|
|
+ , bk = [[], [], []];
|
|
|
+ Ar.prototype.brushVML = function(t) {
|
|
|
+ var e = this.style
|
|
|
+ , i = this._vmlEl;
|
|
|
+ i || (i = ek("shape"),
|
|
|
+ pk(i),
|
|
|
+ this._vmlEl = i),
|
|
|
+ wk(i, "fill", e, this),
|
|
|
+ wk(i, "stroke", e, this);
|
|
|
+ var n = this.transform
|
|
|
+ , o = null != n
|
|
|
+ , a = i.getElementsByTagName("stroke")[0];
|
|
|
+ if (a) {
|
|
|
+ var r = e.lineWidth;
|
|
|
+ if (o && !e.strokeNoScale) {
|
|
|
+ var s = n[0] * n[3] - n[1] * n[2];
|
|
|
+ r *= ak(rk(s))
|
|
|
+ }
|
|
|
+ a.weight = r + "px"
|
|
|
+ }
|
|
|
+ var l = this.path || (this.path = new rr);
|
|
|
+ this.__dirtyPath && (l.beginPath(),
|
|
|
+ l.subPixelOptimize = !1,
|
|
|
+ this.buildPath(l, this.shape),
|
|
|
+ l.toStatic(),
|
|
|
+ this.__dirtyPath = !1),
|
|
|
+ i.path = function(t, e) {
|
|
|
+ var i, n, o, a, r, s, l = nk.M, u = nk.C, h = nk.L, c = nk.A, d = nk.Q, f = [], p = t.data, g = t.len();
|
|
|
+ for (a = 0; a < g; ) {
|
|
|
+ switch (n = "",
|
|
|
+ i = 0,
|
|
|
+ o = p[a++]) {
|
|
|
+ case l:
|
|
|
+ n = " m ",
|
|
|
+ i = 1,
|
|
|
+ r = p[a++],
|
|
|
+ s = p[a++],
|
|
|
+ bk[0][0] = r,
|
|
|
+ bk[0][1] = s;
|
|
|
+ break;
|
|
|
+ case h:
|
|
|
+ n = " l ",
|
|
|
+ i = 1,
|
|
|
+ r = p[a++],
|
|
|
+ s = p[a++],
|
|
|
+ bk[0][0] = r,
|
|
|
+ bk[0][1] = s;
|
|
|
+ break;
|
|
|
+ case d:
|
|
|
+ case u:
|
|
|
+ n = " c ",
|
|
|
+ i = 3;
|
|
|
+ var m, v, y = p[a++], x = p[a++], _ = p[a++], w = p[a++];
|
|
|
+ o === d ? (_ = ((m = _) + 2 * y) / 3,
|
|
|
+ w = ((v = w) + 2 * x) / 3,
|
|
|
+ y = (r + 2 * y) / 3,
|
|
|
+ x = (s + 2 * x) / 3) : (m = p[a++],
|
|
|
+ v = p[a++]),
|
|
|
+ bk[0][0] = y,
|
|
|
+ bk[0][1] = x,
|
|
|
+ bk[1][0] = _,
|
|
|
+ bk[1][1] = w,
|
|
|
+ r = bk[2][0] = m,
|
|
|
+ s = bk[2][1] = v;
|
|
|
+ break;
|
|
|
+ case c:
|
|
|
+ var b = 0
|
|
|
+ , S = 0
|
|
|
+ , M = 1
|
|
|
+ , I = 1
|
|
|
+ , T = 0;
|
|
|
+ e && (b = e[4],
|
|
|
+ S = e[5],
|
|
|
+ M = ak(e[0] * e[0] + e[1] * e[1]),
|
|
|
+ I = ak(e[2] * e[2] + e[3] * e[3]),
|
|
|
+ T = Math.atan2(-e[1] / I, e[0] / M));
|
|
|
+ var A = p[a++]
|
|
|
+ , D = p[a++]
|
|
|
+ , C = p[a++]
|
|
|
+ , L = p[a++]
|
|
|
+ , k = p[a++] + T
|
|
|
+ , P = p[a++] + k + T;
|
|
|
+ a++;
|
|
|
+ var N = p[a++]
|
|
|
+ , O = A + sk(k) * C
|
|
|
+ , E = D + lk(k) * L
|
|
|
+ , R = (y = A + sk(P) * C,
|
|
|
+ x = D + lk(P) * L,
|
|
|
+ N ? " wa " : " at ");
|
|
|
+ Math.abs(O - y) < 1e-4 && (.01 < Math.abs(P - k) ? N && (O += .0125) : Math.abs(E - D) < 1e-4 ? N && O < A || !N && A < O ? x -= .0125 : x += .0125 : N && E < D || !N && D < E ? y += .0125 : y -= .0125),
|
|
|
+ f.push(R, ok(((A - C) * M + b) * dk - fk), hk, ok(((D - L) * I + S) * dk - fk), hk, ok(((A + C) * M + b) * dk - fk), hk, ok(((D + L) * I + S) * dk - fk), hk, ok((O * M + b) * dk - fk), hk, ok((E * I + S) * dk - fk), hk, ok((y * M + b) * dk - fk), hk, ok((x * I + S) * dk - fk)),
|
|
|
+ r = y,
|
|
|
+ s = x;
|
|
|
+ break;
|
|
|
+ case nk.R:
|
|
|
+ var z = bk[0]
|
|
|
+ , B = bk[1];
|
|
|
+ z[0] = p[a++],
|
|
|
+ z[1] = p[a++],
|
|
|
+ B[0] = z[0] + p[a++],
|
|
|
+ B[1] = z[1] + p[a++],
|
|
|
+ e && (bt(z, z, e),
|
|
|
+ bt(B, B, e)),
|
|
|
+ z[0] = ok(z[0] * dk - fk),
|
|
|
+ B[0] = ok(B[0] * dk - fk),
|
|
|
+ z[1] = ok(z[1] * dk - fk),
|
|
|
+ B[1] = ok(B[1] * dk - fk),
|
|
|
+ f.push(" m ", z[0], hk, z[1], " l ", B[0], hk, z[1], " l ", B[0], hk, B[1], " l ", z[0], hk, B[1]);
|
|
|
+ break;
|
|
|
+ case nk.Z:
|
|
|
+ f.push(" x ")
|
|
|
+ }
|
|
|
+ if (0 < i) {
|
|
|
+ f.push(n);
|
|
|
+ for (var V = 0; V < i; V++) {
|
|
|
+ var G = bk[V];
|
|
|
+ e && bt(G, G, e),
|
|
|
+ f.push(ok(G[0] * dk - fk), hk, ok(G[1] * dk - fk), V < i - 1 ? hk : "")
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return f.join("")
|
|
|
+ }(l, this.transform),
|
|
|
+ i.style.zIndex = yk(this.zlevel, this.z, this.z2),
|
|
|
+ mk(t, i),
|
|
|
+ null != e.text ? this.drawRectText(t, this.getBoundingRect()) : this.removeRectText(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ar.prototype.onRemove = function(t) {
|
|
|
+ vk(t, this._vmlEl),
|
|
|
+ this.removeRectText(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ar.prototype.onAdd = function(t) {
|
|
|
+ mk(t, this._vmlEl),
|
|
|
+ this.appendRectText(t)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ Qn.prototype.brushVML = function(t) {
|
|
|
+ var e, i, n = this.style, o = n.image;
|
|
|
+ if (function(t) {
|
|
|
+ return "object" == typeof t && t.tagName && "IMG" === t.tagName.toUpperCase()
|
|
|
+ }(o)) {
|
|
|
+ var a = o.src;
|
|
|
+ if (a === this._imageSrc)
|
|
|
+ e = this._imageWidth,
|
|
|
+ i = this._imageHeight;
|
|
|
+ else {
|
|
|
+ var r = o.runtimeStyle
|
|
|
+ , s = r.width
|
|
|
+ , l = r.height;
|
|
|
+ r.width = "auto",
|
|
|
+ r.height = "auto",
|
|
|
+ e = o.width,
|
|
|
+ i = o.height,
|
|
|
+ r.width = s,
|
|
|
+ r.height = l,
|
|
|
+ this._imageSrc = a,
|
|
|
+ this._imageWidth = e,
|
|
|
+ this._imageHeight = i
|
|
|
+ }
|
|
|
+ o = a
|
|
|
+ } else
|
|
|
+ o === this._imageSrc && (e = this._imageWidth,
|
|
|
+ i = this._imageHeight);
|
|
|
+ if (o) {
|
|
|
+ var u = n.x || 0
|
|
|
+ , h = n.y || 0
|
|
|
+ , c = n.width
|
|
|
+ , d = n.height
|
|
|
+ , f = n.sWidth
|
|
|
+ , p = n.sHeight
|
|
|
+ , g = n.sx || 0
|
|
|
+ , m = n.sy || 0
|
|
|
+ , v = f && p
|
|
|
+ , y = this._vmlEl;
|
|
|
+ y || (y = tk.createElement("div"),
|
|
|
+ pk(y),
|
|
|
+ this._vmlEl = y);
|
|
|
+ var x, _ = y.style, w = !1, b = 1, S = 1;
|
|
|
+ if (this.transform && (x = this.transform,
|
|
|
+ b = ak(x[0] * x[0] + x[1] * x[1]),
|
|
|
+ S = ak(x[2] * x[2] + x[3] * x[3]),
|
|
|
+ w = x[1] || x[2]),
|
|
|
+ w) {
|
|
|
+ var M = [u, h]
|
|
|
+ , I = [u + c, h]
|
|
|
+ , T = [u, h + d]
|
|
|
+ , A = [u + c, h + d];
|
|
|
+ bt(M, M, x),
|
|
|
+ bt(I, I, x),
|
|
|
+ bt(T, T, x),
|
|
|
+ bt(A, A, x);
|
|
|
+ var D = uk(M[0], I[0], T[0], A[0])
|
|
|
+ , C = uk(M[1], I[1], T[1], A[1])
|
|
|
+ , L = [];
|
|
|
+ L.push("M11=", x[0] / b, hk, "M12=", x[2] / S, hk, "M21=", x[1] / b, hk, "M22=", x[3] / S, hk, "Dx=", ok(u * b + x[4]), hk, "Dy=", ok(h * S + x[5])),
|
|
|
+ _.padding = "0 " + ok(D) + "px " + ok(C) + "px 0",
|
|
|
+ _.filter = ck + ".Matrix(" + L.join("") + ", SizingMethod=clip)"
|
|
|
+ } else
|
|
|
+ x && (u = u * b + x[4],
|
|
|
+ h = h * S + x[5]),
|
|
|
+ _.filter = "",
|
|
|
+ _.left = ok(u) + "px",
|
|
|
+ _.top = ok(h) + "px";
|
|
|
+ var k = this._imageEl
|
|
|
+ , P = this._cropEl;
|
|
|
+ k || (k = tk.createElement("div"),
|
|
|
+ this._imageEl = k);
|
|
|
+ var N = k.style;
|
|
|
+ if (v) {
|
|
|
+ if (e && i)
|
|
|
+ N.width = ok(b * e * c / f) + "px",
|
|
|
+ N.height = ok(S * i * d / p) + "px";
|
|
|
+ else {
|
|
|
+ var O = new Image
|
|
|
+ , E = this;
|
|
|
+ O.onload = function() {
|
|
|
+ O.onload = null,
|
|
|
+ e = O.width,
|
|
|
+ i = O.height,
|
|
|
+ N.width = ok(b * e * c / f) + "px",
|
|
|
+ N.height = ok(S * i * d / p) + "px",
|
|
|
+ E._imageWidth = e,
|
|
|
+ E._imageHeight = i,
|
|
|
+ E._imageSrc = o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ O.src = o
|
|
|
+ }
|
|
|
+ P || ((P = tk.createElement("div")).style.overflow = "hidden",
|
|
|
+ this._cropEl = P);
|
|
|
+ var R = P.style;
|
|
|
+ R.width = ok((c + g * c / f) * b),
|
|
|
+ R.height = ok((d + m * d / p) * S),
|
|
|
+ R.filter = ck + ".Matrix(Dx=" + -g * c / f * b + ",Dy=" + -m * d / p * S + ")",
|
|
|
+ P.parentNode || y.appendChild(P),
|
|
|
+ k.parentNode !== P && P.appendChild(k)
|
|
|
+ } else
|
|
|
+ N.width = ok(b * c) + "px",
|
|
|
+ N.height = ok(S * d) + "px",
|
|
|
+ y.appendChild(k),
|
|
|
+ P && P.parentNode && (y.removeChild(P),
|
|
|
+ this._cropEl = null);
|
|
|
+ var z = ""
|
|
|
+ , B = n.opacity;
|
|
|
+ B < 1 && (z += ".Alpha(opacity=" + ok(100 * B) + ") "),
|
|
|
+ z += ck + ".AlphaImageLoader(src=" + o + ", SizingMethod=scale)",
|
|
|
+ N.filter = z,
|
|
|
+ y.style.zIndex = yk(this.zlevel, this.z, this.z2),
|
|
|
+ mk(t, y),
|
|
|
+ null != n.text && this.drawRectText(t, this.getBoundingRect())
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Qn.prototype.onRemove = function(t) {
|
|
|
+ vk(t, this._vmlEl),
|
|
|
+ this._vmlEl = null,
|
|
|
+ this._cropEl = null,
|
|
|
+ this._imageEl = null,
|
|
|
+ this.removeRectText(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Qn.prototype.onAdd = function(t) {
|
|
|
+ mk(t, this._vmlEl),
|
|
|
+ this.appendRectText(t)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var Sk, Mk = "normal", Ik = {}, Tk = 0, Ak = document.createElement("div");
|
|
|
+ ik = function(t, e) {
|
|
|
+ var i = tk;
|
|
|
+ Sk || ((Sk = i.createElement("div")).style.cssText = "position:absolute;top:-20000px;left:0;padding:0;margin:0;border:none;white-space:pre;",
|
|
|
+ tk.body.appendChild(Sk));
|
|
|
+ try {
|
|
|
+ Sk.style.font = e
|
|
|
+ } catch (t) {}
|
|
|
+ return Sk.innerHTML = "",
|
|
|
+ Sk.appendChild(i.createTextNode(t)),
|
|
|
+ {
|
|
|
+ width: Sk.offsetWidth
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fn["measureText"] = ik;
|
|
|
+ for (var Dk = new Di, Ck = function(t, e, i, n) {
|
|
|
+ var o = this.style;
|
|
|
+ this.__dirty && En(o);
|
|
|
+ var a = o.text;
|
|
|
+ if (null != a && (a += ""),
|
|
|
+ a) {
|
|
|
+ if (o.rich) {
|
|
|
+ var r = In(a, o);
|
|
|
+ a = [];
|
|
|
+ for (var s = 0; s < r.lines.length; s++) {
|
|
|
+ for (var l = r.lines[s].tokens, u = [], h = 0; h < l.length; h++)
|
|
|
+ u.push(l[h].text);
|
|
|
+ a.push(u.join(""))
|
|
|
+ }
|
|
|
+ a = a.join("\n")
|
|
|
+ }
|
|
|
+ var c, d, f = o.textAlign, p = o.textVerticalAlign, g = function(t) {
|
|
|
+ var e = Ik[t];
|
|
|
+ if (!e) {
|
|
|
+ 100 < Tk && (Tk = 0,
|
|
|
+ Ik = {});
|
|
|
+ var i, n = Ak.style;
|
|
|
+ try {
|
|
|
+ n.font = t,
|
|
|
+ i = n.fontFamily.split(",")[0]
|
|
|
+ } catch (t) {}
|
|
|
+ e = {
|
|
|
+ style: n.fontStyle || Mk,
|
|
|
+ variant: n.fontVariant || Mk,
|
|
|
+ weight: n.fontWeight || Mk,
|
|
|
+ size: 0 | parseFloat(n.fontSize || 12),
|
|
|
+ family: i || "Microsoft YaHei"
|
|
|
+ },
|
|
|
+ Ik[t] = e,
|
|
|
+ Tk++
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }(o.font), m = g.style + " " + g.variant + " " + g.weight + " " + g.size + 'px "' + g.family + '"';
|
|
|
+ i = i || gn(a, m, f, p, o.textPadding, o.textLineHeight);
|
|
|
+ var v = this.transform;
|
|
|
+ if (v && !n && (Dk.copy(e),
|
|
|
+ Dk.applyTransform(v),
|
|
|
+ e = Dk),
|
|
|
+ n)
|
|
|
+ c = e.x,
|
|
|
+ d = e.y;
|
|
|
+ else {
|
|
|
+ var y = o.textPosition;
|
|
|
+ if (y instanceof Array)
|
|
|
+ c = e.x + xk(y[0], e.width),
|
|
|
+ d = e.y + xk(y[1], e.height),
|
|
|
+ f = f || "left";
|
|
|
+ else {
|
|
|
+ var x = this.calculateTextPosition ? this.calculateTextPosition({}, o, e) : yn({}, o, e);
|
|
|
+ c = x.x,
|
|
|
+ d = x.y,
|
|
|
+ f = f || x.textAlign,
|
|
|
+ p = p || x.textVerticalAlign
|
|
|
+ }
|
|
|
+ }
|
|
|
+ c = mn(c, i.width, f),
|
|
|
+ d = vn(d, i.height, p),
|
|
|
+ d += i.height / 2;
|
|
|
+ var _, w, b, S = ek, M = this._textVmlEl;
|
|
|
+ M ? w = (_ = (b = M.firstChild).nextSibling).nextSibling : (M = S("line"),
|
|
|
+ _ = S("path"),
|
|
|
+ w = S("textpath"),
|
|
|
+ b = S("skew"),
|
|
|
+ w.style["v-text-align"] = "left",
|
|
|
+ pk(M),
|
|
|
+ _.textpathok = !0,
|
|
|
+ w.on = !0,
|
|
|
+ M.from = "0 0",
|
|
|
+ M.to = "1000 0.05",
|
|
|
+ mk(M, b),
|
|
|
+ mk(M, _),
|
|
|
+ mk(M, w),
|
|
|
+ this._textVmlEl = M);
|
|
|
+ var I = [c, d]
|
|
|
+ , T = M.style;
|
|
|
+ v && n ? (bt(I, I, v),
|
|
|
+ b.on = !0,
|
|
|
+ b.matrix = v[0].toFixed(3) + hk + v[2].toFixed(3) + hk + v[1].toFixed(3) + hk + v[3].toFixed(3) + ",0,0",
|
|
|
+ b.offset = (ok(I[0]) || 0) + "," + (ok(I[1]) || 0),
|
|
|
+ b.origin = "0 0",
|
|
|
+ T.left = "0px",
|
|
|
+ T.top = "0px") : (b.on = !1,
|
|
|
+ T.left = ok(c) + "px",
|
|
|
+ T.top = ok(d) + "px"),
|
|
|
+ w.string = function(t) {
|
|
|
+ return String(t).replace(/&/g, "&").replace(/"/g, """)
|
|
|
+ }(a);
|
|
|
+ try {
|
|
|
+ w.style.font = m
|
|
|
+ } catch (t) {}
|
|
|
+ wk(M, "fill", {
|
|
|
+ fill: o.textFill,
|
|
|
+ opacity: o.opacity
|
|
|
+ }, this),
|
|
|
+ wk(M, "stroke", {
|
|
|
+ stroke: o.textStroke,
|
|
|
+ opacity: o.opacity,
|
|
|
+ lineDash: o.lineDash || null
|
|
|
+ }, this),
|
|
|
+ M.style.zIndex = yk(this.zlevel, this.z, this.z2),
|
|
|
+ mk(t, M)
|
|
|
+ }
|
|
|
+ }, Lk = function(t) {
|
|
|
+ vk(t, this._textVmlEl),
|
|
|
+ this._textVmlEl = null
|
|
|
+ }, kk = function(t) {
|
|
|
+ mk(t, this._textVmlEl)
|
|
|
+ }, Pk = [Kn, Jn, Qn, Ar, Ur], Nk = 0; Nk < Pk.length; Nk++) {
|
|
|
+ var Ok = Pk[Nk].prototype;
|
|
|
+ Ok.drawRectText = Ck,
|
|
|
+ Ok.removeRectText = Lk,
|
|
|
+ Ok.appendRectText = kk
|
|
|
+ }
|
|
|
+ Ur.prototype.brushVML = function(t) {
|
|
|
+ var e = this.style;
|
|
|
+ null != e.text ? this.drawRectText(t, {
|
|
|
+ x: e.x || 0,
|
|
|
+ y: e.y || 0,
|
|
|
+ width: 0,
|
|
|
+ height: 0
|
|
|
+ }, this.getBoundingRect(), !0) : this.removeRectText(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ur.prototype.onRemove = function(t) {
|
|
|
+ this.removeRectText(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ Ur.prototype.onAdd = function(t) {
|
|
|
+ this.appendRectText(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function Ek(t) {
|
|
|
+ return parseInt(t, 10)
|
|
|
+ }
|
|
|
+ function Rk(t, e) {
|
|
|
+ !function() {
|
|
|
+ if (!QL && tk) {
|
|
|
+ QL = !0;
|
|
|
+ var t = tk.styleSheets;
|
|
|
+ t.length < 31 ? tk.createStyleSheet().addRule(".zrvml", "behavior:url(#default#VML)") : t[0].addRule(".zrvml", "behavior:url(#default#VML)")
|
|
|
+ }
|
|
|
+ }(),
|
|
|
+ this.root = t,
|
|
|
+ this.storage = e;
|
|
|
+ var i = document.createElement("div")
|
|
|
+ , n = document.createElement("div");
|
|
|
+ i.style.cssText = "display:inline-block;overflow:hidden;position:relative;width:300px;height:150px;",
|
|
|
+ n.style.cssText = "position:absolute;left:0;top:0;",
|
|
|
+ t.appendChild(i),
|
|
|
+ this._vmlRoot = n,
|
|
|
+ this._vmlViewport = i,
|
|
|
+ this.resize();
|
|
|
+ var o = e.delFromStorage
|
|
|
+ , a = e.addToStorage;
|
|
|
+ e.delFromStorage = function(t) {
|
|
|
+ o.call(e, t),
|
|
|
+ t && t.onRemove && t.onRemove(n)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ e.addToStorage = function(t) {
|
|
|
+ t.onAdd && t.onAdd(n),
|
|
|
+ a.call(e, t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this._firstPaint = !0
|
|
|
+ }
|
|
|
+ Rk.prototype = {
|
|
|
+ constructor: Rk,
|
|
|
+ getType: function() {
|
|
|
+ return "vml"
|
|
|
+ },
|
|
|
+ getViewportRoot: function() {
|
|
|
+ return this._vmlViewport
|
|
|
+ },
|
|
|
+ getViewportRootOffset: function() {
|
|
|
+ var t = this.getViewportRoot();
|
|
|
+ if (t)
|
|
|
+ return {
|
|
|
+ offsetLeft: t.offsetLeft || 0,
|
|
|
+ offsetTop: t.offsetTop || 0
|
|
|
+ }
|
|
|
+ },
|
|
|
+ refresh: function() {
|
|
|
+ var t = this.storage.getDisplayList(!0, !0);
|
|
|
+ this._paintList(t)
|
|
|
+ },
|
|
|
+ _paintList: function(t) {
|
|
|
+ for (var e = this._vmlRoot, i = 0; i < t.length; i++) {
|
|
|
+ var n = t[i];
|
|
|
+ n.invisible || n.ignore ? (n.__alreadyNotVisible || n.onRemove(e),
|
|
|
+ n.__alreadyNotVisible = !0) : (n.__alreadyNotVisible && n.onAdd(e),
|
|
|
+ n.__alreadyNotVisible = !1,
|
|
|
+ n.__dirty && (n.beforeBrush && n.beforeBrush(),
|
|
|
+ (n.brushVML || n.brush).call(n, e),
|
|
|
+ n.afterBrush && n.afterBrush())),
|
|
|
+ n.__dirty = !1
|
|
|
+ }
|
|
|
+ this._firstPaint && (this._vmlViewport.appendChild(e),
|
|
|
+ this._firstPaint = !1)
|
|
|
+ },
|
|
|
+ resize: function(t, e) {
|
|
|
+ t = null == t ? this._getWidth() : t,
|
|
|
+ e = null == e ? this._getHeight() : e;
|
|
|
+ if (this._width !== t || this._height !== e) {
|
|
|
+ this._width = t,
|
|
|
+ this._height = e;
|
|
|
+ var i = this._vmlViewport.style;
|
|
|
+ i.width = t + "px",
|
|
|
+ i.height = e + "px"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this.root.innerHTML = "",
|
|
|
+ this._vmlRoot = this._vmlViewport = this.storage = null
|
|
|
+ },
|
|
|
+ getWidth: function() {
|
|
|
+ return this._width
|
|
|
+ },
|
|
|
+ getHeight: function() {
|
|
|
+ return this._height
|
|
|
+ },
|
|
|
+ clear: function() {
|
|
|
+ this._vmlViewport && this.root.removeChild(this._vmlViewport)
|
|
|
+ },
|
|
|
+ _getWidth: function() {
|
|
|
+ var t = this.root
|
|
|
+ , e = t.currentStyle;
|
|
|
+ return (t.clientWidth || Ek(e.width)) - Ek(e.paddingLeft) - Ek(e.paddingRight) | 0
|
|
|
+ },
|
|
|
+ _getHeight: function() {
|
|
|
+ var t = this.root
|
|
|
+ , e = t.currentStyle;
|
|
|
+ return (t.clientHeight || Ek(e.height)) - Ek(e.paddingTop) - Ek(e.paddingBottom) | 0
|
|
|
+ }
|
|
|
+ },
|
|
|
+ E(["getLayer", "insertLayer", "eachLayer", "eachBuiltinLayer", "eachOtherLayer", "getLayers", "modLayer", "delLayer", "clearLayer", "toDataURL", "pathToImage"], function(t) {
|
|
|
+ Rk.prototype[t] = function(t) {
|
|
|
+ return function() {
|
|
|
+ vi('In IE8.0 VML mode painter not support method "' + t + '"')
|
|
|
+ }
|
|
|
+ }(t)
|
|
|
+ }),
|
|
|
+ Po("vml", Rk);
|
|
|
+ function zk(t) {
|
|
|
+ return document.createElementNS("http://www.w3.org/2000/svg", t)
|
|
|
+ }
|
|
|
+ var Bk = rr.CMD
|
|
|
+ , Vk = Array.prototype.join
|
|
|
+ , Gk = "none"
|
|
|
+ , Fk = Math.round
|
|
|
+ , Wk = Math.sin
|
|
|
+ , Hk = Math.cos
|
|
|
+ , Zk = Math.PI
|
|
|
+ , Uk = 2 * Math.PI
|
|
|
+ , Xk = 180 / Zk
|
|
|
+ , Yk = 1e-4;
|
|
|
+ function jk(t) {
|
|
|
+ return Fk(1e4 * t) / 1e4
|
|
|
+ }
|
|
|
+ function qk(t) {
|
|
|
+ return t < Yk && -Yk < t
|
|
|
+ }
|
|
|
+ function Kk(t, e) {
|
|
|
+ e && $k(t, "transform", "matrix(" + Vk.call(e, ",") + ")")
|
|
|
+ }
|
|
|
+ function $k(t, e, i) {
|
|
|
+ i && ("linear" === i.type || "radial" === i.type) || t.setAttribute(e, i)
|
|
|
+ }
|
|
|
+ function Jk(t, e, i, n) {
|
|
|
+ if (function(t, e) {
|
|
|
+ var i = e ? t.textFill : t.fill;
|
|
|
+ return null != i && i !== Gk
|
|
|
+ }(e, i)) {
|
|
|
+ var o = i ? e.textFill : e.fill;
|
|
|
+ $k(t, "fill", o = "transparent" === o ? Gk : o),
|
|
|
+ $k(t, "fill-opacity", null != e.fillOpacity ? e.fillOpacity * e.opacity : e.opacity)
|
|
|
+ } else
|
|
|
+ $k(t, "fill", Gk);
|
|
|
+ if (function(t, e) {
|
|
|
+ var i = e ? t.textStroke : t.stroke;
|
|
|
+ return null != i && i !== Gk
|
|
|
+ }(e, i)) {
|
|
|
+ var a = i ? e.textStroke : e.stroke;
|
|
|
+ $k(t, "stroke", a = "transparent" === a ? Gk : a),
|
|
|
+ $k(t, "stroke-width", (i ? e.textStrokeWidth : e.lineWidth) / (!i && e.strokeNoScale ? n.getLineScale() : 1)),
|
|
|
+ $k(t, "paint-order", i ? "stroke" : "fill"),
|
|
|
+ $k(t, "stroke-opacity", null != e.strokeOpacity ? e.strokeOpacity : e.opacity),
|
|
|
+ e.lineDash ? ($k(t, "stroke-dasharray", e.lineDash.join(",")),
|
|
|
+ $k(t, "stroke-dashoffset", Fk(e.lineDashOffset || 0))) : $k(t, "stroke-dasharray", ""),
|
|
|
+ e.lineCap && $k(t, "stroke-linecap", e.lineCap),
|
|
|
+ e.lineJoin && $k(t, "stroke-linejoin", e.lineJoin),
|
|
|
+ e.miterLimit && $k(t, "stroke-miterlimit", e.miterLimit)
|
|
|
+ } else
|
|
|
+ $k(t, "stroke", Gk)
|
|
|
+ }
|
|
|
+ var Qk = {};
|
|
|
+ Qk.brush = function(t) {
|
|
|
+ var e = t.style
|
|
|
+ , i = t.__svgEl;
|
|
|
+ i || (i = zk("path"),
|
|
|
+ t.__svgEl = i),
|
|
|
+ t.path || t.createPathProxy();
|
|
|
+ var n = t.path;
|
|
|
+ if (t.__dirtyPath) {
|
|
|
+ n.beginPath(),
|
|
|
+ n.subPixelOptimize = !1,
|
|
|
+ t.buildPath(n, t.shape),
|
|
|
+ t.__dirtyPath = !1;
|
|
|
+ var o = function(t) {
|
|
|
+ for (var e = [], i = t.data, n = t.len(), o = 0; o < n; ) {
|
|
|
+ var a = ""
|
|
|
+ , r = 0;
|
|
|
+ switch (i[o++]) {
|
|
|
+ case Bk.M:
|
|
|
+ a = "M",
|
|
|
+ r = 2;
|
|
|
+ break;
|
|
|
+ case Bk.L:
|
|
|
+ a = "L",
|
|
|
+ r = 2;
|
|
|
+ break;
|
|
|
+ case Bk.Q:
|
|
|
+ a = "Q",
|
|
|
+ r = 4;
|
|
|
+ break;
|
|
|
+ case Bk.C:
|
|
|
+ a = "C",
|
|
|
+ r = 6;
|
|
|
+ break;
|
|
|
+ case Bk.A:
|
|
|
+ var s = i[o++]
|
|
|
+ , l = i[o++]
|
|
|
+ , u = i[o++]
|
|
|
+ , h = i[o++]
|
|
|
+ , c = i[o++]
|
|
|
+ , d = i[o++]
|
|
|
+ , f = i[o++]
|
|
|
+ , p = i[o++]
|
|
|
+ , g = Math.abs(d)
|
|
|
+ , m = qk(g - Uk) || (p ? Uk <= d : Uk <= -d)
|
|
|
+ , v = 0 < d ? d % Uk : d % Uk + Uk
|
|
|
+ , y = !1;
|
|
|
+ y = !!m || !qk(g) && Zk <= v == !!p;
|
|
|
+ var x = jk(s + u * Hk(c))
|
|
|
+ , _ = jk(l + h * Wk(c));
|
|
|
+ m && (d = p ? Uk - 1e-4 : 1e-4 - Uk,
|
|
|
+ y = !0,
|
|
|
+ 9 === o && e.push("M", x, _));
|
|
|
+ var w = jk(s + u * Hk(c + d))
|
|
|
+ , b = jk(l + h * Wk(c + d));
|
|
|
+ e.push("A", jk(u), jk(h), Fk(f * Xk), +y, +p, w, b);
|
|
|
+ break;
|
|
|
+ case Bk.Z:
|
|
|
+ a = "Z";
|
|
|
+ break;
|
|
|
+ case Bk.R:
|
|
|
+ w = jk(i[o++]),
|
|
|
+ b = jk(i[o++]);
|
|
|
+ var S = jk(i[o++])
|
|
|
+ , M = jk(i[o++]);
|
|
|
+ e.push("M", w, b, "L", w + S, b, "L", w + S, b + M, "L", w, b + M, "L", w, b)
|
|
|
+ }
|
|
|
+ a && e.push(a);
|
|
|
+ for (var I = 0; I < r; I++)
|
|
|
+ e.push(jk(i[o++]))
|
|
|
+ }
|
|
|
+ return e.join(" ")
|
|
|
+ }(n);
|
|
|
+ o.indexOf("NaN") < 0 && $k(i, "d", o)
|
|
|
+ }
|
|
|
+ Jk(i, e, !1, t),
|
|
|
+ Kk(i, t.transform),
|
|
|
+ null != e.text ? rP(t, t.getBoundingRect()) : lP(t)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ var tP = {
|
|
|
+ brush: function(t) {
|
|
|
+ var e = t.style
|
|
|
+ , i = e.image;
|
|
|
+ i instanceof HTMLImageElement && (i = i.src);
|
|
|
+ if (i) {
|
|
|
+ var n = e.x || 0
|
|
|
+ , o = e.y || 0
|
|
|
+ , a = e.width
|
|
|
+ , r = e.height
|
|
|
+ , s = t.__svgEl;
|
|
|
+ s || (s = zk("image"),
|
|
|
+ t.__svgEl = s),
|
|
|
+ i !== t.__imageSrc && (function(t, e, i) {
|
|
|
+ t.setAttributeNS("http://www.w3.org/1999/xlink", e, i)
|
|
|
+ }(s, "href", i),
|
|
|
+ t.__imageSrc = i),
|
|
|
+ $k(s, "width", a),
|
|
|
+ $k(s, "height", r),
|
|
|
+ $k(s, "x", n),
|
|
|
+ $k(s, "y", o),
|
|
|
+ Kk(s, t.transform),
|
|
|
+ null != e.text ? rP(t, t.getBoundingRect()) : lP(t)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ , eP = {}
|
|
|
+ , iP = new Di
|
|
|
+ , nP = {}
|
|
|
+ , oP = []
|
|
|
+ , aP = {
|
|
|
+ left: "start",
|
|
|
+ right: "end",
|
|
|
+ center: "middle",
|
|
|
+ middle: "middle"
|
|
|
+ }
|
|
|
+ , rP = function(t, e) {
|
|
|
+ var i = t.style
|
|
|
+ , n = t.transform
|
|
|
+ , o = t instanceof Ur || i.transformText;
|
|
|
+ t.__dirty && En(i);
|
|
|
+ var a = i.text;
|
|
|
+ if (null != a && (a += ""),
|
|
|
+ qn(a, i)) {
|
|
|
+ null == a && (a = ""),
|
|
|
+ !o && n && (iP.copy(e),
|
|
|
+ iP.applyTransform(n),
|
|
|
+ e = iP);
|
|
|
+ var r = t.__textSvgEl;
|
|
|
+ r || (r = zk("text"),
|
|
|
+ t.__textSvgEl = r);
|
|
|
+ var s = r.style
|
|
|
+ , l = i.font || dn
|
|
|
+ , u = r.__computedFont;
|
|
|
+ l !== r.__styleFont && (s.font = r.__styleFont = l,
|
|
|
+ u = r.__computedFont = s.font);
|
|
|
+ var h = i.textPadding
|
|
|
+ , c = i.textLineHeight
|
|
|
+ , d = t.__textCotentBlock;
|
|
|
+ d && !t.__dirtyText || (d = t.__textCotentBlock = Mn(a, u, h, c, i.truncate));
|
|
|
+ var f = d.outerHeight
|
|
|
+ , p = d.lineHeight;
|
|
|
+ Hn(nP, t, i, e);
|
|
|
+ var g = nP.baseX
|
|
|
+ , m = nP.baseY
|
|
|
+ , v = nP.textAlign || "left"
|
|
|
+ , y = nP.textVerticalAlign;
|
|
|
+ !function(t, e, i, n, o, a, r) {
|
|
|
+ re(oP),
|
|
|
+ e && i && se(oP, i);
|
|
|
+ var s = n.textRotation;
|
|
|
+ if (o && s) {
|
|
|
+ var l = n.textOrigin;
|
|
|
+ "center" === l ? (a = o.width / 2 + o.x,
|
|
|
+ r = o.height / 2 + o.y) : l && (a = l[0] + o.x,
|
|
|
+ r = l[1] + o.y),
|
|
|
+ oP[4] -= a,
|
|
|
+ oP[5] -= r,
|
|
|
+ he(oP, oP, s),
|
|
|
+ oP[4] += a,
|
|
|
+ oP[5] += r
|
|
|
+ }
|
|
|
+ Kk(t, oP)
|
|
|
+ }(r, o, n, i, e, g, m);
|
|
|
+ var x = g
|
|
|
+ , _ = vn(m, f, y);
|
|
|
+ h && (x = function(t, e, i) {
|
|
|
+ return "right" === e ? t - i[1] : "center" === e ? t + i[3] / 2 - i[1] / 2 : t + i[3]
|
|
|
+ }(g, v, h),
|
|
|
+ _ += h[0]),
|
|
|
+ _ += p / 2,
|
|
|
+ Jk(r, i, !0, t);
|
|
|
+ var w = d.canCacheByTextString
|
|
|
+ , b = t.__tspanList || (t.__tspanList = [])
|
|
|
+ , S = b.length;
|
|
|
+ if (w && t.__canCacheByTextString && t.__text === a) {
|
|
|
+ if (t.__dirtyText && S)
|
|
|
+ for (var M = 0; M < S; ++M)
|
|
|
+ sP(b[M], v, x, _ + M * p)
|
|
|
+ } else {
|
|
|
+ t.__text = a,
|
|
|
+ t.__canCacheByTextString = w;
|
|
|
+ var I = d.lines
|
|
|
+ , T = I.length;
|
|
|
+ for (M = 0; M < T; M++) {
|
|
|
+ var A = b[M]
|
|
|
+ , D = I[M];
|
|
|
+ A ? A.__zrText !== D && (A.innerHTML = "",
|
|
|
+ A.appendChild(document.createTextNode(D))) : (A = b[M] = zk("tspan"),
|
|
|
+ r.appendChild(A),
|
|
|
+ A.appendChild(document.createTextNode(D))),
|
|
|
+ sP(A, v, x, _ + M * p)
|
|
|
+ }
|
|
|
+ if (T < S) {
|
|
|
+ for (; M < S; M++)
|
|
|
+ r.removeChild(b[M]);
|
|
|
+ b.length = T
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ function sP(t, e, i, n) {
|
|
|
+ $k(t, "dominant-baseline", "middle"),
|
|
|
+ $k(t, "text-anchor", aP[e]),
|
|
|
+ $k(t, "x", i),
|
|
|
+ $k(t, "y", n)
|
|
|
+ }
|
|
|
+ function lP(t) {
|
|
|
+ t && t.__textSvgEl && (t.__textSvgEl.parentNode && t.__textSvgEl.parentNode.removeChild(t.__textSvgEl),
|
|
|
+ t.__textSvgEl = null,
|
|
|
+ t.__tspanList = [],
|
|
|
+ t.__text = null)
|
|
|
+ }
|
|
|
+ function uP() {}
|
|
|
+ function hP(t, e) {
|
|
|
+ for (var i = 0, n = e.length, o = 0, a = 0; i < n; i++) {
|
|
|
+ var r = e[i];
|
|
|
+ if (r.removed) {
|
|
|
+ for (s = [],
|
|
|
+ l = a; l < a + r.count; l++)
|
|
|
+ s.push(l);
|
|
|
+ r.indices = s,
|
|
|
+ a += r.count
|
|
|
+ } else {
|
|
|
+ for (var s = [], l = o; l < o + r.count; l++)
|
|
|
+ s.push(l);
|
|
|
+ r.indices = s,
|
|
|
+ o += r.count,
|
|
|
+ r.added || (a += r.count)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return e
|
|
|
+ }
|
|
|
+ eP.drawRectText = rP,
|
|
|
+ eP.brush = function(t) {
|
|
|
+ null != t.style.text ? rP(t, !1) : lP(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ uP.prototype = {
|
|
|
+ diff: function(l, u, t) {
|
|
|
+ t = t || function(t, e) {
|
|
|
+ return t === e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ this.equals = t;
|
|
|
+ var h = this;
|
|
|
+ l = l.slice();
|
|
|
+ var c = (u = u.slice()).length
|
|
|
+ , d = l.length
|
|
|
+ , f = 1
|
|
|
+ , e = c + d
|
|
|
+ , p = [{
|
|
|
+ newPos: -1,
|
|
|
+ components: []
|
|
|
+ }]
|
|
|
+ , i = this.extractCommon(p[0], u, l, 0);
|
|
|
+ if (p[0].newPos + 1 >= c && d <= i + 1) {
|
|
|
+ for (var n = [], o = 0; o < u.length; o++)
|
|
|
+ n.push(o);
|
|
|
+ return [{
|
|
|
+ indices: n,
|
|
|
+ count: u.length
|
|
|
+ }]
|
|
|
+ }
|
|
|
+ function a() {
|
|
|
+ for (var t = -1 * f; t <= f; t += 2) {
|
|
|
+ var e, i = p[t - 1], n = p[t + 1], o = (n ? n.newPos : 0) - t;
|
|
|
+ i && (p[t - 1] = void 0);
|
|
|
+ var a = i && i.newPos + 1 < c
|
|
|
+ , r = n && 0 <= o && o < d;
|
|
|
+ if (a || r) {
|
|
|
+ if (!a || r && i.newPos < n.newPos ? (e = {
|
|
|
+ newPos: (s = n).newPos,
|
|
|
+ components: s.components.slice(0)
|
|
|
+ },
|
|
|
+ h.pushComponent(e.components, void 0, !0)) : ((e = i).newPos++,
|
|
|
+ h.pushComponent(e.components, !0, void 0)),
|
|
|
+ o = h.extractCommon(e, u, l, t),
|
|
|
+ e.newPos + 1 >= c && d <= o + 1)
|
|
|
+ return hP(h, e.components, u, l);
|
|
|
+ p[t] = e
|
|
|
+ } else
|
|
|
+ p[t] = void 0
|
|
|
+ }
|
|
|
+ var s;
|
|
|
+ f++
|
|
|
+ }
|
|
|
+ for (; f <= e; ) {
|
|
|
+ var r = a();
|
|
|
+ if (r)
|
|
|
+ return r
|
|
|
+ }
|
|
|
+ },
|
|
|
+ pushComponent: function(t, e, i) {
|
|
|
+ var n = t[t.length - 1];
|
|
|
+ n && n.added === e && n.removed === i ? t[t.length - 1] = {
|
|
|
+ count: n.count + 1,
|
|
|
+ added: e,
|
|
|
+ removed: i
|
|
|
+ } : t.push({
|
|
|
+ count: 1,
|
|
|
+ added: e,
|
|
|
+ removed: i
|
|
|
+ })
|
|
|
+ },
|
|
|
+ extractCommon: function(t, e, i, n) {
|
|
|
+ for (var o = e.length, a = i.length, r = t.newPos, s = r - n, l = 0; r + 1 < o && s + 1 < a && this.equals(e[r + 1], i[s + 1]); )
|
|
|
+ r++,
|
|
|
+ s++,
|
|
|
+ l++;
|
|
|
+ return l && t.components.push({
|
|
|
+ count: l
|
|
|
+ }),
|
|
|
+ t.newPos = r,
|
|
|
+ s
|
|
|
+ },
|
|
|
+ tokenize: function(t) {
|
|
|
+ return t.slice()
|
|
|
+ },
|
|
|
+ join: function(t) {
|
|
|
+ return t.slice()
|
|
|
+ }
|
|
|
+ };
|
|
|
+ var cP = new uP;
|
|
|
+ function dP(t, e, i, n, o) {
|
|
|
+ this._zrId = t,
|
|
|
+ this._svgRoot = e,
|
|
|
+ this._tagNames = "string" == typeof i ? [i] : i,
|
|
|
+ this._markLabel = n,
|
|
|
+ this._domName = o || "_dom",
|
|
|
+ this.nextId = 0
|
|
|
+ }
|
|
|
+ function fP(t, e) {
|
|
|
+ dP.call(this, t, e, ["linearGradient", "radialGradient"], "__gradient_in_use__")
|
|
|
+ }
|
|
|
+ function pP(t, e) {
|
|
|
+ dP.call(this, t, e, "clipPath", "__clippath_in_use__")
|
|
|
+ }
|
|
|
+ function gP(t, e) {
|
|
|
+ dP.call(this, t, e, ["filter"], "__filter_in_use__", "_shadowDom")
|
|
|
+ }
|
|
|
+ function mP(t) {
|
|
|
+ return t && (t.shadowBlur || t.shadowOffsetX || t.shadowOffsetY || t.textShadowBlur || t.textShadowOffsetX || t.textShadowOffsetY)
|
|
|
+ }
|
|
|
+ function vP(t) {
|
|
|
+ return parseInt(t, 10)
|
|
|
+ }
|
|
|
+ function yP(t, e) {
|
|
|
+ return e && t && e.parentNode !== t
|
|
|
+ }
|
|
|
+ function xP(t, e, i) {
|
|
|
+ if (yP(t, e) && i) {
|
|
|
+ var n = i.nextSibling;
|
|
|
+ n ? t.insertBefore(e, n) : t.appendChild(e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function _P(t, e) {
|
|
|
+ if (yP(t, e)) {
|
|
|
+ var i = t.firstChild;
|
|
|
+ i ? t.insertBefore(e, i) : t.appendChild(e)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function wP(t, e) {
|
|
|
+ e && t && e.parentNode === t && t.removeChild(e)
|
|
|
+ }
|
|
|
+ function bP(t) {
|
|
|
+ return t.__textSvgEl
|
|
|
+ }
|
|
|
+ function SP(t) {
|
|
|
+ return t.__svgEl
|
|
|
+ }
|
|
|
+ dP.prototype.createElement = zk,
|
|
|
+ dP.prototype.getDefs = function(t) {
|
|
|
+ var e = this._svgRoot
|
|
|
+ , n = this._svgRoot.getElementsByTagName("defs");
|
|
|
+ return 0 === n.length ? t ? ((n = e.insertBefore(this.createElement("defs"), e.firstChild)).contains || (n.contains = function(t) {
|
|
|
+ var e = n.children;
|
|
|
+ if (!e)
|
|
|
+ return !1;
|
|
|
+ for (var i = e.length - 1; 0 <= i; --i)
|
|
|
+ if (e[i] === t)
|
|
|
+ return !0;
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ n) : null : n[0]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.update = function(t, e) {
|
|
|
+ if (t) {
|
|
|
+ var i = this.getDefs(!1);
|
|
|
+ if (t[this._domName] && i.contains(t[this._domName]))
|
|
|
+ "function" == typeof e && e(t);
|
|
|
+ else {
|
|
|
+ var n = this.add(t);
|
|
|
+ n && (t[this._domName] = n)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.addDom = function(t) {
|
|
|
+ this.getDefs(!0).appendChild(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.removeDom = function(t) {
|
|
|
+ var e = this.getDefs(!1);
|
|
|
+ e && t[this._domName] && (e.removeChild(t[this._domName]),
|
|
|
+ t[this._domName] = null)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.getDoms = function() {
|
|
|
+ var i = this.getDefs(!1);
|
|
|
+ if (!i)
|
|
|
+ return [];
|
|
|
+ var n = [];
|
|
|
+ return E(this._tagNames, function(t) {
|
|
|
+ var e = i.getElementsByTagName(t);
|
|
|
+ n = n.concat([].slice.call(e))
|
|
|
+ }),
|
|
|
+ n
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.markAllUnused = function() {
|
|
|
+ var t = this.getDoms()
|
|
|
+ , e = this;
|
|
|
+ E(t, function(t) {
|
|
|
+ t[e._markLabel] = "0"
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.markUsed = function(t) {
|
|
|
+ t && (t[this._markLabel] = "1")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.removeUnused = function() {
|
|
|
+ var e = this.getDefs(!1);
|
|
|
+ if (e) {
|
|
|
+ var t = this.getDoms()
|
|
|
+ , i = this;
|
|
|
+ E(t, function(t) {
|
|
|
+ "1" !== t[i._markLabel] && e.removeChild(t)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.getSvgProxy = function(t) {
|
|
|
+ return t instanceof Ar ? Qk : t instanceof Qn ? tP : t instanceof Ur ? eP : Qk
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.getTextSvgElement = function(t) {
|
|
|
+ return t.__textSvgEl
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ dP.prototype.getSvgElement = function(t) {
|
|
|
+ return t.__svgEl
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(fP, dP),
|
|
|
+ fP.prototype.addWithoutUpdate = function(a, r) {
|
|
|
+ if (r && r.style) {
|
|
|
+ var s = this;
|
|
|
+ E(["fill", "stroke"], function(t) {
|
|
|
+ if (r.style[t] && ("linear" === r.style[t].type || "radial" === r.style[t].type)) {
|
|
|
+ var e, i = r.style[t], n = s.getDefs(!0);
|
|
|
+ i._dom ? (e = i._dom,
|
|
|
+ n.contains(i._dom) || s.addDom(e)) : e = s.add(i),
|
|
|
+ s.markUsed(r);
|
|
|
+ var o = e.getAttribute("id");
|
|
|
+ a.setAttribute(t, "url(#" + o + ")")
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fP.prototype.add = function(t) {
|
|
|
+ var e;
|
|
|
+ if ("linear" === t.type)
|
|
|
+ e = this.createElement("linearGradient");
|
|
|
+ else {
|
|
|
+ if ("radial" !== t.type)
|
|
|
+ return vi("Illegal gradient type."),
|
|
|
+ null;
|
|
|
+ e = this.createElement("radialGradient")
|
|
|
+ }
|
|
|
+ return t.id = t.id || this.nextId++,
|
|
|
+ e.setAttribute("id", "zr" + this._zrId + "-gradient-" + t.id),
|
|
|
+ this.updateDom(t, e),
|
|
|
+ this.addDom(e),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fP.prototype.update = function(i) {
|
|
|
+ var n = this;
|
|
|
+ dP.prototype.update.call(this, i, function() {
|
|
|
+ var t = i.type
|
|
|
+ , e = i._dom.tagName;
|
|
|
+ "linear" === t && "linearGradient" === e || "radial" === t && "radialGradient" === e ? n.updateDom(i, i._dom) : (n.removeDom(i),
|
|
|
+ n.add(i))
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fP.prototype.updateDom = function(t, e) {
|
|
|
+ if ("linear" === t.type)
|
|
|
+ e.setAttribute("x1", t.x),
|
|
|
+ e.setAttribute("y1", t.y),
|
|
|
+ e.setAttribute("x2", t.x2),
|
|
|
+ e.setAttribute("y2", t.y2);
|
|
|
+ else {
|
|
|
+ if ("radial" !== t.type)
|
|
|
+ return void vi("Illegal gradient type.");
|
|
|
+ e.setAttribute("cx", t.x),
|
|
|
+ e.setAttribute("cy", t.y),
|
|
|
+ e.setAttribute("r", t.r)
|
|
|
+ }
|
|
|
+ t.global ? e.setAttribute("gradientUnits", "userSpaceOnUse") : e.setAttribute("gradientUnits", "objectBoundingBox"),
|
|
|
+ e.innerHTML = "";
|
|
|
+ for (var i = t.colorStops, n = 0, o = i.length; n < o; ++n) {
|
|
|
+ var a = this.createElement("stop");
|
|
|
+ a.setAttribute("offset", 100 * i[n].offset + "%");
|
|
|
+ var r = i[n].color;
|
|
|
+ if (r.indexOf(!1)) {
|
|
|
+ var s = Fe(r)[3]
|
|
|
+ , l = Ze(r);
|
|
|
+ a.setAttribute("stop-color", "#" + l),
|
|
|
+ a.setAttribute("stop-opacity", s)
|
|
|
+ } else
|
|
|
+ a.setAttribute("stop-color", i[n].color);
|
|
|
+ e.appendChild(a)
|
|
|
+ }
|
|
|
+ t._dom = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ fP.prototype.markUsed = function(t) {
|
|
|
+ if (t.style) {
|
|
|
+ var e = t.style.fill;
|
|
|
+ e && e._dom && dP.prototype.markUsed.call(this, e._dom),
|
|
|
+ (e = t.style.stroke) && e._dom && dP.prototype.markUsed.call(this, e._dom)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(pP, dP),
|
|
|
+ pP.prototype.update = function(t) {
|
|
|
+ var e = this.getSvgElement(t);
|
|
|
+ e && this.updateDom(e, t.__clipPaths, !1);
|
|
|
+ var i = this.getTextSvgElement(t);
|
|
|
+ i && this.updateDom(i, t.__clipPaths, !0),
|
|
|
+ this.markUsed(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pP.prototype.updateDom = function(t, e, i) {
|
|
|
+ if (e && 0 < e.length) {
|
|
|
+ var n, o, a = this.getDefs(!0), r = e[0], s = i ? "_textDom" : "_dom";
|
|
|
+ r[s] ? (o = r[s].getAttribute("id"),
|
|
|
+ n = r[s],
|
|
|
+ a.contains(n) || a.appendChild(n)) : (o = "zr" + this._zrId + "-clip-" + this.nextId,
|
|
|
+ ++this.nextId,
|
|
|
+ (n = this.createElement("clipPath")).setAttribute("id", o),
|
|
|
+ a.appendChild(n),
|
|
|
+ r[s] = n);
|
|
|
+ var l = this.getSvgProxy(r);
|
|
|
+ if (r.transform && r.parent.invTransform && !i) {
|
|
|
+ var u = Array.prototype.slice.call(r.transform);
|
|
|
+ le(r.transform, r.parent.invTransform, r.transform),
|
|
|
+ l.brush(r),
|
|
|
+ r.transform = u
|
|
|
+ } else
|
|
|
+ l.brush(r);
|
|
|
+ var h = this.getSvgElement(r);
|
|
|
+ n.innerHTML = "",
|
|
|
+ n.appendChild(h.cloneNode()),
|
|
|
+ t.setAttribute("clip-path", "url(#" + o + ")"),
|
|
|
+ 1 < e.length && this.updateDom(n, e.slice(1), i)
|
|
|
+ } else
|
|
|
+ t && t.setAttribute("clip-path", "none")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ pP.prototype.markUsed = function(t) {
|
|
|
+ var e = this;
|
|
|
+ t.__clipPaths && E(t.__clipPaths, function(t) {
|
|
|
+ t._dom && dP.prototype.markUsed.call(e, t._dom),
|
|
|
+ t._textDom && dP.prototype.markUsed.call(e, t._textDom)
|
|
|
+ })
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ w(gP, dP),
|
|
|
+ gP.prototype.addWithoutUpdate = function(t, e) {
|
|
|
+ if (e && mP(e.style)) {
|
|
|
+ var i;
|
|
|
+ if (e._shadowDom)
|
|
|
+ i = e._shadowDom,
|
|
|
+ this.getDefs(!0).contains(e._shadowDom) || this.addDom(i);
|
|
|
+ else
|
|
|
+ i = this.add(e);
|
|
|
+ this.markUsed(e);
|
|
|
+ var n = i.getAttribute("id");
|
|
|
+ t.style.filter = "url(#" + n + ")"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gP.prototype.add = function(t) {
|
|
|
+ var e = this.createElement("filter");
|
|
|
+ return t._shadowDomId = t._shadowDomId || this.nextId++,
|
|
|
+ e.setAttribute("id", "zr" + this._zrId + "-shadow-" + t._shadowDomId),
|
|
|
+ this.updateDom(t, e),
|
|
|
+ this.addDom(e),
|
|
|
+ e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gP.prototype.update = function(t, e) {
|
|
|
+ if (mP(e.style)) {
|
|
|
+ var i = this;
|
|
|
+ dP.prototype.update.call(this, e, function() {
|
|
|
+ i.updateDom(e, e._shadowDom)
|
|
|
+ })
|
|
|
+ } else
|
|
|
+ this.remove(t, e)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gP.prototype.remove = function(t, e) {
|
|
|
+ null != e._shadowDomId && (this.removeDom(t),
|
|
|
+ t.style.filter = "")
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gP.prototype.updateDom = function(t, e) {
|
|
|
+ var i = e.getElementsByTagName("feDropShadow");
|
|
|
+ i = 0 === i.length ? this.createElement("feDropShadow") : i[0];
|
|
|
+ var n, o, a, r, s = t.style, l = t.scale && t.scale[0] || 1, u = t.scale && t.scale[1] || 1;
|
|
|
+ if (s.shadowBlur || s.shadowOffsetX || s.shadowOffsetY)
|
|
|
+ n = s.shadowOffsetX || 0,
|
|
|
+ o = s.shadowOffsetY || 0,
|
|
|
+ a = s.shadowBlur,
|
|
|
+ r = s.shadowColor;
|
|
|
+ else {
|
|
|
+ if (!s.textShadowBlur)
|
|
|
+ return void this.removeDom(e, s);
|
|
|
+ n = s.textShadowOffsetX || 0,
|
|
|
+ o = s.textShadowOffsetY || 0,
|
|
|
+ a = s.textShadowBlur,
|
|
|
+ r = s.textShadowColor
|
|
|
+ }
|
|
|
+ i.setAttribute("dx", n / l),
|
|
|
+ i.setAttribute("dy", o / u),
|
|
|
+ i.setAttribute("flood-color", r);
|
|
|
+ var h = a / 2 / l + " " + a / 2 / u;
|
|
|
+ i.setAttribute("stdDeviation", h),
|
|
|
+ e.setAttribute("x", "-100%"),
|
|
|
+ e.setAttribute("y", "-100%"),
|
|
|
+ e.setAttribute("width", Math.ceil(a / 2 * 200) + "%"),
|
|
|
+ e.setAttribute("height", Math.ceil(a / 2 * 200) + "%"),
|
|
|
+ e.appendChild(i),
|
|
|
+ t._shadowDom = e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ gP.prototype.markUsed = function(t) {
|
|
|
+ t._shadowDom && dP.prototype.markUsed.call(this, t._shadowDom)
|
|
|
+ }
|
|
|
+ ;
|
|
|
+ function MP(t, e, i, n) {
|
|
|
+ this.root = t,
|
|
|
+ this.storage = e,
|
|
|
+ this._opts = i = P({}, i || {});
|
|
|
+ var o = zk("svg");
|
|
|
+ o.setAttribute("xmlns", "http://www.w3.org/2000/svg"),
|
|
|
+ o.setAttribute("version", "1.1"),
|
|
|
+ o.setAttribute("baseProfile", "full"),
|
|
|
+ o.style.cssText = "user-select:none;position:absolute;left:0;top:0;";
|
|
|
+ var a = zk("g");
|
|
|
+ o.appendChild(a);
|
|
|
+ var r = zk("g");
|
|
|
+ o.appendChild(r),
|
|
|
+ this.gradientManager = new fP(n,r),
|
|
|
+ this.clipPathManager = new pP(n,r),
|
|
|
+ this.shadowManager = new gP(n,r);
|
|
|
+ var s = document.createElement("div");
|
|
|
+ s.style.cssText = "overflow:hidden;position:relative",
|
|
|
+ this._svgDom = o,
|
|
|
+ this._svgRoot = r,
|
|
|
+ this._backgroundRoot = a,
|
|
|
+ this._viewport = s,
|
|
|
+ t.appendChild(s),
|
|
|
+ s.appendChild(o),
|
|
|
+ this.resize(i.width, i.height),
|
|
|
+ this._visibleList = []
|
|
|
+ }
|
|
|
+ MP.prototype = {
|
|
|
+ constructor: MP,
|
|
|
+ getType: function() {
|
|
|
+ return "svg"
|
|
|
+ },
|
|
|
+ getViewportRoot: function() {
|
|
|
+ return this._viewport
|
|
|
+ },
|
|
|
+ getSvgDom: function() {
|
|
|
+ return this._svgDom
|
|
|
+ },
|
|
|
+ getSvgRoot: function() {
|
|
|
+ return this._svgRoot
|
|
|
+ },
|
|
|
+ getViewportRootOffset: function() {
|
|
|
+ var t = this.getViewportRoot();
|
|
|
+ if (t)
|
|
|
+ return {
|
|
|
+ offsetLeft: t.offsetLeft || 0,
|
|
|
+ offsetTop: t.offsetTop || 0
|
|
|
+ }
|
|
|
+ },
|
|
|
+ refresh: function() {
|
|
|
+ var t = this.storage.getDisplayList(!0);
|
|
|
+ this._paintList(t)
|
|
|
+ },
|
|
|
+ setBackgroundColor: function(t) {
|
|
|
+ this._backgroundRoot && this._backgroundNode && this._backgroundRoot.removeChild(this._backgroundNode);
|
|
|
+ var e = zk("rect");
|
|
|
+ e.setAttribute("width", this.getWidth()),
|
|
|
+ e.setAttribute("height", this.getHeight()),
|
|
|
+ e.setAttribute("x", 0),
|
|
|
+ e.setAttribute("y", 0),
|
|
|
+ e.setAttribute("id", 0),
|
|
|
+ e.style.fill = t,
|
|
|
+ this._backgroundRoot.appendChild(e),
|
|
|
+ this._backgroundNode = e
|
|
|
+ },
|
|
|
+ _paintList: function(t) {
|
|
|
+ this.gradientManager.markAllUnused(),
|
|
|
+ this.clipPathManager.markAllUnused(),
|
|
|
+ this.shadowManager.markAllUnused();
|
|
|
+ var e, i, n = this._svgRoot, o = this._visibleList, a = t.length, r = [];
|
|
|
+ for (e = 0; e < a; e++) {
|
|
|
+ var s = t[e]
|
|
|
+ , l = (i = s)instanceof Ar ? Qk : i instanceof Qn ? tP : i instanceof Ur ? eP : Qk
|
|
|
+ , u = SP(s) || bP(s);
|
|
|
+ s.invisible || (s.__dirty && (l && l.brush(s),
|
|
|
+ this.clipPathManager.update(s),
|
|
|
+ s.style && (this.gradientManager.update(s.style.fill),
|
|
|
+ this.gradientManager.update(s.style.stroke),
|
|
|
+ this.shadowManager.update(u, s)),
|
|
|
+ s.__dirty = !1),
|
|
|
+ r.push(s))
|
|
|
+ }
|
|
|
+ var h, c = function(t, e, i) {
|
|
|
+ return cP.diff(t, e, i)
|
|
|
+ }(o, r);
|
|
|
+ for (e = 0; e < c.length; e++) {
|
|
|
+ if ((p = c[e]).removed)
|
|
|
+ for (var d = 0; d < p.count; d++) {
|
|
|
+ u = SP(s = o[p.indices[d]]);
|
|
|
+ var f = bP(s);
|
|
|
+ wP(n, u),
|
|
|
+ wP(n, f)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (e = 0; e < c.length; e++) {
|
|
|
+ var p;
|
|
|
+ if ((p = c[e]).added)
|
|
|
+ for (d = 0; d < p.count; d++) {
|
|
|
+ u = SP(s = r[p.indices[d]]),
|
|
|
+ f = bP(s);
|
|
|
+ h ? xP(n, u, h) : _P(n, u),
|
|
|
+ u ? xP(n, f, u) : h ? xP(n, f, h) : _P(n, f),
|
|
|
+ xP(n, f, u),
|
|
|
+ h = f || u || h,
|
|
|
+ this.gradientManager.addWithoutUpdate(u || f, s),
|
|
|
+ this.shadowManager.addWithoutUpdate(u || f, s),
|
|
|
+ this.clipPathManager.markUsed(s)
|
|
|
+ }
|
|
|
+ else if (!p.removed)
|
|
|
+ for (d = 0; d < p.count; d++) {
|
|
|
+ u = SP(s = r[p.indices[d]]),
|
|
|
+ f = bP(s),
|
|
|
+ u = SP(s),
|
|
|
+ f = bP(s);
|
|
|
+ this.gradientManager.markUsed(s),
|
|
|
+ this.gradientManager.addWithoutUpdate(u || f, s),
|
|
|
+ this.shadowManager.markUsed(s),
|
|
|
+ this.shadowManager.addWithoutUpdate(u || f, s),
|
|
|
+ this.clipPathManager.markUsed(s),
|
|
|
+ f && xP(n, f, u),
|
|
|
+ h = u || f || h
|
|
|
+ }
|
|
|
+ }
|
|
|
+ this.gradientManager.removeUnused(),
|
|
|
+ this.clipPathManager.removeUnused(),
|
|
|
+ this.shadowManager.removeUnused(),
|
|
|
+ this._visibleList = r
|
|
|
+ },
|
|
|
+ _getDefs: function(t) {
|
|
|
+ var n, e = this._svgDom;
|
|
|
+ return 0 !== (n = e.getElementsByTagName("defs")).length ? n[0] : t ? ((n = e.insertBefore(zk("defs"), e.firstChild)).contains || (n.contains = function(t) {
|
|
|
+ var e = n.children;
|
|
|
+ if (!e)
|
|
|
+ return !1;
|
|
|
+ for (var i = e.length - 1; 0 <= i; --i)
|
|
|
+ if (e[i] === t)
|
|
|
+ return !0;
|
|
|
+ return !1
|
|
|
+ }
|
|
|
+ ),
|
|
|
+ n) : null
|
|
|
+ },
|
|
|
+ resize: function(t, e) {
|
|
|
+ var i = this._viewport;
|
|
|
+ i.style.display = "none";
|
|
|
+ var n = this._opts;
|
|
|
+ if (null != t && (n.width = t),
|
|
|
+ null != e && (n.height = e),
|
|
|
+ t = this._getSize(0),
|
|
|
+ e = this._getSize(1),
|
|
|
+ i.style.display = "",
|
|
|
+ this._width !== t || this._height !== e) {
|
|
|
+ this._width = t,
|
|
|
+ this._height = e;
|
|
|
+ var o = i.style;
|
|
|
+ o.width = t + "px",
|
|
|
+ o.height = e + "px";
|
|
|
+ var a = this._svgDom;
|
|
|
+ a.setAttribute("width", t),
|
|
|
+ a.setAttribute("height", e)
|
|
|
+ }
|
|
|
+ this._backgroundNode && (this._backgroundNode.setAttribute("width", t),
|
|
|
+ this._backgroundNode.setAttribute("height", e))
|
|
|
+ },
|
|
|
+ getWidth: function() {
|
|
|
+ return this._width
|
|
|
+ },
|
|
|
+ getHeight: function() {
|
|
|
+ return this._height
|
|
|
+ },
|
|
|
+ _getSize: function(t) {
|
|
|
+ var e = this._opts
|
|
|
+ , i = ["width", "height"][t]
|
|
|
+ , n = ["clientWidth", "clientHeight"][t]
|
|
|
+ , o = ["paddingLeft", "paddingTop"][t]
|
|
|
+ , a = ["paddingRight", "paddingBottom"][t];
|
|
|
+ if (null != e[i] && "auto" !== e[i])
|
|
|
+ return parseFloat(e[i]);
|
|
|
+ var r = this.root
|
|
|
+ , s = document.defaultView.getComputedStyle(r);
|
|
|
+ return (r[n] || vP(s[i]) || vP(r.style[i])) - (vP(s[o]) || 0) - (vP(s[a]) || 0) | 0
|
|
|
+ },
|
|
|
+ dispose: function() {
|
|
|
+ this.root.innerHTML = "",
|
|
|
+ this._svgRoot = this._backgroundRoot = this._svgDom = this._backgroundNode = this._viewport = this.storage = null
|
|
|
+ },
|
|
|
+ clear: function() {
|
|
|
+ this._viewport && this.root.removeChild(this._viewport)
|
|
|
+ },
|
|
|
+ toDataURL: function() {
|
|
|
+ return this.refresh(),
|
|
|
+ "data:image/svg+xml;charset=UTF-8," + encodeURIComponent(this._svgDom.outerHTML.replace(/></g, ">\n\r<"))
|
|
|
+ }
|
|
|
+ },
|
|
|
+ E(["getLayer", "insertLayer", "eachLayer", "eachBuiltinLayer", "eachOtherLayer", "getLayers", "modLayer", "delLayer", "clearLayer", "pathToImage"], function(t) {
|
|
|
+ MP.prototype[t] = function(t) {
|
|
|
+ return function() {
|
|
|
+ vi('In SVG mode painter not support method "' + t + '"')
|
|
|
+ }
|
|
|
+ }(t)
|
|
|
+ }),
|
|
|
+ Po("svg", MP),
|
|
|
+ t.version = "4.8.0",
|
|
|
+ t.dependencies = {
|
|
|
+ zrender: "4.3.1"
|
|
|
+ },
|
|
|
+ t.PRIORITY = Ld,
|
|
|
+ t.init = function(t, e, i) {
|
|
|
+ var n = mf(t);
|
|
|
+ if (n)
|
|
|
+ return n;
|
|
|
+ var o = new Rd(t,e,i);
|
|
|
+ return o.id = "ec_" + cf++,
|
|
|
+ uf[o.id] = o,
|
|
|
+ Jo(t, ff, o.id),
|
|
|
+ function(n) {
|
|
|
+ var o = "__connectUpdateStatus";
|
|
|
+ function a(t, e) {
|
|
|
+ for (var i = 0; i < t.length; i++) {
|
|
|
+ t[i][o] = e
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Td(ef, function(t, e) {
|
|
|
+ n._messageCenter.on(e, function(t) {
|
|
|
+ if (hf[n.group] && 0 !== n[o]) {
|
|
|
+ if (t && t.escapeConnect)
|
|
|
+ return;
|
|
|
+ var e = n.makeActionFromEvent(t)
|
|
|
+ , i = [];
|
|
|
+ Td(uf, function(t) {
|
|
|
+ t !== n && t.group === n.group && i.push(t)
|
|
|
+ }),
|
|
|
+ a(i, 0),
|
|
|
+ Td(i, function(t) {
|
|
|
+ 1 !== t[o] && t.dispatchAction(e)
|
|
|
+ }),
|
|
|
+ a(i, 2)
|
|
|
+ }
|
|
|
+ })
|
|
|
+ })
|
|
|
+ }(o),
|
|
|
+ o
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.connect = function(e) {
|
|
|
+ if (L(e)) {
|
|
|
+ var t = e;
|
|
|
+ e = null,
|
|
|
+ Td(t, function(t) {
|
|
|
+ null != t.group && (e = t.group)
|
|
|
+ }),
|
|
|
+ e = e || "g_" + df++,
|
|
|
+ Td(t, function(t) {
|
|
|
+ t.group = e
|
|
|
+ })
|
|
|
+ }
|
|
|
+ return hf[e] = !0,
|
|
|
+ e
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.disConnect = pf,
|
|
|
+ t.disconnect = gf,
|
|
|
+ t.dispose = function(t) {
|
|
|
+ "string" == typeof t ? t = uf[t] : t instanceof Rd || (t = mf(t)),
|
|
|
+ t instanceof Rd && !t.isDisposed() && t.dispose()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.getInstanceByDom = mf,
|
|
|
+ t.getInstanceById = function(t) {
|
|
|
+ return uf[t]
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.registerTheme = vf,
|
|
|
+ t.registerPreprocessor = yf,
|
|
|
+ t.registerProcessor = xf,
|
|
|
+ t.registerPostUpdate = function(t) {
|
|
|
+ af.push(t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.registerAction = _f,
|
|
|
+ t.registerCoordinateSystem = wf,
|
|
|
+ t.getCoordinateSystemDimensions = function(t) {
|
|
|
+ var e = lh.get(t);
|
|
|
+ if (e)
|
|
|
+ return e.getDimensionsInfo ? e.getDimensionsInfo() : e.dimensions.slice()
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.registerLayout = bf,
|
|
|
+ t.registerVisual = Sf,
|
|
|
+ t.registerLoading = If,
|
|
|
+ t.extendComponentModel = Tf,
|
|
|
+ t.extendComponentView = Af,
|
|
|
+ t.extendSeriesModel = Df,
|
|
|
+ t.extendChartView = Cf,
|
|
|
+ t.setCanvasCreator = function(t) {
|
|
|
+ f("createCanvas", t)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.registerMap = function(t, e, i) {
|
|
|
+ Sd.registerMap(t, e, i)
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.getMap = function(t) {
|
|
|
+ var e = Sd.retrieveMap(t);
|
|
|
+ return e && e[0] && {
|
|
|
+ geoJson: e[0].geoJSON,
|
|
|
+ specialAreas: e[0].specialAreas
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ,
|
|
|
+ t.dataTool = {},
|
|
|
+ t.zrender = Oo,
|
|
|
+ t.number = Ql,
|
|
|
+ t.format = mu,
|
|
|
+ t.throttle = Lc,
|
|
|
+ t.helper = Sg,
|
|
|
+ t.matrix = pe,
|
|
|
+ t.vector = It,
|
|
|
+ t.color = Je,
|
|
|
+ t.parseGeoJSON = Cg,
|
|
|
+ t.parseGeoJson = Wg,
|
|
|
+ t.util = Hg,
|
|
|
+ t.graphic = Zg,
|
|
|
+ t.List = Yf,
|
|
|
+ t.Model = Cl,
|
|
|
+ t.Axis = Gg,
|
|
|
+ t.env = v
|
|
|
+});
|
fengxu
