From 841b95977be7b319b85bab30433842ecb7e65477 Mon Sep 17 00:00:00 2001 From: Weilbyte Date: Sun, 26 May 2019 19:34:50 +0200 Subject: [PATCH] Modified charts.js Charts.js modified for PVE 5.4-3 --- serverside/jsmod/5.4-3/charts.js | 22013 +++++++++++++++++++++++++++++ 1 file changed, 22013 insertions(+) create mode 100644 serverside/jsmod/5.4-3/charts.js diff --git a/serverside/jsmod/5.4-3/charts.js b/serverside/jsmod/5.4-3/charts.js new file mode 100644 index 0000000..bc45966 --- /dev/null +++ b/serverside/jsmod/5.4-3/charts.js @@ -0,0 +1,22013 @@ +Ext.define("Ext.draw.ContainerBase", { + extend: "Ext.panel.Panel", + requires: ["Ext.window.Window"], + previewTitleText: "Chart Preview", + previewAltText: "Chart preview", + layout: "container", + addElementListener: function() { + var b = this, + a = arguments; + if (b.rendered) { + b.el.on.apply(b.el, a) + } else { + b.on("render", function() { + b.el.on.apply(b.el, a) + }) + } + }, + removeElementListener: function() { + var b = this, + a = arguments; + if (b.rendered) { + b.el.un.apply(b.el, a) + } + }, + afterRender: function() { + this.callParent(arguments); + this.initAnimator() + }, + getItems: function() { + var b = this, + a = b.items; + if (!a || !a.isMixedCollection) { + b.initItems() + } + return b.items + }, + onRender: function() { + this.callParent(arguments); + this.element = this.el; + this.innerElement = this.body + }, + setItems: function(a) { + this.items = a; + return a + }, + setSurfaceSize: function(b, a) { + this.resizeHandler({ + width: b, + height: a + }); + this.renderFrame() + }, + onResize: function(c, a, b, e) { + var d = this; + d.callParent([c, a, b, e]); + d.setBodySize({ + width: c, + height: a + }) + }, + preview: function() { + var a = this.getImage(); + new Ext.window.Window({ + title: this.previewTitleText, + closeable: true, + renderTo: Ext.getBody(), + autoShow: true, + maximizeable: true, + maximized: true, + border: true, + layout: { + type: "hbox", + pack: "center", + align: "middle" + }, + items: { + xtype: "container", + items: { + xtype: "image", + mode: "img", + cls: Ext.baseCSSPrefix + "chart-image", + alt: this.previewAltText, + src: a.data, + listeners: { + afterrender: function() { + var e = this, + b = e.imgEl.dom, + d = a.type === "svg" ? 1 : (window.devicePixelRatio || 1), + c; + if (!b.naturalWidth || !b.naturalHeight) { + b.onload = function() { + var g = b.naturalWidth, + f = b.naturalHeight; + e.setWidth(Math.floor(g / d)); + e.setHeight(Math.floor(f / d)) + } + } else { + c = e.getSize(); + e.setWidth(Math.floor(c.width / d)); + e.setHeight(Math.floor(c.height / d)) + } + } + } + } + } + }) + }, + privates: { + getTargetEl: function() { + return this.innerElement + }, + reattachToBody: function() { + var a = this; + if (a.pendingDetachSize) { + a.onBodyResize() + } + a.pendingDetachSize = false; + a.callParent() + } + } +}); +Ext.define("Ext.draw.SurfaceBase", { + extend: "Ext.Widget", + getOwnerBody: function() { + return this.ownerCt.body + }, + destroy: function() { + var a = this; + if (a.hasListeners.destroy) { + a.fireEvent("destroy", a) + } + a.callParent() + } +}); +Ext.define("Ext.draw.Color", { + statics: { + colorToHexRe: /(.*?)rgb\((\d+),\s*(\d+),\s*(\d+)\)/, + rgbToHexRe: /\s*rgb\((\d+),\s*(\d+),\s*(\d+)\)/, + rgbaToHexRe: /\s*rgba\((\d+),\s*(\d+),\s*(\d+),\s*([\.\d]+)\)/, + hexRe: /\s*#([0-9a-fA-F][0-9a-fA-F]?)([0-9a-fA-F][0-9a-fA-F]?)([0-9a-fA-F][0-9a-fA-F]?)\s*/, + NONE: "none", + RGBA_NONE: "rgba(0, 0, 0, 0)" + }, + isColor: true, + lightnessFactor: 0.2, + constructor: function(d, b, a, c) { + this.setRGB(d, b, a, c) + }, + setRGB: function(e, c, a, d) { + var b = this; + b.r = Math.min(255, Math.max(0, e)); + b.g = Math.min(255, Math.max(0, c)); + b.b = Math.min(255, Math.max(0, a)); + if (d === undefined) { + b.a = 1 + } else { + b.a = Math.min(1, Math.max(0, d)) + } + }, + getGrayscale: function() { + return this.r * 0.3 + this.g * 0.59 + this.b * 0.11 + }, + getHSL: function() { + var i = this, + a = i.r / 255, + f = i.g / 255, + j = i.b / 255, + k = Math.max(a, f, j), + d = Math.min(a, f, j), + m = k - d, + e, n = 0, + c = 0.5 * (k + d); + if (d !== k) { + n = (c <= 0.5) ? m / (k + d) : m / (2 - k - d); + if (a === k) { + e = 60 * (f - j) / m + } else { + if (f === k) { + e = 120 + 60 * (j - a) / m + } else { + e = 240 + 60 * (a - f) / m + } + } + if (e < 0) { + e += 360 + } + if (e >= 360) { + e -= 360 + } + } + return [e, n, c] + }, + getHSV: function() { + var i = this, + a = i.r / 255, + f = i.g / 255, + j = i.b / 255, + k = Math.max(a, f, j), + d = Math.min(a, f, j), + c = k - d, + e, m = 0, + l = k; + if (d != k) { + m = l ? c / l : 0; + if (a === k) { + e = 60 * (f - j) / c + } else { + if (f === k) { + e = 60 * (j - a) / c + 120 + } else { + e = 60 * (a - f) / c + 240 + } + } + if (e < 0) { + e += 360 + } + if (e >= 360) { + e -= 360 + } + } + return [e, m, l] + }, + setHSL: function(g, f, e) { + var i = this, + d = Math.abs, + j, b, a; + g = (g % 360 + 360) % 360; + f = f > 1 ? 1 : f < 0 ? 0 : f; + e = e > 1 ? 1 : e < 0 ? 0 : e; + if (f === 0 || g === null) { + e *= 255; + i.setRGB(e, e, e) + } else { + g /= 60; + j = f * (1 - d(2 * e - 1)); + b = j * (1 - d(g % 2 - 1)); + a = e - j / 2; + a *= 255; + j *= 255; + b *= 255; + switch (Math.floor(g)) { + case 0: + i.setRGB(j + a, b + a, a); + break; + case 1: + i.setRGB(b + a, j + a, a); + break; + case 2: + i.setRGB(a, j + a, b + a); + break; + case 3: + i.setRGB(a, b + a, j + a); + break; + case 4: + i.setRGB(b + a, a, j + a); + break; + case 5: + i.setRGB(j + a, a, b + a); + break + } + } + return i + }, + setHSV: function(f, e, d) { + var g = this, + i, b, a; + f = (f % 360 + 360) % 360; + e = e > 1 ? 1 : e < 0 ? 0 : e; + d = d > 1 ? 1 : d < 0 ? 0 : d; + if (e === 0 || f === null) { + d *= 255; + g.setRGB(d, d, d) + } else { + f /= 60; + i = d * e; + b = i * (1 - Math.abs(f % 2 - 1)); + a = d - i; + a *= 255; + i *= 255; + b *= 255; + switch (Math.floor(f)) { + case 0: + g.setRGB(i + a, b + a, a); + break; + case 1: + g.setRGB(b + a, i + a, a); + break; + case 2: + g.setRGB(a, i + a, b + a); + break; + case 3: + g.setRGB(a, b + a, i + a); + break; + case 4: + g.setRGB(b + a, a, i + a); + break; + case 5: + g.setRGB(i + a, a, b + a); + break + } + } + return g + }, + createLighter: function(b) { + if (!b && b !== 0) { + b = this.lightnessFactor + } + var a = this.getHSL(); + a[2] = Ext.Number.constrain(a[2] + b, 0, 1); + return Ext.draw.Color.fromHSL(a[0], a[1], a[2]) + }, + createDarker: function(a) { + if (!a && a !== 0) { + a = this.lightnessFactor + } + return this.createLighter(-a) + }, + toString: function() { + var f = this, + c = Math.round; + if (f.a === 1) { + var e = c(f.r).toString(16), + d = c(f.g).toString(16), + a = c(f.b).toString(16); + e = (e.length === 1) ? "0" + e : e; + d = (d.length === 1) ? "0" + d : d; + a = (a.length === 1) ? "0" + a : a; + return ["#", e, d, a].join("") + } else { + return "rgba(" + [c(f.r), c(f.g), c(f.b), f.a === 0 ? 0 : f.a.toFixed(15)].join(", ") + ")" + } + }, + toHex: function(b) { + if (Ext.isArray(b)) { + b = b[0] + } + if (!Ext.isString(b)) { + return "" + } + if (b.substr(0, 1) === "#") { + return b + } + var e = Ext.draw.Color.colorToHexRe.exec(b); + if (Ext.isArray(e)) { + var f = parseInt(e[2], 10), + d = parseInt(e[3], 10), + a = parseInt(e[4], 10), + c = a | (d << 8) | (f << 16); + return e[1] + "#" + ("000000" + c.toString(16)).slice(-6) + } else { + return "" + } + }, + setFromString: function(j) { + var e, h, f, c, d = 1, + i = parseInt; + if (j === Ext.draw.Color.NONE) { + this.r = this.g = this.b = this.a = 0; + return this + } + if ((j.length === 4 || j.length === 7) && j.substr(0, 1) === "#") { + e = j.match(Ext.draw.Color.hexRe); + if (e) { + h = i(e[1], 16) >> 0; + f = i(e[2], 16) >> 0; + c = i(e[3], 16) >> 0; + if (j.length === 4) { + h += (h * 16); + f += (f * 16); + c += (c * 16) + } + } + } else { + if ((e = j.match(Ext.draw.Color.rgbToHexRe))) { + h = +e[1]; + f = +e[2]; + c = +e[3] + } else { + if ((e = j.match(Ext.draw.Color.rgbaToHexRe))) { + h = +e[1]; + f = +e[2]; + c = +e[3]; + d = +e[4] + } else { + if (Ext.draw.Color.ColorList.hasOwnProperty(j.toLowerCase())) { + return this.setFromString(Ext.draw.Color.ColorList[j.toLowerCase()]) + } + } + } + } + if (typeof h === "undefined") { + return this + } + this.r = h; + this.g = f; + this.b = c; + this.a = d; + return this + } +}, function() { + var a = new this(); + this.addStatics({ + fly: function(f, e, c, d) { + switch (arguments.length) { + case 1: + a.setFromString(f); + break; + case 3: + case 4: + a.setRGB(f, e, c, d); + break; + default: + return null + } + return a + }, + ColorList: { + aliceblue: "#f0f8ff", + antiquewhite: "#faebd7", + aqua: "#00ffff", + aquamarine: "#7fffd4", + azure: "#f0ffff", + beige: "#f5f5dc", + bisque: "#ffe4c4", + black: "#000000", + blanchedalmond: "#ffebcd", + blue: "#0000ff", + blueviolet: "#8a2be2", + brown: "#a52a2a", + burlywood: "#deb887", + cadetblue: "#5f9ea0", + chartreuse: "#7fff00", + chocolate: "#d2691e", + coral: "#ff7f50", + cornflowerblue: "#6495ed", + cornsilk: "#fff8dc", + crimson: "#dc143c", + cyan: "#00ffff", + darkblue: "#00008b", + darkcyan: "#008b8b", + darkgoldenrod: "#b8860b", + darkgray: "#a9a9a9", + darkgreen: "#006400", + darkkhaki: "#bdb76b", + darkmagenta: "#8b008b", + darkolivegreen: "#556b2f", + darkorange: "#ff8c00", + darkorchid: "#9932cc", + darkred: "#8b0000", + darksalmon: "#e9967a", + darkseagreen: "#8fbc8f", + darkslateblue: "#483d8b", + darkslategray: "#2f4f4f", + darkturquoise: "#00ced1", + darkviolet: "#9400d3", + deeppink: "#ff1493", + deepskyblue: "#00bfff", + dimgray: "#696969", + dodgerblue: "#1e90ff", + firebrick: "#b22222", + floralwhite: "#fffaf0", + forestgreen: "#228b22", + fuchsia: "#ff00ff", + gainsboro: "#dcdcdc", + ghostwhite: "#f8f8ff", + gold: "#ffd700", + goldenrod: "#daa520", + gray: "#808080", + green: "#008000", + greenyellow: "#adff2f", + honeydew: "#f0fff0", + hotpink: "#ff69b4", + indianred: "#cd5c5c", + indigo: "#4b0082", + ivory: "#fffff0", + khaki: "#f0e68c", + lavender: "#e6e6fa", + lavenderblush: "#fff0f5", + lawngreen: "#7cfc00", + lemonchiffon: "#fffacd", + lightblue: "#add8e6", + lightcoral: "#f08080", + lightcyan: "#e0ffff", + lightgoldenrodyellow: "#fafad2", + lightgray: "#d3d3d3", + lightgrey: "#d3d3d3", + lightgreen: "#90ee90", + lightpink: "#ffb6c1", + lightsalmon: "#ffa07a", + lightseagreen: "#20b2aa", + lightskyblue: "#87cefa", + lightslategray: "#778899", + lightsteelblue: "#b0c4de", + lightyellow: "#ffffe0", + lime: "#00ff00", + limegreen: "#32cd32", + linen: "#faf0e6", + magenta: "#ff00ff", + maroon: "#800000", + mediumaquamarine: "#66cdaa", + mediumblue: "#0000cd", + mediumorchid: "#ba55d3", + mediumpurple: "#9370d8", + mediumseagreen: "#3cb371", + mediumslateblue: "#7b68ee", + mediumspringgreen: "#00fa9a", + mediumturquoise: "#48d1cc", + mediumvioletred: "#c71585", + midnightblue: "#191970", + mintcream: "#f5fffa", + mistyrose: "#ffe4e1", + moccasin: "#ffe4b5", + navajowhite: "#ffdead", + navy: "#000080", + oldlace: "#fdf5e6", + olive: "#808000", + olivedrab: "#6b8e23", + orange: "#ffa500", + orangered: "#ff4500", + orchid: "#da70d6", + palegoldenrod: "#eee8aa", + palegreen: "#98fb98", + paleturquoise: "#afeeee", + palevioletred: "#d87093", + papayawhip: "#ffefd5", + peachpuff: "#ffdab9", + peru: "#cd853f", + pink: "#ffc0cb", + plum: "#dda0dd", + powderblue: "#b0e0e6", + purple: "#800080", + red: "#ff0000", + rosybrown: "#bc8f8f", + royalblue: "#4169e1", + saddlebrown: "#8b4513", + salmon: "#fa8072", + sandybrown: "#f4a460", + seagreen: "#2e8b57", + seashell: "#fff5ee", + sienna: "#a0522d", + silver: "#c0c0c0", + skyblue: "#87ceeb", + slateblue: "#6a5acd", + slategray: "#708090", + snow: "#fffafa", + springgreen: "#00ff7f", + steelblue: "#4682b4", + tan: "#d2b48c", + teal: "#008080", + thistle: "#d8bfd8", + tomato: "#ff6347", + turquoise: "#40e0d0", + violet: "#ee82ee", + wheat: "#f5deb3", + white: "#ffffff", + whitesmoke: "#f5f5f5", + yellow: "#ffff00", + yellowgreen: "#9acd32" + }, + fromHSL: function(d, c, b) { + return (new this(0, 0, 0, 0)).setHSL(d, c, b) + }, + fromHSV: function(d, c, b) { + return (new this(0, 0, 0, 0)).setHSL(d, c, b) + }, + fromString: function(b) { + return (new this(0, 0, 0, 0)).setFromString(b) + }, + create: function(b) { + if (b instanceof this) { + return b + } else { + if (Ext.isArray(b)) { + return new Ext.draw.Color(b[0], b[1], b[2], b[3]) + } else { + if (Ext.isString(b)) { + return Ext.draw.Color.fromString(b) + } else { + if (arguments.length > 2) { + return new Ext.draw.Color(arguments[0], arguments[1], arguments[2], arguments[3]) + } else { + return new Ext.draw.Color(0, 0, 0, 0) + } + } + } + } + } + }) +}); +Ext.define("Ext.draw.sprite.AnimationParser", function() { + function a(d, c, b) { + return d + (c - d) * b + } + return { + singleton: true, + attributeRe: /^url\(#([a-zA-Z\-]+)\)$/, + requires: ["Ext.draw.Color"], + color: { + parseInitial: function(c, b) { + if (Ext.isString(c)) { + c = Ext.draw.Color.create(c) + } + if (Ext.isString(b)) { + b = Ext.draw.Color.create(b) + } + if ((c instanceof Ext.draw.Color) && (b instanceof Ext.draw.Color)) { + return [ + [c.r, c.g, c.b, c.a], + [b.r, b.g, b.b, b.a] + ] + } else { + return [c || b, b || c] + } + }, + compute: function(d, c, b) { + if (!Ext.isArray(d) || !Ext.isArray(c)) { + return c || d + } else { + return [a(d[0], c[0], b), a(d[1], c[1], b), a(d[2], c[2], b), a(d[3], c[3], b)] + } + }, + serve: function(c) { + var b = Ext.draw.Color.fly(c[0], c[1], c[2], c[3]); + return b.toString() + } + }, + number: { + parse: function(b) { + return b === null ? null : +b + }, + compute: function(d, c, b) { + if (!Ext.isNumber(d) || !Ext.isNumber(c)) { + return c || d + } else { + return a(d, c, b) + } + } + }, + angle: { + parseInitial: function(c, b) { + if (b - c > Math.PI) { + b -= Math.PI * 2 + } else { + if (b - c < -Math.PI) { + b += Math.PI * 2 + } + } + return [c, b] + }, + compute: function(d, c, b) { + if (!Ext.isNumber(d) || !Ext.isNumber(c)) { + return c || d + } else { + return a(d, c, b) + } + } + }, + path: { + parseInitial: function(m, n) { + var c = m.toStripes(), + o = n.toStripes(), + e, d, k = c.length, + p = o.length, + h, f, b, g = o[p - 1], + l = [g[g.length - 2], g[g.length - 1]]; + for (e = k; e < p; e++) { + c.push(c[k - 1].slice(0)) + } + for (e = p; e < k; e++) { + o.push(l.slice(0)) + } + b = c.length; + o.path = n; + o.temp = new Ext.draw.Path(); + for (e = 0; e < b; e++) { + h = c[e]; + f = o[e]; + k = h.length; + p = f.length; + o.temp.commands.push("M"); + for (d = p; d < k; d += 6) { + f.push(l[0], l[1], l[0], l[1], l[0], l[1]) + } + g = o[o.length - 1]; + l = [g[g.length - 2], g[g.length - 1]]; + for (d = k; d < p; d += 6) { + h.push(l[0], l[1], l[0], l[1], l[0], l[1]) + } + for (e = 0; e < f.length; e++) { + f[e] -= h[e] + } + for (e = 2; e < f.length; e += 6) { + o.temp.commands.push("C") + } + } + return [c, o] + }, + compute: function(c, l, m) { + if (m >= 1) { + return l.path + } + var e = 0, + f = c.length, + d = 0, + b, k, h, n = l.temp.params, + g = 0; + for (; e < f; e++) { + k = c[e]; + h = l[e]; + b = k.length; + for (d = 0; d < b; d++) { + n[g++] = h[d] * m + k[d] + } + } + return l.temp + } + }, + data: { + compute: function(h, j, k, g) { + var m = h.length - 1, + b = j.length - 1, + e = Math.max(m, b), + d, l, c; + if (!g || g === h) { + g = [] + } + g.length = e + 1; + for (c = 0; c <= e; c++) { + d = h[Math.min(c, m)]; + l = j[Math.min(c, b)]; + if (Ext.isNumber(d)) { + if (!Ext.isNumber(l)) { + l = 0 + } + g[c] = (l - d) * k + d + } else { + g[c] = l + } + } + return g + } + }, + text: { + compute: function(d, c, b) { + return d.substr(0, Math.round(d.length * (1 - b))) + c.substr(Math.round(c.length * (1 - b))) + } + }, + limited: "number", + limited01: "number" + } +}); +(function() { + if (!Ext.global.Float32Array) { + var a = function(d) { + if (typeof d === "number") { + this.length = d + } else { + if ("length" in d) { + this.length = d.length; + for (var c = 0, b = d.length; c < b; c++) { + this[c] = +d[c] + } + } + } + }; + a.prototype = []; + Ext.global.Float32Array = a + } +})(); +Ext.define("Ext.draw.Draw", { + singleton: true, + radian: Math.PI / 180, + pi2: Math.PI * 2, + reflectFn: function(b) { + return b + }, + rad: function(a) { + return (a % 360) * this.radian + }, + degrees: function(a) { + return (a / this.radian) % 360 + }, + isBBoxIntersect: function(b, a, c) { + c = c || 0; + return (Math.max(b.x, a.x) - c > Math.min(b.x + b.width, a.x + a.width)) || (Math.max(b.y, a.y) - c > Math.min(b.y + b.height, a.y + a.height)) + }, + isPointInBBox: function(a, c, b) { + return !!b && a >= b.x && a <= (b.x + b.width) && c >= b.y && c <= (b.y + b.height) + }, + spline: function(m) { + var e, c, k = m.length, + b, h, l, f, a = 0, + g = new Float32Array(m.length), + n = new Float32Array(m.length * 3 - 2); + g[0] = 0; + g[k - 1] = 0; + for (e = 1; e < k - 1; e++) { + g[e] = (m[e + 1] + m[e - 1] - 2 * m[e]) - g[e - 1]; + a = 1 / (4 - a); + g[e] *= a + } + for (e = k - 2; e > 0; e--) { + a = 3.732050807568877 + 48.248711305964385 / (-13.928203230275537 + Math.pow(0.07179676972449123, e)); + g[e] -= g[e + 1] * a + } + f = m[0]; + b = f - g[0]; + for (e = 0, c = 0; e < k - 1; c += 3) { + l = f; + h = b; + e++; + f = m[e]; + b = f - g[e]; + n[c] = l; + n[c + 1] = (b + 2 * h) / 3; + n[c + 2] = (b * 2 + h) / 3 + } + n[c] = f; + return n + }, + getAnchors: function(e, d, i, h, t, s, o) { + o = o || 4; + var n = Math.PI, + p = n / 2, + k = Math.abs, + a = Math.sin, + b = Math.cos, + f = Math.atan, + r, q, g, j, m, l, v, u, c; + r = (i - e) / o; + q = (t - i) / o; + if ((h >= d && h >= s) || (h <= d && h <= s)) { + g = j = p + } else { + g = f((i - e) / k(h - d)); + if (d < h) { + g = n - g + } + j = f((t - i) / k(h - s)); + if (s < h) { + j = n - j + } + } + c = p - ((g + j) % (n * 2)) / 2; + if (c > p) { + c -= n + } + g += c; + j += c; + m = i - r * a(g); + l = h + r * b(g); + v = i + q * a(j); + u = h + q * b(j); + if ((h > d && l < d) || (h < d && l > d)) { + m += k(d - l) * (m - i) / (l - h); + l = d + } + if ((h > s && u < s) || (h < s && u > s)) { + v -= k(s - u) * (v - i) / (u - h); + u = s + } + return { + x1: m, + y1: l, + x2: v, + y2: u + } + }, + smooth: function(l, j, o) { + var k = l.length, + h, g, c, b, q, p, n, m, f = [], + e = [], + d, a; + for (d = 0; d < k - 1; d++) { + h = l[d]; + g = j[d]; + if (d === 0) { + n = h; + m = g; + f.push(n); + e.push(m); + if (k === 1) { + break + } + } + c = l[d + 1]; + b = j[d + 1]; + q = l[d + 2]; + p = j[d + 2]; + if (!Ext.isNumber(q + p)) { + f.push(n, c, c); + e.push(m, b, b); + break + } + a = this.getAnchors(h, g, c, b, q, p, o); + f.push(n, a.x1, c); + e.push(m, a.y1, b); + n = a.x2; + m = a.y2 + } + return { + smoothX: f, + smoothY: e + } + }, + beginUpdateIOS: Ext.os.is.iOS ? function() { + this.iosUpdateEl = Ext.getBody().createChild({ + style: "position: absolute; top: 0px; bottom: 0px; left: 0px; right: 0px; background: rgba(0,0,0,0.001); z-index: 100000" + }) + } : Ext.emptyFn, + endUpdateIOS: function() { + this.iosUpdateEl = Ext.destroy(this.iosUpdateEl) + } +}); +Ext.define("Ext.draw.gradient.Gradient", { + requires: ["Ext.draw.Color"], + isGradient: true, + config: { + stops: [] + }, + applyStops: function(f) { + var e = [], + d = f.length, + c, b, a; + for (c = 0; c < d; c++) { + b = f[c]; + a = b.color; + if (!(a && a.isColor)) { + a = Ext.draw.Color.fly(a || Ext.draw.Color.NONE) + } + e.push({ + offset: Math.min(1, Math.max(0, "offset" in b ? b.offset : b.position || 0)), + color: a.toString() + }) + } + e.sort(function(h, g) { + return h.offset - g.offset + }); + return e + }, + onClassExtended: function(a, b) { + if (!b.alias && b.type) { + b.alias = "gradient." + b.type + } + }, + constructor: function(a) { + this.initConfig(a) + }, + generateGradient: Ext.emptyFn +}); +Ext.define("Ext.draw.gradient.GradientDefinition", { + singleton: true, + urlStringRe: /^url\(#([\w\-]+)\)$/, + gradients: {}, + add: function(a) { + var b = this.gradients, + c, e, d; + for (c = 0, e = a.length; c < e; c++) { + d = a[c]; + if (Ext.isString(d.id)) { + b[d.id] = d + } + } + }, + get: function(d) { + var a = this.gradients, + b = d.match(this.urlStringRe), + c; + if (b && b[1] && (c = a[b[1]])) { + return c || d + } + return d + } +}); +Ext.define("Ext.draw.sprite.AttributeParser", { + singleton: true, + attributeRe: /^url\(#([a-zA-Z\-]+)\)$/, + requires: ["Ext.draw.Color", "Ext.draw.gradient.GradientDefinition"], + "default": Ext.identityFn, + string: function(a) { + return String(a) + }, + number: function(a) { + if (Ext.isNumber(+a)) { + return a + } + }, + angle: function(a) { + if (Ext.isNumber(a)) { + a %= Math.PI * 2; + if (a < -Math.PI) { + a += Math.PI * 2 + } else { + if (a >= Math.PI) { + a -= Math.PI * 2 + } + } + return a + } + }, + data: function(a) { + if (Ext.isArray(a)) { + return a.slice() + } else { + if (a instanceof Float32Array) { + return new Float32Array(a) + } + } + }, + bool: function(a) { + return !!a + }, + color: function(a) { + if (a instanceof Ext.draw.Color) { + return a.toString() + } else { + if (a instanceof Ext.draw.gradient.Gradient) { + return a + } else { + if (!a) { + return Ext.draw.Color.NONE + } else { + if (Ext.isString(a)) { + if (a.substr(0, 3) === "url") { + a = Ext.draw.gradient.GradientDefinition.get(a); + if (Ext.isString(a)) { + return a + } + } else { + return Ext.draw.Color.fly(a).toString() + } + } + } + } + } + if (a.type === "linear") { + return Ext.create("Ext.draw.gradient.Linear", a) + } else { + if (a.type === "radial") { + return Ext.create("Ext.draw.gradient.Radial", a) + } else { + if (a.type === "pattern") { + return Ext.create("Ext.draw.gradient.Pattern", a) + } else { + return Ext.draw.Color.NONE + } + } + } + }, + limited: function(a, b) { + return function(c) { + c = +c; + return Ext.isNumber(c) ? Math.min(Math.max(c, a), b) : undefined + } + }, + limited01: function(a) { + a = +a; + return Ext.isNumber(a) ? Math.min(Math.max(a, 0), 1) : undefined + }, + enums: function() { + var d = {}, + a = Array.prototype.slice.call(arguments, 0), + b, c; + for (b = 0, c = a.length; b < c; b++) { + d[a[b]] = true + } + return function(e) { + return e in d ? e : undefined + } + } +}); +Ext.define("Ext.draw.sprite.AttributeDefinition", { + requires: ["Ext.draw.sprite.AttributeParser", "Ext.draw.sprite.AnimationParser"], + config: { + defaults: { + $value: {}, + lazy: true + }, + aliases: {}, + animationProcessors: {}, + processors: { + $value: {}, + lazy: true + }, + dirtyTriggers: {}, + triggers: {}, + updaters: {} + }, + inheritableStatics: { + processorFactoryRe: /^(\w+)\(([\w\-,]*)\)$/ + }, + spriteClass: null, + constructor: function(a) { + var b = this; + b.initConfig(a) + }, + applyDefaults: function(b, a) { + a = Ext.apply(a || {}, this.normalize(b)); + return a + }, + applyAliases: function(b, a) { + return Ext.apply(a || {}, b) + }, + applyProcessors: function(e, i) { + this.getAnimationProcessors(); + var j = i || {}, + h = Ext.draw.sprite.AttributeParser, + a = this.self.processorFactoryRe, + g = {}, + d, b, c, f; + for (b in e) { + f = e[b]; + if (typeof f === "string") { + c = f.match(a); + if (c) { + f = h[c[1]].apply(h, c[2].split(",")) + } else { + if (h[f]) { + g[b] = f; + d = true; + f = h[f] + } + } + } + j[b] = f + } + if (d) { + this.setAnimationProcessors(g) + } + return j + }, + applyAnimationProcessors: function(c, a) { + var e = Ext.draw.sprite.AnimationParser, + b, d; + if (!a) { + a = {} + } + for (b in c) { + d = c[b]; + if (d === "none") { + a[b] = null + } else { + if (Ext.isString(d) && !(b in a)) { + if (d in e) { + while (Ext.isString(e[d])) { + d = e[d] + } + a[b] = e[d] + } + } else { + if (Ext.isObject(d)) { + a[b] = d + } + } + } + } + return a + }, + updateDirtyTriggers: function(a) { + this.setTriggers(a) + }, + applyTriggers: function(b, c) { + if (!c) { + c = {} + } + for (var a in b) { + c[a] = b[a].split(",") + } + return c + }, + applyUpdaters: function(b, a) { + return Ext.apply(a || {}, b) + }, + batchedNormalize: function(f, n) { + if (!f) { + return {} + } + var j = this.getProcessors(), + d = this.getAliases(), + a = f.translation || f.translate, + o = {}, + g, h, b, e, p, c, m, l, k; + if ("rotation" in f) { + p = f.rotation + } else { + p = ("rotate" in f) ? f.rotate : undefined + } + if ("scaling" in f) { + c = f.scaling + } else { + c = ("scale" in f) ? f.scale : undefined + } + if (typeof c !== "undefined") { + if (Ext.isNumber(c)) { + o.scalingX = c; + o.scalingY = c + } else { + if ("x" in c) { + o.scalingX = c.x + } + if ("y" in c) { + o.scalingY = c.y + } + if ("centerX" in c) { + o.scalingCenterX = c.centerX + } + if ("centerY" in c) { + o.scalingCenterY = c.centerY + } + } + } + if (typeof p !== "undefined") { + if (Ext.isNumber(p)) { + p = Ext.draw.Draw.rad(p); + o.rotationRads = p + } else { + if ("rads" in p) { + o.rotationRads = p.rads + } else { + if ("degrees" in p) { + if (Ext.isArray(p.degrees)) { + o.rotationRads = Ext.Array.map(p.degrees, function(i) { + return Ext.draw.Draw.rad(i) + }) + } else { + o.rotationRads = Ext.draw.Draw.rad(p.degrees) + } + } + } + if ("centerX" in p) { + o.rotationCenterX = p.centerX + } + if ("centerY" in p) { + o.rotationCenterY = p.centerY + } + } + } + if (typeof a !== "undefined") { + if ("x" in a) { + o.translationX = a.x + } + if ("y" in a) { + o.translationY = a.y + } + } + if ("matrix" in f) { + m = Ext.draw.Matrix.create(f.matrix); + k = m.split(); + o.matrix = m; + o.rotationRads = k.rotation; + o.rotationCenterX = 0; + o.rotationCenterY = 0; + o.scalingX = k.scaleX; + o.scalingY = k.scaleY; + o.scalingCenterX = 0; + o.scalingCenterY = 0; + o.translationX = k.translateX; + o.translationY = k.translateY + } + for (b in f) { + e = f[b]; + if (typeof e === "undefined") { + continue + } else { + if (Ext.isArray(e)) { + if (b in d) { + b = d[b] + } + if (b in j) { + o[b] = []; + for (g = 0, h = e.length; g < h; g++) { + l = j[b].call(this, e[g]); + if (typeof l !== "undefined") { + o[b][g] = l + } + } + } else { + if (n) { + o[b] = e + } + } + } else { + if (b in d) { + b = d[b] + } + if (b in j) { + e = j[b].call(this, e); + if (typeof e !== "undefined") { + o[b] = e + } + } else { + if (n) { + o[b] = e + } + } + } + } + } + return o + }, + normalize: function(i, j) { + if (!i) { + return {} + } + var f = this.getProcessors(), + d = this.getAliases(), + a = i.translation || i.translate, + k = {}, + b, e, l, c, h, g; + if ("rotation" in i) { + l = i.rotation + } else { + l = ("rotate" in i) ? i.rotate : undefined + } + if ("scaling" in i) { + c = i.scaling + } else { + c = ("scale" in i) ? i.scale : undefined + } + if (a) { + if ("x" in a) { + k.translationX = a.x + } + if ("y" in a) { + k.translationY = a.y + } + } + if (typeof c !== "undefined") { + if (Ext.isNumber(c)) { + k.scalingX = c; + k.scalingY = c + } else { + if ("x" in c) { + k.scalingX = c.x + } + if ("y" in c) { + k.scalingY = c.y + } + if ("centerX" in c) { + k.scalingCenterX = c.centerX + } + if ("centerY" in c) { + k.scalingCenterY = c.centerY + } + } + } + if (typeof l !== "undefined") { + if (Ext.isNumber(l)) { + l = Ext.draw.Draw.rad(l); + k.rotationRads = l + } else { + if ("rads" in l) { + k.rotationRads = l.rads + } else { + if ("degrees" in l) { + k.rotationRads = Ext.draw.Draw.rad(l.degrees) + } + } + if ("centerX" in l) { + k.rotationCenterX = l.centerX + } + if ("centerY" in l) { + k.rotationCenterY = l.centerY + } + } + } + if ("matrix" in i) { + h = Ext.draw.Matrix.create(i.matrix); + g = h.split(); + k.matrix = h; + k.rotationRads = g.rotation; + k.rotationCenterX = 0; + k.rotationCenterY = 0; + k.scalingX = g.scaleX; + k.scalingY = g.scaleY; + k.scalingCenterX = 0; + k.scalingCenterY = 0; + k.translationX = g.translateX; + k.translationY = g.translateY + } + for (b in i) { + e = i[b]; + if (typeof e === "undefined") { + continue + } + if (b in d) { + b = d[b] + } + if (b in f) { + e = f[b].call(this, e); + if (typeof e !== "undefined") { + k[b] = e + } + } else { + if (j) { + k[b] = e + } + } + } + return k + }, + setBypassingNormalization: function(a, c, b) { + return c.pushDown(a, b) + }, + set: function(a, c, b) { + b = this.normalize(b); + return this.setBypassingNormalization(a, c, b) + } +}); +Ext.define("Ext.draw.Matrix", { + isMatrix: true, + statics: { + createAffineMatrixFromTwoPair: function(h, t, g, s, k, o, i, j) { + var v = g - h, + u = s - t, + e = i - k, + q = j - o, + d = 1 / (v * v + u * u), + p = v * e + u * q, + n = e * u - v * q, + m = -p * h - n * t, + l = n * h - p * t; + return new this(p * d, -n * d, n * d, p * d, m * d + k, l * d + o) + }, + createPanZoomFromTwoPair: function(q, e, p, c, h, s, n, g) { + if (arguments.length === 2) { + return this.createPanZoomFromTwoPair.apply(this, q.concat(e)) + } + var k = p - q, + j = c - e, + d = (q + p) * 0.5, + b = (e + c) * 0.5, + o = n - h, + a = g - s, + f = (h + n) * 0.5, + l = (s + g) * 0.5, + m = k * k + j * j, + i = o * o + a * a, + t = Math.sqrt(i / m); + return new this(t, 0, 0, t, f - t * d, l - t * b) + }, + fly: (function() { + var a = null, + b = function(c) { + a.elements = c; + return a + }; + return function(c) { + if (!a) { + a = new Ext.draw.Matrix() + } + a.elements = c; + Ext.draw.Matrix.fly = b; + return a + } + })(), + create: function(a) { + if (a instanceof this) { + return a + } + return new this(a) + } + }, + constructor: function(e, d, a, f, c, b) { + if (e && e.length === 6) { + this.elements = e.slice() + } else { + if (e !== undefined) { + this.elements = [e, d, a, f, c, b] + } else { + this.elements = [1, 0, 0, 1, 0, 0] + } + } + }, + prepend: function(a, l, h, g, m, k) { + var b = this.elements, + d = b[0], + j = b[1], + e = b[2], + c = b[3], + i = b[4], + f = b[5]; + b[0] = a * d + h * j; + b[1] = l * d + g * j; + b[2] = a * e + h * c; + b[3] = l * e + g * c; + b[4] = a * i + h * f + m; + b[5] = l * i + g * f + k; + return this + }, + prependMatrix: function(a) { + return this.prepend.apply(this, a.elements) + }, + append: function(a, l, h, g, m, k) { + var b = this.elements, + d = b[0], + j = b[1], + e = b[2], + c = b[3], + i = b[4], + f = b[5]; + b[0] = a * d + l * e; + b[1] = a * j + l * c; + b[2] = h * d + g * e; + b[3] = h * j + g * c; + b[4] = m * d + k * e + i; + b[5] = m * j + k * c + f; + return this + }, + appendMatrix: function(a) { + return this.append.apply(this, a.elements) + }, + set: function(f, e, a, g, c, b) { + var d = this.elements; + d[0] = f; + d[1] = e; + d[2] = a; + d[3] = g; + d[4] = c; + d[5] = b; + return this + }, + inverse: function(i) { + var g = this.elements, + o = g[0], + m = g[1], + l = g[2], + k = g[3], + j = g[4], + h = g[5], + n = 1 / (o * k - m * l); + o *= n; + m *= n; + l *= n; + k *= n; + if (i) { + i.set(k, -m, -l, o, l * h - k * j, m * j - o * h); + return i + } else { + return new Ext.draw.Matrix(k, -m, -l, o, l * h - k * j, m * j - o * h) + } + }, + translate: function(a, c, b) { + if (b) { + return this.prepend(1, 0, 0, 1, a, c) + } else { + return this.append(1, 0, 0, 1, a, c) + } + }, + scale: function(f, e, c, a, b) { + var d = this; + if (e == null) { + e = f + } + if (c === undefined) { + c = 0 + } + if (a === undefined) { + a = 0 + } + if (b) { + return d.prepend(f, 0, 0, e, c - c * f, a - a * e) + } else { + return d.append(f, 0, 0, e, c - c * f, a - a * e) + } + }, + rotate: function(g, e, c, b) { + var d = this, + f = Math.cos(g), + a = Math.sin(g); + e = e || 0; + c = c || 0; + if (b) { + return d.prepend(f, a, -a, f, e - f * e + c * a, c - f * c - e * a) + } else { + return d.append(f, a, -a, f, e - f * e + c * a, c - f * c - e * a) + } + }, + rotateFromVector: function(a, h, c) { + var e = this, + g = Math.sqrt(a * a + h * h), + f = a / g, + b = h / g; + if (c) { + return e.prepend(f, b, -b, f, 0, 0) + } else { + return e.append(f, b, -b, f, 0, 0) + } + }, + clone: function() { + return new Ext.draw.Matrix(this.elements) + }, + flipX: function() { + return this.append(-1, 0, 0, 1, 0, 0) + }, + flipY: function() { + return this.append(1, 0, 0, -1, 0, 0) + }, + skewX: function(a) { + return this.append(1, 0, Math.tan(a), 1, 0, 0) + }, + skewY: function(a) { + return this.append(1, Math.tan(a), 0, 1, 0, 0) + }, + shearX: function(a) { + return this.append(1, 0, a, 1, 0, 0) + }, + shearY: function(a) { + return this.append(1, a, 0, 1, 0, 0) + }, + reset: function() { + return this.set(1, 0, 0, 1, 0, 0) + }, + precisionCompensate: function(j, g) { + var c = this.elements, + f = c[0], + e = c[1], + i = c[2], + h = c[3], + d = c[4], + b = c[5], + a = e * i - f * h; + g.b = j * e / f; + g.c = j * i / h; + g.d = j; + g.xx = f / j; + g.yy = h / j; + g.dx = (b * f * i - d * f * h) / a / j; + g.dy = (d * e * h - b * f * h) / a / j + }, + precisionCompensateRect: function(j, g) { + var b = this.elements, + f = b[0], + e = b[1], + i = b[2], + h = b[3], + c = b[4], + a = b[5], + d = i / f; + g.b = j * e / f; + g.c = j * d; + g.d = j * h / f; + g.xx = f / j; + g.yy = f / j; + g.dx = (a * i - c * h) / (e * d - h) / j; + g.dy = -(a * f - c * e) / (e * d - h) / j + }, + x: function(a, c) { + var b = this.elements; + return a * b[0] + c * b[2] + b[4] + }, + y: function(a, c) { + var b = this.elements; + return a * b[1] + c * b[3] + b[5] + }, + get: function(b, a) { + return +this.elements[b + a * 2].toFixed(4) + }, + transformPoint: function(b) { + var c = this.elements, + a, d; + if (b.isPoint) { + a = b.x; + d = b.y + } else { + a = b[0]; + d = b[1] + } + return [a * c[0] + d * c[2] + c[4], a * c[1] + d * c[3] + c[5]] + }, + transformBBox: function(q, i, j) { + var b = this.elements, + d = q.x, + r = q.y, + g = q.width * 0.5, + o = q.height * 0.5, + a = b[0], + s = b[1], + n = b[2], + k = b[3], + e = d + g, + c = r + o, + p, f, m; + if (i) { + g -= i; + o -= i; + m = [Math.sqrt(b[0] * b[0] + b[2] * b[2]), Math.sqrt(b[1] * b[1] + b[3] * b[3])]; + p = Math.abs(g * a) + Math.abs(o * n) + Math.abs(m[0] * i); + f = Math.abs(g * s) + Math.abs(o * k) + Math.abs(m[1] * i) + } else { + p = Math.abs(g * a) + Math.abs(o * n); + f = Math.abs(g * s) + Math.abs(o * k) + } + if (!j) { + j = {} + } + j.x = e * a + c * n + b[4] - p; + j.y = e * s + c * k + b[5] - f; + j.width = p + p; + j.height = f + f; + return j + }, + transformList: function(e) { + var b = this.elements, + a = b[0], + h = b[2], + l = b[4], + k = b[1], + g = b[3], + j = b[5], + f = e.length, + c, d; + for (d = 0; d < f; d++) { + c = e[d]; + e[d] = [c[0] * a + c[1] * h + l, c[0] * k + c[1] * g + j] + } + return e + }, + isIdentity: function() { + var a = this.elements; + return a[0] === 1 && a[1] === 0 && a[2] === 0 && a[3] === 1 && a[4] === 0 && a[5] === 0 + }, + isEqual: function(a) { + var c = a && a.isMatrix ? a.elements : a, + b = this.elements; + return b[0] === c[0] && b[1] === c[1] && b[2] === c[2] && b[3] === c[3] && b[4] === c[4] && b[5] === c[5] + }, + equals: function(a) { + return this.isEqual(a) + }, + toArray: function() { + var a = this.elements; + return [a[0], a[2], a[4], a[1], a[3], a[5]] + }, + toVerticalArray: function() { + return this.elements.slice() + }, + toString: function() { + var a = this; + return [a.get(0, 0), a.get(0, 1), a.get(1, 0), a.get(1, 1), a.get(2, 0), a.get(2, 1)].join(",") + }, + toContext: function(a) { + a.transform.apply(a, this.elements); + return this + }, + toSvg: function() { + var a = this.elements; + return "matrix(" + a[0].toFixed(9) + "," + a[1].toFixed(9) + "," + a[2].toFixed(9) + "," + a[3].toFixed(9) + "," + a[4].toFixed(9) + "," + a[5].toFixed(9) + ")" + }, + getScaleX: function() { + var a = this.elements; + return Math.sqrt(a[0] * a[0] + a[2] * a[2]) + }, + getScaleY: function() { + var a = this.elements; + return Math.sqrt(a[1] * a[1] + a[3] * a[3]) + }, + getXX: function() { + return this.elements[0] + }, + getXY: function() { + return this.elements[1] + }, + getYX: function() { + return this.elements[2] + }, + getYY: function() { + return this.elements[3] + }, + getDX: function() { + return this.elements[4] + }, + getDY: function() { + return this.elements[5] + }, + split: function() { + var b = this.elements, + d = b[0], + c = b[1], + e = b[3], + a = { + translateX: b[4], + translateY: b[5] + }; + a.rotate = a.rotation = Math.atan2(c, d); + a.scaleX = d / Math.cos(a.rotate); + a.scaleY = e / d * a.scaleX; + return a + } +}, function() { + function b(e, c, d) { + e[c] = { + get: function() { + return this.elements[d] + }, + set: function(f) { + this.elements[d] = f + } + } + } + if (Object.defineProperties) { + var a = {}; + b(a, "a", 0); + b(a, "b", 1); + b(a, "c", 2); + b(a, "d", 3); + b(a, "e", 4); + b(a, "f", 5); + Object.defineProperties(this.prototype, a) + } + this.prototype.multiply = this.prototype.appendMatrix +}); +Ext.define("Ext.draw.modifier.Modifier", { + mixins: { + observable: "Ext.mixin.Observable" + }, + config: { + previous: null, + next: null, + sprite: null + }, + constructor: function(a) { + this.mixins.observable.constructor.call(this, a) + }, + updateNext: function(a) { + if (a) { + a.setPrevious(this) + } + }, + updatePrevious: function(a) { + if (a) { + a.setNext(this) + } + }, + prepareAttributes: function(a) { + if (this._previous) { + this._previous.prepareAttributes(a) + } + }, + popUp: function(a, b) { + if (this._next) { + this._next.popUp(a, b) + } else { + Ext.apply(a, b) + } + }, + pushDown: function(a, c) { + if (this._previous) { + return this._previous.pushDown(a, c) + } else { + for (var b in c) { + if (c[b] === a[b]) { + delete c[b] + } + } + return c + } + } +}); +Ext.define("Ext.draw.modifier.Target", { + requires: ["Ext.draw.Matrix"], + extend: "Ext.draw.modifier.Modifier", + alias: "modifier.target", + statics: { + uniqueId: 0 + }, + prepareAttributes: function(a) { + var b = this.getPrevious(); + if (b) { + b.prepareAttributes(a) + } + a.attributeId = "attribute-" + Ext.draw.modifier.Target.uniqueId++; + if (!a.hasOwnProperty("canvasAttributes")) { + a.bbox = { + plain: { + dirty: true + }, + transform: { + dirty: true + } + }; + a.dirty = true; + a.pendingUpdaters = {}; + a.canvasAttributes = {}; + a.matrix = new Ext.draw.Matrix(); + a.inverseMatrix = new Ext.draw.Matrix() + } + }, + applyChanges: function(f, k) { + Ext.apply(f, k); + var l = this.getSprite(), + o = f.pendingUpdaters, + h = l.self.def.getTriggers(), + p, a, m, b, e, n, d, c, g; + for (b in k) { + e = true; + if ((p = h[b])) { + l.scheduleUpdaters(f, p, [b]) + } + if (f.template && k.removeFromInstance && k.removeFromInstance[b]) { + delete f[b] + } + } + if (!e) { + return + } + if (o.canvas) { + n = o.canvas; + delete o.canvas; + for (d = 0, g = n.length; d < g; d++) { + b = n[d]; + f.canvasAttributes[b] = f[b] + } + } + if (f.hasOwnProperty("children")) { + a = f.children; + for (d = 0, g = a.length; d < g; d++) { + m = a[d]; + Ext.apply(m.pendingUpdaters, o); + if (n) { + for (c = 0; c < n.length; c++) { + b = n[c]; + m.canvasAttributes[b] = m[b] + } + } + l.callUpdaters(m) + } + } + l.setDirty(true); + l.callUpdaters(f) + }, + popUp: function(a, b) { + this.applyChanges(a, b) + }, + pushDown: function(a, b) { + var c = this.getPrevious(); + if (c) { + b = c.pushDown(a, b) + } + this.applyChanges(a, b); + return b + } +}); +Ext.define("Ext.draw.TimingFunctions", function() { + var g = Math.pow, + j = Math.sin, + m = Math.cos, + l = Math.sqrt, + e = Math.PI, + b = ["quad", "cube", "quart", "quint"], + c = { + pow: function(o, i) { + return g(o, i || 6) + }, + expo: function(i) { + return g(2, 8 * (i - 1)) + }, + circ: function(i) { + return 1 - l(1 - i * i) + }, + sine: function(i) { + return 1 - j((1 - i) * e / 2) + }, + back: function(i, o) { + o = o || 1.616; + return i * i * ((o + 1) * i - o) + }, + bounce: function(q) { + for (var o = 0, i = 1; 1; o += i, i /= 2) { + if (q >= (7 - 4 * o) / 11) { + return i * i - g((11 - 6 * o - 11 * q) / 4, 2) + } + } + }, + elastic: function(o, i) { + return g(2, 10 * --o) * m(20 * o * e * (i || 1) / 3) + } + }, + k = {}, + a, f, d; + + function h(i) { + return function(o) { + return g(o, i) + } + } + + function n(i, o) { + k[i + "In"] = function(p) { + return o(p) + }; + k[i + "Out"] = function(p) { + return 1 - o(1 - p) + }; + k[i + "InOut"] = function(p) { + return (p <= 0.5) ? o(2 * p) / 2 : (2 - o(2 * (1 - p))) / 2 + } + } + for (d = 0, f = b.length; d < f; ++d) { + c[b[d]] = h(d + 2) + } + for (a in c) { + n(a, c[a]) + } + k.linear = Ext.identityFn; + k.easeIn = k.quadIn; + k.easeOut = k.quadOut; + k.easeInOut = k.quadInOut; + return { + singleton: true, + easingMap: k + } +}, function(a) { + Ext.apply(a, a.easingMap) +}); +Ext.define("Ext.draw.Animator", { + uses: ["Ext.draw.Draw"], + singleton: true, + frameCallbacks: {}, + frameCallbackId: 0, + scheduled: 0, + frameStartTimeOffset: Ext.now(), + animations: [], + running: false, + animationTime: function() { + return Ext.AnimationQueue.frameStartTime - this.frameStartTimeOffset + }, + add: function(b) { + var a = this; + if (!a.contains(b)) { + a.animations.push(b); + a.ignite(); + if ("fireEvent" in b) { + b.fireEvent("animationstart", b) + } + } + }, + remove: function(d) { + var c = this, + e = c.animations, + b = 0, + a = e.length; + for (; b < a; ++b) { + if (e[b] === d) { + e.splice(b, 1); + if ("fireEvent" in d) { + d.fireEvent("animationend", d) + } + return + } + } + }, + contains: function(a) { + return Ext.Array.indexOf(this.animations, a) > -1 + }, + empty: function() { + return this.animations.length === 0 + }, + step: function(d) { + var c = this, + f = c.animations, + e, a = 0, + b = f.length; + for (; a < b; a++) { + e = f[a]; + e.step(d); + if (!e.animating) { + f.splice(a, 1); + a--; + b--; + if (e.fireEvent) { + e.fireEvent("animationend", e) + } + } + } + }, + schedule: function(c, a) { + a = a || this; + var b = "frameCallback" + (this.frameCallbackId++); + if (Ext.isString(c)) { + c = a[c] + } + Ext.draw.Animator.frameCallbacks[b] = { + fn: c, + scope: a, + once: true + }; + this.scheduled++; + Ext.draw.Animator.ignite(); + return b + }, + scheduleIf: function(e, b) { + b = b || this; + var c = Ext.draw.Animator.frameCallbacks, + a, d; + if (Ext.isString(e)) { + e = b[e] + } + for (d in c) { + a = c[d]; + if (a.once && a.fn === e && a.scope === b) { + return null + } + } + return this.schedule(e, b) + }, + cancel: function(a) { + if (Ext.draw.Animator.frameCallbacks[a] && Ext.draw.Animator.frameCallbacks[a].once) { + this.scheduled--; + delete Ext.draw.Animator.frameCallbacks[a] + } + }, + addFrameCallback: function(c, a) { + a = a || this; + if (Ext.isString(c)) { + c = a[c] + } + var b = "frameCallback" + (this.frameCallbackId++); + Ext.draw.Animator.frameCallbacks[b] = { + fn: c, + scope: a + }; + return b + }, + removeFrameCallback: function(a) { + delete Ext.draw.Animator.frameCallbacks[a] + }, + fireFrameCallbacks: function() { + var c = this.frameCallbacks, + d, b, a; + for (d in c) { + a = c[d]; + b = a.fn; + if (Ext.isString(b)) { + b = a.scope[b] + } + b.call(a.scope); + if (c[d] && a.once) { + this.scheduled--; + delete c[d] + } + } + }, + handleFrame: function() { + this.step(this.animationTime()); + this.fireFrameCallbacks(); + if (!this.scheduled && this.empty()) { + Ext.AnimationQueue.stop(this.handleFrame, this); + this.running = false; + Ext.draw.Draw.endUpdateIOS() + } + }, + ignite: function() { + if (!this.running) { + this.running = true; + Ext.AnimationQueue.start(this.handleFrame, this); + Ext.draw.Draw.beginUpdateIOS() + } + } +}); +Ext.define("Ext.draw.modifier.Animation", { + requires: ["Ext.draw.TimingFunctions", "Ext.draw.Animator"], + extend: "Ext.draw.modifier.Modifier", + alias: "modifier.animation", + config: { + easing: Ext.identityFn, + duration: 0, + customEasings: {}, + customDurations: {}, + customDuration: null + }, + constructor: function(a) { + var b = this; + b.anyAnimation = b.anySpecialAnimations = false; + b.animating = 0; + b.animatingPool = []; + b.callParent([a]) + }, + prepareAttributes: function(a) { + if (!a.hasOwnProperty("timers")) { + a.animating = false; + a.timers = {}; + a.animationOriginal = Ext.Object.chain(a); + a.animationOriginal.prototype = a + } + if (this._previous) { + this._previous.prepareAttributes(a.animationOriginal) + } + }, + updateSprite: function(a) { + this.setConfig(a.config.fx) + }, + updateDuration: function(a) { + this.anyAnimation = a > 0 + }, + applyEasing: function(a) { + if (typeof a === "string") { + a = Ext.draw.TimingFunctions.easingMap[a] + } + return a + }, + applyCustomEasings: function(a, e) { + e = e || {}; + var g, d, b, h, c, f; + for (d in a) { + g = true; + h = a[d]; + b = d.split(","); + if (typeof h === "string") { + h = Ext.draw.TimingFunctions.easingMap[h] + } + for (c = 0, f = b.length; c < f; c++) { + e[b[c]] = h + } + } + if (g) { + this.anySpecialAnimations = g + } + return e + }, + setEasingOn: function(a, e) { + a = Ext.Array.from(a).slice(); + var c = {}, + d = a.length, + b = 0; + for (; b < d; b++) { + c[a[b]] = e + } + this.setCustomEasings(c) + }, + clearEasingOn: function(a) { + a = Ext.Array.from(a, true); + var b = 0, + c = a.length; + for (; b < c; b++) { + delete this._customEasings[a[b]] + } + }, + applyCustomDurations: function(g, h) { + h = h || {}; + var e, c, f, a, b, d; + for (c in g) { + e = true; + f = g[c]; + a = c.split(","); + for (b = 0, d = a.length; b < d; b++) { + h[a[b]] = f + } + } + if (e) { + this.anySpecialAnimations = e + } + return h + }, + applyCustomDuration: function(a, b) { + if (a) { + this.getCustomDurations(); + this.setCustomDurations(a) + } + }, + setDurationOn: function(b, e) { + b = Ext.Array.from(b).slice(); + var a = {}, + c = 0, + d = b.length; + for (; c < d; c++) { + a[b[c]] = e + } + this.setCustomDurations(a) + }, + clearDurationOn: function(a) { + a = Ext.Array.from(a, true); + var b = 0, + c = a.length; + for (; b < c; b++) { + delete this._customDurations[a[b]] + } + }, + setAnimating: function(a, b) { + var e = this, + d = e.animatingPool; + if (a.animating !== b) { + a.animating = b; + if (b) { + d.push(a); + if (e.animating === 0) { + Ext.draw.Animator.add(e) + } + e.animating++ + } else { + for (var c = d.length; c--;) { + if (d[c] === a) { + d.splice(c, 1) + } + } + e.animating = d.length + } + } + }, + setAttrs: function(r, t) { + var s = this, + m = r.timers, + h = s._sprite.self.def._animationProcessors, + f = s._easing, + e = s._duration, + j = s._customDurations, + i = s._customEasings, + g = s.anySpecialAnimations, + n = s.anyAnimation || g, + o = r.animationOriginal, + d = false, + k, u, l, p, c, q, a; + if (!n) { + for (u in t) { + if (r[u] === t[u]) { + delete t[u] + } else { + r[u] = t[u] + } + delete o[u]; + delete m[u] + } + return t + } else { + for (u in t) { + l = t[u]; + p = r[u]; + if (l !== p && p !== undefined && p !== null && (c = h[u])) { + q = f; + a = e; + if (g) { + if (u in i) { + q = i[u] + } + if (u in j) { + a = j[u] + } + } + if (p && p.isGradient || l && l.isGradient) { + a = 0 + } + if (a) { + if (!m[u]) { + m[u] = {} + } + k = m[u]; + k.start = 0; + k.easing = q; + k.duration = a; + k.compute = c.compute; + k.serve = c.serve || Ext.identityFn; + k.remove = t.removeFromInstance && t.removeFromInstance[u]; + if (c.parseInitial) { + var b = c.parseInitial(p, l); + k.source = b[0]; + k.target = b[1] + } else { + if (c.parse) { + k.source = c.parse(p); + k.target = c.parse(l) + } else { + k.source = p; + k.target = l + } + } + o[u] = l; + delete t[u]; + d = true; + continue + } else { + delete o[u] + } + } else { + delete o[u] + } + delete m[u] + } + } + if (d && !r.animating) { + s.setAnimating(r, true) + } + return t + }, + updateAttributes: function(g) { + if (!g.animating) { + return {} + } + var h = {}, + e = false, + d = g.timers, + f = g.animationOriginal, + c = Ext.draw.Animator.animationTime(), + a, b, i; + if (g.lastUpdate === c) { + return null + } + for (a in d) { + b = d[a]; + if (!b.start) { + b.start = c; + i = 0 + } else { + i = (c - b.start) / b.duration + } + if (i >= 1) { + h[a] = f[a]; + delete f[a]; + if (d[a].remove) { + h.removeFromInstance = h.removeFromInstance || {}; + h.removeFromInstance[a] = true + } + delete d[a] + } else { + h[a] = b.serve(b.compute(b.source, b.target, b.easing(i), g[a])); + e = true + } + } + g.lastUpdate = c; + this.setAnimating(g, e); + return h + }, + pushDown: function(a, b) { + b = this.callParent([a.animationOriginal, b]); + return this.setAttrs(a, b) + }, + popUp: function(a, b) { + a = a.prototype; + b = this.setAttrs(a, b); + if (this._next) { + return this._next.popUp(a, b) + } else { + return Ext.apply(a, b) + } + }, + step: function(g) { + var f = this, + c = f.animatingPool.slice(), + e = c.length, + b = 0, + a, d; + for (; b < e; b++) { + a = c[b]; + d = f.updateAttributes(a); + if (d && f._next) { + f._next.popUp(a, d) + } + } + }, + stop: function() { + this.step(); + var d = this, + b = d.animatingPool, + a, c; + for (a = 0, c = b.length; a < c; a++) { + b[a].animating = false + } + d.animatingPool.length = 0; + d.animating = 0; + Ext.draw.Animator.remove(d) + }, + destroy: function() { + this.animatingPool.length = 0; + this.animating = 0; + this.callParent() + } +}); +Ext.define("Ext.draw.modifier.Highlight", { + extend: "Ext.draw.modifier.Modifier", + alias: "modifier.highlight", + config: { + enabled: false, + highlightStyle: null + }, + preFx: true, + applyHighlightStyle: function(b, a) { + a = a || {}; + if (this.getSprite()) { + Ext.apply(a, this.getSprite().self.def.normalize(b)) + } else { + Ext.apply(a, b) + } + return a + }, + prepareAttributes: function(a) { + if (!a.hasOwnProperty("highlightOriginal")) { + a.highlighted = false; + a.highlightOriginal = Ext.Object.chain(a); + a.highlightOriginal.prototype = a; + a.highlightOriginal.removeFromInstance = {} + } + if (this._previous) { + this._previous.prepareAttributes(a.highlightOriginal) + } + }, + updateSprite: function(b, a) { + if (b) { + if (this.getHighlightStyle()) { + this._highlightStyle = b.self.def.normalize(this.getHighlightStyle()) + } + this.setHighlightStyle(b.config.highlight) + } + b.self.def.setConfig({ + defaults: { + highlighted: false + }, + processors: { + highlighted: "bool" + } + }); + this.setSprite(b) + }, + filterChanges: function(a, d) { + var e = this, + f = a.highlightOriginal, + c = e.getHighlightStyle(), + b; + if (a.highlighted) { + for (b in d) { + if (c.hasOwnProperty(b)) { + f[b] = d[b]; + delete d[b] + } + } + } + for (b in d) { + if (b !== "highlighted" && f[b] === d[b]) { + delete d[b] + } + } + return d + }, + pushDown: function(e, g) { + var f = this.getHighlightStyle(), + c = e.highlightOriginal, + i = c.removeFromInstance, + d, a, h, b; + if (g.hasOwnProperty("highlighted")) { + d = g.highlighted; + delete g.highlighted; + if (this._previous) { + g = this._previous.pushDown(c, g) + } + g = this.filterChanges(e, g); + if (d !== e.highlighted) { + if (d) { + for (a in f) { + if (a in g) { + c[a] = g[a] + } else { + h = e.template && e.template.ownAttr; + if (h && !e.prototype.hasOwnProperty(a)) { + i[a] = true; + c[a] = h.animationOriginal[a] + } else { + b = c.timers[a]; + if (b && b.remove) { + i[a] = true + } + c[a] = e[a] + } + } + if (c[a] !== f[a]) { + g[a] = f[a] + } + } + } else { + for (a in f) { + if (!(a in g)) { + g[a] = c[a] + } + delete c[a] + } + g.removeFromInstance = g.removeFromInstance || {}; + Ext.apply(g.removeFromInstance, i); + c.removeFromInstance = {} + } + g.highlighted = d + } + } else { + if (this._previous) { + g = this._previous.pushDown(c, g) + } + g = this.filterChanges(e, g) + } + return g + }, + popUp: function(a, b) { + b = this.filterChanges(a, b); + Ext.draw.modifier.Modifier.prototype.popUp.call(this, a, b) + } +}); +Ext.define("Ext.draw.sprite.Sprite", { + alias: "sprite.sprite", + mixins: { + observable: "Ext.mixin.Observable" + }, + requires: ["Ext.draw.Draw", "Ext.draw.gradient.Gradient", "Ext.draw.sprite.AttributeDefinition", "Ext.draw.modifier.Target", "Ext.draw.modifier.Animation", "Ext.draw.modifier.Highlight"], + isSprite: true, + statics: { + defaultHitTestOptions: { + fill: true, + stroke: true + } + }, + inheritableStatics: { + def: { + processors: { + strokeStyle: "color", + fillStyle: "color", + strokeOpacity: "limited01", + fillOpacity: "limited01", + lineWidth: "number", + lineCap: "enums(butt,round,square)", + lineJoin: "enums(round,bevel,miter)", + lineDash: "data", + lineDashOffset: "number", + miterLimit: "number", + shadowColor: "color", + shadowOffsetX: "number", + shadowOffsetY: "number", + shadowBlur: "number", + globalAlpha: "limited01", + globalCompositeOperation: "enums(source-over,destination-over,source-in,destination-in,source-out,destination-out,source-atop,destination-atop,lighter,xor,copy)", + hidden: "bool", + transformFillStroke: "bool", + zIndex: "number", + translationX: "number", + translationY: "number", + rotationRads: "number", + rotationCenterX: "number", + rotationCenterY: "number", + scalingX: "number", + scalingY: "number", + scalingCenterX: "number", + scalingCenterY: "number", + constrainGradients: "bool" + }, + aliases: { + stroke: "strokeStyle", + fill: "fillStyle", + color: "fillStyle", + "stroke-width": "lineWidth", + "stroke-linecap": "lineCap", + "stroke-linejoin": "lineJoin", + "stroke-miterlimit": "miterLimit", + "text-anchor": "textAlign", + opacity: "globalAlpha", + translateX: "translationX", + translateY: "translationY", + rotateRads: "rotationRads", + rotateCenterX: "rotationCenterX", + rotateCenterY: "rotationCenterY", + scaleX: "scalingX", + scaleY: "scalingY", + scaleCenterX: "scalingCenterX", + scaleCenterY: "scalingCenterY" + }, + defaults: { + hidden: false, + zIndex: 0, + strokeStyle: "none", + fillStyle: "none", + lineWidth: 1, + lineDash: [], + lineDashOffset: 0, + lineCap: "butt", + lineJoin: "miter", + miterLimit: 10, + shadowColor: "none", + shadowOffsetX: 0, + shadowOffsetY: 0, + shadowBlur: 0, + globalAlpha: 1, + strokeOpacity: 1, + fillOpacity: 1, + transformFillStroke: false, + translationX: 0, + translationY: 0, + rotationRads: 0, + rotationCenterX: null, + rotationCenterY: null, + scalingX: 1, + scalingY: 1, + scalingCenterX: null, + scalingCenterY: null, + constrainGradients: false + }, + triggers: { + zIndex: "zIndex", + globalAlpha: "canvas", + globalCompositeOperation: "canvas", + transformFillStroke: "canvas", + strokeStyle: "canvas", + fillStyle: "canvas", + strokeOpacity: "canvas", + fillOpacity: "canvas", + lineWidth: "canvas", + lineCap: "canvas", + lineJoin: "canvas", + lineDash: "canvas", + lineDashOffset: "canvas", + miterLimit: "canvas", + shadowColor: "canvas", + shadowOffsetX: "canvas", + shadowOffsetY: "canvas", + shadowBlur: "canvas", + translationX: "transform", + translationY: "transform", + rotationRads: "transform", + rotationCenterX: "transform", + rotationCenterY: "transform", + scalingX: "transform", + scalingY: "transform", + scalingCenterX: "transform", + scalingCenterY: "transform", + constrainGradients: "canvas" + }, + updaters: { + bbox: "bboxUpdater", + zIndex: function(a) { + a.dirtyZIndex = true + }, + transform: function(a) { + a.dirtyTransform = true; + a.bbox.transform.dirty = true + } + } + } + }, + config: { + parent: null, + surface: null + }, + onClassExtended: function(d, c) { + var b = d.superclass.self.def.initialConfig, + e = c.inheritableStatics && c.inheritableStatics.def, + a; + if (e) { + a = Ext.Object.merge({}, b, e); + d.def = new Ext.draw.sprite.AttributeDefinition(a); + delete c.inheritableStatics.def + } else { + d.def = new Ext.draw.sprite.AttributeDefinition(b) + } + d.def.spriteClass = d + }, + constructor: function(b) { + var d = this, + c = d.self.def, + e = c.getDefaults(), + a; + b = Ext.isObject(b) ? b : {}; + d.id = b.id || Ext.id(null, "ext-sprite-"); + d.attr = {}; + d.mixins.observable.constructor.apply(d, arguments); + a = Ext.Array.from(b.modifiers, true); + d.prepareModifiers(a); + d.initializeAttributes(); + d.setAttributes(e, true); + d.setAttributes(b) + }, + getDirty: function() { + return this.attr.dirty + }, + setDirty: function(b) { + this.attr.dirty = b; + if (b) { + var a = this.getParent(); + if (a) { + a.setDirty(true) + } + } + }, + addModifier: function(a, b) { + var c = this; + if (!(a instanceof Ext.draw.modifier.Modifier)) { + a = Ext.factory(a, null, null, "modifier") + } + a.setSprite(c); + if (a.preFx || a.config && a.config.preFx) { + if (c.fx.getPrevious()) { + c.fx.getPrevious().setNext(a) + } + a.setNext(c.fx) + } else { + c.topModifier.getPrevious().setNext(a); + a.setNext(c.topModifier) + } + if (b) { + c.initializeAttributes() + } + return a + }, + prepareModifiers: function(d) { + var c = this, + a, b; + c.topModifier = new Ext.draw.modifier.Target({ + sprite: c + }); + c.fx = new Ext.draw.modifier.Animation({ + sprite: c + }); + c.fx.setNext(c.topModifier); + for (a = 0, b = d.length; a < b; a++) { + c.addModifier(d[a], false) + } + }, + getAnimation: function() { + return this.fx + }, + setAnimation: function(a) { + this.fx.setConfig(a) + }, + initializeAttributes: function() { + this.topModifier.prepareAttributes(this.attr) + }, + callUpdaters: function(d) { + var e = this, + h = d.pendingUpdaters, + i = e.self.def.getUpdaters(), + c = false, + a = false, + b, g, f; + e.callUpdaters = Ext.emptyFn; + do { + c = false; + for (g in h) { + c = true; + b = h[g]; + delete h[g]; + f = i[g]; + if (typeof f === "string") { + f = e[f] + } + if (f) { + f.call(e, d, b) + } + } + a = a || c + } while (c); + delete e.callUpdaters; + if (a) { + e.setDirty(true) + } + }, + scheduleUpdaters: function(a, e, c) { + var f; + if (c) { + for (var b = 0, d = e.length; b < d; b++) { + f = e[b]; + this.scheduleUpdater(a, f, c) + } + } else { + for (f in e) { + c = e[f]; + this.scheduleUpdater(a, f, c) + } + } + }, + scheduleUpdater: function(a, c, b) { + b = b || []; + var d = a.pendingUpdaters; + if (c in d) { + if (b.length) { + d[c] = Ext.Array.merge(d[c], b) + } + } else { + d[c] = b + } + }, + setAttributes: function(d, g, c) { + var a = this.attr, + b, e, f; + if (g) { + if (c) { + this.topModifier.pushDown(a, d) + } else { + f = {}; + for (b in d) { + e = d[b]; + if (e !== a[b]) { + f[b] = e + } + } + this.topModifier.pushDown(a, f) + } + } else { + this.topModifier.pushDown(a, this.self.def.normalize(d)) + } + }, + setAttributesBypassingNormalization: function(b, a) { + return this.setAttributes(b, true, a) + }, + bboxUpdater: function(b) { + var c = b.rotationRads !== 0, + a = b.scalingX !== 1 || b.scalingY !== 1, + d = b.rotationCenterX === null || b.rotationCenterY === null, + e = b.scalingCenterX === null || b.scalingCenterY === null; + b.bbox.plain.dirty = true; + b.bbox.transform.dirty = true; + if (c && d || a && e) { + this.scheduleUpdater(b, "transform") + } + }, + getBBox: function(d) { + var e = this, + a = e.attr, + f = a.bbox, + c = f.plain, + b = f.transform; + if (c.dirty) { + e.updatePlainBBox(c); + c.dirty = false + } + if (!d) { + e.applyTransformations(); + if (b.dirty) { + e.updateTransformedBBox(b, c); + b.dirty = false + } + return b + } + return c + }, + updatePlainBBox: Ext.emptyFn, + updateTransformedBBox: function(a, b) { + this.attr.matrix.transformBBox(b, 0, a) + }, + getBBoxCenter: function(a) { + var b = this.getBBox(a); + if (b) { + return [b.x + b.width * 0.5, b.y + b.height * 0.5] + } else { + return [0, 0] + } + }, + hide: function() { + this.attr.hidden = true; + this.setDirty(true); + return this + }, + show: function() { + this.attr.hidden = false; + this.setDirty(true); + return this + }, + useAttributes: function(i, f) { + this.applyTransformations(); + var d = this.attr, + h = d.canvasAttributes, + e = h.strokeStyle, + g = h.fillStyle, + b = h.lineDash, + c = h.lineDashOffset, + a; + if (e) { + if (e.isGradient) { + i.strokeStyle = "black"; + i.strokeGradient = e + } else { + i.strokeGradient = false + } + } + if (g) { + if (g.isGradient) { + i.fillStyle = "black"; + i.fillGradient = g + } else { + i.fillGradient = false + } + } + if (b) { + i.setLineDash(b) + } + if (Ext.isNumber(c + i.lineDashOffset)) { + i.lineDashOffset = c + } + for (a in h) { + if (h[a] !== undefined && h[a] !== i[a]) { + i[a] = h[a] + } + } + this.setGradientBBox(i, f) + }, + setGradientBBox: function(b, c) { + var a = this.attr; + if (a.constrainGradients) { + b.setGradientBBox({ + x: c[0], + y: c[1], + width: c[2], + height: c[3] + }) + } else { + b.setGradientBBox(this.getBBox(a.transformFillStroke)) + } + }, + applyTransformations: function(b) { + if (!b && !this.attr.dirtyTransform) { + return + } + var r = this, + k = r.attr, + p = r.getBBoxCenter(true), + g = p[0], + f = p[1], + q = k.translationX, + o = k.translationY, + j = k.scalingX, + i = k.scalingY === null ? k.scalingX : k.scalingY, + m = k.scalingCenterX === null ? g : k.scalingCenterX, + l = k.scalingCenterY === null ? f : k.scalingCenterY, + s = k.rotationRads, + e = k.rotationCenterX === null ? g : k.rotationCenterX, + d = k.rotationCenterY === null ? f : k.rotationCenterY, + c = Math.cos(s), + a = Math.sin(s), + n, h; + if (j === 1 && i === 1) { + m = 0; + l = 0 + } + if (s === 0) { + e = 0; + d = 0 + } + n = m * (1 - j) - e; + h = l * (1 - i) - d; + k.matrix.elements = [c * j, a * j, -a * i, c * i, c * n - a * h + e + q, a * n + c * h + d + o]; + k.matrix.inverse(k.inverseMatrix); + k.dirtyTransform = false; + k.bbox.transform.dirty = true + }, + transform: function(b, c) { + var a = this.attr, + e = a.matrix, + d; + if (b && b.isMatrix) { + d = b.elements + } else { + d = b + } + e.prepend.apply(e, d.slice()); + e.inverse(a.inverseMatrix); + if (c) { + this.updateTransformAttributes() + } + a.dirtyTransform = false; + a.bbox.transform.dirty = true; + this.setDirty(true); + return this + }, + updateTransformAttributes: function() { + var a = this.attr, + b = a.matrix.split(); + a.rotationRads = b.rotate; + a.rotationCenterX = 0; + a.rotationCenterY = 0; + a.scalingX = b.scaleX; + a.scalingY = b.scaleY; + a.scalingCenterX = 0; + a.scalingCenterY = 0; + a.translationX = b.translateX; + a.translationY = b.translateY + }, + resetTransform: function(b) { + var a = this.attr; + a.matrix.reset(); + a.inverseMatrix.reset(); + if (!b) { + this.updateTransformAttributes() + } + a.dirtyTransform = false; + a.bbox.transform.dirty = true; + this.setDirty(true); + return this + }, + setTransform: function(a, b) { + this.resetTransform(true); + this.transform.call(this, a, b); + return this + }, + preRender: Ext.emptyFn, + render: Ext.emptyFn, + hitTest: function(b, c) { + if (this.isVisible()) { + var a = b[0], + f = b[1], + e = this.getBBox(), + d = e && a >= e.x && a <= (e.x + e.width) && f >= e.y && f <= (e.y + e.height); + if (d) { + return { + sprite: this + } + } + } + return null + }, + isVisible: function() { + var e = this.attr, + f = this.getParent(), + g = f && (f.isSurface || f.isVisible()), + d = g && !e.hidden && e.globalAlpha, + b = Ext.draw.Color.NONE, + a = Ext.draw.Color.RGBA_NONE, + c = e.fillOpacity && e.fillStyle !== b && e.fillStyle !== a, + i = e.strokeOpacity && e.strokeStyle !== b && e.strokeStyle !== a, + h = d && (c || i); + return !!h + }, + repaint: function() { + var a = this.getSurface(); + if (a) { + a.renderFrame() + } + }, + remove: function() { + var a = this.getSurface(); + if (a && a.isSurface) { + return a.remove(this) + } + return null + }, + destroy: function() { + var b = this, + a = b.topModifier, + c; + while (a) { + c = a; + a = a.getPrevious(); + c.destroy() + } + delete b.attr; + b.remove(); + if (b.fireEvent("beforedestroy", b) !== false) { + b.fireEvent("destroy", b) + } + b.callParent() + } +}, function() { + this.def = new Ext.draw.sprite.AttributeDefinition(this.def); + this.def.spriteClass = this +}); +Ext.define("Ext.draw.Path", { + requires: ["Ext.draw.Draw"], + statics: { + pathRe: /,?([achlmqrstvxz]),?/gi, + pathRe2: /-/gi, + pathSplitRe: /\s|,/g + }, + svgString: "", + constructor: function(a) { + var b = this; + b.commands = []; + b.params = []; + b.cursor = null; + b.startX = 0; + b.startY = 0; + if (a) { + b.fromSvgString(a) + } + }, + clear: function() { + var a = this; + a.params.length = 0; + a.commands.length = 0; + a.cursor = null; + a.startX = 0; + a.startY = 0; + a.dirt() + }, + dirt: function() { + this.svgString = "" + }, + moveTo: function(a, c) { + var b = this; + if (!b.cursor) { + b.cursor = [a, c] + } + b.params.push(a, c); + b.commands.push("M"); + b.startX = a; + b.startY = c; + b.cursor[0] = a; + b.cursor[1] = c; + b.dirt() + }, + lineTo: function(a, c) { + var b = this; + if (!b.cursor) { + b.cursor = [a, c]; + b.params.push(a, c); + b.commands.push("M") + } else { + b.params.push(a, c); + b.commands.push("L") + } + b.cursor[0] = a; + b.cursor[1] = c; + b.dirt() + }, + bezierCurveTo: function(c, e, b, d, a, g) { + var f = this; + if (!f.cursor) { + f.moveTo(c, e) + } + f.params.push(c, e, b, d, a, g); + f.commands.push("C"); + f.cursor[0] = a; + f.cursor[1] = g; + f.dirt() + }, + quadraticCurveTo: function(b, e, a, d) { + var c = this; + if (!c.cursor) { + c.moveTo(b, e) + } + c.bezierCurveTo((2 * b + c.cursor[0]) / 3, (2 * e + c.cursor[1]) / 3, (2 * b + a) / 3, (2 * e + d) / 3, a, d) + }, + closePath: function() { + var a = this; + if (a.cursor) { + a.cursor = null; + a.commands.push("Z"); + a.dirt() + } + }, + arcTo: function(A, f, z, d, j, i, v) { + var E = this; + if (i === undefined) { + i = j + } + if (v === undefined) { + v = 0 + } + if (!E.cursor) { + E.moveTo(A, f); + return + } + if (j === 0 || i === 0) { + E.lineTo(A, f); + return + } + z -= A; + d -= f; + var B = E.cursor[0] - A, + g = E.cursor[1] - f, + C = z * g - d * B, + b, a, l, r, k, q, x = Math.sqrt(B * B + g * g), + u = Math.sqrt(z * z + d * d), + t, e, c; + if (C === 0) { + E.lineTo(A, f); + return + } + if (i !== j) { + b = Math.cos(v); + a = Math.sin(v); + l = b / j; + r = a / i; + k = -a / j; + q = b / i; + var D = l * B + r * g; + g = k * B + q * g; + B = D; + D = l * z + r * d; + d = k * z + q * d; + z = D + } else { + B /= j; + g /= i; + z /= j; + d /= i + } + e = B * u + z * x; + c = g * u + d * x; + t = 1 / (Math.sin(Math.asin(Math.abs(C) / (x * u)) * 0.5) * Math.sqrt(e * e + c * c)); + e *= t; + c *= t; + var o = (e * B + c * g) / (B * B + g * g), + m = (e * z + c * d) / (z * z + d * d); + var n = B * o - e, + p = g * o - c, + h = z * m - e, + y = d * m - c, + w = Math.atan2(p, n), + s = Math.atan2(y, h); + if (C > 0) { + if (s < w) { + s += Math.PI * 2 + } + } else { + if (w < s) { + w += Math.PI * 2 + } + } + if (i !== j) { + e = b * e * j - a * c * i + A; + c = a * c * i + b * c * i + f; + E.lineTo(b * j * n - a * i * p + e, a * j * n + b * i * p + c); + E.ellipse(e, c, j, i, v, w, s, C < 0) + } else { + e = e * j + A; + c = c * i + f; + E.lineTo(j * n + e, i * p + c); + E.ellipse(e, c, j, i, v, w, s, C < 0) + } + }, + ellipse: function(h, f, c, a, q, n, d, e) { + var o = this, + g = o.params, + b = g.length, + m, l, k; + if (d - n >= Math.PI * 2) { + o.ellipse(h, f, c, a, q, n, n + Math.PI, e); + o.ellipse(h, f, c, a, q, n + Math.PI, d, e); + return + } + if (!e) { + if (d < n) { + d += Math.PI * 2 + } + m = o.approximateArc(g, h, f, c, a, q, n, d) + } else { + if (n < d) { + n += Math.PI * 2 + } + m = o.approximateArc(g, h, f, c, a, q, d, n); + for (l = b, k = g.length - 2; l < k; l += 2, k -= 2) { + var p = g[l]; + g[l] = g[k]; + g[k] = p; + p = g[l + 1]; + g[l + 1] = g[k + 1]; + g[k + 1] = p + } + } + if (!o.cursor) { + o.cursor = [g[g.length - 2], g[g.length - 1]]; + o.commands.push("M") + } else { + o.cursor[0] = g[g.length - 2]; + o.cursor[1] = g[g.length - 1]; + o.commands.push("L") + } + for (l = 2; l < m; l += 6) { + o.commands.push("C") + } + o.dirt() + }, + arc: function(b, f, a, d, c, e) { + this.ellipse(b, f, a, a, 0, d, c, e) + }, + rect: function(b, e, c, a) { + if (c == 0 || a == 0) { + return + } + var d = this; + d.moveTo(b, e); + d.lineTo(b + c, e); + d.lineTo(b + c, e + a); + d.lineTo(b, e + a); + d.closePath() + }, + approximateArc: function(s, i, f, o, n, d, x, v) { + var e = Math.cos(d), + z = Math.sin(d), + k = Math.cos(x), + l = Math.sin(x), + q = e * k * o - z * l * n, + y = -e * l * o - z * k * n, + p = z * k * o + e * l * n, + w = -z * l * o + e * k * n, + m = Math.PI / 2, + r = 2, + j = q, + u = y, + h = p, + t = w, + b = 0.547443256150549, + C, g, A, a, B, c; + v -= x; + if (v < 0) { + v += Math.PI * 2 + } + s.push(q + i, p + f); + while (v >= m) { + s.push(j + u * b + i, h + t * b + f, j * b + u + i, h * b + t + f, u + i, t + f); + r += 6; + v -= m; + C = j; + j = u; + u = -C; + C = h; + h = t; + t = -C + } + if (v) { + g = (0.3294738052815987 + 0.012120855841304373 * v) * v; + A = Math.cos(v); + a = Math.sin(v); + B = A + g * a; + c = a - g * A; + s.push(j + u * g + i, h + t * g + f, j * B + u * c + i, h * B + t * c + f, j * A + u * a + i, h * A + t * a + f); + r += 6 + } + return r + }, + arcSvg: function(j, h, r, m, w, t, c) { + if (j < 0) { + j = -j + } + if (h < 0) { + h = -h + } + var x = this, + u = x.cursor[0], + f = x.cursor[1], + a = (u - t) / 2, + y = (f - c) / 2, + d = Math.cos(r), + s = Math.sin(r), + o = a * d + y * s, + v = -a * s + y * d, + i = o / j, + g = v / h, + p = i * i + g * g, + e = (u + t) * 0.5, + b = (f + c) * 0.5, + l = 0, + k = 0; + if (p >= 1) { + p = Math.sqrt(p); + j *= p; + h *= p + } else { + p = Math.sqrt(1 / p - 1); + if (m === w) { + p = -p + } + l = p * j * g; + k = -p * h * i; + e += d * l - s * k; + b += s * l + d * k + } + var q = Math.atan2((v - k) / h, (o - l) / j), + n = Math.atan2((-v - k) / h, (-o - l) / j) - q; + if (w) { + if (n <= 0) { + n += Math.PI * 2 + } + } else { + if (n >= 0) { + n -= Math.PI * 2 + } + } + x.ellipse(e, b, j, h, r, q, q + n, 1 - w) + }, + fromSvgString: function(e) { + if (!e) { + return + } + var m = this, + h, l = { + a: 7, + c: 6, + h: 1, + l: 2, + m: 2, + q: 4, + s: 4, + t: 2, + v: 1, + z: 0, + A: 7, + C: 6, + H: 1, + L: 2, + M: 2, + Q: 4, + S: 4, + T: 2, + V: 1, + Z: 0 + }, + k = "", + g, f, c = 0, + b = 0, + d = false, + j, n, a; + if (Ext.isString(e)) { + h = e.replace(Ext.draw.Path.pathRe, " $1 ").replace(Ext.draw.Path.pathRe2, " -").split(Ext.draw.Path.pathSplitRe) + } else { + if (Ext.isArray(e)) { + h = e.join(",").split(Ext.draw.Path.pathSplitRe) + } + } + for (j = 0, n = 0; j < h.length; j++) { + if (h[j] !== "") { + h[n++] = h[j] + } + } + h.length = n; + m.clear(); + for (j = 0; j < h.length;) { + k = d; + d = h[j]; + a = (d.toUpperCase() !== d); + j++; + switch (d) { + case "M": + m.moveTo(c = +h[j], b = +h[j + 1]); + j += 2; + while (j < n && !l.hasOwnProperty(h[j])) { + m.lineTo(c = +h[j], b = +h[j + 1]); + j += 2 + } + break; + case "L": + m.lineTo(c = +h[j], b = +h[j + 1]); + j += 2; + while (j < n && !l.hasOwnProperty(h[j])) { + m.lineTo(c = +h[j], b = +h[j + 1]); + j += 2 + } + break; + case "A": + while (j < n && !l.hasOwnProperty(h[j])) { + m.arcSvg(+h[j], +h[j + 1], +h[j + 2] * Math.PI / 180, +h[j + 3], +h[j + 4], c = +h[j + 5], b = +h[j + 6]); + j += 7 + } + break; + case "C": + while (j < n && !l.hasOwnProperty(h[j])) { + m.bezierCurveTo(+h[j], +h[j + 1], g = +h[j + 2], f = +h[j + 3], c = +h[j + 4], b = +h[j + 5]); + j += 6 + } + break; + case "Z": + m.closePath(); + break; + case "m": + m.moveTo(c += +h[j], b += +h[j + 1]); + j += 2; + while (j < n && !l.hasOwnProperty(h[j])) { + m.lineTo(c += +h[j], b += +h[j + 1]); + j += 2 + } + break; + case "l": + m.lineTo(c += +h[j], b += +h[j + 1]); + j += 2; + while (j < n && !l.hasOwnProperty(h[j])) { + m.lineTo(c += +h[j], b += +h[j + 1]); + j += 2 + } + break; + case "a": + while (j < n && !l.hasOwnProperty(h[j])) { + m.arcSvg(+h[j], +h[j + 1], +h[j + 2] * Math.PI / 180, +h[j + 3], +h[j + 4], c += +h[j + 5], b += +h[j + 6]); + j += 7 + } + break; + case "c": + while (j < n && !l.hasOwnProperty(h[j])) { + m.bezierCurveTo(c + (+h[j]), b + (+h[j + 1]), g = c + (+h[j + 2]), f = b + (+h[j + 3]), c += +h[j + 4], b += +h[j + 5]); + j += 6 + } + break; + case "z": + m.closePath(); + break; + case "s": + if (!(k === "c" || k === "C" || k === "s" || k === "S")) { + g = c; + f = b + } + while (j < n && !l.hasOwnProperty(h[j])) { + m.bezierCurveTo(c + c - g, b + b - f, g = c + (+h[j]), f = b + (+h[j + 1]), c += +h[j + 2], b += +h[j + 3]); + j += 4 + } + break; + case "S": + if (!(k === "c" || k === "C" || k === "s" || k === "S")) { + g = c; + f = b + } + while (j < n && !l.hasOwnProperty(h[j])) { + m.bezierCurveTo(c + c - g, b + b - f, g = +h[j], f = +h[j + 1], c = (+h[j + 2]), b = (+h[j + 3])); + j += 4 + } + break; + case "q": + while (j < n && !l.hasOwnProperty(h[j])) { + m.quadraticCurveTo(g = c + (+h[j]), f = b + (+h[j + 1]), c += +h[j + 2], b += +h[j + 3]); + j += 4 + } + break; + case "Q": + while (j < n && !l.hasOwnProperty(h[j])) { + m.quadraticCurveTo(g = +h[j], f = +h[j + 1], c = +h[j + 2], b = +h[j + 3]); + j += 4 + } + break; + case "t": + if (!(k === "q" || k === "Q" || k === "t" || k === "T")) { + g = c; + f = b + } + while (j < n && !l.hasOwnProperty(h[j])) { + m.quadraticCurveTo(g = c + c - g, f = b + b - f, c += +h[j + 1], b += +h[j + 2]); + j += 2 + } + break; + case "T": + if (!(k === "q" || k === "Q" || k === "t" || k === "T")) { + g = c; + f = b + } + while (j < n && !l.hasOwnProperty(h[j])) { + m.quadraticCurveTo(g = c + c - g, f = b + b - f, c = (+h[j + 1]), b = (+h[j + 2])); + j += 2 + } + break; + case "h": + while (j < n && !l.hasOwnProperty(h[j])) { + m.lineTo(c += +h[j], b); + j++ + } + break; + case "H": + while (j < n && !l.hasOwnProperty(h[j])) { + m.lineTo(c = +h[j], b); + j++ + } + break; + case "v": + while (j < n && !l.hasOwnProperty(h[j])) { + m.lineTo(c, b += +h[j]); + j++ + } + break; + case "V": + while (j < n && !l.hasOwnProperty(h[j])) { + m.lineTo(c, b = +h[j]); + j++ + } + break + } + } + }, + clone: function() { + var a = this, + b = new Ext.draw.Path(); + b.params = a.params.slice(0); + b.commands = a.commands.slice(0); + b.cursor = a.cursor ? a.cursor.slice(0) : null; + b.startX = a.startX; + b.startY = a.startY; + b.svgString = a.svgString; + return b + }, + transform: function(j) { + if (j.isIdentity()) { + return + } + var a = j.getXX(), + f = j.getYX(), + m = j.getDX(), + l = j.getXY(), + e = j.getYY(), + k = j.getDY(), + b = this.params, + c = 0, + d = b.length, + h, g; + for (; c < d; c += 2) { + h = b[c]; + g = b[c + 1]; + b[c] = h * a + g * f + m; + b[c + 1] = h * l + g * e + k + } + this.dirt() + }, + getDimension: function(f) { + if (!f) { + f = {} + } + if (!this.commands || !this.commands.length) { + f.x = 0; + f.y = 0; + f.width = 0; + f.height = 0; + return f + } + f.left = Infinity; + f.top = Infinity; + f.right = -Infinity; + f.bottom = -Infinity; + var d = 0, + c = 0, + b = this.commands, + g = this.params, + e = b.length, + a, h; + for (; d < e; d++) { + switch (b[d]) { + case "M": + case "L": + a = g[c]; + h = g[c + 1]; + f.left = Math.min(a, f.left); + f.top = Math.min(h, f.top); + f.right = Math.max(a, f.right); + f.bottom = Math.max(h, f.bottom); + c += 2; + break; + case "C": + this.expandDimension(f, a, h, g[c], g[c + 1], g[c + 2], g[c + 3], a = g[c + 4], h = g[c + 5]); + c += 6; + break + } + } + f.x = f.left; + f.y = f.top; + f.width = f.right - f.left; + f.height = f.bottom - f.top; + return f + }, + getDimensionWithTransform: function(n, f) { + if (!this.commands || !this.commands.length) { + if (!f) { + f = {} + } + f.x = 0; + f.y = 0; + f.width = 0; + f.height = 0; + return f + } + f.left = Infinity; + f.top = Infinity; + f.right = -Infinity; + f.bottom = -Infinity; + var a = n.getXX(), + k = n.getYX(), + q = n.getDX(), + p = n.getXY(), + h = n.getYY(), + o = n.getDY(), + e = 0, + d = 0, + b = this.commands, + c = this.params, + g = b.length, + m, l; + for (; e < g; e++) { + switch (b[e]) { + case "M": + case "L": + m = c[d] * a + c[d + 1] * k + q; + l = c[d] * p + c[d + 1] * h + o; + f.left = Math.min(m, f.left); + f.top = Math.min(l, f.top); + f.right = Math.max(m, f.right); + f.bottom = Math.max(l, f.bottom); + d += 2; + break; + case "C": + this.expandDimension(f, m, l, c[d] * a + c[d + 1] * k + q, c[d] * p + c[d + 1] * h + o, c[d + 2] * a + c[d + 3] * k + q, c[d + 2] * p + c[d + 3] * h + o, m = c[d + 4] * a + c[d + 5] * k + q, l = c[d + 4] * p + c[d + 5] * h + o); + d += 6; + break + } + } + if (!f) { + f = {} + } + f.x = f.left; + f.y = f.top; + f.width = f.right - f.left; + f.height = f.bottom - f.top; + return f + }, + expandDimension: function(i, d, p, k, g, j, e, c, o) { + var m = this, + f = i.left, + a = i.right, + q = i.top, + n = i.bottom, + h = m.dim || (m.dim = []); + m.curveDimension(d, k, j, c, h); + f = Math.min(f, h[0]); + a = Math.max(a, h[1]); + m.curveDimension(p, g, e, o, h); + q = Math.min(q, h[0]); + n = Math.max(n, h[1]); + i.left = f; + i.right = a; + i.top = q; + i.bottom = n + }, + curveDimension: function(p, n, k, j, h) { + var i = 3 * (-p + 3 * (n - k) + j), + g = 6 * (p - 2 * n + k), + f = -3 * (p - n), + o, m, e = Math.min(p, j), + l = Math.max(p, j), + q; + if (i === 0) { + if (g === 0) { + h[0] = e; + h[1] = l; + return + } else { + o = -f / g; + if (0 < o && o < 1) { + m = this.interpolate(p, n, k, j, o); + e = Math.min(e, m); + l = Math.max(l, m) + } + } + } else { + q = g * g - 4 * i * f; + if (q >= 0) { + q = Math.sqrt(q); + o = (q - g) / 2 / i; + if (0 < o && o < 1) { + m = this.interpolate(p, n, k, j, o); + e = Math.min(e, m); + l = Math.max(l, m) + } + if (q > 0) { + o -= q / i; + if (0 < o && o < 1) { + m = this.interpolate(p, n, k, j, o); + e = Math.min(e, m); + l = Math.max(l, m) + } + } + } + } + h[0] = e; + h[1] = l + }, + interpolate: function(f, e, j, i, g) { + if (g === 0) { + return f + } + if (g === 1) { + return i + } + var h = (1 - g) / g; + return g * g * g * (i + h * (3 * j + h * (3 * e + h * f))) + }, + fromStripes: function(g) { + var e = this, + c = 0, + d = g.length, + b, a, f; + e.clear(); + for (; c < d; c++) { + f = g[c]; + e.params.push.apply(e.params, f); + e.commands.push("M"); + for (b = 2, a = f.length; b < a; b += 6) { + e.commands.push("C") + } + } + if (!e.cursor) { + e.cursor = [] + } + e.cursor[0] = e.params[e.params.length - 2]; + e.cursor[1] = e.params[e.params.length - 1]; + e.dirt() + }, + toStripes: function(k) { + var o = k || [], + p, n, m, b, a, h, g, f, e, c = this.commands, + d = this.params, + l = c.length; + for (f = 0, e = 0; f < l; f++) { + switch (c[f]) { + case "M": + p = [h = b = d[e++], g = a = d[e++]]; + o.push(p); + break; + case "L": + n = d[e++]; + m = d[e++]; + p.push((b + b + n) / 3, (a + a + m) / 3, (b + n + n) / 3, (a + m + m) / 3, b = n, a = m); + break; + case "C": + p.push(d[e++], d[e++], d[e++], d[e++], b = d[e++], a = d[e++]); + break; + case "Z": + n = h; + m = g; + p.push((b + b + n) / 3, (a + a + m) / 3, (b + n + n) / 3, (a + m + m) / 3, b = n, a = m); + break + } + } + return o + }, + updateSvgString: function() { + var b = [], + a = this.commands, + f = this.params, + e = a.length, + d = 0, + c = 0; + for (; d < e; d++) { + switch (a[d]) { + case "M": + b.push("M" + f[c] + "," + f[c + 1]); + c += 2; + break; + case "L": + b.push("L" + f[c] + "," + f[c + 1]); + c += 2; + break; + case "C": + b.push("C" + f[c] + "," + f[c + 1] + " " + f[c + 2] + "," + f[c + 3] + " " + f[c + 4] + "," + f[c + 5]); + c += 6; + break; + case "Z": + b.push("Z"); + break + } + } + this.svgString = b.join("") + }, + toString: function() { + if (!this.svgString) { + this.updateSvgString() + } + return this.svgString + } +}); +Ext.define("Ext.draw.overrides.Path", { + override: "Ext.draw.Path", + rayOrigin: { + x: -10000, + y: -10000 + }, + isPointInPath: function(o, n) { + var m = this, + c = m.commands, + q = Ext.draw.PathUtil, + p = m.rayOrigin, + f = m.params, + l = c.length, + e = null, + d = null, + b = 0, + a = 0, + k = 0, + h, g; + for (h = 0, g = 0; h < l; h++) { + switch (c[h]) { + case "M": + if (e !== null) { + if (q.linesIntersection(e, d, b, a, p.x, p.y, o, n)) { + k += 1 + } + } + e = b = f[g]; + d = a = f[g + 1]; + g += 2; + break; + case "L": + if (q.linesIntersection(b, a, f[g], f[g + 1], p.x, p.y, o, n)) { + k += 1 + } + b = f[g]; + a = f[g + 1]; + g += 2; + break; + case "C": + k += q.cubicLineIntersections(b, f[g], f[g + 2], f[g + 4], a, f[g + 1], f[g + 3], f[g + 5], p.x, p.y, o, n).length; + b = f[g + 4]; + a = f[g + 5]; + g += 6; + break; + case "Z": + if (e !== null) { + if (q.linesIntersection(e, d, b, a, p.x, p.y, o, n)) { + k += 1 + } + } + break + } + } + return k % 2 === 1 + }, + isPointOnPath: function(n, m) { + var l = this, + c = l.commands, + o = Ext.draw.PathUtil, + f = l.params, + k = c.length, + e = null, + d = null, + b = 0, + a = 0, + h, g; + for (h = 0, g = 0; h < k; h++) { + switch (c[h]) { + case "M": + if (e !== null) { + if (o.pointOnLine(e, d, b, a, n, m)) { + return true + } + } + e = b = f[g]; + d = a = f[g + 1]; + g += 2; + break; + case "L": + if (o.pointOnLine(b, a, f[g], f[g + 1], n, m)) { + return true + } + b = f[g]; + a = f[g + 1]; + g += 2; + break; + case "C": + if (o.pointOnCubic(b, f[g], f[g + 2], f[g + 4], a, f[g + 1], f[g + 3], f[g + 5], n, m)) { + return true + } + b = f[g + 4]; + a = f[g + 5]; + g += 6; + break; + case "Z": + if (e !== null) { + if (o.pointOnLine(e, d, b, a, n, m)) { + return true + } + } + break + } + } + return false + }, + getSegmentIntersections: function(t, d, s, c, r, b, o, a) { + var w = this, + g = arguments.length, + v = Ext.draw.PathUtil, + f = w.commands, + u = w.params, + k = f.length, + m = null, + l = null, + h = 0, + e = 0, + x = [], + q, n, p; + for (q = 0, n = 0; q < k; q++) { + switch (f[q]) { + case "M": + if (m !== null) { + switch (g) { + case 4: + p = v.linesIntersection(m, l, h, e, t, d, s, c); + if (p) { + x.push(p) + } + break; + case 8: + p = v.cubicLineIntersections(t, s, r, o, d, c, b, a, m, l, h, e); + x.push.apply(x, p); + break + } + } + m = h = u[n]; + l = e = u[n + 1]; + n += 2; + break; + case "L": + switch (g) { + case 4: + p = v.linesIntersection(h, e, u[n], u[n + 1], t, d, s, c); + if (p) { + x.push(p) + } + break; + case 8: + p = v.cubicLineIntersections(t, s, r, o, d, c, b, a, h, e, u[n], u[n + 1]); + x.push.apply(x, p); + break + } + h = u[n]; + e = u[n + 1]; + n += 2; + break; + case "C": + switch (g) { + case 4: + p = v.cubicLineIntersections(h, u[n], u[n + 2], u[n + 4], e, u[n + 1], u[n + 3], u[n + 5], t, d, s, c); + x.push.apply(x, p); + break; + case 8: + p = v.cubicsIntersections(h, u[n], u[n + 2], u[n + 4], e, u[n + 1], u[n + 3], u[n + 5], t, s, r, o, d, c, b, a); + x.push.apply(x, p); + break + } + h = u[n + 4]; + e = u[n + 5]; + n += 6; + break; + case "Z": + if (m !== null) { + switch (g) { + case 4: + p = v.linesIntersection(m, l, h, e, t, d, s, c); + if (p) { + x.push(p) + } + break; + case 8: + p = v.cubicLineIntersections(t, s, r, o, d, c, b, a, m, l, h, e); + x.push.apply(x, p); + break + } + } + break + } + } + return x + }, + getIntersections: function(o) { + var m = this, + c = m.commands, + g = m.params, + l = c.length, + f = null, + e = null, + b = 0, + a = 0, + d = [], + k, h, n; + for (k = 0, h = 0; k < l; k++) { + switch (c[k]) { + case "M": + if (f !== null) { + n = o.getSegmentIntersections.call(o, f, e, b, a); + d.push.apply(d, n) + } + f = b = g[h]; + e = a = g[h + 1]; + h += 2; + break; + case "L": + n = o.getSegmentIntersections.call(o, b, a, g[h], g[h + 1]); + d.push.apply(d, n); + b = g[h]; + a = g[h + 1]; + h += 2; + break; + case "C": + n = o.getSegmentIntersections.call(o, b, a, g[h], g[h + 1], g[h + 2], g[h + 3], g[h + 4], g[h + 5]); + d.push.apply(d, n); + b = g[h + 4]; + a = g[h + 5]; + h += 6; + break; + case "Z": + if (f !== null) { + n = o.getSegmentIntersections.call(o, f, e, b, a); + d.push.apply(d, n) + } + break + } + } + return d + } +}); +Ext.define("Ext.draw.sprite.Path", { + extend: "Ext.draw.sprite.Sprite", + requires: ["Ext.draw.Draw", "Ext.draw.Path"], + alias: ["sprite.path", "Ext.draw.Sprite"], + type: "path", + isPath: true, + inheritableStatics: { + def: { + processors: { + path: function(b, a) { + if (!(b instanceof Ext.draw.Path)) { + b = new Ext.draw.Path(b) + } + return b + } + }, + aliases: { + d: "path" + }, + triggers: { + path: "bbox" + }, + updaters: { + path: function(a) { + var b = a.path; + if (!b || b.bindAttr !== a) { + b = new Ext.draw.Path(); + b.bindAttr = a; + a.path = b + } + b.clear(); + this.updatePath(b, a); + this.scheduleUpdater(a, "bbox", ["path"]) + } + } + } + }, + updatePlainBBox: function(a) { + if (this.attr.path) { + this.attr.path.getDimension(a) + } + }, + updateTransformedBBox: function(a) { + if (this.attr.path) { + this.attr.path.getDimensionWithTransform(this.attr.matrix, a) + } + }, + render: function(b, c) { + var d = this.attr.matrix, + a = this.attr; + if (!a.path || a.path.params.length === 0) { + return + } + d.toContext(c); + c.appendPath(a.path); + c.fillStroke(a) + }, + updatePath: function(b, a) {} +}); +Ext.define("Ext.draw.overrides.sprite.Path", { + override: "Ext.draw.sprite.Path", + requires: ["Ext.draw.Color"], + isPointInPath: function(c, g) { + var b = this.attr; + if (b.fillStyle === Ext.draw.Color.RGBA_NONE) { + return this.isPointOnPath(c, g) + } + var e = b.path, + d = b.matrix, + f, a; + if (!d.isIdentity()) { + f = e.params.slice(0); + e.transform(b.matrix) + } + a = e.isPointInPath(c, g); + if (f) { + e.params = f + } + return a + }, + isPointOnPath: function(c, g) { + var b = this.attr, + e = b.path, + d = b.matrix, + f, a; + if (!d.isIdentity()) { + f = e.params.slice(0); + e.transform(b.matrix) + } + a = e.isPointOnPath(c, g); + if (f) { + e.params = f + } + return a + }, + hitTest: function(i, l) { + var e = this, + c = e.attr, + k = c.path, + g = c.matrix, + h = i[0], + f = i[1], + d = e.callParent([i, l]), + j = null, + a, b; + if (!d) { + return j + } + l = l || Ext.draw.sprite.Sprite.defaultHitTestOptions; + if (!g.isIdentity()) { + a = k.params.slice(0); + k.transform(c.matrix) + } + if (l.fill && l.stroke) { + b = c.fillStyle !== Ext.draw.Color.NONE && c.fillStyle !== Ext.draw.Color.RGBA_NONE; + if (b) { + if (k.isPointInPath(h, f)) { + j = { + sprite: e + } + } + } else { + if (k.isPointInPath(h, f) || k.isPointOnPath(h, f)) { + j = { + sprite: e + } + } + } + } else { + if (l.stroke && !l.fill) { + if (k.isPointOnPath(h, f)) { + j = { + sprite: e + } + } + } else { + if (l.fill && !l.stroke) { + if (k.isPointInPath(h, f)) { + j = { + sprite: e + } + } + } + } + } + if (a) { + k.params = a + } + return j + }, + getIntersections: function(j) { + if (!(j.isSprite && j.isPath)) { + return [] + } + var e = this.attr, + d = j.attr, + i = e.path, + h = d.path, + g = e.matrix, + a = d.matrix, + c, f, b; + if (!g.isIdentity()) { + c = i.params.slice(0); + i.transform(e.matrix) + } + if (!a.isIdentity()) { + f = h.params.slice(0); + h.transform(d.matrix) + } + b = i.getIntersections(h); + if (c) { + i.params = c + } + if (f) { + h.params = f + } + return b + } +}); +Ext.define("Ext.draw.sprite.Circle", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.circle", + type: "circle", + inheritableStatics: { + def: { + processors: { + cx: "number", + cy: "number", + r: "number" + }, + aliases: { + radius: "r", + x: "cx", + y: "cy", + centerX: "cx", + centerY: "cy" + }, + defaults: { + cx: 0, + cy: 0, + r: 4 + }, + triggers: { + cx: "path", + cy: "path", + r: "path" + } + } + }, + updatePlainBBox: function(c) { + var b = this.attr, + a = b.cx, + e = b.cy, + d = b.r; + c.x = a - d; + c.y = e - d; + c.width = d + d; + c.height = d + d + }, + updateTransformedBBox: function(d) { + var g = this.attr, + f = g.cx, + e = g.cy, + a = g.r, + h = g.matrix, + j = h.getScaleX(), + i = h.getScaleY(), + c, b; + c = j * a; + b = i * a; + d.x = h.x(f, e) - c; + d.y = h.y(f, e) - b; + d.width = c + c; + d.height = b + b + }, + updatePath: function(b, a) { + b.arc(a.cx, a.cy, a.r, 0, Math.PI * 2, false) + } +}); +Ext.define("Ext.draw.sprite.Arc", { + extend: "Ext.draw.sprite.Circle", + alias: "sprite.arc", + type: "arc", + inheritableStatics: { + def: { + processors: { + startAngle: "number", + endAngle: "number", + anticlockwise: "bool" + }, + aliases: { + from: "startAngle", + to: "endAngle", + start: "startAngle", + end: "endAngle" + }, + defaults: { + startAngle: 0, + endAngle: Math.PI * 2, + anticlockwise: false + }, + triggers: { + startAngle: "path", + endAngle: "path", + anticlockwise: "path" + } + } + }, + updatePath: function(b, a) { + b.arc(a.cx, a.cy, a.r, a.startAngle, a.endAngle, a.anticlockwise) + } +}); +Ext.define("Ext.draw.sprite.Arrow", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.arrow", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + size: "number" + }, + defaults: { + x: 0, + y: 0, + size: 4 + }, + triggers: { + x: "path", + y: "path", + size: "path" + } + } + }, + updatePath: function(d, b) { + var c = b.size * 1.5, + a = b.x - b.lineWidth / 2, + e = b.y; + d.fromSvgString("M".concat(a - c * 0.7, ",", e - c * 0.4, "l", [c * 0.6, 0, 0, -c * 0.4, c, c * 0.8, -c, c * 0.8, 0, -c * 0.4, -c * 0.6, 0], "z")) + } +}); +Ext.define("Ext.draw.sprite.Composite", { + extend: "Ext.draw.sprite.Sprite", + alias: "sprite.composite", + type: "composite", + isComposite: true, + config: { + sprites: [] + }, + constructor: function() { + this.sprites = []; + this.sprites.map = {}; + this.callParent(arguments) + }, + add: function(c) { + if (!c) { + return null + } + if (!c.isSprite) { + c = Ext.create("sprite." + c.type, c); + c.setParent(this); + c.setSurface(this.getSurface()) + } + var d = this, + a = d.attr, + b = c.applyTransformations; + c.applyTransformations = function() { + if (c.attr.dirtyTransform) { + a.dirtyTransform = true; + a.bbox.plain.dirty = true; + a.bbox.transform.dirty = true + } + b.call(c) + }; + d.sprites.push(c); + d.sprites.map[c.id] = c.getId(); + a.bbox.plain.dirty = true; + a.bbox.transform.dirty = true; + return c + }, + updateSurface: function(a) { + for (var b = 0, c = this.sprites.length; b < c; b++) { + this.sprites[b].setSurface(a) + } + }, + addAll: function(b) { + if (b.isSprite || b.type) { + this.add(b) + } else { + if (Ext.isArray(b)) { + var a = 0; + while (a < b.length) { + this.add(b[a++]) + } + } + } + }, + updatePlainBBox: function(g) { + var e = this, + b = Infinity, + h = -Infinity, + f = Infinity, + a = -Infinity, + j, k, c, d; + for (c = 0, d = e.sprites.length; c < d; c++) { + j = e.sprites[c]; + j.applyTransformations(); + k = j.getBBox(); + if (b > k.x) { + b = k.x + } + if (h < k.x + k.width) { + h = k.x + k.width + } + if (f > k.y) { + f = k.y + } + if (a < k.y + k.height) { + a = k.y + k.height + } + } + g.x = b; + g.y = f; + g.width = h - b; + g.height = a - f + }, + render: function(a, b, f) { + var d = this.attr.matrix, + c, e; + d.toContext(b); + for (c = 0, e = this.sprites.length; c < e; c++) { + a.renderSprite(this.sprites[c], f) + } + }, + destroy: function() { + var c = this, + d = c.sprites, + b = d.length, + a; + c.callParent(); + for (a = 0; a < b; a++) { + d[a].destroy() + } + d.length = 0 + } +}); +Ext.define("Ext.draw.sprite.Cross", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.cross", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + size: "number" + }, + defaults: { + x: 0, + y: 0, + size: 4 + }, + triggers: { + x: "path", + y: "path", + size: "path" + } + } + }, + updatePath: function(d, b) { + var c = b.size / 1.7, + a = b.x - b.lineWidth / 2, + e = b.y; + d.fromSvgString("M".concat(a - c, ",", e, "l", [-c, -c, c, -c, c, c, c, -c, c, c, -c, c, c, c, -c, c, -c, -c, -c, c, -c, -c, "z"])) + } +}); +Ext.define("Ext.draw.sprite.Diamond", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.diamond", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + size: "number" + }, + defaults: { + x: 0, + y: 0, + size: 4 + }, + triggers: { + x: "path", + y: "path", + size: "path" + } + } + }, + updatePath: function(d, b) { + var c = b.size * 1.25, + a = b.x - b.lineWidth / 2, + e = b.y; + d.fromSvgString(["M", a, e - c, "l", c, c, -c, c, -c, -c, c, -c, "z"]) + } +}); +Ext.define("Ext.draw.sprite.Ellipse", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.ellipse", + type: "ellipse", + inheritableStatics: { + def: { + processors: { + cx: "number", + cy: "number", + rx: "number", + ry: "number", + axisRotation: "number" + }, + aliases: { + radius: "r", + x: "cx", + y: "cy", + centerX: "cx", + centerY: "cy", + radiusX: "rx", + radiusY: "ry" + }, + defaults: { + cx: 0, + cy: 0, + rx: 1, + ry: 1, + axisRotation: 0 + }, + triggers: { + cx: "path", + cy: "path", + rx: "path", + ry: "path", + axisRotation: "path" + } + } + }, + updatePlainBBox: function(c) { + var b = this.attr, + a = b.cx, + f = b.cy, + e = b.rx, + d = b.ry; + c.x = a - e; + c.y = f - d; + c.width = e + e; + c.height = d + d + }, + updateTransformedBBox: function(d) { + var i = this.attr, + f = i.cx, + e = i.cy, + c = i.rx, + b = i.ry, + l = b / c, + m = i.matrix.clone(), + a, q, k, j, p, o, n, g; + m.append(1, 0, 0, l, 0, e * (1 - l)); + a = m.getXX(); + k = m.getYX(); + p = m.getDX(); + q = m.getXY(); + j = m.getYY(); + o = m.getDY(); + n = Math.sqrt(a * a + k * k) * c; + g = Math.sqrt(q * q + j * j) * c; + d.x = f * a + e * k + p - n; + d.y = f * q + e * j + o - g; + d.width = n + n; + d.height = g + g + }, + updatePath: function(b, a) { + b.ellipse(a.cx, a.cy, a.rx, a.ry, a.axisRotation, 0, Math.PI * 2, false) + } +}); +Ext.define("Ext.draw.sprite.EllipticalArc", { + extend: "Ext.draw.sprite.Ellipse", + alias: "sprite.ellipticalArc", + type: "ellipticalArc", + inheritableStatics: { + def: { + processors: { + startAngle: "number", + endAngle: "number", + anticlockwise: "bool" + }, + aliases: { + from: "startAngle", + to: "endAngle", + start: "startAngle", + end: "endAngle" + }, + defaults: { + startAngle: 0, + endAngle: Math.PI * 2, + anticlockwise: false + }, + triggers: { + startAngle: "path", + endAngle: "path", + anticlockwise: "path" + } + } + }, + updatePath: function(b, a) { + b.ellipse(a.cx, a.cy, a.rx, a.ry, a.axisRotation, a.startAngle, a.endAngle, a.anticlockwise) + } +}); +Ext.define("Ext.draw.sprite.Rect", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.rect", + type: "rect", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + width: "number", + height: "number", + radius: "number" + }, + aliases: {}, + triggers: { + x: "path", + y: "path", + width: "path", + height: "path", + radius: "path" + }, + defaults: { + x: 0, + y: 0, + width: 8, + height: 8, + radius: 0 + } + } + }, + updatePlainBBox: function(b) { + var a = this.attr; + b.x = a.x; + b.y = a.y; + b.width = a.width; + b.height = a.height + }, + updateTransformedBBox: function(a, b) { + this.attr.matrix.transformBBox(b, this.attr.radius, a) + }, + updatePath: function(f, d) { + var c = d.x, + g = d.y, + e = d.width, + b = d.height, + a = Math.min(d.radius, Math.abs(d.height) * 0.5, Math.abs(d.width) * 0.5); + if (a === 0) { + f.rect(c, g, e, b) + } else { + f.moveTo(c + a, g); + f.arcTo(c + e, g, c + e, g + b, a); + f.arcTo(c + e, g + b, c, g + b, a); + f.arcTo(c, g + b, c, g, a); + f.arcTo(c, g, c + a, g, a) + } + } +}); +Ext.define("Ext.draw.sprite.Image", { + extend: "Ext.draw.sprite.Rect", + alias: "sprite.image", + type: "image", + statics: { + imageLoaders: {} + }, + inheritableStatics: { + def: { + processors: { + src: "string" + }, + defaults: { + src: "", + width: null, + height: null + } + } + }, + render: function(c, o) { + var j = this, + h = j.attr, + n = h.matrix, + a = h.src, + l = h.x, + k = h.y, + b = h.width, + m = h.height, + g = Ext.draw.sprite.Image.imageLoaders[a], + f, d, e; + if (g && g.done) { + n.toContext(o); + d = g.image; + o.drawImage(d, l, k, b || (d.naturalWidth || d.width) / c.devicePixelRatio, m || (d.naturalHeight || d.height) / c.devicePixelRatio) + } else { + if (!g) { + f = new Image(); + g = Ext.draw.sprite.Image.imageLoaders[a] = { + image: f, + done: false, + pendingSprites: [j], + pendingSurfaces: [c] + }; + f.width = b; + f.height = m; + f.onload = function() { + if (!g.done) { + g.done = true; + for (e = 0; e < g.pendingSprites.length; e++) { + g.pendingSprites[e].setDirty(true) + } + for (e in g.pendingSurfaces) { + g.pendingSurfaces[e].renderFrame() + } + } + }; + f.src = a + } else { + Ext.Array.include(g.pendingSprites, j); + Ext.Array.include(g.pendingSurfaces, c) + } + } + } +}); +Ext.define("Ext.draw.sprite.Instancing", { + extend: "Ext.draw.sprite.Sprite", + alias: "sprite.instancing", + type: "instancing", + isInstancing: true, + config: { + template: null + }, + instances: null, + applyTemplate: function(a) { + if (!a.isSprite) { + if (!a.xclass && !a.type) { + a.type = "circle" + } + a = Ext.create(a.xclass || "sprite." + a.type, a) + } + a.setParent(this); + return a + }, + updateTemplate: function(a, b) { + if (b) { + delete b.ownAttr + } + a.setSurface(this.getSurface()); + a.ownAttr = a.attr; + this.clearAll() + }, + updateSurface: function(a) { + var b = this.getTemplate(); + if (b) { + b.setSurface(a) + } + }, + get: function(a) { + return this.instances[a] + }, + getCount: function() { + return this.instances.length + }, + clearAll: function() { + var a = this.getTemplate(); + a.attr.children = this.instances = []; + this.position = 0 + }, + createInstance: function(d, f, c) { + var e = this.getTemplate(), + b = e.attr, + a = Ext.Object.chain(b); + e.topModifier.prepareAttributes(a); + e.attr = a; + e.setAttributes(d, f, c); + a.template = e; + this.instances.push(a); + e.attr = b; + this.position++; + return a + }, + getBBox: function() { + return null + }, + getBBoxFor: function(b, d) { + var c = this.getTemplate(), + a = c.attr, + e; + c.attr = this.instances[b]; + e = c.getBBox(d); + c.attr = a; + return e + }, + isVisible: function() { + var b = this.attr, + c = this.getParent(), + a; + a = c && c.isSurface && !b.hidden && b.globalAlpha; + return !!a + }, + isInstanceVisible: function(c) { + var e = this, + d = e.getTemplate(), + b = d.attr, + f = e.instances, + a = false; + if (!Ext.isNumber(c) || c < 0 || c >= f.length || !e.isVisible()) { + return a + } + d.attr = f[c]; + a = d.isVisible(point, options); + d.attr = b; + return a + }, + render: function(b, l, d, h) { + var g = this, + j = g.getTemplate(), + k = g.attr.matrix, + c = j.attr, + a = g.instances, + e, f = g.position; + k.toContext(l); + j.preRender(b, l, d, h); + j.useAttributes(l, h); + for (e = 0; e < f; e++) { + if (a[e].dirtyZIndex) { + break + } + } + for (e = 0; e < f; e++) { + if (a[e].hidden) { + continue + } + l.save(); + j.attr = a[e]; + j.useAttributes(l, h); + j.render(b, l, d, h); + l.restore() + } + j.attr = c + }, + setAttributesFor: function(c, e, f) { + var d = this.getTemplate(), + b = d.attr, + a = this.instances[c]; + if (!a) { + return + } + d.attr = a; + if (f) { + e = Ext.apply({}, e) + } else { + e = d.self.def.normalize(e) + } + d.topModifier.pushDown(a, e); + d.attr = b + }, + destroy: function() { + var b = this, + a = b.getTemplate(); + b.instances = null; + if (a) { + a.destroy() + } + b.callParent() + } +}); +Ext.define("Ext.draw.overrides.sprite.Instancing", { + override: "Ext.draw.sprite.Instancing", + hitTest: function(f, j) { + var e = this, + g = e.getTemplate(), + b = g.attr, + a = e.instances, + d = a.length, + c = 0, + h = null; + if (!e.isVisible()) { + return h + } + for (; c < d; c++) { + g.attr = a[c]; + h = g.hitTest(f, j); + if (h) { + h.isInstance = true; + h.template = h.sprite; + h.sprite = this; + h.instance = a[c]; + h.index = c; + return h + } + } + g.attr = b; + return h + } +}); +Ext.define("Ext.draw.sprite.Line", { + extend: "Ext.draw.sprite.Sprite", + alias: "sprite.line", + type: "line", + inheritableStatics: { + def: { + processors: { + fromX: "number", + fromY: "number", + toX: "number", + toY: "number" + }, + defaults: { + fromX: 0, + fromY: 0, + toX: 1, + toY: 1, + strokeStyle: "black" + }, + aliases: { + x1: "fromX", + y1: "fromY", + x2: "toX", + y2: "toY" + } + } + }, + updateLineBBox: function(b, i, s, g, r, f) { + var o = this.attr, + q = o.matrix, + h = o.lineWidth / 2, + m, l, d, c, k, j, n; + if (i) { + n = q.transformPoint([s, g]); + s = n[0]; + g = n[1]; + n = q.transformPoint([r, f]); + r = n[0]; + f = n[1] + } + m = Math.min(s, r); + d = Math.max(s, r); + l = Math.min(g, f); + c = Math.max(g, f); + var t = Math.atan2(d - m, c - l), + a = Math.sin(t), + e = Math.cos(t), + k = h * e, + j = h * a; + m -= k; + l -= j; + d += k; + c += j; + b.x = m; + b.y = l; + b.width = d - m; + b.height = c - l + }, + updatePlainBBox: function(b) { + var a = this.attr; + this.updateLineBBox(b, false, a.fromX, a.fromY, a.toX, a.toY) + }, + updateTransformedBBox: function(b, c) { + var a = this.attr; + this.updateLineBBox(b, true, a.fromX, a.fromY, a.toX, a.toY) + }, + render: function(b, c) { + var a = this.attr, + d = this.attr.matrix; + d.toContext(c); + c.beginPath(); + c.moveTo(a.fromX, a.fromY); + c.lineTo(a.toX, a.toY); + c.stroke() + } +}); +Ext.define("Ext.draw.sprite.Plus", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.plus", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + size: "number" + }, + defaults: { + x: 0, + y: 0, + size: 4 + }, + triggers: { + x: "path", + y: "path", + size: "path" + } + } + }, + updatePath: function(d, b) { + var c = b.size / 1.3, + a = b.x - b.lineWidth / 2, + e = b.y; + d.fromSvgString("M".concat(a - c / 2, ",", e - c / 2, "l", [0, -c, c, 0, 0, c, c, 0, 0, c, -c, 0, 0, c, -c, 0, 0, -c, -c, 0, 0, -c, "z"])) + } +}); +Ext.define("Ext.draw.sprite.Sector", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.sector", + type: "sector", + inheritableStatics: { + def: { + processors: { + centerX: "number", + centerY: "number", + startAngle: "number", + endAngle: "number", + startRho: "number", + endRho: "number", + margin: "number" + }, + aliases: { + rho: "endRho" + }, + triggers: { + centerX: "path,bbox", + centerY: "path,bbox", + startAngle: "path,bbox", + endAngle: "path,bbox", + startRho: "path,bbox", + endRho: "path,bbox", + margin: "path,bbox" + }, + defaults: { + centerX: 0, + centerY: 0, + startAngle: 0, + endAngle: 0, + startRho: 0, + endRho: 150, + margin: 0, + path: "M 0,0" + } + } + }, + getMidAngle: function() { + return this.midAngle || 0 + }, + updatePath: function(j, h) { + var g = Math.min(h.startAngle, h.endAngle), + c = Math.max(h.startAngle, h.endAngle), + b = this.midAngle = (g + c) * 0.5, + d = h.margin, + f = h.centerX, + e = h.centerY, + i = Math.min(h.startRho, h.endRho), + a = Math.max(h.startRho, h.endRho); + if (d) { + f += d * Math.cos(b); + e += d * Math.sin(b) + } + j.moveTo(f + i * Math.cos(g), e + i * Math.sin(g)); + j.lineTo(f + a * Math.cos(g), e + a * Math.sin(g)); + j.arc(f, e, a, g, c, false); + j.lineTo(f + i * Math.cos(c), e + i * Math.sin(c)); + j.arc(f, e, i, c, g, true) + } +}); +Ext.define("Ext.draw.sprite.Square", { + extend: "Ext.draw.sprite.Rect", + alias: "sprite.square", + inheritableStatics: { + def: { + processors: { + size: "number" + }, + defaults: { + size: 4 + }, + triggers: { + size: "size" + }, + updaters: { + size: function(a) { + var c = a.size, + b = a.lineWidth / 2; + this.setAttributes({ + x: a.x - c - b, + y: a.y - c, + height: 2 * c, + width: 2 * c + }) + } + } + } + } +}); +Ext.define("Ext.draw.TextMeasurer", { + singleton: true, + requires: ["Ext.util.TextMetrics"], + measureDiv: null, + measureCache: {}, + precise: Ext.isIE8, + measureDivTpl: { + tag: "div", + style: { + overflow: "hidden", + position: "relative", + "float": "left", + width: 0, + height: 0 + }, + children: { + tag: "div", + style: { + display: "block", + position: "absolute", + x: -100000, + y: -100000, + padding: 0, + margin: 0, + "z-index": -100000, + "white-space": "nowrap" + } + } + }, + actualMeasureText: function(g, b) { + var e = Ext.draw.TextMeasurer, + f = e.measureDiv, + a = 100000, + c; + if (!f) { + var d = Ext.Element.create({ + style: { + overflow: "hidden", + position: "relative", + "float": "left", + width: 0, + height: 0 + } + }); + e.measureDiv = f = Ext.Element.create({ + style: { + position: "absolute", + x: a, + y: a, + "z-index": -a, + "white-space": "nowrap", + display: "block", + padding: 0, + margin: 0 + } + }); + Ext.getBody().appendChild(d); + d.appendChild(f) + } + if (b) { + f.setStyle({ + font: b, + lineHeight: "normal" + }) + } + f.setText("(" + g + ")"); + c = f.getSize(); + f.setText("()"); + c.width -= f.getSize().width; + return c + }, + measureTextSingleLine: function(h, d) { + if (this.precise) { + return this.preciseMeasureTextSingleLine(h, d) + } + h = h.toString(); + var a = this.measureCache, + g = h.split(""), + c = 0, + j = 0, + l, b, e, f, k; + if (!a[d]) { + a[d] = {} + } + a = a[d]; + if (a[h]) { + return a[h] + } + for (e = 0, f = g.length; e < f; e++) { + b = g[e]; + if (!(l = a[b])) { + k = this.actualMeasureText(b, d); + l = a[b] = k + } + c += l.width; + j = Math.max(j, l.height) + } + return a[h] = { + width: c, + height: j + } + }, + preciseMeasureTextSingleLine: function(c, a) { + c = c.toString(); + var b = this.measureDiv || (this.measureDiv = Ext.getBody().createChild(this.measureDivTpl).down("div")); + b.setStyle({ + font: a || "" + }); + return Ext.util.TextMetrics.measure(b, c) + }, + measureText: function(e, b) { + var h = e.split("\n"), + d = h.length, + f = 0, + a = 0, + j, c, g; + if (d === 1) { + return this.measureTextSingleLine(e, b) + } + g = []; + for (c = 0; c < d; c++) { + j = this.measureTextSingleLine(h[c], b); + g.push(j); + f += j.height; + a = Math.max(a, j.width) + } + return { + width: a, + height: f, + sizes: g + } + } +}); +Ext.define("Ext.draw.sprite.Text", function() { + var d = { + "xx-small": true, + "x-small": true, + small: true, + medium: true, + large: true, + "x-large": true, + "xx-large": true + }; + var b = { + normal: true, + bold: true, + bolder: true, + lighter: true, + 100: true, + 200: true, + 300: true, + 400: true, + 500: true, + 600: true, + 700: true, + 800: true, + 900: true + }; + var a = { + start: "start", + left: "start", + center: "center", + middle: "center", + end: "end", + right: "end" + }; + var c = { + top: "top", + hanging: "hanging", + middle: "middle", + center: "middle", + alphabetic: "alphabetic", + ideographic: "ideographic", + bottom: "bottom" + }; + return { + extend: "Ext.draw.sprite.Sprite", + requires: ["Ext.draw.TextMeasurer", "Ext.draw.Color"], + alias: "sprite.text", + type: "text", + lineBreakRe: /\r?\n/g, + inheritableStatics: { + def: { + animationProcessors: { + text: "text" + }, + processors: { + x: "number", + y: "number", + text: "string", + fontSize: function(e) { + if (Ext.isNumber(+e)) { + return e + "px" + } else { + if (e.match(Ext.dom.Element.unitRe)) { + return e + } else { + if (e in d) { + return e + } + } + } + }, + fontStyle: "enums(,italic,oblique)", + fontVariant: "enums(,small-caps)", + fontWeight: function(e) { + if (e in b) { + return String(e) + } else { + return "" + } + }, + fontFamily: "string", + textAlign: function(e) { + return a[e] || "center" + }, + textBaseline: function(e) { + return c[e] || "alphabetic" + }, + font: "string" + }, + aliases: { + "font-size": "fontSize", + "font-family": "fontFamily", + "font-weight": "fontWeight", + "font-variant": "fontVariant", + "text-anchor": "textAlign" + }, + defaults: { + fontStyle: "", + fontVariant: "", + fontWeight: "", + fontSize: "10px", + fontFamily: "sans-serif", + font: "10px sans-serif", + textBaseline: "alphabetic", + textAlign: "start", + strokeStyle: "rgba(0, 0, 0, 0)", + fillStyle: "#000", + x: 0, + y: 0, + text: "" + }, + triggers: { + fontStyle: "fontX,bbox", + fontVariant: "fontX,bbox", + fontWeight: "fontX,bbox", + fontSize: "fontX,bbox", + fontFamily: "fontX,bbox", + font: "font,bbox,canvas", + textBaseline: "bbox", + textAlign: "bbox", + x: "bbox", + y: "bbox", + text: "bbox" + }, + updaters: { + fontX: "makeFontShorthand", + font: "parseFontShorthand" + } + } + }, + constructor: function(e) { + if (e && e.font) { + e = Ext.clone(e); + for (var f in e) { + if (f !== "font" && f.indexOf("font") === 0) { + delete e[f] + } + } + } + Ext.draw.sprite.Sprite.prototype.constructor.call(this, e) + }, + fontValuesMap: { + italic: "fontStyle", + oblique: "fontStyle", + "small-caps": "fontVariant", + bold: "fontWeight", + bolder: "fontWeight", + lighter: "fontWeight", + "100": "fontWeight", + "200": "fontWeight", + "300": "fontWeight", + "400": "fontWeight", + "500": "fontWeight", + "600": "fontWeight", + "700": "fontWeight", + "800": "fontWeight", + "900": "fontWeight", + "xx-small": "fontSize", + "x-small": "fontSize", + small: "fontSize", + medium: "fontSize", + large: "fontSize", + "x-large": "fontSize", + "xx-large": "fontSize" + }, + makeFontShorthand: function(e) { + var f = []; + if (e.fontStyle) { + f.push(e.fontStyle) + } + if (e.fontVariant) { + f.push(e.fontVariant) + } + if (e.fontWeight) { + f.push(e.fontWeight) + } + if (e.fontSize) { + f.push(e.fontSize) + } + if (e.fontFamily) { + f.push(e.fontFamily) + } + this.setAttributes({ + font: f.join(" ") + }, true) + }, + parseFontShorthand: function(j) { + var m = j.font, + k = m.length, + l = {}, + n = this.fontValuesMap, + e = 0, + i, g, f, h; + while (e < k && i !== -1) { + i = m.indexOf(" ", e); + if (i < 0) { + f = m.substr(e) + } else { + if (i > e) { + f = m.substr(e, i - e) + } else { + continue + } + } + g = f.indexOf("/"); + if (g > 0) { + f = f.substr(0, g) + } else { + if (g === 0) { + continue + } + } + if (f !== "normal" && f !== "inherit") { + h = n[f]; + if (h) { + l[h] = f + } else { + if (f.match(Ext.dom.Element.unitRe)) { + l.fontSize = f + } else { + l.fontFamily = m.substr(e); + break + } + } + } + e = i + 1 + } + if (!l.fontStyle) { + l.fontStyle = "" + } + if (!l.fontVariant) { + l.fontVariant = "" + } + if (!l.fontWeight) { + l.fontWeight = "" + } + this.setAttributes(l, true) + }, + fontProperties: { + fontStyle: true, + fontVariant: true, + fontWeight: true, + fontSize: true, + fontFamily: true + }, + setAttributes: function(g, i, e) { + var f, h; + if (g && g.font) { + h = {}; + for (f in g) { + if (!(f in this.fontProperties)) { + h[f] = g[f] + } + } + g = h + } + this.callParent([g, i, e]) + }, + getBBox: function(g) { + var h = this, + f = h.attr.bbox.plain, + e = h.getSurface(); + if (f.dirty) { + h.updatePlainBBox(f); + f.dirty = false + } + if (e.getInherited().rtl && e.getFlipRtlText()) { + h.updatePlainBBox(f, true) + } + return h.callParent([g]) + }, + rtlAlignments: { + start: "end", + center: "center", + end: "start" + }, + updatePlainBBox: function(k, B) { + var C = this, + w = C.attr, + o = w.x, + n = w.y, + q = [], + t = w.font, + r = w.text, + s = w.textBaseline, + l = w.textAlign, + u = (B && C.oldSize) ? C.oldSize : (C.oldSize = Ext.draw.TextMeasurer.measureText(r, t)), + z = C.getSurface(), + p = z.getInherited().rtl, + v = p && z.getFlipRtlText(), + h = z.getRect(), + f = u.sizes, + g = u.height, + j = u.width, + m = f ? f.length : 0, + e, A = 0; + switch (s) { + case "hanging": + case "top": + break; + case "ideographic": + case "bottom": + n -= g; + break; + case "alphabetic": + n -= g * 0.8; + break; + case "middle": + n -= g * 0.5; + break + } + if (v) { + o = h[2] - h[0] - o; + l = C.rtlAlignments[l] + } + switch (l) { + case "start": + if (p) { + for (; A < m; A++) { + e = f[A].width; + q.push(-(j - e)) + } + } + break; + case "end": + o -= j; + if (p) { + break + } + for (; A < m; A++) { + e = f[A].width; + q.push(j - e) + } + break; + case "center": + o -= j * 0.5; + for (; A < m; A++) { + e = f[A].width; + q.push((p ? -1 : 1) * (j - e) * 0.5) + } + break + } + w.textAlignOffsets = q; + k.x = o; + k.y = n; + k.width = j; + k.height = g + }, + setText: function(e) { + this.setAttributes({ + text: e + }, true) + }, + render: function(e, q, k) { + var h = this, + g = h.attr, + p = Ext.draw.Matrix.fly(g.matrix.elements.slice(0)), + o = h.getBBox(true), + s = g.textAlignOffsets, + m = Ext.draw.Color.RGBA_NONE, + l, j, f, r, n; + if (g.text.length === 0) { + return + } + r = g.text.split(h.lineBreakRe); + n = o.height / r.length; + l = g.bbox.plain.x; + j = g.bbox.plain.y + n * 0.78; + p.toContext(q); + if (e.getInherited().rtl) { + l += g.bbox.plain.width + } + for (f = 0; f < r.length; f++) { + if (q.fillStyle !== m) { + q.fillText(r[f], l + (s[f] || 0), j + n * f) + } + if (q.strokeStyle !== m) { + q.strokeText(r[f], l + (s[f] || 0), j + n * f) + } + } + } + } +}); +Ext.define("Ext.draw.sprite.Tick", { + extend: "Ext.draw.sprite.Line", + alias: "sprite.tick", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + size: "number" + }, + defaults: { + x: 0, + y: 0, + size: 4 + }, + triggers: { + x: "tick", + y: "tick", + size: "tick" + }, + updaters: { + tick: function(b) { + var d = b.size * 1.5, + c = b.lineWidth / 2, + a = b.x, + e = b.y; + this.setAttributes({ + fromX: a - c, + fromY: e - d, + toX: a - c, + toY: e + d + }) + } + } + } + } +}); +Ext.define("Ext.draw.sprite.Triangle", { + extend: "Ext.draw.sprite.Path", + alias: "sprite.triangle", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + size: "number" + }, + defaults: { + x: 0, + y: 0, + size: 4 + }, + triggers: { + x: "path", + y: "path", + size: "path" + } + } + }, + updatePath: function(d, b) { + var c = b.size * 2.2, + a = b.x, + e = b.y; + d.fromSvgString("M".concat(a, ",", e, "m0-", c * 0.58, "l", c * 0.5, ",", c * 0.87, "-", c, ",0z")) + } +}); +Ext.define("Ext.draw.gradient.Linear", { + extend: "Ext.draw.gradient.Gradient", + requires: ["Ext.draw.Color"], + type: "linear", + config: { + degrees: 0, + radians: 0 + }, + applyRadians: function(b, a) { + if (Ext.isNumber(b)) { + return b + } + return a + }, + applyDegrees: function(b, a) { + if (Ext.isNumber(b)) { + return b + } + return a + }, + updateRadians: function(a) { + this.setDegrees(Ext.draw.Draw.degrees(a)) + }, + updateDegrees: function(a) { + this.setRadians(Ext.draw.Draw.rad(a)) + }, + generateGradient: function(q, o) { + var c = this.getRadians(), + p = Math.cos(c), + j = Math.sin(c), + m = o.width, + f = o.height, + d = o.x + m * 0.5, + b = o.y + f * 0.5, + n = this.getStops(), + g = n.length, + k, a, e; + if (Ext.isNumber(d + b) && f > 0 && m > 0) { + a = (Math.sqrt(f * f + m * m) * Math.abs(Math.cos(c - Math.atan(f / m)))) / 2; + k = q.createLinearGradient(d + p * a, b + j * a, d - p * a, b - j * a); + for (e = 0; e < g; e++) { + k.addColorStop(n[e].offset, n[e].color) + } + return k + } + return Ext.draw.Color.NONE + } +}); +Ext.define("Ext.draw.gradient.Radial", { + extend: "Ext.draw.gradient.Gradient", + type: "radial", + config: { + start: { + x: 0, + y: 0, + r: 0 + }, + end: { + x: 0, + y: 0, + r: 1 + } + }, + applyStart: function(a, b) { + if (!b) { + return a + } + var c = { + x: b.x, + y: b.y, + r: b.r + }; + if ("x" in a) { + c.x = a.x + } else { + if ("centerX" in a) { + c.x = a.centerX + } + } + if ("y" in a) { + c.y = a.y + } else { + if ("centerY" in a) { + c.y = a.centerY + } + } + if ("r" in a) { + c.r = a.r + } else { + if ("radius" in a) { + c.r = a.radius + } + } + return c + }, + applyEnd: function(b, a) { + if (!a) { + return b + } + var c = { + x: a.x, + y: a.y, + r: a.r + }; + if ("x" in b) { + c.x = b.x + } else { + if ("centerX" in b) { + c.x = b.centerX + } + } + if ("y" in b) { + c.y = b.y + } else { + if ("centerY" in b) { + c.y = b.centerY + } + } + if ("r" in b) { + c.r = b.r + } else { + if ("radius" in b) { + c.r = b.radius + } + } + return c + }, + generateGradient: function(n, m) { + var a = this.getStart(), + b = this.getEnd(), + k = m.width * 0.5, + d = m.height * 0.5, + j = m.x + k, + f = m.y + d, + g = n.createRadialGradient(j + a.x * k, f + a.y * d, a.r * Math.max(k, d), j + b.x * k, f + b.y * d, b.r * Math.max(k, d)), + l = this.getStops(), + e = l.length, + c; + for (c = 0; c < e; c++) { + g.addColorStop(l[c].offset, l[c].color) + } + return g + } +}); +Ext.define("Ext.draw.Surface", { + extend: "Ext.draw.SurfaceBase", + xtype: "surface", + requires: ["Ext.draw.sprite.*", "Ext.draw.gradient.*", "Ext.draw.sprite.AttributeDefinition", "Ext.draw.Matrix", "Ext.draw.Draw"], + uses: ["Ext.draw.engine.Canvas"], + devicePixelRatio: window.devicePixelRatio || window.screen.deviceXDPI / window.screen.logicalXDPI, + deprecated: { + "5.1.0": { + statics: { + methods: { + stableSort: function(a) { + return Ext.Array.sort(a, function(d, c) { + return d.attr.zIndex - c.attr.zIndex + }) + } + } + } + } + }, + config: { + cls: Ext.baseCSSPrefix + "surface", + rect: null, + background: null, + items: [], + dirty: false, + flipRtlText: false + }, + isSurface: true, + isPendingRenderFrame: false, + dirtyPredecessorCount: 0, + constructor: function(a) { + var b = this; + b.predecessors = []; + b.successors = []; + b.map = {}; + b.callParent([a]); + b.matrix = new Ext.draw.Matrix(); + b.inverseMatrix = b.matrix.inverse() + }, + roundPixel: function(a) { + return Math.round(this.devicePixelRatio * a) / this.devicePixelRatio + }, + waitFor: function(a) { + var b = this, + c = b.predecessors; + if (!Ext.Array.contains(c, a)) { + c.push(a); + a.successors.push(b); + if (a.getDirty()) { + b.dirtyPredecessorCount++ + } + } + }, + updateDirty: function(d) { + var c = this.successors, + e = c.length, + b = 0, + a; + for (; b < e; b++) { + a = c[b]; + if (d) { + a.dirtyPredecessorCount++; + a.setDirty(true) + } else { + a.dirtyPredecessorCount--; + if (a.dirtyPredecessorCount === 0 && a.isPendingRenderFrame) { + a.renderFrame() + } + } + } + }, + applyBackground: function(a, b) { + this.setDirty(true); + if (Ext.isString(a)) { + a = { + fillStyle: a + } + } + return Ext.factory(a, Ext.draw.sprite.Rect, b) + }, + applyRect: function(a, b) { + if (b && a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3]) { + return + } + if (Ext.isArray(a)) { + return [a[0], a[1], a[2], a[3]] + } else { + if (Ext.isObject(a)) { + return [a.x || a.left, a.y || a.top, a.width || (a.right - a.left), a.height || (a.bottom - a.top)] + } + } + }, + updateRect: function(i) { + var h = this, + c = i[0], + f = i[1], + g = c + i[2], + a = f + i[3], + e = h.getBackground(), + d = h.element; + d.setLocalXY(Math.floor(c), Math.floor(f)); + d.setSize(Math.ceil(g - Math.floor(c)), Math.ceil(a - Math.floor(f))); + if (e) { + e.setAttributes({ + x: 0, + y: 0, + width: Math.ceil(g - Math.floor(c)), + height: Math.ceil(a - Math.floor(f)) + }) + } + h.setDirty(true) + }, + resetTransform: function() { + this.matrix.set(1, 0, 0, 1, 0, 0); + this.inverseMatrix.set(1, 0, 0, 1, 0, 0); + this.setDirty(true) + }, + get: function(a) { + return this.map[a] || this.getItems()[a] + }, + add: function() { + var g = this, + e = Array.prototype.slice.call(arguments), + j = Ext.isArray(e[0]), + a = g.map, + c = [], + f, k, h, b, d; + f = Ext.Array.clean(j ? e[0] : e); + if (!f.length) { + return c + } + for (b = 0, d = f.length; b < d; b++) { + k = f[b]; + h = null; + if (k.isSprite && !a[k.getId()]) { + h = k + } else { + if (!a[k.id]) { + h = this.createItem(k) + } + } + if (h) { + a[h.getId()] = h; + c.push(h); + h.setParent(g); + h.setSurface(g); + g.onAdd(h) + } + } + f = g.getItems(); + if (f) { + f.push.apply(f, c) + } + g.dirtyZIndex = true; + g.setDirty(true); + if (!j && c.length === 1) { + return c[0] + } else { + return c + } + }, + onAdd: Ext.emptyFn, + remove: function(a, c) { + var b = this, + e, d; + if (a) { + if (a.charAt) { + a = b.map[a] + } + if (!a || !a.isSprite) { + return null + } + if (a.isDestroyed || a.isDestroying) { + return a + } + e = a.getId(); + d = b.map[e]; + delete b.map[e]; + if (c) { + a.destroy() + } + if (!d) { + return a + } + a.setParent(null); + a.setSurface(null); + Ext.Array.remove(b.getItems(), a); + b.dirtyZIndex = true; + b.setDirty(true) + } + return a || null + }, + removeAll: function(d) { + var a = this.getItems(), + b = a.length - 1, + c; + if (d) { + for (; b >= 0; b--) { + a[b].destroy() + } + } else { + for (; b >= 0; b--) { + c = a[b]; + c.setParent(null); + c.setSurface(null) + } + } + a.length = 0; + this.map = {}; + this.dirtyZIndex = true + }, + applyItems: function(a) { + if (this.getItems()) { + this.removeAll(true) + } + return Ext.Array.from(this.add(a)) + }, + createItem: function(a) { + return Ext.create(a.xclass || "sprite." + a.type, a) + }, + getBBox: function(f, b) { + var f = Ext.Array.from(f), + c = Infinity, + h = -Infinity, + g = Infinity, + a = -Infinity, + j, k, d, e; + for (d = 0, e = f.length; d < e; d++) { + j = f[d]; + k = j.getBBox(b); + if (c > k.x) { + c = k.x + } + if (h < k.x + k.width) { + h = k.x + k.width + } + if (g > k.y) { + g = k.y + } + if (a < k.y + k.height) { + a = k.y + k.height + } + } + return { + x: c, + y: g, + width: h - c, + height: a - g + } + }, + emptyRect: [0, 0, 0, 0], + getEventXY: function(d) { + var g = this, + f = g.getInherited().rtl, + c = d.getXY(), + a = g.getOwnerBody(), + i = a.getXY(), + h = g.getRect() || g.emptyRect, + j = [], + b; + if (f) { + b = a.getWidth(); + j[0] = i[0] - c[0] - h[0] + b + } else { + j[0] = c[0] - i[0] - h[0] + } + j[1] = c[1] - i[1] - h[1]; + return j + }, + clear: Ext.emptyFn, + orderByZIndex: function() { + var d = this, + a = d.getItems(), + e = false, + b, c; + if (d.getDirty()) { + for (b = 0, c = a.length; b < c; b++) { + if (a[b].attr.dirtyZIndex) { + e = true; + break + } + } + if (e) { + Ext.Array.sort(a, function(g, f) { + return g.attr.zIndex - f.attr.zIndex + }); + this.setDirty(true) + } + for (b = 0, c = a.length; b < c; b++) { + a[b].attr.dirtyZIndex = false + } + } + }, + repaint: function() { + var a = this; + a.repaint = Ext.emptyFn; + Ext.defer(function() { + delete a.repaint; + a.element.repaint() + }, 1) + }, + renderFrame: function() { + var g = this; + if (!g.element) { + return + } + if (g.dirtyPredecessorCount > 0) { + g.isPendingRenderFrame = true; + return + } + var f = g.getRect(), + c = g.getBackground(), + a = g.getItems(), + e, b, d; + if (!f) { + return + } + g.orderByZIndex(); + if (g.getDirty()) { + g.clear(); + g.clearTransform(); + if (c) { + g.renderSprite(c) + } + for (b = 0, d = a.length; b < d; b++) { + e = a[b]; + if (g.renderSprite(e) === false) { + return + } + e.attr.textPositionCount = g.textPosition + } + g.setDirty(false) + } + }, + renderSprite: Ext.emptyFn, + clearTransform: Ext.emptyFn, + destroy: function() { + var a = this; + a.removeAll(true); + a.predecessors = null; + a.successors = null; + a.callParent() + } +}); +Ext.define("Ext.draw.overrides.Surface", { + override: "Ext.draw.Surface", + hitTest: function(b, c) { + var f = this, + g = f.getItems(), + e, d, a; + c = c || Ext.draw.sprite.Sprite.defaultHitTestOptions; + for (e = g.length - 1; e >= 0; e--) { + d = g[e]; + if (d.hitTest) { + a = d.hitTest(b, c); + if (a) { + return a + } + } + } + return null + }, + hitTestEvent: function(b, a) { + var c = this.getEventXY(b); + return this.hitTest(c, a) + } +}); +Ext.define("Ext.draw.engine.SvgContext", { + requires: ["Ext.draw.Color"], + toSave: ["strokeOpacity", "strokeStyle", "fillOpacity", "fillStyle", "globalAlpha", "lineWidth", "lineCap", "lineJoin", "lineDash", "lineDashOffset", "miterLimit", "shadowOffsetX", "shadowOffsetY", "shadowBlur", "shadowColor", "globalCompositeOperation", "position", "fillGradient", "strokeGradient"], + strokeOpacity: 1, + strokeStyle: "none", + fillOpacity: 1, + fillStyle: "none", + lineDash: [], + lineDashOffset: 0, + globalAlpha: 1, + lineWidth: 1, + lineCap: "butt", + lineJoin: "miter", + miterLimit: 10, + shadowOffsetX: 0, + shadowOffsetY: 0, + shadowBlur: 0, + shadowColor: "none", + globalCompositeOperation: "src", + urlStringRe: /^url\(#([\w\-]+)\)$/, + constructor: function(a) { + this.surface = a; + this.state = []; + this.matrix = new Ext.draw.Matrix(); + this.path = null; + this.clear() + }, + clear: function() { + this.group = this.surface.mainGroup; + this.position = 0; + this.path = null + }, + getElement: function(a) { + return this.surface.getSvgElement(this.group, a, this.position++) + }, + removeElement: function(d) { + var d = Ext.fly(d), + h, g, b, f, a, e, c; + if (!d) { + return + } + if (d.dom.tagName === "g") { + a = d.dom.gradients; + for (c in a) { + a[c].destroy() + } + } else { + h = d.getAttribute("fill"); + g = d.getAttribute("stroke"); + b = h && h.match(this.urlStringRe); + f = g && g.match(this.urlStringRe); + if (b && b[1]) { + e = Ext.fly(b[1]); + if (e) { + e.destroy() + } + } + if (f && f[1]) { + e = Ext.fly(f[1]); + if (e) { + e.destroy() + } + } + } + d.destroy() + }, + save: function() { + var c = this.toSave, + e = {}, + d = this.getElement("g"), + b, a; + for (a = 0; a < c.length; a++) { + b = c[a]; + if (b in this) { + e[b] = this[b] + } + } + this.position = 0; + e.matrix = this.matrix.clone(); + this.state.push(e); + this.group = d; + return d + }, + restore: function() { + var d = this.toSave, + e = this.state.pop(), + c = this.group.dom.childNodes, + b, a; + while (c.length > this.position) { + this.removeElement(c[c.length - 1]) + } + for (a = 0; a < d.length; a++) { + b = d[a]; + if (b in e) { + this[b] = e[b] + } else { + delete this[b] + } + } + this.setTransform.apply(this, e.matrix.elements); + this.group = this.group.getParent() + }, + transform: function(f, b, e, g, d, c) { + if (this.path) { + var a = Ext.draw.Matrix.fly([f, b, e, g, d, c]).inverse(); + this.path.transform(a) + } + this.matrix.append(f, b, e, g, d, c) + }, + setTransform: function(e, a, d, f, c, b) { + if (this.path) { + this.path.transform(this.matrix) + } + this.matrix.reset(); + this.transform(e, a, d, f, c, b) + }, + scale: function(a, b) { + this.transform(a, 0, 0, b, 0, 0) + }, + rotate: function(d) { + var c = Math.cos(d), + a = Math.sin(d), + b = -Math.sin(d), + e = Math.cos(d); + this.transform(c, a, b, e, 0, 0) + }, + translate: function(a, b) { + this.transform(1, 0, 0, 1, a, b) + }, + setGradientBBox: function(a) { + this.bbox = a + }, + beginPath: function() { + this.path = new Ext.draw.Path() + }, + moveTo: function(a, b) { + if (!this.path) { + this.beginPath() + } + this.path.moveTo(a, b); + this.path.element = null + }, + lineTo: function(a, b) { + if (!this.path) { + this.beginPath() + } + this.path.lineTo(a, b); + this.path.element = null + }, + rect: function(b, d, c, a) { + this.moveTo(b, d); + this.lineTo(b + c, d); + this.lineTo(b + c, d + a); + this.lineTo(b, d + a); + this.closePath() + }, + strokeRect: function(b, d, c, a) { + this.beginPath(); + this.rect(b, d, c, a); + this.stroke() + }, + fillRect: function(b, d, c, a) { + this.beginPath(); + this.rect(b, d, c, a); + this.fill() + }, + closePath: function() { + if (!this.path) { + this.beginPath() + } + this.path.closePath(); + this.path.element = null + }, + arcSvg: function(d, a, f, g, c, b, e) { + if (!this.path) { + this.beginPath() + } + this.path.arcSvg(d, a, f, g, c, b, e); + this.path.element = null + }, + arc: function(b, f, a, d, c, e) { + if (!this.path) { + this.beginPath() + } + this.path.arc(b, f, a, d, c, e); + this.path.element = null + }, + ellipse: function(a, h, g, f, d, c, b, e) { + if (!this.path) { + this.beginPath() + } + this.path.ellipse(a, h, g, f, d, c, b, e); + this.path.element = null + }, + arcTo: function(b, e, a, d, g, f, c) { + if (!this.path) { + this.beginPath() + } + this.path.arcTo(b, e, a, d, g, f, c); + this.path.element = null + }, + bezierCurveTo: function(d, f, b, e, a, c) { + if (!this.path) { + this.beginPath() + } + this.path.bezierCurveTo(d, f, b, e, a, c); + this.path.element = null + }, + strokeText: function(d, a, e) { + d = String(d); + if (this.strokeStyle) { + var b = this.getElement("text"), + c = this.surface.getSvgElement(b, "tspan", 0); + this.surface.setElementAttributes(b, { + x: a, + y: e, + transform: this.matrix.toSvg(), + stroke: this.strokeStyle, + fill: "none", + opacity: this.globalAlpha, + "stroke-opacity": this.strokeOpacity, + style: "font: " + this.font, + "stroke-dasharray": this.lineDash.join(","), + "stroke-dashoffset": this.lineDashOffset + }); + if (this.lineDash.length) { + this.surface.setElementAttributes(b, { + "stroke-dasharray": this.lineDash.join(","), + "stroke-dashoffset": this.lineDashOffset + }) + } + if (c.dom.firstChild) { + c.dom.removeChild(c.dom.firstChild) + } + this.surface.setElementAttributes(c, { + "alignment-baseline": "alphabetic" + }); + c.dom.appendChild(document.createTextNode(Ext.String.htmlDecode(d))) + } + }, + fillText: function(d, a, e) { + d = String(d); + if (this.fillStyle) { + var b = this.getElement("text"), + c = this.surface.getSvgElement(b, "tspan", 0); + this.surface.setElementAttributes(b, { + x: a, + y: e, + transform: this.matrix.toSvg(), + fill: this.fillStyle, + opacity: this.globalAlpha, + "fill-opacity": this.fillOpacity, + style: "font: " + this.font + }); + if (c.dom.firstChild) { + c.dom.removeChild(c.dom.firstChild) + } + this.surface.setElementAttributes(c, { + "alignment-baseline": "alphabetic" + }); + c.dom.appendChild(document.createTextNode(Ext.String.htmlDecode(d))) + } + }, + drawImage: function(c, k, i, l, e, p, n, a, g) { + var f = this, + d = f.getElement("image"), + j = k, + h = i, + b = typeof l === "undefined" ? c.width : l, + m = typeof e === "undefined" ? c.height : e, + o = null; + if (typeof g !== "undefined") { + o = k + " " + i + " " + l + " " + e; + j = p; + h = n; + b = a; + m = g + } + d.dom.setAttributeNS("http://www.w3.org/1999/xlink", "href", c.src); + f.surface.setElementAttributes(d, { + viewBox: o, + x: j, + y: h, + width: b, + height: m, + opacity: f.globalAlpha, + transform: f.matrix.toSvg() + }) + }, + fill: function() { + if (!this.path) { + return + } + if (this.fillStyle) { + var c, a = this.fillGradient, + d = this.bbox, + b = this.path.element; + if (!b) { + c = this.path.toString(); + b = this.path.element = this.getElement("path"); + this.surface.setElementAttributes(b, { + d: c, + transform: this.matrix.toSvg() + }) + } + this.surface.setElementAttributes(b, { + fill: a && d ? a.generateGradient(this, d) : this.fillStyle, + "fill-opacity": this.fillOpacity * this.globalAlpha + }) + } + }, + stroke: function() { + if (!this.path) { + return + } + if (this.strokeStyle) { + var c, b = this.strokeGradient, + d = this.bbox, + a = this.path.element; + if (!a || !this.path.svgString) { + c = this.path.toString(); + if (!c) { + return + } + a = this.path.element = this.getElement("path"); + this.surface.setElementAttributes(a, { + fill: "none", + d: c, + transform: this.matrix.toSvg() + }) + } + this.surface.setElementAttributes(a, { + stroke: b && d ? b.generateGradient(this, d) : this.strokeStyle, + "stroke-linecap": this.lineCap, + "stroke-linejoin": this.lineJoin, + "stroke-width": this.lineWidth, + "stroke-opacity": this.strokeOpacity * this.globalAlpha, + "stroke-dasharray": this.lineDash.join(","), + "stroke-dashoffset": this.lineDashOffset + }); + if (this.lineDash.length) { + this.surface.setElementAttributes(a, { + "stroke-dasharray": this.lineDash.join(","), + "stroke-dashoffset": this.lineDashOffset + }) + } + } + }, + fillStroke: function(a, e) { + var b = this, + d = b.fillStyle, + g = b.strokeStyle, + c = b.fillOpacity, + f = b.strokeOpacity; + if (e === undefined) { + e = a.transformFillStroke + } + if (!e) { + a.inverseMatrix.toContext(b) + } + if (d && c !== 0) { + b.fill() + } + if (g && f !== 0) { + b.stroke() + } + }, + appendPath: function(a) { + this.path = a.clone() + }, + setLineDash: function(a) { + this.lineDash = a + }, + getLineDash: function() { + return this.lineDash + }, + createLinearGradient: function(d, g, b, e) { + var f = this, + c = f.surface.getNextDef("linearGradient"), + a = f.group.dom.gradients || (f.group.dom.gradients = {}), + h; + f.surface.setElementAttributes(c, { + x1: d, + y1: g, + x2: b, + y2: e, + gradientUnits: "userSpaceOnUse" + }); + h = new Ext.draw.engine.SvgContext.Gradient(f, f.surface, c); + a[c.dom.id] = h; + return h + }, + createRadialGradient: function(b, j, d, a, i, c) { + var g = this, + e = g.surface.getNextDef("radialGradient"), + f = g.group.dom.gradients || (g.group.dom.gradients = {}), + h; + g.surface.setElementAttributes(e, { + fx: b, + fy: j, + cx: a, + cy: i, + r: c, + gradientUnits: "userSpaceOnUse" + }); + h = new Ext.draw.engine.SvgContext.Gradient(g, g.surface, e, d / c); + f[e.dom.id] = h; + return h + } +}); +Ext.define("Ext.draw.engine.SvgContext.Gradient", { + statics: { + map: {} + }, + constructor: function(c, a, d, b) { + var f = this.statics().map, + e; + e = f[d.dom.id]; + if (e) { + e.element = null + } + f[d.dom.id] = this; + this.ctx = c; + this.surface = a; + this.element = d; + this.position = 0; + this.compression = b || 0 + }, + addColorStop: function(d, b) { + var c = this.surface.getSvgElement(this.element, "stop", this.position++), + a = this.compression; + this.surface.setElementAttributes(c, { + offset: (((1 - a) * d + a) * 100).toFixed(2) + "%", + "stop-color": b, + "stop-opacity": Ext.draw.Color.fly(b).a.toFixed(15) + }) + }, + toString: function() { + var a = this.element.dom.childNodes; + while (a.length > this.position) { + Ext.fly(a[a.length - 1]).destroy() + } + return "url(#" + this.element.getId() + ")" + }, + destroy: function() { + var b = this.statics().map, + a = this.element; + if (a && a.dom) { + delete b[a.dom.id]; + a.destroy() + } + this.callParent() + } +}); +Ext.define("Ext.draw.engine.Svg", { + extend: "Ext.draw.Surface", + requires: ["Ext.draw.engine.SvgContext"], + statics: { + BBoxTextCache: {} + }, + config: { + highPrecision: false + }, + getElementConfig: function() { + return { + reference: "element", + style: { + position: "absolute" + }, + children: [{ + reference: "innerElement", + style: { + width: "100%", + height: "100%", + position: "relative" + }, + children: [{ + tag: "svg", + reference: "svgElement", + namespace: "http://www.w3.org/2000/svg", + width: "100%", + height: "100%", + version: 1.1 + }] + }] + } + }, + constructor: function(a) { + var b = this; + b.callParent([a]); + b.mainGroup = b.createSvgNode("g"); + b.defElement = b.createSvgNode("defs"); + b.svgElement.appendChild(b.mainGroup); + b.svgElement.appendChild(b.defElement); + b.ctx = new Ext.draw.engine.SvgContext(b) + }, + createSvgNode: function(a) { + var b = document.createElementNS("http://www.w3.org/2000/svg", a); + return Ext.get(b) + }, + getSvgElement: function(d, b, a) { + var c; + if (d.dom.childNodes.length > a) { + c = d.dom.childNodes[a]; + if (c.tagName === b) { + return Ext.get(c) + } else { + Ext.destroy(c) + } + } + c = Ext.get(this.createSvgNode(b)); + if (a === 0) { + d.insertFirst(c) + } else { + c.insertAfter(Ext.fly(d.dom.childNodes[a - 1])) + } + c.cache = {}; + return c + }, + setElementAttributes: function(d, b) { + var f = d.dom, + a = d.cache, + c, e; + for (c in b) { + e = b[c]; + if (a[c] !== e) { + a[c] = e; + f.setAttribute(c, e) + } + } + }, + getNextDef: function(a) { + return this.getSvgElement(this.defElement, a, this.defPosition++) + }, + clearTransform: function() { + var a = this; + a.mainGroup.set({ + transform: a.matrix.toSvg() + }) + }, + clear: function() { + this.ctx.clear(); + this.defPosition = 0 + }, + renderSprite: function(b) { + var d = this, + c = d.getRect(), + a = d.ctx; + if (b.attr.hidden || b.attr.globalAlpha === 0) { + a.save(); + a.restore(); + return + } + b.element = a.save(); + b.preRender(this); + b.useAttributes(a, c); + if (false === b.render(this, a, [0, 0, c[2], c[3]])) { + return false + } + b.setDirty(false); + a.restore() + }, + flatten: function(e, b) { + var c = '', + f = Ext.getClassName(this), + a, g, d; + c += ''; + for (d = 0; d < b.length; d++) { + a = b[d]; + if (Ext.getClassName(a) !== f) { + continue + } + g = a.getRect(); + c += ''; + c += this.serializeNode(a.svgElement.dom); + c += "" + } + c += ""; + return { + data: "data:image/svg+xml;utf8," + encodeURIComponent(c), + type: "svg" + } + }, + serializeNode: function(d) { + var b = "", + c, f, a, e; + if (d.nodeType === document.TEXT_NODE) { + return d.nodeValue + } + b += "<" + d.nodeName; + if (d.attributes.length) { + for (c = 0, f = d.attributes.length; c < f; c++) { + a = d.attributes[c]; + b += " " + a.name + '="' + a.value + '"' + } + } + b += ">"; + if (d.childNodes && d.childNodes.length) { + for (c = 0, f = d.childNodes.length; c < f; c++) { + e = d.childNodes[c]; + b += this.serializeNode(e) + } + } + b += ""; + return b + }, + destroy: function() { + var a = this; + a.ctx.destroy(); + a.mainGroup.destroy(); + delete a.mainGroup; + delete a.ctx; + a.callParent() + }, + remove: function(a, b) { + if (a && a.element) { + if (this.ctx) { + this.ctx.removeElement(a.element) + } else { + a.element.destroy() + } + a.element = null + } + this.callParent(arguments) + } +}); +Ext.draw || (Ext.draw = {}); +Ext.draw.engine || (Ext.draw.engine = {}); +Ext.draw.engine.excanvas = true; +if (!document.createElement("canvas").getContext) { + (function() { + var ab = Math; + var n = ab.round; + var l = ab.sin; + var A = ab.cos; + var H = ab.abs; + var N = ab.sqrt; + var d = 10; + var f = d / 2; + var z = +navigator.userAgent.match(/MSIE ([\d.]+)?/)[1]; + + function y() { + return this.context_ || (this.context_ = new D(this)) + } + var t = Array.prototype.slice; + + function g(j, m, p) { + var i = t.call(arguments, 2); + return function() { + return j.apply(m, i.concat(t.call(arguments))) + } + } + + function af(i) { + return String(i).replace(/&/g, "&").replace(/"/g, """) + } + + function Y(m, j, i) { + Ext.onReady(function() { + if (!m.namespaces[j]) { + m.namespaces.add(j, i, "#default#VML") + } + }) + } + + function R(j) { + Y(j, "g_vml_", "urn:schemas-microsoft-com:vml"); + Y(j, "g_o_", "urn:schemas-microsoft-com:office:office"); + if (!j.styleSheets.ex_canvas_) { + var i = j.createStyleSheet(); + i.owningElement.id = "ex_canvas_"; + i.cssText = "canvas{display:inline-block;overflow:hidden;text-align:left;width:300px;height:150px}" + } + } + R(document); + var e = { + init: function(i) { + var j = i || document; + j.createElement("canvas"); + j.attachEvent("onreadystatechange", g(this.init_, this, j)) + }, + init_: function(p) { + var m = p.getElementsByTagName("canvas"); + for (var j = 0; j < m.length; j++) { + this.initElement(m[j]) + } + }, + initElement: function(j) { + if (!j.getContext) { + j.getContext = y; + R(j.ownerDocument); + j.innerHTML = ""; + j.attachEvent("onpropertychange", x); + j.attachEvent("onresize", W); + var i = j.attributes; + if (i.width && i.width.specified) { + j.style.width = i.width.nodeValue + "px" + } else { + j.width = j.clientWidth + } + if (i.height && i.height.specified) { + j.style.height = i.height.nodeValue + "px" + } else { + j.height = j.clientHeight + } + } + return j + } + }; + + function x(j) { + var i = j.srcElement; + switch (j.propertyName) { + case "width": + i.getContext().clearRect(); + i.style.width = i.attributes.width.nodeValue + "px"; + i.firstChild.style.width = i.clientWidth + "px"; + break; + case "height": + i.getContext().clearRect(); + i.style.height = i.attributes.height.nodeValue + "px"; + i.firstChild.style.height = i.clientHeight + "px"; + break + } + } + + function W(j) { + var i = j.srcElement; + if (i.firstChild) { + i.firstChild.style.width = i.clientWidth + "px"; + i.firstChild.style.height = i.clientHeight + "px" + } + } + e.init(); + var k = []; + for (var ae = 0; ae < 16; ae++) { + for (var ad = 0; ad < 16; ad++) { + k[ae * 16 + ad] = ae.toString(16) + ad.toString(16) + } + } + + function B() { + return [ + [1, 0, 0], + [0, 1, 0], + [0, 0, 1] + ] + } + + function J(p, m) { + var j = B(); + for (var i = 0; i < 3; i++) { + for (var ah = 0; ah < 3; ah++) { + var Z = 0; + for (var ag = 0; ag < 3; ag++) { + Z += p[i][ag] * m[ag][ah] + } + j[i][ah] = Z + } + } + return j + } + + function v(j, i) { + i.fillStyle = j.fillStyle; + i.lineCap = j.lineCap; + i.lineJoin = j.lineJoin; + i.lineDash = j.lineDash; + i.lineWidth = j.lineWidth; + i.miterLimit = j.miterLimit; + i.shadowBlur = j.shadowBlur; + i.shadowColor = j.shadowColor; + i.shadowOffsetX = j.shadowOffsetX; + i.shadowOffsetY = j.shadowOffsetY; + i.strokeStyle = j.strokeStyle; + i.globalAlpha = j.globalAlpha; + i.font = j.font; + i.textAlign = j.textAlign; + i.textBaseline = j.textBaseline; + i.arcScaleX_ = j.arcScaleX_; + i.arcScaleY_ = j.arcScaleY_; + i.lineScale_ = j.lineScale_ + } + var b = { + aliceblue: "#F0F8FF", + antiquewhite: "#FAEBD7", + aquamarine: "#7FFFD4", + azure: "#F0FFFF", + beige: "#F5F5DC", + bisque: "#FFE4C4", + black: "#000000", + blanchedalmond: "#FFEBCD", + blueviolet: "#8A2BE2", + brown: "#A52A2A", + burlywood: "#DEB887", + cadetblue: "#5F9EA0", + chartreuse: "#7FFF00", + chocolate: "#D2691E", + coral: "#FF7F50", + cornflowerblue: "#6495ED", + cornsilk: "#FFF8DC", + crimson: "#DC143C", + cyan: "#00FFFF", + darkblue: "#00008B", + darkcyan: "#008B8B", + darkgoldenrod: "#B8860B", + darkgray: "#A9A9A9", + darkgreen: "#006400", + darkgrey: "#A9A9A9", + darkkhaki: "#BDB76B", + darkmagenta: "#8B008B", + darkolivegreen: "#556B2F", + darkorange: "#FF8C00", + darkorchid: "#9932CC", + darkred: "#8B0000", + darksalmon: "#E9967A", + darkseagreen: "#8FBC8F", + darkslateblue: "#483D8B", + darkslategray: "#2F4F4F", + darkslategrey: "#2F4F4F", + darkturquoise: "#00CED1", + darkviolet: "#9400D3", + deeppink: "#FF1493", + deepskyblue: "#00BFFF", + dimgray: "#696969", + dimgrey: "#696969", + dodgerblue: "#1E90FF", + firebrick: "#B22222", + floralwhite: "#FFFAF0", + forestgreen: "#228B22", + gainsboro: "#DCDCDC", + ghostwhite: "#F8F8FF", + gold: "#FFD700", + goldenrod: "#DAA520", + grey: "#808080", + greenyellow: "#ADFF2F", + honeydew: "#F0FFF0", + hotpink: "#FF69B4", + indianred: "#CD5C5C", + indigo: "#4B0082", + ivory: "#FFFFF0", + khaki: "#F0E68C", + lavender: "#E6E6FA", + lavenderblush: "#FFF0F5", + lawngreen: "#7CFC00", + lemonchiffon: "#FFFACD", + lightblue: "#ADD8E6", + lightcoral: "#F08080", + lightcyan: "#E0FFFF", + lightgoldenrodyellow: "#FAFAD2", + lightgreen: "#90EE90", + lightgrey: "#D3D3D3", + lightpink: "#FFB6C1", + lightsalmon: "#FFA07A", + lightseagreen: "#20B2AA", + lightskyblue: "#87CEFA", + lightslategray: "#778899", + lightslategrey: "#778899", + lightsteelblue: "#B0C4DE", + lightyellow: "#FFFFE0", + limegreen: "#32CD32", + linen: "#FAF0E6", + magenta: "#FF00FF", + mediumaquamarine: "#66CDAA", + mediumblue: "#0000CD", + mediumorchid: "#BA55D3", + mediumpurple: "#9370DB", + mediumseagreen: "#3CB371", + mediumslateblue: "#7B68EE", + mediumspringgreen: "#00FA9A", + mediumturquoise: "#48D1CC", + mediumvioletred: "#C71585", + midnightblue: "#191970", + mintcream: "#F5FFFA", + mistyrose: "#FFE4E1", + moccasin: "#FFE4B5", + navajowhite: "#FFDEAD", + oldlace: "#FDF5E6", + olivedrab: "#6B8E23", + orange: "#FFA500", + orangered: "#FF4500", + orchid: "#DA70D6", + palegoldenrod: "#EEE8AA", + palegreen: "#98FB98", + paleturquoise: "#AFEEEE", + palevioletred: "#DB7093", + papayawhip: "#FFEFD5", + peachpuff: "#FFDAB9", + peru: "#CD853F", + pink: "#FFC0CB", + plum: "#DDA0DD", + powderblue: "#B0E0E6", + rosybrown: "#BC8F8F", + royalblue: "#4169E1", + saddlebrown: "#8B4513", + salmon: "#FA8072", + sandybrown: "#F4A460", + seagreen: "#2E8B57", + seashell: "#FFF5EE", + sienna: "#A0522D", + skyblue: "#87CEEB", + slateblue: "#6A5ACD", + slategray: "#708090", + slategrey: "#708090", + snow: "#FFFAFA", + springgreen: "#00FF7F", + steelblue: "#4682B4", + tan: "#D2B48C", + thistle: "#D8BFD8", + tomato: "#FF6347", + turquoise: "#40E0D0", + violet: "#EE82EE", + wheat: "#F5DEB3", + whitesmoke: "#F5F5F5", + yellowgreen: "#9ACD32" + }; + + function M(j) { + var p = j.indexOf("(", 3); + var i = j.indexOf(")", p + 1); + var m = j.substring(p + 1, i).split(","); + if (m.length != 4 || j.charAt(3) != "a") { + m[3] = 1 + } + return m + } + + function c(i) { + return parseFloat(i) / 100 + } + + function r(j, m, i) { + return Math.min(i, Math.max(m, j)) + } + + function I(ag) { + var i, ai, aj, ah, ak, Z; + ah = parseFloat(ag[0]) / 360 % 360; + if (ah < 0) { + ah++ + } + ak = r(c(ag[1]), 0, 1); + Z = r(c(ag[2]), 0, 1); + if (ak == 0) { + i = ai = aj = Z + } else { + var j = Z < 0.5 ? Z * (1 + ak) : Z + ak - Z * ak; + var m = 2 * Z - j; + i = a(m, j, ah + 1 / 3); + ai = a(m, j, ah); + aj = a(m, j, ah - 1 / 3) + } + return "#" + k[Math.floor(i * 255)] + k[Math.floor(ai * 255)] + k[Math.floor(aj * 255)] + } + + function a(j, i, m) { + if (m < 0) { + m++ + } + if (m > 1) { + m-- + } + if (6 * m < 1) { + return j + (i - j) * 6 * m + } else { + if (2 * m < 1) { + return i + } else { + if (3 * m < 2) { + return j + (i - j) * (2 / 3 - m) * 6 + } else { + return j + } + } + } + } + var C = {}; + + function F(j) { + if (j in C) { + return C[j] + } + var ag, Z = 1; + j = String(j); + if (j.charAt(0) == "#") { + ag = j + } else { + if (/^rgb/.test(j)) { + var p = M(j); + var ag = "#", + ah; + for (var m = 0; m < 3; m++) { + if (p[m].indexOf("%") != -1) { + ah = Math.floor(c(p[m]) * 255) + } else { + ah = +p[m] + } + ag += k[r(ah, 0, 255)] + } + Z = +p[3] + } else { + if (/^hsl/.test(j)) { + var p = M(j); + ag = I(p); + Z = p[3] + } else { + ag = b[j] || j + } + } + } + return C[j] = { + color: ag, + alpha: Z + } + } + var o = { + style: "normal", + variant: "normal", + weight: "normal", + size: 10, + family: "sans-serif" + }; + var L = {}; + + function E(i) { + if (L[i]) { + return L[i] + } + var p = document.createElement("div"); + var m = p.style; + try { + m.font = i + } catch (j) {} + return L[i] = { + style: m.fontStyle || o.style, + variant: m.fontVariant || o.variant, + weight: m.fontWeight || o.weight, + size: m.fontSize || o.size, + family: m.fontFamily || o.family + } + } + + function u(m, j) { + var i = {}; + for (var ah in m) { + i[ah] = m[ah] + } + var ag = parseFloat(j.currentStyle.fontSize), + Z = parseFloat(m.size); + if (typeof m.size == "number") { + i.size = m.size + } else { + if (m.size.indexOf("px") != -1) { + i.size = Z + } else { + if (m.size.indexOf("em") != -1) { + i.size = ag * Z + } else { + if (m.size.indexOf("%") != -1) { + i.size = (ag / 100) * Z + } else { + if (m.size.indexOf("pt") != -1) { + i.size = Z / 0.75 + } else { + i.size = ag + } + } + } + } + } + i.size *= 0.981; + return i + } + + function ac(i) { + return i.style + " " + i.variant + " " + i.weight + " " + i.size + "px " + i.family + } + var s = { + butt: "flat", + round: "round" + }; + + function S(i) { + return s[i] || "square" + } + + function D(i) { + this.m_ = B(); + this.mStack_ = []; + this.aStack_ = []; + this.currentPath_ = []; + this.strokeStyle = "#000"; + this.fillStyle = "#000"; + this.lineWidth = 1; + this.lineJoin = "miter"; + this.lineDash = []; + this.lineCap = "butt"; + this.miterLimit = d * 1; + this.globalAlpha = 1; + this.font = "10px sans-serif"; + this.textAlign = "left"; + this.textBaseline = "alphabetic"; + this.canvas = i; + var m = "width:" + i.clientWidth + "px;height:" + i.clientHeight + "px;overflow:hidden;position:absolute"; + var j = i.ownerDocument.createElement("div"); + j.style.cssText = m; + i.appendChild(j); + var p = j.cloneNode(false); + p.style.backgroundColor = "red"; + p.style.filter = "alpha(opacity=0)"; + i.appendChild(p); + this.element_ = j; + this.arcScaleX_ = 1; + this.arcScaleY_ = 1; + this.lineScale_ = 1 + } + var q = D.prototype; + q.clearRect = function() { + if (this.textMeasureEl_) { + this.textMeasureEl_.removeNode(true); + this.textMeasureEl_ = null + } + this.element_.innerHTML = "" + }; + q.beginPath = function() { + this.currentPath_ = [] + }; + q.moveTo = function(j, i) { + var m = V(this, j, i); + this.currentPath_.push({ + type: "moveTo", + x: m.x, + y: m.y + }); + this.currentX_ = m.x; + this.currentY_ = m.y + }; + q.lineTo = function(j, i) { + var m = V(this, j, i); + this.currentPath_.push({ + type: "lineTo", + x: m.x, + y: m.y + }); + this.currentX_ = m.x; + this.currentY_ = m.y + }; + q.bezierCurveTo = function(m, j, ak, aj, ai, ag) { + var i = V(this, ai, ag); + var ah = V(this, m, j); + var Z = V(this, ak, aj); + K(this, ah, Z, i) + }; + + function K(i, Z, m, j) { + i.currentPath_.push({ + type: "bezierCurveTo", + cp1x: Z.x, + cp1y: Z.y, + cp2x: m.x, + cp2y: m.y, + x: j.x, + y: j.y + }); + i.currentX_ = j.x; + i.currentY_ = j.y + } + q.quadraticCurveTo = function(ai, m, j, i) { + var ah = V(this, ai, m); + var ag = V(this, j, i); + var aj = { + x: this.currentX_ + 2 / 3 * (ah.x - this.currentX_), + y: this.currentY_ + 2 / 3 * (ah.y - this.currentY_) + }; + var Z = { + x: aj.x + (ag.x - this.currentX_) / 3, + y: aj.y + (ag.y - this.currentY_) / 3 + }; + K(this, aj, Z, ag) + }; + q.arc = function(al, aj, ak, ag, j, m) { + ak *= d; + var ap = m ? "at" : "wa"; + var am = al + A(ag) * ak - f; + var ao = aj + l(ag) * ak - f; + var i = al + A(j) * ak - f; + var an = aj + l(j) * ak - f; + if (am == i && !m) { + am += 0.125 + } + var Z = V(this, al, aj); + var ai = V(this, am, ao); + var ah = V(this, i, an); + this.currentPath_.push({ + type: ap, + x: Z.x, + y: Z.y, + radius: ak, + xStart: ai.x, + yStart: ai.y, + xEnd: ah.x, + yEnd: ah.y + }) + }; + q.rect = function(m, j, i, p) { + this.moveTo(m, j); + this.lineTo(m + i, j); + this.lineTo(m + i, j + p); + this.lineTo(m, j + p); + this.closePath() + }; + q.strokeRect = function(m, j, i, p) { + var Z = this.currentPath_; + this.beginPath(); + this.moveTo(m, j); + this.lineTo(m + i, j); + this.lineTo(m + i, j + p); + this.lineTo(m, j + p); + this.closePath(); + this.stroke(); + this.currentPath_ = Z + }; + q.fillRect = function(m, j, i, p) { + var Z = this.currentPath_; + this.beginPath(); + this.moveTo(m, j); + this.lineTo(m + i, j); + this.lineTo(m + i, j + p); + this.lineTo(m, j + p); + this.closePath(); + this.fill(); + this.currentPath_ = Z + }; + q.createLinearGradient = function(j, p, i, m) { + var Z = new U("gradient"); + Z.x0_ = j; + Z.y0_ = p; + Z.x1_ = i; + Z.y1_ = m; + return Z + }; + q.createRadialGradient = function(p, ag, m, j, Z, i) { + var ah = new U("gradientradial"); + ah.x0_ = p; + ah.y0_ = ag; + ah.r0_ = m; + ah.x1_ = j; + ah.y1_ = Z; + ah.r1_ = i; + return ah + }; + q.drawImage = function(an, j) { + var ah, Z, aj, ar, al, ak, ao, av; + var ai = an.runtimeStyle.width; + var am = an.runtimeStyle.height; + an.runtimeStyle.width = "auto"; + an.runtimeStyle.height = "auto"; + var ag = an.width; + var aq = an.height; + an.runtimeStyle.width = ai; + an.runtimeStyle.height = am; + if (arguments.length == 3) { + ah = arguments[1]; + Z = arguments[2]; + al = ak = 0; + ao = aj = ag; + av = ar = aq + } else { + if (arguments.length == 5) { + ah = arguments[1]; + Z = arguments[2]; + aj = arguments[3]; + ar = arguments[4]; + al = ak = 0; + ao = ag; + av = aq + } else { + if (arguments.length == 9) { + al = arguments[1]; + ak = arguments[2]; + ao = arguments[3]; + av = arguments[4]; + ah = arguments[5]; + Z = arguments[6]; + aj = arguments[7]; + ar = arguments[8] + } else { + throw Error("Invalid number of arguments") + } + } + } + var au = V(this, ah, Z); + var at = []; + var i = 10; + var p = 10; + var ap = this.m_; + at.push(" ', '", ""); + this.element_.insertAdjacentHTML("BeforeEnd", at.join("")) + }; + q.setLineDash = function(i) { + if (i.length === 1) { + i = i.slice(); + i[1] = i[0] + } + this.lineDash = i + }; + q.getLineDash = function() { + return this.lineDash + }; + q.stroke = function(ak) { + var ai = []; + var m = 10; + var al = 10; + ai.push(" aj.x) { + aj.x = j.x + } + if (Z.y == null || j.y < Z.y) { + Z.y = j.y + } + if (aj.y == null || j.y > aj.y) { + aj.y = j.y + } + } + } + ai.push(' ">'); + if (!ak) { + w(this, ai) + } else { + G(this, ai, Z, aj) + } + ai.push(""); + this.element_.insertAdjacentHTML("beforeEnd", ai.join("")) + }; + + function w(m, ag) { + var j = F(m.strokeStyle); + var p = j.color; + var Z = j.alpha * m.globalAlpha; + var i = m.lineScale_ * m.lineWidth; + if (i < 1) { + Z *= i + } + ag.push("') + } + + function G(aq, ai, aK, ar) { + var aj = aq.fillStyle; + var aB = aq.arcScaleX_; + var aA = aq.arcScaleY_; + var j = ar.x - aK.x; + var p = ar.y - aK.y; + if (aj instanceof U) { + var an = 0; + var aF = { + x: 0, + y: 0 + }; + var ax = 0; + var am = 1; + if (aj.type_ == "gradient") { + var al = aj.x0_ / aB; + var m = aj.y0_ / aA; + var ak = aj.x1_ / aB; + var aM = aj.y1_ / aA; + var aJ = V(aq, al, m); + var aI = V(aq, ak, aM); + var ag = aI.x - aJ.x; + var Z = aI.y - aJ.y; + an = Math.atan2(ag, Z) * 180 / Math.PI; + if (an < 0) { + an += 360 + } + if (an < 0.000001) { + an = 0 + } + } else { + var aJ = V(aq, aj.x0_, aj.y0_); + aF = { + x: (aJ.x - aK.x) / j, + y: (aJ.y - aK.y) / p + }; + j /= aB * d; + p /= aA * d; + var aD = ab.max(j, p); + ax = 2 * aj.r0_ / aD; + am = 2 * aj.r1_ / aD - ax + } + var av = aj.colors_; + av.sort(function(aN, i) { + return aN.offset - i.offset + }); + var ap = av.length; + var au = av[0].color; + var at = av[ap - 1].color; + var az = av[0].alpha * aq.globalAlpha; + var ay = av[ap - 1].alpha * aq.globalAlpha; + var aE = []; + for (var aH = 0; aH < ap; aH++) { + var ao = av[aH]; + aE.push(ao.offset * am + ax + " " + ao.color) + } + ai.push('') + } else { + if (aj instanceof T) { + if (j && p) { + var ah = -aK.x; + var aC = -aK.y; + ai.push("') + } + } else { + var aL = F(aq.fillStyle); + var aw = aL.color; + var aG = aL.alpha * aq.globalAlpha; + ai.push('') + } + } + } + q.fill = function() { + this.$stroke(true) + }; + q.closePath = function() { + this.currentPath_.push({ + type: "close" + }) + }; + + function V(j, Z, p) { + var i = j.m_; + return { + x: d * (Z * i[0][0] + p * i[1][0] + i[2][0]) - f, + y: d * (Z * i[0][1] + p * i[1][1] + i[2][1]) - f + } + } + q.save = function() { + var i = {}; + v(this, i); + this.aStack_.push(i); + this.mStack_.push(this.m_); + this.m_ = J(B(), this.m_) + }; + q.restore = function() { + if (this.aStack_.length) { + v(this.aStack_.pop(), this); + this.m_ = this.mStack_.pop() + } + }; + + function h(i) { + return isFinite(i[0][0]) && isFinite(i[0][1]) && isFinite(i[1][0]) && isFinite(i[1][1]) && isFinite(i[2][0]) && isFinite(i[2][1]) + } + + function aa(j, i, p) { + if (!h(i)) { + return + } + j.m_ = i; + if (p) { + var Z = i[0][0] * i[1][1] - i[0][1] * i[1][0]; + j.lineScale_ = N(H(Z)) + } + } + q.translate = function(m, j) { + var i = [ + [1, 0, 0], + [0, 1, 0], + [m, j, 1] + ]; + aa(this, J(i, this.m_), false) + }; + q.rotate = function(j) { + var p = A(j); + var m = l(j); + var i = [ + [p, m, 0], + [-m, p, 0], + [0, 0, 1] + ]; + aa(this, J(i, this.m_), false) + }; + q.scale = function(m, j) { + this.arcScaleX_ *= m; + this.arcScaleY_ *= j; + var i = [ + [m, 0, 0], + [0, j, 0], + [0, 0, 1] + ]; + aa(this, J(i, this.m_), true) + }; + q.transform = function(Z, p, ah, ag, j, i) { + var m = [ + [Z, p, 0], + [ah, ag, 0], + [j, i, 1] + ]; + aa(this, J(m, this.m_), true) + }; + q.setTransform = function(ag, Z, ai, ah, p, j) { + var i = [ + [ag, Z, 0], + [ai, ah, 0], + [p, j, 1] + ]; + aa(this, i, true) + }; + q.drawText_ = function(am, ak, aj, ap, ai) { + var ao = this.m_, + at = 1000, + j = 0, + ar = at, + ah = { + x: 0, + y: 0 + }, + ag = []; + var i = u(E(this.font), this.element_); + var p = ac(i); + var au = this.element_.currentStyle; + var Z = this.textAlign.toLowerCase(); + switch (Z) { + case "left": + case "center": + case "right": + break; + case "end": + Z = au.direction == "ltr" ? "right" : "left"; + break; + case "start": + Z = au.direction == "rtl" ? "right" : "left"; + break; + default: + Z = "left" + } + switch (this.textBaseline) { + case "hanging": + case "top": + ah.y = i.size / 1.75; + break; + case "middle": + break; + default: + case null: + case "alphabetic": + case "ideographic": + case "bottom": + ah.y = -i.size / 3; + break + } + switch (Z) { + case "right": + j = at; + ar = 0.05; + break; + case "center": + j = ar = at / 2; + break + } + var aq = V(this, ak + ah.x, aj + ah.y); + ag.push(''); + if (ai) { + w(this, ag) + } else { + G(this, ag, { + x: -j, + y: 0 + }, { + x: ar, + y: i.size + }) + } + var an = ao[0][0].toFixed(3) + "," + ao[1][0].toFixed(3) + "," + ao[0][1].toFixed(3) + "," + ao[1][1].toFixed(3) + ",0,0"; + var al = n(aq.x / d) + "," + n(aq.y / d); + ag.push('', '', ''); + this.element_.insertAdjacentHTML("beforeEnd", ag.join("")) + }; + q.fillText = function(m, i, p, j) { + this.drawText_(m, i, p, j, false) + }; + q.strokeText = function(m, i, p, j) { + this.drawText_(m, i, p, j, true) + }; + q.measureText = function(m) { + if (!this.textMeasureEl_) { + var i = ''; + this.element_.insertAdjacentHTML("beforeEnd", i); + this.textMeasureEl_ = this.element_.lastChild + } + var j = this.element_.ownerDocument; + this.textMeasureEl_.innerHTML = ""; + this.textMeasureEl_.style.font = this.font; + this.textMeasureEl_.appendChild(j.createTextNode(m)); + return { + width: this.textMeasureEl_.offsetWidth + } + }; + q.clip = function() {}; + q.arcTo = function() {}; + q.createPattern = function(j, i) { + return new T(j, i) + }; + + function U(i) { + this.type_ = i; + this.x0_ = 0; + this.y0_ = 0; + this.r0_ = 0; + this.x1_ = 0; + this.y1_ = 0; + this.r1_ = 0; + this.colors_ = [] + } + U.prototype.addColorStop = function(j, i) { + i = F(i); + this.colors_.push({ + offset: j, + color: i.color, + alpha: i.alpha + }) + }; + + function T(j, i) { + Q(j); + switch (i) { + case "repeat": + case null: + case "": + this.repetition_ = "repeat"; + break; + case "repeat-x": + case "repeat-y": + case "no-repeat": + this.repetition_ = i; + break; + default: + O("SYNTAX_ERR") + } + this.src_ = j.src; + this.width_ = j.width; + this.height_ = j.height + } + + function O(i) { + throw new P(i) + } + + function Q(i) { + if (!i || i.nodeType != 1 || i.tagName != "IMG") { + O("TYPE_MISMATCH_ERR") + } + if (i.readyState != "complete") { + O("INVALID_STATE_ERR") + } + } + + function P(i) { + this.code = this[i]; + this.message = i + ": DOM Exception " + this.code + } + var X = P.prototype = new Error(); + X.INDEX_SIZE_ERR = 1; + X.DOMSTRING_SIZE_ERR = 2; + X.HIERARCHY_REQUEST_ERR = 3; + X.WRONG_DOCUMENT_ERR = 4; + X.INVALID_CHARACTER_ERR = 5; + X.NO_DATA_ALLOWED_ERR = 6; + X.NO_MODIFICATION_ALLOWED_ERR = 7; + X.NOT_FOUND_ERR = 8; + X.NOT_SUPPORTED_ERR = 9; + X.INUSE_ATTRIBUTE_ERR = 10; + X.INVALID_STATE_ERR = 11; + X.SYNTAX_ERR = 12; + X.INVALID_MODIFICATION_ERR = 13; + X.NAMESPACE_ERR = 14; + X.INVALID_ACCESS_ERR = 15; + X.VALIDATION_ERR = 16; + X.TYPE_MISMATCH_ERR = 17; + G_vmlCanvasManager = e; + CanvasRenderingContext2D = D; + CanvasGradient = U; + CanvasPattern = T; + DOMException = P + })() +} +Ext.define("Ext.draw.engine.Canvas", { + extend: "Ext.draw.Surface", + requires: ["Ext.draw.engine.excanvas", "Ext.draw.Animator", "Ext.draw.Color"], + config: { + highPrecision: false + }, + statics: { + contextOverrides: { + setGradientBBox: function(a) { + this.bbox = a + }, + fill: function() { + var c = this.fillStyle, + a = this.fillGradient, + b = this.fillOpacity, + d = this.globalAlpha, + e = this.bbox; + if (c !== Ext.draw.Color.RGBA_NONE && b !== 0) { + if (a && e) { + this.fillStyle = a.generateGradient(this, e) + } + if (b !== 1) { + this.globalAlpha = d * b + } + this.$fill(); + if (b !== 1) { + this.globalAlpha = d + } + if (a && e) { + this.fillStyle = c + } + } + }, + stroke: function() { + var e = this.strokeStyle, + c = this.strokeGradient, + a = this.strokeOpacity, + b = this.globalAlpha, + d = this.bbox; + if (e !== Ext.draw.Color.RGBA_NONE && a !== 0) { + if (c && d) { + this.strokeStyle = c.generateGradient(this, d) + } + if (a !== 1) { + this.globalAlpha = b * a + } + this.$stroke(); + if (a !== 1) { + this.globalAlpha = b + } + if (c && d) { + this.strokeStyle = e + } + } + }, + fillStroke: function(d, e) { + var j = this, + i = this.fillStyle, + h = this.fillOpacity, + f = this.strokeStyle, + c = this.strokeOpacity, + b = j.shadowColor, + a = j.shadowBlur, + g = Ext.draw.Color.RGBA_NONE; + if (e === undefined) { + e = d.transformFillStroke + } + if (!e) { + d.inverseMatrix.toContext(j) + } + if (i !== g && h !== 0) { + j.fill(); + j.shadowColor = g; + j.shadowBlur = 0 + } + if (f !== g && c !== 0) { + j.stroke() + } + j.shadowColor = b; + j.shadowBlur = a + }, + setLineDash: function(a) { + if (this.$setLineDash) { + this.$setLineDash(a) + } + }, + getLineDash: function() { + if (this.$getLineDash) { + return this.$getLineDash() + } + }, + ellipse: function(g, e, c, a, j, b, f, d) { + var i = Math.cos(j), + h = Math.sin(j); + this.transform(i * c, h * c, -h * a, i * a, g, e); + this.arc(0, 0, 1, b, f, d); + this.transform(i / c, -h / a, h / c, i / a, -(i * g + h * e) / c, (h * g - i * e) / a) + }, + appendPath: function(f) { + var e = this, + c = 0, + b = 0, + a = f.commands, + g = f.params, + d = a.length; + e.beginPath(); + for (; c < d; c++) { + switch (a[c]) { + case "M": + e.moveTo(g[b], g[b + 1]); + b += 2; + break; + case "L": + e.lineTo(g[b], g[b + 1]); + b += 2; + break; + case "C": + e.bezierCurveTo(g[b], g[b + 1], g[b + 2], g[b + 3], g[b + 4], g[b + 5]); + b += 6; + break; + case "Z": + e.closePath(); + break + } + } + }, + save: function() { + var c = this.toSave, + d = c.length, + e = d && {}, + b = 0, + a; + for (; b < d; b++) { + a = c[b]; + if (a in this) { + e[a] = this[a] + } + } + this.state.push(e); + this.$save() + }, + restore: function() { + var b = this.state.pop(), + a; + if (b) { + for (a in b) { + this[a] = b[a] + } + } + this.$restore() + } + } + }, + splitThreshold: 3000, + toSave: ["fillGradient", "strokeGradient"], + element: { + reference: "element", + style: { + position: "absolute" + }, + children: [{ + reference: "innerElement", + style: { + width: "100%", + height: "100%", + position: "relative" + } + }] + }, + createCanvas: function() { + var c = Ext.Element.create({ + tag: "canvas", + cls: Ext.baseCSSPrefix + "surface-canvas" + }); + window.G_vmlCanvasManager && G_vmlCanvasManager.initElement(c.dom); + var d = Ext.draw.engine.Canvas.contextOverrides, + a = c.dom.getContext("2d"), + b; + if (a.ellipse) { + delete d.ellipse + } + a.state = []; + a.toSave = this.toSave; + for (b in d) { + a["$" + b] = a[b] + } + Ext.apply(a, d); + if (this.getHighPrecision()) { + this.enablePrecisionCompensation(a) + } else { + this.disablePrecisionCompensation(a) + } + this.innerElement.appendChild(c); + this.canvases.push(c); + this.contexts.push(a) + }, + updateHighPrecision: function(d) { + var e = this.contexts, + c = e.length, + b, a; + for (b = 0; b < c; b++) { + a = e[b]; + if (d) { + this.enablePrecisionCompensation(a) + } else { + this.disablePrecisionCompensation(a) + } + } + }, + precisionNames: ["rect", "fillRect", "strokeRect", "clearRect", "moveTo", "lineTo", "arc", "arcTo", "save", "restore", "updatePrecisionCompensate", "setTransform", "transform", "scale", "translate", "rotate", "quadraticCurveTo", "bezierCurveTo", "createLinearGradient", "createRadialGradient", "fillText", "strokeText", "drawImage"], + disablePrecisionCompensation: function(b) { + var a = Ext.draw.engine.Canvas.contextOverrides, + f = this.precisionNames, + e = f.length, + d, c; + for (d = 0; d < e; d++) { + c = f[d]; + if (!(c in a)) { + delete b[c] + } + } + this.setDirty(true) + }, + enablePrecisionCompensation: function(j) { + var c = this, + a = 1, + g = 1, + l = 0, + k = 0, + i = new Ext.draw.Matrix(), + b = [], + e = {}, + d = Ext.draw.engine.Canvas.contextOverrides, + h = j.constructor.prototype; + var f = { + toSave: c.toSave, + rect: function(m, p, n, o) { + return h.rect.call(this, m * a + l, p * g + k, n * a, o * g) + }, + fillRect: function(m, p, n, o) { + this.updatePrecisionCompensateRect(); + h.fillRect.call(this, m * a + l, p * g + k, n * a, o * g); + this.updatePrecisionCompensate() + }, + strokeRect: function(m, p, n, o) { + this.updatePrecisionCompensateRect(); + h.strokeRect.call(this, m * a + l, p * g + k, n * a, o * g); + this.updatePrecisionCompensate() + }, + clearRect: function(m, p, n, o) { + return h.clearRect.call(this, m * a + l, p * g + k, n * a, o * g) + }, + moveTo: function(m, n) { + return h.moveTo.call(this, m * a + l, n * g + k) + }, + lineTo: function(m, n) { + return h.lineTo.call(this, m * a + l, n * g + k) + }, + arc: function(n, r, m, p, o, q) { + this.updatePrecisionCompensateRect(); + h.arc.call(this, n * a + l, r * a + k, m * a, p, o, q); + this.updatePrecisionCompensate() + }, + arcTo: function(o, q, n, p, m) { + this.updatePrecisionCompensateRect(); + h.arcTo.call(this, o * a + l, q * g + k, n * a + l, p * g + k, m * a); + this.updatePrecisionCompensate() + }, + save: function() { + b.push(i); + i = i.clone(); + d.save.call(this); + h.save.call(this) + }, + restore: function() { + i = b.pop(); + d.restore.call(this); + h.restore.call(this); + this.updatePrecisionCompensate() + }, + updatePrecisionCompensate: function() { + i.precisionCompensate(c.devicePixelRatio, e); + a = e.xx; + g = e.yy; + l = e.dx; + k = e.dy; + h.setTransform.call(this, c.devicePixelRatio, e.b, e.c, e.d, 0, 0) + }, + updatePrecisionCompensateRect: function() { + i.precisionCompensateRect(c.devicePixelRatio, e); + a = e.xx; + g = e.yy; + l = e.dx; + k = e.dy; + h.setTransform.call(this, c.devicePixelRatio, e.b, e.c, e.d, 0, 0) + }, + setTransform: function(q, o, n, m, r, p) { + i.set(q, o, n, m, r, p); + this.updatePrecisionCompensate() + }, + transform: function(q, o, n, m, r, p) { + i.append(q, o, n, m, r, p); + this.updatePrecisionCompensate() + }, + scale: function(n, m) { + this.transform(n, 0, 0, m, 0, 0) + }, + translate: function(n, m) { + this.transform(1, 0, 0, 1, n, m) + }, + rotate: function(o) { + var n = Math.cos(o), + m = Math.sin(o); + this.transform(n, m, -m, n, 0, 0) + }, + quadraticCurveTo: function(n, p, m, o) { + h.quadraticCurveTo.call(this, n * a + l, p * g + k, m * a + l, o * g + k) + }, + bezierCurveTo: function(r, p, o, n, m, q) { + h.bezierCurveTo.call(this, r * a + l, p * g + k, o * a + l, n * g + k, m * a + l, q * g + k) + }, + createLinearGradient: function(n, p, m, o) { + this.updatePrecisionCompensateRect(); + var q = h.createLinearGradient.call(this, n * a + l, p * g + k, m * a + l, o * g + k); + this.updatePrecisionCompensate(); + return q + }, + createRadialGradient: function(p, r, o, n, q, m) { + this.updatePrecisionCompensateRect(); + var s = h.createLinearGradient.call(this, p * a + l, r * a + k, o * a, n * a + l, q * a + k, m * a); + this.updatePrecisionCompensate(); + return s + }, + fillText: function(o, m, p, n) { + h.setTransform.apply(this, i.elements); + if (typeof n === "undefined") { + h.fillText.call(this, o, m, p) + } else { + h.fillText.call(this, o, m, p, n) + } + this.updatePrecisionCompensate() + }, + strokeText: function(o, m, p, n) { + h.setTransform.apply(this, i.elements); + if (typeof n === "undefined") { + h.strokeText.call(this, o, m, p) + } else { + h.strokeText.call(this, o, m, p, n) + } + this.updatePrecisionCompensate() + }, + fill: function() { + var m = this.fillGradient, + n = this.bbox; + this.updatePrecisionCompensateRect(); + if (m && n) { + this.fillStyle = m.generateGradient(this, n) + } + h.fill.call(this); + this.updatePrecisionCompensate() + }, + stroke: function() { + var m = this.strokeGradient, + n = this.bbox; + this.updatePrecisionCompensateRect(); + if (m && n) { + this.strokeStyle = m.generateGradient(this, n) + } + h.stroke.call(this); + this.updatePrecisionCompensate() + }, + drawImage: function(u, s, r, q, p, o, n, m, t) { + switch (arguments.length) { + case 3: + return h.drawImage.call(this, u, s * a + l, r * g + k); + case 5: + return h.drawImage.call(this, u, s * a + l, r * g + k, q * a, p * g); + case 9: + return h.drawImage.call(this, u, s, r, q, p, o * a + l, n * g * k, m * a, t * g) + } + } + }; + Ext.apply(j, f); + this.setDirty(true) + }, + updateRect: function(a) { + this.callParent([a]); + var C = this, + p = Math.floor(a[0]), + e = Math.floor(a[1]), + g = Math.ceil(a[0] + a[2]), + B = Math.ceil(a[1] + a[3]), + u = C.devicePixelRatio, + D = C.canvases, + d = g - p, + y = B - e, + n = Math.round(C.splitThreshold / u), + c = C.xSplits = Math.ceil(d / n), + f = C.ySplits = Math.ceil(y / n), + v, s, q, A, z, x, o, m; + for (s = 0, z = 0; s < f; s++, z += n) { + for (v = 0, A = 0; v < c; v++, A += n) { + q = s * c + v; + if (q >= D.length) { + C.createCanvas() + } + x = D[q].dom; + x.style.left = A + "px"; + x.style.top = z + "px"; + m = Math.min(n, y - z); + if (m * u !== x.height) { + x.height = m * u; + x.style.height = m + "px" + } + o = Math.min(n, d - A); + if (o * u !== x.width) { + x.width = o * u; + x.style.width = o + "px" + } + C.applyDefaults(C.contexts[q]) + } + } + for (q += 1; q < D.length; q++) { + D[q].destroy() + } + C.activeCanvases = c * f; + D.length = C.activeCanvases; + C.clear() + }, + clearTransform: function() { + var f = this, + a = f.xSplits, + g = f.ySplits, + d = f.contexts, + h = f.splitThreshold, + l = f.devicePixelRatio, + e, c, b, m; + for (e = 0; e < a; e++) { + for (c = 0; c < g; c++) { + b = c * a + e; + m = d[b]; + m.translate(-h * e, -h * c); + m.scale(l, l); + f.matrix.toContext(m) + } + } + }, + renderSprite: function(q) { + var C = this, + b = C.getRect(), + e = C.matrix, + g = q.getParent(), + v = Ext.draw.Matrix.fly([1, 0, 0, 1, 0, 0]), + p = C.splitThreshold / C.devicePixelRatio, + c = C.xSplits, + m = C.ySplits, + A, z, s, a, r, o, d = 0, + B, n = 0, + f, l = b[2], + y = b[3], + x, u, t; + while (g && (g !== C)) { + v.prependMatrix(g.matrix || g.attr && g.attr.matrix); + g = g.getParent() + } + v.prependMatrix(e); + a = q.getBBox(); + if (a) { + a = v.transformBBox(a) + } + q.preRender(C); + if (q.attr.hidden || q.attr.globalAlpha === 0) { + q.setDirty(false); + return + } + for (u = 0, z = 0; u < m; u++, z += p) { + for (x = 0, A = 0; x < c; x++, A += p) { + t = u * c + x; + s = C.contexts[t]; + r = Math.min(p, l - A); + o = Math.min(p, y - z); + d = A; + B = d + r; + n = z; + f = n + o; + if (a) { + if (a.x > B || a.x + a.width < d || a.y > f || a.y + a.height < n) { + continue + } + } + s.save(); + q.useAttributes(s, b); + if (false === q.render(C, s, [d, n, r, o], b)) { + return false + } + s.restore() + } + } + q.setDirty(false) + }, + flatten: function(n, a) { + var k = document.createElement("canvas"), + f = Ext.getClassName(this), + g = this.devicePixelRatio, + l = k.getContext("2d"), + b, c, h, e, d, m; + k.width = Math.ceil(n.width * g); + k.height = Math.ceil(n.height * g); + for (e = 0; e < a.length; e++) { + b = a[e]; + if (Ext.getClassName(b) !== f) { + continue + } + h = b.getRect(); + for (d = 0; d < b.canvases.length; d++) { + c = b.canvases[d]; + m = c.getOffsetsTo(c.getParent()); + l.drawImage(c.dom, (h[0] + m[0]) * g, (h[1] + m[1]) * g) + } + } + return { + data: k.toDataURL(), + type: "png" + } + }, + applyDefaults: function(a) { + var b = Ext.draw.Color.RGBA_NONE; + a.strokeStyle = b; + a.fillStyle = b; + a.textAlign = "start"; + a.textBaseline = "alphabetic"; + a.miterLimit = 1 + }, + clear: function() { + var d = this, + e = d.activeCanvases, + c, b, a; + for (c = 0; c < e; c++) { + b = d.canvases[c].dom; + a = d.contexts[c]; + a.setTransform(1, 0, 0, 1, 0, 0); + a.clearRect(0, 0, b.width, b.height) + } + d.setDirty(true) + }, + destroy: function() { + var c = this, + a, b = c.canvases.length; + for (a = 0; a < b; a++) { + c.contexts[a] = null; + c.canvases[a].destroy(); + c.canvases[a] = null + } + delete c.contexts; + delete c.canvases; + c.callParent() + }, + privates: { + initElement: function() { + var a = this; + a.callParent(); + a.canvases = []; + a.contexts = []; + a.activeCanvases = (a.xSplits = 0) * (a.ySplits = 0) + } + } +}, function() { + var c = this, + b = c.prototype, + a = 10000000000; + if (Ext.os.is.Android4 && Ext.browser.is.Chrome) { + a = 3000 + } else { + if (Ext.is.iOS) { + a = 2200 + } + } + b.splitThreshold = a +}); +Ext.define("Ext.draw.Container", { + extend: "Ext.draw.ContainerBase", + alternateClassName: "Ext.draw.Component", + xtype: "draw", + defaultType: "surface", + isDrawContainer: true, + requires: ["Ext.draw.Surface", "Ext.draw.engine.Svg", "Ext.draw.engine.Canvas", "Ext.draw.gradient.GradientDefinition"], + engine: "Ext.draw.engine.Canvas", + config: { + cls: Ext.baseCSSPrefix + "draw-container", + resizeHandler: null, + sprites: null, + gradients: [] + }, + defaultDownloadServerUrl: "http://svg.sencha.io", + supportedFormats: ["png", "pdf", "jpeg", "gif"], + supportedOptions: { + version: Ext.isNumber, + data: Ext.isString, + format: function(a) { + return Ext.Array.indexOf(this.supportedFormats, a) >= 0 + }, + filename: Ext.isString, + width: Ext.isNumber, + height: Ext.isNumber, + scale: Ext.isNumber, + pdf: Ext.isObject, + jpeg: Ext.isObject + }, + initAnimator: function() { + this.frameCallbackId = Ext.draw.Animator.addFrameCallback("renderFrame", this) + }, + applyGradients: function(b) { + var a = [], + c, f, d, e; + if (!Ext.isArray(b)) { + return a + } + for (c = 0, f = b.length; c < f; c++) { + d = b[c]; + if (!Ext.isObject(d)) { + continue + } + if (typeof d.type !== "string") { + d.type = "linear" + } + if (d.angle) { + d.degrees = d.angle; + delete d.angle + } + if (Ext.isObject(d.stops)) { + d.stops = (function(i) { + var g = [], + h; + for (e in i) { + h = i[e]; + h.offset = e / 100; + g.push(h) + } + return g + })(d.stops) + } + a.push(d) + } + Ext.draw.gradient.GradientDefinition.add(a); + return a + }, + applySprites: function(f) { + if (!f) { + return + } + f = Ext.Array.from(f); + var e = f.length, + b = [], + d, a, c; + for (d = 0; d < e; d++) { + c = f[d]; + a = c.surface; + if (!(a && a.isSurface)) { + if (Ext.isString(a)) { + a = this.getSurface(a) + } else { + a = this.getSurface("main") + } + } + c = a.add(c); + b.push(c) + } + return b + }, + onBodyResize: function() { + var b = this.element, + a; + if (!b) { + return + } + a = b.getSize(); + if (a.width && a.height) { + this.setBodySize(a) + } + }, + setBodySize: function(c) { + var d = this, + b = d.getResizeHandler() || d.defaultResizeHandler, + a; + d.fireEvent("bodyresize", d, c); + a = b.call(d, c); + if (a !== false) { + d.renderFrame() + } + }, + defaultResizeHandler: function(a) { + this.getItems().each(function(b) { + b.setRect([0, 0, a.width, a.height]) + }) + }, + getSurface: function(d) { + d = this.getId() + "-" + (d || "main"); + var c = this, + b = c.getItems(), + a = b.get(d); + if (!a) { + a = c.add({ + xclass: c.engine, + id: d + }); + c.onBodyResize() + } + return a + }, + renderFrame: function() { + var e = this, + a = e.getItems(), + b, d, c; + for (b = 0, d = a.length; b < d; b++) { + c = a.items[b]; + if (c.isSurface) { + c.renderFrame() + } + } + }, + getImage: function(k) { + var l = this.innerElement.getSize(), + a = Array.prototype.slice.call(this.items.items), + d, g, c = this.surfaceZIndexes, + f, e, b, h; + for (e = 1; e < a.length; e++) { + b = a[e]; + h = c[b.type]; + f = e - 1; + while (f >= 0 && c[a[f].type] > h) { + a[f + 1] = a[f]; + f-- + } + a[f + 1] = b + } + d = a[0].flatten(l, a); + if (k === "image") { + g = new Image(); + g.src = d.data; + d.data = g; + return d + } + if (k === "stream") { + d.data = d.data.replace(/^data:image\/[^;]+/, "data:application/octet-stream"); + return d + } + return d + }, + download: function(d) { + var e = this, + a = [], + b, c, f; + d = Ext.apply({ + version: 2, + data: e.getImage().data + }, d); + for (c in d) { + if (d.hasOwnProperty(c)) { + f = d[c]; + if (c in e.supportedOptions) { + if (e.supportedOptions[c].call(e, f)) { + a.push({ + tag: "input", + type: "hidden", + name: c, + value: Ext.String.htmlEncode(Ext.isObject(f) ? Ext.JSON.encode(f) : f) + }) + } + } + } + } + b = Ext.dom.Helper.markup({ + tag: "html", + children: [{ + tag: "head" + }, { + tag: "body", + children: [{ + tag: "form", + method: "POST", + action: d.url || e.defaultDownloadServerUrl, + children: a + }, { + tag: "script", + type: "text/javascript", + children: 'document.getElementsByTagName("form")[0].submit();' + }] + }] + }); + window.open("", "ImageDownload_" + Date.now()).document.write(b) + }, + destroy: function() { + var a = this.frameCallbackId; + if (a) { + Ext.draw.Animator.removeFrameCallback(a) + } + this.callParent() + } +}, function() { + if (location.search.match("svg")) { + Ext.draw.Container.prototype.engine = "Ext.draw.engine.Svg" + } else { + if ((Ext.os.is.BlackBerry && Ext.os.version.getMajor() === 10) || (Ext.browser.is.AndroidStock4 && (Ext.os.version.getMinor() === 1 || Ext.os.version.getMinor() === 2 || Ext.os.version.getMinor() === 3))) { + Ext.draw.Container.prototype.engine = "Ext.draw.engine.Svg" + } + } +}); +Ext.define("Ext.chart.theme.Base", { + mixins: { + factoryable: "Ext.mixin.Factoryable" + }, + requires: ["Ext.draw.Color"], + factoryConfig: { + type: "chart.theme" + }, + isTheme: true, + config: { + baseColor: null, + colors: undefined, + gradients: null, + chart: { + defaults: { + background: "#23272a" + } + }, + axis: { + defaults: { + label: { + x: 0, + y: 0, + textBaseline: "middle", + textAlign: "center", + fontSize: "default", + fontFamily: "default", + fontWeight: "default", + fillStyle: "white", + color: "white" + }, + title: { + fillStyle: "black", + fontSize: "default*1.23", + fontFamily: "default", + fontWeight: "default", + color: "white" + }, + style: { + strokeStyle: "black" + }, + grid: { + strokeStyle: "rgba(44, 47, 51, 1)" + } + }, + top: { + style: { + textPadding: 5 + } + }, + bottom: { + style: { + textPadding: 5 + } + } + }, + series: { + defaults: { + label: { + fillStyle: "black", + strokeStyle: "none", + fontFamily: "default", + fontWeight: "default", + fontSize: "default*1.077", + textBaseline: "middle", + textAlign: "center" + }, + labelOverflowPadding: 5 + } + }, + sprites: { + text: { + fontSize: "default", + fontWeight: "default", + fontFamily: "default", + fillStyle: "black", + color: "white" + } + }, + seriesThemes: undefined, + markerThemes: { + type: ["circle", "cross", "plus", "square", "triangle", "diamond"] + }, + useGradients: false, + background: null + }, + colorDefaults: ["#94ae0a", "#115fa6", "#a61120", "#ff8809", "#ffd13e", "#a61187", "#24ad9a", "#7c7474", "#a66111"], + constructor: function(a) { + this.initConfig(a); + this.resolveDefaults() + }, + defaultRegEx: /^default([+\-/\*]\d+(?:\.\d+)?)?$/, + defaultOperators: { + "*": function(b, a) { + return b * a + }, + "+": function(b, a) { + return b + a + }, + "-": function(b, a) { + return b - a + } + }, + resolveDefaults: function() { + var a = this; + Ext.onReady(function() { + var f = Ext.clone(a.getSprites()), + e = Ext.clone(a.getAxis()), + d = Ext.clone(a.getSeries()), + g, c, b; + if (!a.superclass.defaults) { + g = Ext.getBody().createChild({ + tag: "div", + cls: "x-component" + }); + a.superclass.defaults = { + fontFamily: g.getStyle("fontFamily"), + fontWeight: g.getStyle("fontWeight"), + fontSize: parseFloat(g.getStyle("fontSize")), + fontVariant: g.getStyle("fontVariant"), + fontStyle: g.getStyle("fontStyle") + }; + g.destroy() + } + a.replaceDefaults(f.text); + a.setSprites(f); + for (c in e) { + b = e[c]; + a.replaceDefaults(b.label); + a.replaceDefaults(b.title) + } + a.setAxis(e); + for (c in d) { + b = d[c]; + a.replaceDefaults(b.label) + } + a.setSeries(d) + }) + }, + replaceDefaults: function(h) { + var e = this, + g = e.superclass.defaults, + a = e.defaultRegEx, + d, f, c, b; + if (Ext.isObject(h)) { + for (d in g) { + c = a.exec(h[d]); + if (c) { + f = g[d]; + c = c[1]; + if (c) { + b = e.defaultOperators[c.charAt(0)]; + f = Math.round(b(f, parseFloat(c.substr(1)))) + } + h[d] = f + } + } + } + }, + applyBaseColor: function(c) { + var a, b; + if (c) { + a = c.isColor ? c : Ext.draw.Color.fromString(c); + b = a.getHSL()[2]; + if (b < 0.15) { + a = a.createLighter(0.3) + } else { + if (b < 0.3) { + a = a.createLighter(0.15) + } else { + if (b > 0.85) { + a = a.createDarker(0.3) + } else { + if (b > 0.7) { + a = a.createDarker(0.15) + } + } + } + } + this.setColors([a.createDarker(0.3).toString(), a.createDarker(0.15).toString(), a.toString(), a.createLighter(0.12).toString(), a.createLighter(0.24).toString(), a.createLighter(0.31).toString()]) + } + return c + }, + applyColors: function(a) { + return a || this.colorDefaults + }, + updateUseGradients: function(a) { + if (a) { + this.updateGradients({ + type: "linear", + degrees: 90 + }) + } + }, + updateBackground: function(a) { + if (a) { + var b = this.getChart(); + b.defaults.background = a; + this.setChart(b) + } + }, + updateGradients: function(a) { + var c = this.getColors(), + e = [], + h, b, d, f, g; + if (Ext.isObject(a)) { + for (f = 0, g = c && c.length || 0; f < g; f++) { + b = Ext.draw.Color.fromString(c[f]); + if (b) { + d = b.createLighter(0.15).toString(); + h = Ext.apply(Ext.Object.chain(a), { + stops: [{ + offset: 1, + color: b.toString() + }, { + offset: 0, + color: d.toString() + }] + }); + e.push(h) + } + } + this.setColors(e) + } + }, + applySeriesThemes: function(a) { + this.getBaseColor(); + this.getUseGradients(); + this.getGradients(); + var b = this.getColors(); + if (!a) { + a = { + fillStyle: Ext.Array.clone(b), + strokeStyle: Ext.Array.map(b, function(d) { + var c = Ext.draw.Color.fromString(d.stops ? d.stops[0].color : d); + return c.createDarker(0.15).toString() + }) + } + } + return a + } +}); +Ext.define("Ext.chart.theme.Default", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.default", "chart.theme.Base"] +}); +Ext.define("Ext.chart.Markers", { + extend: "Ext.draw.sprite.Instancing", + isMarkers: true, + defaultCategory: "default", + constructor: function() { + this.callParent(arguments); + this.categories = {}; + this.revisions = {} + }, + destroy: function() { + this.categories = null; + this.revisions = null; + this.callParent() + }, + getMarkerFor: function(b, a) { + if (b in this.categories) { + var c = this.categories[b]; + if (a in c) { + return this.get(c[a]) + } + } + }, + clear: function(a) { + a = a || this.defaultCategory; + if (!(a in this.revisions)) { + this.revisions[a] = 1 + } else { + this.revisions[a]++ + } + }, + putMarkerFor: function(e, b, c, h, f) { + e = e || this.defaultCategory; + var d = this, + g = d.categories[e] || (d.categories[e] = {}), + a; + if (c in g) { + d.setAttributesFor(g[c], b, h) + } else { + g[c] = d.getCount(); + d.createInstance(b, h) + } + a = d.get(g[c]); + if (a) { + a.category = e; + if (!f) { + a.revision = d.revisions[e] || (d.revisions[e] = 1) + } + } + }, + getMarkerBBoxFor: function(c, a, b) { + if (c in this.categories) { + var d = this.categories[c]; + if (a in d) { + return this.getBBoxFor(d[a], b) + } + } + }, + getBBox: function() { + return null + }, + render: function(a, l, b) { + var f = this, + k = f.revisions, + j = f.attr.matrix, + h = f.getTemplate(), + d = h.attr, + g, c, e; + j.toContext(l); + h.preRender(a, l, b); + h.useAttributes(l, b); + for (c = 0, e = f.instances.length; c < e; c++) { + g = f.get(c); + if (g.hidden || g.revision !== k[g.category]) { + continue + } + l.save(); + h.attr = g; + h.useAttributes(l, b); + h.render(a, l, b); + l.restore() + } + h.attr = d + } +}); +Ext.define("Ext.chart.label.Callout", { + extend: "Ext.draw.modifier.Modifier", + prepareAttributes: function(a) { + if (!a.hasOwnProperty("calloutOriginal")) { + a.calloutOriginal = Ext.Object.chain(a); + a.calloutOriginal.prototype = a + } + if (this._previous) { + this._previous.prepareAttributes(a.calloutOriginal) + } + }, + setAttrs: function(e, h) { + var d = e.callout, + i = e.calloutOriginal, + l = e.bbox.plain, + c = (l.width || 0) + e.labelOverflowPadding, + m = (l.height || 0) + e.labelOverflowPadding, + p, o; + if ("callout" in h) { + d = h.callout + } + if ("callout" in h || "calloutPlaceX" in h || "calloutPlaceY" in h || "x" in h || "y" in h) { + var n = "rotationRads" in h ? i.rotationRads = h.rotationRads : i.rotationRads, + g = "x" in h ? (i.x = h.x) : i.x, + f = "y" in h ? (i.y = h.y) : i.y, + b = "calloutPlaceX" in h ? h.calloutPlaceX : e.calloutPlaceX, + a = "calloutPlaceY" in h ? h.calloutPlaceY : e.calloutPlaceY, + k = "calloutVertical" in h ? h.calloutVertical : e.calloutVertical, + j; + n %= Math.PI * 2; + if (Math.cos(n) < 0) { + n = (n + Math.PI) % (Math.PI * 2) + } + if (n > Math.PI) { + n -= Math.PI * 2 + } + if (k) { + n = n * (1 - d) - Math.PI / 2 * d; + j = c; + c = m; + m = j + } else { + n = n * (1 - d) + } + h.rotationRads = n; + h.x = g * (1 - d) + b * d; + h.y = f * (1 - d) + a * d; + p = b - g; + o = a - f; + if (Math.abs(o * c) > Math.abs(p * m)) { + if (o > 0) { + h.calloutEndX = h.x - (m / 2) * (p / o) * d; + h.calloutEndY = h.y - (m / 2) * d + } else { + h.calloutEndX = h.x + (m / 2) * (p / o) * d; + h.calloutEndY = h.y + (m / 2) * d + } + } else { + if (p > 0) { + h.calloutEndX = h.x - c / 2; + h.calloutEndY = h.y - (c / 2) * (o / p) * d + } else { + h.calloutEndX = h.x + c / 2; + h.calloutEndY = h.y + (c / 2) * (o / p) * d + } + } + if (h.calloutStartX && h.calloutStartY) { + h.calloutHasLine = (p > 0 && h.calloutStartX < h.calloutEndX) || (p <= 0 && h.calloutStartX > h.calloutEndX) || (o > 0 && h.calloutStartY < h.calloutEndY) || (o <= 0 && h.calloutStartY > h.calloutEndY) + } else { + h.calloutHasLine = true + } + } + return h + }, + pushDown: function(a, b) { + b = this.callParent([a.calloutOriginal, b]); + return this.setAttrs(a, b) + }, + popUp: function(a, b) { + a = a.prototype; + b = this.setAttrs(a, b); + if (this._next) { + return this._next.popUp(a, b) + } else { + return Ext.apply(a, b) + } + } +}); +Ext.define("Ext.chart.label.Label", { + extend: "Ext.draw.sprite.Text", + requires: ["Ext.chart.label.Callout"], + inheritableStatics: { + def: { + processors: { + callout: "limited01", + calloutHasLine: "bool", + calloutPlaceX: "number", + calloutPlaceY: "number", + calloutStartX: "number", + calloutStartY: "number", + calloutEndX: "number", + calloutEndY: "number", + calloutColor: "color", + calloutWidth: "number", + calloutVertical: "bool", + labelOverflowPadding: "number", + display: "enums(none,under,over,rotate,insideStart,insideEnd,inside,outside)", + orientation: "enums(horizontal,vertical)", + renderer: "default" + }, + defaults: { + callout: 0, + calloutHasLine: true, + calloutPlaceX: 0, + calloutPlaceY: 0, + calloutStartX: 0, + calloutStartY: 0, + calloutEndX: 0, + calloutEndY: 0, + calloutWidth: 1, + calloutVertical: false, + calloutColor: "black", + labelOverflowPadding: 5, + display: "none", + orientation: "", + renderer: null + }, + triggers: { + callout: "transform", + calloutPlaceX: "transform", + calloutPlaceY: "transform", + labelOverflowPadding: "transform", + calloutRotation: "transform", + display: "hidden" + }, + updaters: { + hidden: function(a) { + a.hidden = a.display === "none" + } + } + } + }, + config: { + fx: { + customDurations: { + callout: 200 + } + }, + field: null, + calloutLine: true + }, + applyCalloutLine: function(a) { + if (a) { + return Ext.apply({}, a) + } + }, + prepareModifiers: function() { + this.callParent(arguments); + this.calloutModifier = new Ext.chart.label.Callout({ + sprite: this + }); + this.fx.setNext(this.calloutModifier); + this.calloutModifier.setNext(this.topModifier) + }, + render: function(b, c) { + var e = this, + a = e.attr, + d = a.calloutColor; + c.save(); + c.globalAlpha *= a.callout; + if (c.globalAlpha > 0 && a.calloutHasLine) { + if (d && d.isGradient) { + d = d.getStops()[0].color + } + c.strokeStyle = d; + c.fillStyle = d; + c.lineWidth = a.calloutWidth; + c.beginPath(); + c.moveTo(e.attr.calloutStartX, e.attr.calloutStartY); + c.lineTo(e.attr.calloutEndX, e.attr.calloutEndY); + c.stroke(); + c.beginPath(); + c.arc(e.attr.calloutStartX, e.attr.calloutStartY, 1 * a.calloutWidth, 0, 2 * Math.PI, true); + c.fill(); + c.beginPath(); + c.arc(e.attr.calloutEndX, e.attr.calloutEndY, 1 * a.calloutWidth, 0, 2 * Math.PI, true); + c.fill() + } + c.restore(); + Ext.draw.sprite.Text.prototype.render.apply(e, arguments) + } +}); +Ext.define("Ext.chart.series.Series", { + requires: ["Ext.chart.Markers", "Ext.chart.label.Label", "Ext.tip.ToolTip"], + mixins: ["Ext.mixin.Observable", "Ext.mixin.Bindable"], + isSeries: true, + defaultBindProperty: "store", + type: null, + seriesType: "sprite", + identifiablePrefix: "ext-line-", + observableType: "series", + darkerStrokeRatio: 0.15, + config: { + chart: null, + title: null, + renderer: null, + showInLegend: true, + triggerAfterDraw: false, + style: {}, + subStyle: {}, + themeStyle: {}, + colors: null, + useDarkerStrokeColor: true, + store: null, + label: {}, + labelOverflowPadding: null, + showMarkers: true, + marker: null, + markerSubStyle: null, + itemInstancing: null, + background: null, + highlightItem: null, + surface: null, + overlaySurface: null, + hidden: false, + highlight: false, + highlightCfg: { + merge: function(a) { + return a + }, + $value: { + fillStyle: "yellow", + strokeStyle: "red" + } + }, + animation: null, + tooltip: null + }, + directions: [], + sprites: null, + themeColorCount: function() { + return 1 + }, + isStoreDependantColorCount: false, + themeMarkerCount: function() { + return 0 + }, + getFields: function(f) { + var e = this, + a = [], + c, b, d; + for (b = 0, d = f.length; b < d; b++) { + c = e["get" + f[b] + "Field"](); + if (Ext.isArray(c)) { + a.push.apply(a, c) + } else { + a.push(c) + } + } + return a + }, + applyAnimation: function(a, b) { + if (!a) { + a = { + duration: 0 + } + } else { + if (a === true) { + a = { + easing: "easeInOut", + duration: 500 + } + } + } + return b ? Ext.apply({}, a, b) : a + }, + getAnimation: function() { + var a = this.getChart(); + if (a && a.animationSuspendCount) { + return { + duration: 0 + } + } else { + return this.callParent() + } + }, + updateTitle: function(a) { + var j = this, + g = j.getChart(); + if (!g || g.isInitializing) { + return + } + a = Ext.Array.from(a); + var c = g.getSeries(), + b = Ext.Array.indexOf(c, j), + e = g.getLegendStore(), + h = j.getYField(), + d, l, k, f; + if (e.getCount() && b !== -1) { + f = h ? Math.min(a.length, h.length) : a.length; + for (d = 0; d < f; d++) { + k = a[d]; + l = e.getAt(b + d); + if (k && l) { + l.set("name", k) + } + } + } + }, + applyHighlight: function(a, b) { + if (Ext.isObject(a)) { + a = Ext.merge({}, this.config.highlightCfg, a) + } else { + if (a === true) { + a = this.config.highlightCfg + } + } + return Ext.apply(b || {}, a) + }, + updateHighlight: function(a) { + this.getStyle(); + if (!Ext.Object.isEmpty(a)) { + this.addItemHighlight() + } + }, + updateHighlightCfg: function(a) { + if (!Ext.Object.equals(a, this.defaultConfig.highlightCfg)) { + this.addItemHighlight() + } + }, + applyItemInstancing: function(a, b) { + return Ext.merge(b || {}, a) + }, + setAttributesForItem: function(c, d) { + var b = c && c.sprite, + a; + if (b) { + if (b.itemsMarker && c.category === "items") { + b.putMarker(c.category, d, c.index, false, true) + } + if (b.isMarkerHolder && c.category === "markers") { + b.putMarker(c.category, d, c.index, false, true) + } else { + if (b.isInstancing) { + b.setAttributesFor(c.index, d) + } else { + if (Ext.isArray(b)) { + for (a = 0; a < b.length; a++) { + b[a].setAttributes(d) + } + } else { + b.setAttributes(d) + } + } + } + } + }, + getBBoxForItem: function(a) { + if (a && a.sprite) { + if (a.sprite.itemsMarker && a.category === "items") { + return a.sprite.getMarkerBBox(a.category, a.index) + } else { + if (a.sprite instanceof Ext.draw.sprite.Instancing) { + return a.sprite.getBBoxFor(a.index) + } else { + return a.sprite.getBBox() + } + } + } + return null + }, + applyHighlightItem: function(d, a) { + if (d === a) { + return + } + if (Ext.isObject(d) && Ext.isObject(a)) { + var c = d.sprite === a.sprite, + b = d.index === a.index; + if (c && b) { + return + } + } + return d + }, + updateHighlightItem: function(b, a) { + this.setAttributesForItem(a, { + highlighted: false + }); + this.setAttributesForItem(b, { + highlighted: true + }) + }, + constructor: function(a) { + var b = this, + c; + a = a || {}; + if (a.tips) { + a = Ext.apply({ + tooltip: a.tips + }, a) + } + if (a.highlightCfg) { + a = Ext.apply({ + highlight: a.highlightCfg + }, a) + } + if ("id" in a) { + c = a.id + } else { + if ("id" in b.config) { + c = b.config.id + } else { + c = b.getId() + } + } + b.setId(c); + b.sprites = []; + b.dataRange = []; + b.mixins.observable.constructor.call(b, a); + b.initBindable() + }, + lookupViewModel: function(a) { + var b = this.getChart(); + return b ? b.lookupViewModel(a) : null + }, + applyTooltip: function(c, b) { + var a = Ext.apply({ + xtype: "tooltip", + renderer: Ext.emptyFn, + constrainPosition: true, + shrinkWrapDock: true, + autoHide: true, + offsetX: 10, + offsetY: 10 + }, c); + return Ext.create(a) + }, + updateTooltip: function() { + this.addItemHighlight() + }, + addItemHighlight: function() { + var d = this.getChart(); + if (!d) { + return + } + var e = d.getInteractions(), + c, a, b; + for (c = 0; c < e.length; c++) { + a = e[c]; + if (a.isItemHighlight || a.isItemEdit) { + b = true; + break + } + } + if (!b) { + e.push("itemhighlight"); + d.setInteractions(e) + } + }, + showTooltip: function(l, m) { + var d = this, + n = d.getTooltip(), + j, a, i, f, h, k, g, e, b, c; + if (!n) { + return + } + clearTimeout(d.tooltipTimeout); + b = n.config; + if (n.trackMouse) { + m[0] += b.offsetX; + m[1] += b.offsetY + } else { + j = l.sprite; + a = j.getSurface(); + i = Ext.get(a.getId()); + if (i) { + k = l.series.getBBoxForItem(l); + g = k.x + k.width / 2; + e = k.y + k.height / 2; + h = a.matrix.transformPoint([g, e]); + f = i.getXY(); + c = a.getInherited().rtl; + g = c ? f[0] + i.getWidth() - h[0] : f[0] + h[0]; + e = f[1] + h[1]; + m = [g, e] + } + } + Ext.callback(n.renderer, n.scope, [n, l.record, l], 0, d); + n.show(m) + }, + hideTooltip: function(b) { + var a = this, + c = a.getTooltip(); + if (!c) { + return + } + clearTimeout(a.tooltipTimeout); + a.tooltipTimeout = Ext.defer(function() { + c.hide() + }, 1) + }, + applyStore: function(a) { + return a && Ext.StoreManager.lookup(a) + }, + getStore: function() { + return this._store || this.getChart() && this.getChart().getStore() + }, + updateStore: function(b, a) { + var h = this, + g = h.getChart(), + c = g && g.getStore(), + f, j, e, d; + a = a || c; + if (a && a !== b) { + a.un({ + datachanged: "onDataChanged", + update: "onDataChanged", + scope: h + }) + } + if (b) { + b.on({ + datachanged: "onDataChanged", + update: "onDataChanged", + scope: h + }); + f = h.getSprites(); + for (d = 0, e = f.length; d < e; d++) { + j = f[d]; + if (j.setStore) { + j.setStore(b) + } + } + h.onDataChanged() + } + h.fireEvent("storechange", h, b, a) + }, + onStoreChange: function(b, a, c) { + if (!this._store) { + this.updateStore(a, c) + } + }, + coordinate: function(o, m, e) { + var l = this, + p = l.getStore(), + h = l.getHidden(), + k = p.getData().items, + b = l["get" + o + "Axis"](), + f = { + min: Infinity, + max: -Infinity + }, + q = l["fieldCategory" + o] || [o], + g = l.getFields(q), + d, n, c, a = {}, + j = l.getSprites(); + if (j.length > 0) { + if (!Ext.isBoolean(h) || !h) { + for (d = 0; d < q.length; d++) { + n = g[d]; + c = l.coordinateData(k, n, b); + l.getRangeOfData(c, f); + a["data" + q[d]] = c + } + } + l.dataRange[m] = f.min; + l.dataRange[m + e] = f.max; + a["dataMin" + o] = f.min; + a["dataMax" + o] = f.max; + if (b) { + b.range = null; + a["range" + o] = b.getRange() + } + for (d = 0; d < j.length; d++) { + j[d].setAttributes(a) + } + } + }, + coordinateData: function(b, h, d) { + var g = [], + f = b.length, + e = d && d.getLayout(), + c, a; + for (c = 0; c < f; c++) { + a = b[c].data[h]; + if (!Ext.isEmpty(a, true)) { + if (e) { + g[c] = e.getCoordFor(a, h, c, b) + } else { + g[c] = +a + } + } else { + g[c] = a + } + } + return g + }, + getRangeOfData: function(g, b) { + var e = g.length, + d = b.min, + a = b.max, + c, f; + for (c = 0; c < e; c++) { + f = g[c]; + if (f < d) { + d = f + } + if (f > a) { + a = f + } + } + b.min = d; + b.max = a + }, + updateLabelData: function() { + var h = this, + l = h.getStore(), + g = l.getData().items, + f = h.getSprites(), + a = h.getLabel().getTemplate(), + n = Ext.Array.from(a.getField()), + c, b, e, d, m, k; + if (!f.length || !n.length) { + return + } + for (c = 0; c < f.length; c++) { + d = []; + m = f[c]; + k = m.getField(); + if (Ext.Array.indexOf(n, k) < 0) { + k = n[c] + } + for (b = 0, e = g.length; b < e; b++) { + d.push(g[b].get(k)) + } + m.setAttributes({ + labels: d + }) + } + }, + processData: function() { + if (!this.getStore()) { + return + } + var d = this, + f = this.directions, + a, c = f.length, + e, b; + for (a = 0; a < c; a++) { + e = f[a]; + b = d["get" + e + "Axis"](); + if (b) { + b.processData(d); + continue + } + if (d["coordinate" + e]) { + d["coordinate" + e]() + } + } + d.updateLabelData() + }, + applyBackground: function(a) { + if (this.getChart()) { + this.getSurface().setBackground(a); + return this.getSurface().getBackground() + } else { + return a + } + }, + updateChart: function(d, a) { + var c = this, + b = c._store; + if (a) { + a.un("axeschange", "onAxesChange", c); + c.clearSprites(); + c.setSurface(null); + c.setOverlaySurface(null); + a.unregister(c); + c.onChartDetached(a); + if (!b) { + c.updateStore(null) + } + } + if (d) { + c.setSurface(d.getSurface("series")); + c.setOverlaySurface(d.getSurface("overlay")); + d.on("axeschange", "onAxesChange", c); + if (d.getAxes()) { + c.onAxesChange(d) + } + c.onChartAttached(d); + d.register(c); + if (!b) { + c.updateStore(d.getStore()) + } + } + }, + onAxesChange: function(h) { + var k = this, + g = h.getAxes(), + c, a = {}, + b = {}, + e = false, + j = this.directions, + l, d, f; + for (d = 0, f = j.length; d < f; d++) { + l = j[d]; + b[l] = k.getFields(k["fieldCategory" + l]) + } + for (d = 0, f = g.length; d < f; d++) { + c = g[d]; + if (!a[c.getDirection()]) { + a[c.getDirection()] = [c] + } else { + a[c.getDirection()].push(c) + } + } + for (d = 0, f = j.length; d < f; d++) { + l = j[d]; + if (k["get" + l + "Axis"]()) { + continue + } + if (a[l]) { + c = k.findMatchingAxis(a[l], b[l]); + if (c) { + k["set" + l + "Axis"](c); + if (c.getNeedHighPrecision()) { + e = true + } + } + } + } + this.getSurface().setHighPrecision(e) + }, + findMatchingAxis: function(f, e) { + var d, c, b, a; + for (b = 0; b < f.length; b++) { + d = f[b]; + c = d.getFields(); + if (!c.length) { + return d + } else { + if (e) { + for (a = 0; a < e.length; a++) { + if (Ext.Array.indexOf(c, e[a]) >= 0) { + return d + } + } + } + } + } + }, + onChartDetached: function(a) { + var b = this; + b.fireEvent("chartdetached", a, b); + a.un("storechange", "onStoreChange", b) + }, + onChartAttached: function(a) { + var b = this; + b.setBackground(b.getBackground()); + b.fireEvent("chartattached", a, b); + a.on("storechange", "onStoreChange", b); + b.processData() + }, + updateOverlaySurface: function(a) { + var b = this; + if (a) { + if (b.getLabel()) { + b.getOverlaySurface().add(b.getLabel()) + } + } + }, + applyLabel: function(a, b) { + if (!b) { + b = new Ext.chart.Markers({ + zIndex: 10 + }); + b.setTemplate(new Ext.chart.label.Label(a)) + } else { + b.getTemplate().setAttributes(a) + } + return b + }, + createItemInstancingSprite: function(c, b) { + var e = this, + f = new Ext.chart.Markers(), + a, d; + f.setAttributes({ + zIndex: Number.MAX_VALUE + }); + a = Ext.apply({}, b); + if (e.getHighlight()) { + a.highlight = e.getHighlight(); + a.modifiers = ["highlight"] + } + f.setTemplate(a); + d = f.getTemplate(); + d.setAttributes(e.getStyle()); + d.fx.on("animationstart", "onSpriteAnimationStart", this); + d.fx.on("animationend", "onSpriteAnimationEnd", this); + c.bindMarker("items", f); + e.getSurface().add(f); + return f + }, + getDefaultSpriteConfig: function() { + return { + type: this.seriesType, + renderer: this.getRenderer() + } + }, + updateRenderer: function(c) { + var b = this, + a = b.getChart(), + d; + if (a && a.isInitializing) { + return + } + d = b.getSprites(); + if (d.length) { + d[0].setAttributes({ + renderer: c || null + }); + if (a && !a.isInitializing) { + a.redraw() + } + } + }, + updateShowMarkers: function(a) { + var d = this.getSprites(), + b = d && d[0], + c = b && b.getMarker("markers"); + if (c) { + c.getTemplate().setAttributes({ + hidden: !a + }) + } + }, + createSprite: function() { + var f = this, + a = f.getSurface(), + e = f.getItemInstancing(), + d = a.add(f.getDefaultSpriteConfig()), + b = f.getMarker(), + g, c; + d.setAttributes(f.getStyle()); + d.setSeries(f); + if (e) { + d.itemsMarker = f.createItemInstancingSprite(d, e) + } + if (d.bindMarker) { + if (b) { + g = new Ext.chart.Markers(); + c = Ext.Object.merge({}, b); + if (f.getHighlight()) { + c.highlight = f.getHighlight(); + c.modifiers = ["highlight"] + } + g.setTemplate(c); + g.getTemplate().fx.setCustomDurations({ + translationX: 0, + translationY: 0 + }); + d.dataMarker = g; + d.bindMarker("markers", g); + f.getOverlaySurface().add(g) + } + if (f.getLabel().getTemplate().getField()) { + d.bindMarker("labels", f.getLabel()) + } + } + if (d.setStore) { + d.setStore(f.getStore()) + } + d.fx.on("animationstart", "onSpriteAnimationStart", f); + d.fx.on("animationend", "onSpriteAnimationEnd", f); + f.sprites.push(d); + return d + }, + getSprites: Ext.emptyFn, + onDataChanged: function() { + var d = this, + c = d.getChart(), + b = c && c.getStore(), + a = d.getStore(); + if (a !== b) { + d.processData() + } + }, + isXType: function(a) { + return a === "series" + }, + getItemId: function() { + return this.getId() + }, + applyThemeStyle: function(e, a) { + var b = this, + d, c; + d = e && e.subStyle && e.subStyle.fillStyle; + c = d && e.subStyle.strokeStyle; + if (d && !c) { + e.subStyle.strokeStyle = b.getStrokeColorsFromFillColors(d) + } + d = e && e.markerSubStyle && e.markerSubStyle.fillStyle; + c = d && e.markerSubStyle.strokeStyle; + if (d && !c) { + e.markerSubStyle.strokeStyle = b.getStrokeColorsFromFillColors(d) + } + return Ext.apply(a || {}, e) + }, + applyStyle: function(c, b) { + var a = Ext.ClassManager.get(Ext.ClassManager.getNameByAlias("sprite." + this.seriesType)); + if (a && a.def) { + c = a.def.normalize(c) + } + return Ext.apply({}, c, b) + }, + applySubStyle: function(b, c) { + var a = Ext.ClassManager.get(Ext.ClassManager.getNameByAlias("sprite." + this.seriesType)); + if (a && a.def) { + b = a.def.batchedNormalize(b, true) + } + return Ext.merge({}, c, b) + }, + applyMarker: function(c, a) { + var d = (c && c.type) || (a && a.type) || "circle", + b = Ext.ClassManager.get(Ext.ClassManager.getNameByAlias("sprite." + d)); + if (b && b.def) { + c = b.def.normalize(Ext.isObject(c) ? c : {}, true); + c.type = d + } + return Ext.merge(a || {}, c) + }, + applyMarkerSubStyle: function(c, a) { + var d = (c && c.type) || (a && a.type) || "circle", + b = Ext.ClassManager.get(Ext.ClassManager.getNameByAlias("sprite." + d)); + if (b && b.def) { + c = b.def.batchedNormalize(c, true) + } + return Ext.merge(a || {}, c) + }, + updateHidden: function(b) { + var a = this; + a.getColors(); + a.getSubStyle(); + a.setSubStyle({ + hidden: b + }); + a.processData(); + a.doUpdateStyles(); + if (!Ext.isArray(b)) { + a.updateLegendStore(b) + } + }, + updateLegendStore: function(f, b) { + var e = this, + d = e.getChart(), + c = d.getLegendStore(), + g = e.getId(), + a; + if (c) { + if (arguments.length > 1) { + a = c.findBy(function(h) { + return h.get("series") === g && h.get("index") === b + }); + if (a !== -1) { + a = c.getAt(a) + } + } else { + a = c.findRecord("series", g) + } + if (a && a.get("disabled") !== f) { + a.set("disabled", f) + } + } + }, + setHiddenByIndex: function(a, c) { + var b = this; + if (Ext.isArray(b.getHidden())) { + b.getHidden()[a] = c; + b.updateHidden(b.getHidden()); + b.updateLegendStore(c, a) + } else { + b.setHidden(c) + } + }, + getStrokeColorsFromFillColors: function(a) { + var c = this, + e = c.getUseDarkerStrokeColor(), + b = (Ext.isNumber(e) ? e : c.darkerStrokeRatio), + d; + if (e) { + d = Ext.Array.map(a, function(f) { + f = Ext.isString(f) ? f : f.stops[0].color; + f = Ext.draw.Color.fromString(f); + return f.createDarker(b).toString() + }) + } else { + d = Ext.Array.clone(a) + } + return d + }, + updateThemeColors: function(b) { + var c = this, + d = c.getThemeStyle(), + a = Ext.Array.clone(b), + f = c.getStrokeColorsFromFillColors(b), + e = { + fillStyle: a, + strokeStyle: f + }; + d.subStyle = Ext.apply(d.subStyle || {}, e); + d.markerSubStyle = Ext.apply(d.markerSubStyle || {}, e); + c.doUpdateStyles() + }, + themeOnlyIfConfigured: {}, + updateTheme: function(d) { + var h = this, + a = d.getSeries(), + n = h.getInitialConfig(), + c = h.defaultConfig, + f = h.getConfigurator().configs, + j = a.defaults, + k = a[h.type], + g = h.themeOnlyIfConfigured, + l, i, o, b, m, e; + a = Ext.merge({}, j, k); + for (l in a) { + i = a[l]; + e = f[l]; + if (i !== null && i !== undefined && e) { + m = n[l]; + o = Ext.isObject(i); + b = m === c[l]; + if (o) { + if (b && g[l]) { + continue + } + i = Ext.merge({}, i, m) + } + if (b || o) { + h[e.names.set](i) + } + } + } + }, + updateChartColors: function(a) { + var b = this; + if (!b.getColors()) { + b.updateThemeColors(a) + } + }, + updateColors: function(a) { + this.updateThemeColors(a) + }, + updateStyle: function() { + this.doUpdateStyles() + }, + updateSubStyle: function() { + this.doUpdateStyles() + }, + updateThemeStyle: function() { + this.doUpdateStyles() + }, + doUpdateStyles: function() { + var g = this, + h = g.sprites, + d = g.getItemInstancing(), + c = 0, + f = h && h.length, + a = g.getConfig("showMarkers", true), + b = g.getMarker(), + e; + for (; c < f; c++) { + e = g.getStyleByIndex(c); + if (d) { + h[c].itemsMarker.getTemplate().setAttributes(e) + } + h[c].setAttributes(e); + if (b && h[c].dataMarker) { + h[c].dataMarker.getTemplate().setAttributes(g.getMarkerStyleByIndex(c)) + } + } + }, + getStyleWithTheme: function() { + var b = this, + c = b.getThemeStyle(), + d = (c && c.style) || {}, + a = Ext.applyIf(Ext.apply({}, b.getStyle()), d); + return a + }, + getSubStyleWithTheme: function() { + var c = this, + d = c.getThemeStyle(), + a = (d && d.subStyle) || {}, + b = Ext.applyIf(Ext.apply({}, c.getSubStyle()), a); + return b + }, + getStyleByIndex: function(b) { + var e = this, + h = e.getThemeStyle(), + d, g, c, f, a = {}; + d = e.getStyle(); + g = (h && h.style) || {}; + c = e.styleDataForIndex(e.getSubStyle(), b); + f = e.styleDataForIndex((h && h.subStyle), b); + Ext.apply(a, g); + Ext.apply(a, f); + Ext.apply(a, d); + Ext.apply(a, c); + return a + }, + getMarkerStyleByIndex: function(d) { + var g = this, + c = g.getThemeStyle(), + a, e, k, j, b, l, h, f, m = {}; + a = g.getStyle(); + e = (c && c.style) || {}; + k = g.styleDataForIndex(g.getSubStyle(), d); + if (k.hasOwnProperty("hidden")) { + k.hidden = k.hidden || !this.getConfig("showMarkers", true) + } + j = g.styleDataForIndex((c && c.subStyle), d); + b = g.getMarker(); + l = (c && c.marker) || {}; + h = g.getMarkerSubStyle(); + f = g.styleDataForIndex((c && c.markerSubStyle), d); + Ext.apply(m, e); + Ext.apply(m, j); + Ext.apply(m, l); + Ext.apply(m, f); + Ext.apply(m, a); + Ext.apply(m, k); + Ext.apply(m, b); + Ext.apply(m, h); + return m + }, + styleDataForIndex: function(d, c) { + var e, b, a = {}; + if (d) { + for (b in d) { + e = d[b]; + if (Ext.isArray(e)) { + a[b] = e[c % e.length] + } else { + a[b] = e + } + } + } + return a + }, + getItemForPoint: Ext.emptyFn, + getItemByIndex: function(a, e) { + var d = this, + f = d.getSprites(), + b = f && f[0], + c; + if (!b) { + return + } + if (e === undefined && b.isMarkerHolder) { + e = d.getItemInstancing() ? "items" : "markers" + } else { + if (!e || e === "" || e === "sprites") { + b = f[a] + } + } + if (b) { + c = { + series: d, + category: e, + index: a, + record: d.getStore().getData().items[a], + field: d.getYField(), + sprite: b + }; + return c + } + }, + onSpriteAnimationStart: function(a) { + this.fireEvent("animationstart", this, a) + }, + onSpriteAnimationEnd: function(a) { + this.fireEvent("animationend", this, a) + }, + resolveListenerScope: function(e) { + var d = this, + a = Ext._namedScopes[e], + c = d.getChart(), + b; + if (!a) { + b = c ? c.resolveListenerScope(e, false) : (e || d) + } else { + if (a.isThis) { + b = d + } else { + if (a.isController) { + b = c ? c.resolveListenerScope(e, false) : d + } else { + if (a.isSelf) { + b = c ? c.resolveListenerScope(e, false) : d; + if (b === c && !c.getInheritedConfig("defaultListenerScope")) { + b = d + } + } + } + } + } + return b + }, + provideLegendInfo: function(a) { + a.push({ + name: this.getTitle() || this.getId(), + mark: "black", + disabled: this.getHidden(), + series: this.getId(), + index: 0 + }) + }, + clearSprites: function() { + var d = this.sprites, + b, a, c; + for (a = 0, c = d.length; a < c; a++) { + b = d[a]; + if (b && b.isSprite) { + b.destroy() + } + } + this.sprites = [] + }, + destroy: function() { + var b = this, + a = b._store, + c = b.getConfig("tooltip", true); + if (a && a.getAutoDestroy()) { + Ext.destroy(a) + } + b.setChart(null); + b.clearListeners(); + if (c) { + Ext.destroy(c); + clearTimeout(b.tooltipTimeout) + } + b.callParent() + } +}); +Ext.define("Ext.chart.interactions.Abstract", { + xtype: "interaction", + mixins: { + observable: "Ext.mixin.Observable" + }, + config: { + gestures: { + tap: "onGesture" + }, + chart: null, + enabled: true + }, + throttleGap: 0, + stopAnimationBeforeSync: false, + constructor: function(a) { + var b = this, + c; + a = a || {}; + if ("id" in a) { + c = a.id + } else { + if ("id" in b.config) { + c = b.config.id + } else { + c = b.getId() + } + } + b.setId(c); + b.mixins.observable.constructor.call(b, a) + }, + initialize: Ext.emptyFn, + updateChart: function(c, a) { + var b = this; + if (a === c) { + return + } + if (a) { + a.unregister(b); + b.removeChartListener(a) + } + if (c) { + c.register(b); + b.addChartListener() + } + }, + updateEnabled: function(a) { + var c = this, + b = c.getChart(); + if (b) { + if (a) { + c.addChartListener() + } else { + c.removeChartListener(b) + } + } + }, + onGesture: Ext.emptyFn, + getItemForEvent: function(d) { + var b = this, + a = b.getChart(), + c = a.getEventXY(d); + return a.getItemForPoint(c[0], c[1]) + }, + getItemsForEvent: function(d) { + var b = this, + a = b.getChart(), + c = a.getEventXY(d); + return a.getItemsForPoint(c[0], c[1]) + }, + addChartListener: function() { + var c = this, + b = c.getChart(), + e = c.getGestures(), + a; + if (!c.getEnabled()) { + return + } + + function d(f, g) { + b.addElementListener(f, c.listeners[f] = function(j) { + var i = c.getLocks(), + h; + if (c.getEnabled() && (!(f in i) || i[f] === c)) { + h = (Ext.isFunction(g) ? g : c[g]).apply(this, arguments); + if (h === false && j && j.stopPropagation) { + j.stopPropagation() + } + return h + } + }, c) + } + c.listeners = c.listeners || {}; + for (a in e) { + d(a, e[a]) + } + }, + removeChartListener: function(c) { + var d = this, + e = d.getGestures(), + b; + + function a(f) { + var g = d.listeners[f]; + if (g) { + c.removeElementListener(f, g); + delete d.listeners[f] + } + } + if (d.listeners) { + for (b in e) { + a(b) + } + } + }, + lockEvents: function() { + var d = this, + c = d.getLocks(), + a = Array.prototype.slice.call(arguments), + b = a.length; + while (b--) { + c[a[b]] = d + } + }, + unlockEvents: function() { + var c = this.getLocks(), + a = Array.prototype.slice.call(arguments), + b = a.length; + while (b--) { + delete c[a[b]] + } + }, + getLocks: function() { + var a = this.getChart(); + return a.lockedEvents || (a.lockedEvents = {}) + }, + isMultiTouch: function() { + if (Ext.browser.is.IE10) { + return true + } + return !Ext.os.is.Desktop + }, + initializeDefaults: Ext.emptyFn, + doSync: function() { + var b = this, + a = b.getChart(); + if (b.syncTimer) { + clearTimeout(b.syncTimer); + b.syncTimer = null + } + if (b.stopAnimationBeforeSync) { + a.animationSuspendCount++ + } + a.redraw(); + if (b.stopAnimationBeforeSync) { + a.animationSuspendCount-- + } + b.syncThrottle = Date.now() + b.throttleGap + }, + sync: function() { + var a = this; + if (a.throttleGap && Ext.frameStartTime < a.syncThrottle) { + if (a.syncTimer) { + return + } + a.syncTimer = Ext.defer(function() { + a.doSync() + }, a.throttleGap) + } else { + a.doSync() + } + }, + getItemId: function() { + return this.getId() + }, + isXType: function(a) { + return a === "interaction" + }, + destroy: function() { + var a = this; + a.setChart(null); + delete a.listeners; + a.callParent() + } +}, function() { + if (Ext.os.is.Android4) { + this.prototype.throttleGap = 40 + } +}); +Ext.define("Ext.chart.MarkerHolder", { + extend: "Ext.Mixin", + mixinConfig: { + id: "markerHolder", + after: { + constructor: "constructor", + preRender: "preRender" + }, + before: { + destroy: "destroy" + } + }, + isMarkerHolder: true, + surfaceMatrix: null, + inverseSurfaceMatrix: null, + deprecated: { + 6: { + methods: { + getBoundMarker: { + message: "Please use the 'getMarker' method instead.", + fn: function(b) { + var a = this.boundMarkers[b]; + return a ? [a] : a + } + } + } + } + }, + constructor: function() { + this.boundMarkers = {}; + this.cleanRedraw = false + }, + bindMarker: function(b, a) { + var c = this, + d = c.boundMarkers; + if (a && a.isMarkers) { + c.releaseMarker(b); + d[b] = a; + a.on("destroy", c.onMarkerDestroy, c) + } + }, + onMarkerDestroy: function(a) { + this.releaseMarker(a) + }, + releaseMarker: function(a) { + var c = this.boundMarkers, + b; + if (a && a.isMarkers) { + for (b in c) { + if (c[b] === a) { + delete c[b]; + break + } + } + } else { + b = a; + a = c[b]; + delete c[b] + } + return a || null + }, + getMarker: function(a) { + return this.boundMarkers[a] || null + }, + preRender: function() { + var f = this, + g = f.getId(), + d = f.boundMarkers, + e = f.getParent(), + c, a, b; + if (f.surfaceMatrix) { + b = f.surfaceMatrix.set(1, 0, 0, 1, 0, 0) + } else { + b = f.surfaceMatrix = new Ext.draw.Matrix() + } + f.cleanRedraw = !f.attr.dirty; + if (!f.cleanRedraw) { + for (c in d) { + a = d[c]; + if (a) { + a.clear(g) + } + } + } + while (e && e.attr && e.attr.matrix) { + b.prependMatrix(e.attr.matrix); + e = e.getParent() + } + b.prependMatrix(e.matrix); + f.surfaceMatrix = b; + f.inverseSurfaceMatrix = b.inverse(f.inverseSurfaceMatrix) + }, + putMarker: function(d, a, c, g, e) { + var b = this.boundMarkers[d], + f = this.getId(); + if (b) { + b.putMarkerFor(f, a, c, g, e) + } + }, + getMarkerBBox: function(c, b, d) { + var a = this.boundMarkers[c], + e = this.getId(); + if (a) { + return a.getMarkerBBoxFor(e, b, d) + } + }, + destroy: function() { + var c = this.boundMarkers, + b, a; + for (b in c) { + a = c[b]; + a.destroy() + } + } +}); +Ext.define("Ext.chart.axis.sprite.Axis", { + extend: "Ext.draw.sprite.Sprite", + alias: "sprite.axis", + type: "axis", + mixins: { + markerHolder: "Ext.chart.MarkerHolder" + }, + requires: ["Ext.draw.sprite.Text"], + inheritableStatics: { + def: { + processors: { + grid: "bool", + axisLine: "bool", + minorTicks: "bool", + minorTickSize: "number", + majorTicks: "bool", + majorTickSize: "number", + length: "number", + startGap: "number", + endGap: "number", + dataMin: "number", + dataMax: "number", + visibleMin: "number", + visibleMax: "number", + position: "enums(left,right,top,bottom,angular,radial,gauge)", + minStepSize: "number", + estStepSize: "number", + titleOffset: "number", + textPadding: "number", + min: "number", + max: "number", + centerX: "number", + centerY: "number", + radius: "number", + totalAngle: "number", + baseRotation: "number", + data: "default", + enlargeEstStepSizeByText: "bool" + }, + defaults: { + grid: false, + axisLine: true, + minorTicks: false, + minorTickSize: 3, + majorTicks: true, + majorTickSize: 5, + length: 0, + startGap: 0, + endGap: 0, + visibleMin: 0, + visibleMax: 1, + dataMin: 0, + dataMax: 1, + position: "", + minStepSize: 0, + estStepSize: 20, + min: 0, + max: 1, + centerX: 0, + centerY: 0, + radius: 1, + baseRotation: 0, + data: null, + titleOffset: 0, + textPadding: 0, + scalingCenterY: 0, + scalingCenterX: 0, + strokeStyle: "black", + enlargeEstStepSizeByText: false + }, + triggers: { + minorTickSize: "bbox", + majorTickSize: "bbox", + position: "bbox,layout", + axisLine: "bbox,layout", + min: "layout", + max: "layout", + length: "layout", + minStepSize: "layout", + estStepSize: "layout", + data: "layout", + dataMin: "layout", + dataMax: "layout", + visibleMin: "layout", + visibleMax: "layout", + enlargeEstStepSizeByText: "layout" + }, + updaters: { + layout: "layoutUpdater" + } + } + }, + config: { + label: null, + layout: null, + segmenter: null, + renderer: null, + layoutContext: null, + axis: null + }, + thickness: 0, + stepSize: 0, + getBBox: function() { + return null + }, + defaultRenderer: function(a) { + return this.segmenter.renderer(a, this) + }, + layoutUpdater: function() { + var h = this, + f = h.getAxis().getChart(); + if (f.isInitializing) { + return + } + var e = h.attr, + d = h.getLayout(), + g = f.getInherited().rtl, + b = e.dataMin + (e.dataMax - e.dataMin) * e.visibleMin, + i = e.dataMin + (e.dataMax - e.dataMin) * e.visibleMax, + c = e.position, + a = { + attr: e, + segmenter: h.getSegmenter(), + renderer: h.defaultRenderer + }; + if (c === "left" || c === "right") { + e.translationX = 0; + e.translationY = i * e.length / (i - b); + e.scalingX = 1; + e.scalingY = -e.length / (i - b); + e.scalingCenterY = 0; + e.scalingCenterX = 0; + h.applyTransformations(true) + } else { + if (c === "top" || c === "bottom") { + if (g) { + e.translationX = e.length + b * e.length / (i - b) + 1 + } else { + e.translationX = -b * e.length / (i - b) + } + e.translationY = 0; + e.scalingX = (g ? -1 : 1) * e.length / (i - b); + e.scalingY = 1; + e.scalingCenterY = 0; + e.scalingCenterX = 0; + h.applyTransformations(true) + } + } + if (d) { + d.calculateLayout(a); + h.setLayoutContext(a) + } + }, + iterate: function(e, j) { + var c, g, a, b, h, d, k = Ext.Array.some, + m = Math.abs, + f; + if (e.getLabel) { + if (e.min < e.from) { + j.call(this, e.min, e.getLabel(e.min), -1, e) + } + for (c = 0; c <= e.steps; c++) { + j.call(this, e.get(c), e.getLabel(c), c, e) + } + if (e.max > e.to) { + j.call(this, e.max, e.getLabel(e.max), e.steps + 1, e) + } + } else { + b = this.getAxis(); + h = b.floatingAxes; + d = []; + f = (e.to - e.from) / (e.steps + 1); + if (b.getFloating()) { + for (a in h) { + d.push(h[a]) + } + } + + function l(i) { + return !d.length || k(d, function(n) { + return m(n - i) > f + }) + } + if (e.min < e.from && l(e.min)) { + j.call(this, e.min, e.min, -1, e) + } + for (c = 0; c <= e.steps; c++) { + g = e.get(c); + if (l(g)) { + j.call(this, g, g, c, e) + } + } + if (e.max > e.to && l(e.max)) { + j.call(this, e.max, e.max, e.steps + 1, e) + } + } + }, + renderTicks: function(l, m, s, p) { + var v = this, + k = v.attr, + u = k.position, + n = k.matrix, + e = 0.5 * k.lineWidth, + f = n.getXX(), + i = n.getDX(), + j = n.getYY(), + h = n.getDY(), + o = s.majorTicks, + d = k.majorTickSize, + a = s.minorTicks, + r = k.minorTickSize; + if (o) { + switch (u) { + case "right": + function q(w) { + return function(x, z, y) { + x = l.roundPixel(x * j + h) + e; + m.moveTo(0, x); + m.lineTo(w, x) + } + } + v.iterate(o, q(d)); + a && v.iterate(a, q(r)); + break; + case "left": + function t(w) { + return function(x, z, y) { + x = l.roundPixel(x * j + h) + e; + m.moveTo(p[2] - w, x); + m.lineTo(p[2], x) + } + } + v.iterate(o, t(d)); + a && v.iterate(a, t(r)); + break; + case "bottom": + function c(w) { + return function(x, z, y) { + x = l.roundPixel(x * f + i) - e; + m.moveTo(x, 0); + m.lineTo(x, w) + } + } + v.iterate(o, c(d)); + a && v.iterate(a, c(r)); + break; + case "top": + function b(w) { + return function(x, z, y) { + x = l.roundPixel(x * f + i) - e; + m.moveTo(x, p[3]); + m.lineTo(x, p[3] - w) + } + } + v.iterate(o, b(d)); + a && v.iterate(a, b(r)); + break; + case "angular": + v.iterate(o, function(w, y, x) { + w = w / (k.max + 1) * Math.PI * 2 + k.baseRotation; + m.moveTo(k.centerX + (k.length) * Math.cos(w), k.centerY + (k.length) * Math.sin(w)); + m.lineTo(k.centerX + (k.length + d) * Math.cos(w), k.centerY + (k.length + d) * Math.sin(w)) + }); + break; + case "gauge": + var g = v.getGaugeAngles(); + v.iterate(o, function(w, y, x) { + w = (w - k.min) / (k.max - k.min + 1) * k.totalAngle - k.totalAngle + g.start; + m.moveTo(k.centerX + (k.length) * Math.cos(w), k.centerY + (k.length) * Math.sin(w)); + m.lineTo(k.centerX + (k.length + d) * Math.cos(w), k.centerY + (k.length + d) * Math.sin(w)) + }); + break + } + } + }, + renderLabels: function(E, q, D, K) { + var o = this, + k = o.attr, + i = 0.5 * k.lineWidth, + u = k.position, + y = k.matrix, + A = k.textPadding, + x = y.getXX(), + d = y.getDX(), + g = y.getYY(), + c = y.getDY(), + n = 0, + I = D.majorTicks, + G = Math.max(k.majorTickSize, k.minorTickSize) + k.lineWidth, + f = Ext.draw.Draw.isBBoxIntersect, + F = o.getLabel(), + J, s, r = null, + w = 0, + b = 0, + m = D.segmenter, + B = o.getRenderer(), + t = o.getAxis(), + z = t.getTitle(), + a = z && z.attr.text !== "" && z.getBBox(), + l, h = null, + p, C, v, e, H; + if (I && F && !F.attr.hidden) { + J = F.attr.font; + if (q.font !== J) { + q.font = J + } + F.setAttributes({ + translationX: 0, + translationY: 0 + }, true); + F.applyTransformations(); + l = F.attr.inverseMatrix.elements.slice(0); + switch (u) { + case "left": + e = a ? a.x + a.width : 0; + switch (F.attr.textAlign) { + case "start": + H = E.roundPixel(e + d) - i; + break; + case "end": + H = E.roundPixel(K[2] - G + d) - i; + break; + default: + H = E.roundPixel(e + (K[2] - e - G) / 2 + d) - i + } + F.setAttributes({ + translationX: H + }, true); + break; + case "right": + e = a ? K[2] - a.x : 0; + switch (F.attr.textAlign) { + case "start": + H = E.roundPixel(G + d) + i; + break; + case "end": + H = E.roundPixel(K[2] - e + d) + i; + break; + default: + H = E.roundPixel(G + (K[2] - G - e) / 2 + d) + i + } + F.setAttributes({ + translationX: H + }, true); + break; + case "top": + e = a ? a.y + a.height : 0; + F.setAttributes({ + translationY: E.roundPixel(e + (K[3] - e - G) / 2) - i + }, true); + break; + case "bottom": + e = a ? K[3] - a.y : 0; + F.setAttributes({ + translationY: E.roundPixel(G + (K[3] - G - e) / 2) + i + }, true); + break; + case "radial": + F.setAttributes({ + translationX: k.centerX + }, true); + break; + case "angular": + F.setAttributes({ + translationY: k.centerY + }, true); + break; + case "gauge": + F.setAttributes({ + translationY: k.centerY + }, true); + break + } + if (u === "left" || u === "right") { + o.iterate(I, function(L, N, M) { + if (N === undefined) { + return + } + if (B) { + v = Ext.callback(B, null, [t, N, D, r], 0, t) + } else { + v = m.renderer(N, D, r) + } + r = N; + F.setAttributes({ + text: String(v), + translationY: E.roundPixel(L * g + c) + }, true); + F.applyTransformations(); + n = Math.max(n, F.getBBox().width + G); + if (n <= o.thickness) { + C = Ext.draw.Matrix.fly(F.attr.matrix.elements.slice(0)); + p = C.prepend.apply(C, l).transformBBox(F.getBBox(true)); + if (h && !f(p, h, A)) { + return + } + E.renderSprite(F); + h = p; + w += p.height; + b++ + } + }) + } else { + if (u === "top" || u === "bottom") { + o.iterate(I, function(L, N, M) { + if (N === undefined) { + return + } + if (B) { + v = Ext.callback(B, null, [t, N, D, r], 0, t) + } else { + v = m.renderer(N, D, r) + } + r = N; + F.setAttributes({ + text: String(v), + translationX: E.roundPixel(L * x + d) + }, true); + F.applyTransformations(); + n = Math.max(n, F.getBBox().height + G); + if (n <= o.thickness) { + C = Ext.draw.Matrix.fly(F.attr.matrix.elements.slice(0)); + p = C.prepend.apply(C, l).transformBBox(F.getBBox(true)); + if (h && !f(p, h, A)) { + return + } + E.renderSprite(F); + h = p; + w += p.width; + b++ + } + }) + } else { + if (u === "radial") { + o.iterate(I, function(L, N, M) { + if (N === undefined) { + return + } + if (B) { + v = Ext.callback(B, null, [t, N, D, r], 0, t) + } else { + v = m.renderer(N, D, r) + } + r = N; + if (typeof v !== "undefined") { + F.setAttributes({ + text: String(v), + translationX: k.centerX - E.roundPixel(L) / k.max * k.length * Math.cos(k.baseRotation + Math.PI / 2), + translationY: k.centerY - E.roundPixel(L) / k.max * k.length * Math.sin(k.baseRotation + Math.PI / 2) + }, true); + F.applyTransformations(); + p = F.attr.matrix.transformBBox(F.getBBox(true)); + if (h && !f(p, h)) { + return + } + E.renderSprite(F); + h = p; + w += p.width; + b++ + } + }) + } else { + if (u === "angular") { + s = k.majorTickSize + k.lineWidth * 0.5 + (parseInt(F.attr.fontSize, 10) || 10) / 2; + o.iterate(I, function(L, N, M) { + if (N === undefined) { + return + } + if (B) { + v = Ext.callback(B, null, [t, N, D, r], 0, t) + } else { + v = m.renderer(N, D, r) + } + r = N; + n = Math.max(n, Math.max(k.majorTickSize, k.minorTickSize) + (k.lineCap !== "butt" ? k.lineWidth * 0.5 : 0)); + if (typeof v !== "undefined") { + var O = L / (k.max + 1) * Math.PI * 2 + k.baseRotation; + F.setAttributes({ + text: String(v), + translationX: k.centerX + (k.length + s) * Math.cos(O), + translationY: k.centerY + (k.length + s) * Math.sin(O) + }, true); + F.applyTransformations(); + p = F.attr.matrix.transformBBox(F.getBBox(true)); + if (h && !f(p, h)) { + return + } + E.renderSprite(F); + h = p; + w += p.width; + b++ + } + }) + } else { + if (u === "gauge") { + var j = o.getGaugeAngles(); + o.iterate(I, function(L, N, M) { + if (N === undefined) { + return + } + if (B) { + v = Ext.callback(B, null, [t, N, D, r], 0, t) + } else { + v = m.renderer(N, D, r) + } + r = N; + if (typeof v !== "undefined") { + var O = (L - k.min) / (k.max - k.min + 1) * k.totalAngle - k.totalAngle + j.start; + F.setAttributes({ + text: String(v), + translationX: k.centerX + (k.length + 10) * Math.cos(O), + translationY: k.centerY + (k.length + 10) * Math.sin(O) + }, true); + F.applyTransformations(); + p = F.attr.matrix.transformBBox(F.getBBox(true)); + if (h && !f(p, h)) { + return + } + E.renderSprite(F); + h = p; + w += p.width; + b++ + } + }) + } + } + } + } + } + if (k.enlargeEstStepSizeByText && b) { + w /= b; + w += G; + w *= 2; + if (k.estStepSize < w) { + k.estStepSize = w + } + } + if (Math.abs(o.thickness - (n)) > 1) { + o.thickness = n; + k.bbox.plain.dirty = true; + k.bbox.transform.dirty = true; + o.doThicknessChanged(); + return false + } + } + }, + renderAxisLine: function(a, i, e, c) { + var h = this, + g = h.attr, + b = g.lineWidth * 0.5, + j = g.position, + d, f; + if (g.axisLine && g.length) { + switch (j) { + case "left": + d = a.roundPixel(c[2]) - b; + i.moveTo(d, -g.endGap); + i.lineTo(d, g.length + g.startGap + 1); + break; + case "right": + i.moveTo(b, -g.endGap); + i.lineTo(b, g.length + g.startGap + 1); + break; + case "bottom": + i.moveTo(-g.startGap, b); + i.lineTo(g.length + g.endGap, b); + break; + case "top": + d = a.roundPixel(c[3]) - b; + i.moveTo(-g.startGap, d); + i.lineTo(g.length + g.endGap, d); + break; + case "angular": + i.moveTo(g.centerX + g.length, g.centerY); + i.arc(g.centerX, g.centerY, g.length, 0, Math.PI * 2, true); + break; + case "gauge": + f = h.getGaugeAngles(); + i.moveTo(g.centerX + Math.cos(f.start) * g.length, g.centerY + Math.sin(f.start) * g.length); + i.arc(g.centerX, g.centerY, g.length, f.start, f.end, true); + break + } + } + }, + getGaugeAngles: function() { + var a = this, + c = a.attr.totalAngle, + b; + if (c <= Math.PI) { + b = (Math.PI - c) * 0.5 + } else { + b = -(Math.PI * 2 - c) * 0.5 + } + b = Math.PI * 2 - b; + return { + start: b, + end: b - c + } + }, + renderGridLines: function(m, n, s, r) { + var t = this, + b = t.getAxis(), + l = t.attr, + p = l.matrix, + d = l.startGap, + a = l.endGap, + c = p.getXX(), + k = p.getYY(), + h = p.getDX(), + g = p.getDY(), + u = l.position, + f = b.getGridAlignment(), + q = s.majorTicks, + e, o, i; + if (l.grid) { + if (q) { + if (u === "left" || u === "right") { + i = l.min * k + g + a + d; + t.iterate(q, function(j, w, v) { + e = j * k + g + a; + t.putMarker(f + "-" + (v % 2 ? "odd" : "even"), { + y: e, + height: i - e + }, o = v, true); + i = e + }); + o++; + e = 0; + t.putMarker(f + "-" + (o % 2 ? "odd" : "even"), { + y: e, + height: i - e + }, o, true) + } else { + if (u === "top" || u === "bottom") { + i = l.min * c + h + d; + if (d) { + t.putMarker(f + "-even", { + x: 0, + width: i + }, -1, true) + } + t.iterate(q, function(j, w, v) { + e = j * c + h + d; + t.putMarker(f + "-" + (v % 2 ? "odd" : "even"), { + x: e, + width: i - e + }, o = v, true); + i = e + }); + o++; + e = l.length + l.startGap + l.endGap; + t.putMarker(f + "-" + (o % 2 ? "odd" : "even"), { + x: e, + width: i - e + }, o, true) + } else { + if (u === "radial") { + t.iterate(q, function(j, w, v) { + if (!j) { + return + } + e = j / l.max * l.length; + t.putMarker(f + "-" + (v % 2 ? "odd" : "even"), { + scalingX: e, + scalingY: e + }, v, true); + i = e + }) + } else { + if (u === "angular") { + t.iterate(q, function(j, w, v) { + if (!l.length) { + return + } + e = j / (l.max + 1) * Math.PI * 2 + l.baseRotation; + t.putMarker(f + "-" + (v % 2 ? "odd" : "even"), { + rotationRads: e, + rotationCenterX: 0, + rotationCenterY: 0, + scalingX: l.length, + scalingY: l.length + }, v, true); + i = e + }) + } + } + } + } + } + } + }, + renderLimits: function(o) { + var t = this, + a = t.getAxis(), + h = a.getChart(), + p = h.getInnerPadding(), + d = Ext.Array.from(a.getLimits()); + if (!d.length) { + return + } + var r = a.limits.surface.getRect(), + m = t.attr, + n = m.matrix, + u = m.position, + k = Ext.Object.chain, + v = a.limits.titles, + c, j, b, s, l, q, f, g, e; + v.instances = []; + v.position = 0; + if (u === "left" || u === "right") { + for (q = 0, f = d.length; q < f; q++) { + s = k(d[q]); + !s.line && (s.line = {}); + l = Ext.isString(s.value) ? a.getCoordFor(s.value) : s.value; + l = l * n.getYY() + n.getDY(); + s.line.y = l + p.top; + s.line.strokeStyle = s.line.strokeStyle || m.strokeStyle; + t.putMarker("horizontal-limit-lines", s.line, q, true); + if (s.line.title) { + v.createInstance(s.line.title); + c = v.getBBoxFor(v.position - 1); + j = s.line.title.position || (u === "left" ? "start" : "end"); + switch (j) { + case "start": + g = 10; + break; + case "end": + g = r[2] - 10; + break; + case "middle": + g = r[2] / 2; + break + } + v.setAttributesFor(v.position - 1, { + x: g, + y: s.line.y - c.height / 2, + textAlign: j, + fillStyle: s.line.title.fillStyle || s.line.strokeStyle + }) + } + } + } else { + if (u === "top" || u === "bottom") { + for (q = 0, f = d.length; q < f; q++) { + s = k(d[q]); + !s.line && (s.line = {}); + l = Ext.isString(s.value) ? a.getCoordFor(s.value) : s.value; + l = l * n.getXX() + n.getDX(); + s.line.x = l + p.left; + s.line.strokeStyle = s.line.strokeStyle || m.strokeStyle; + t.putMarker("vertical-limit-lines", s.line, q, true); + if (s.line.title) { + v.createInstance(s.line.title); + c = v.getBBoxFor(v.position - 1); + j = s.line.title.position || (u === "top" ? "end" : "start"); + switch (j) { + case "start": + e = r[3] - c.width / 2 - 10; + break; + case "end": + e = c.width / 2 + 10; + break; + case "middle": + e = r[3] / 2; + break + } + v.setAttributesFor(v.position - 1, { + x: s.line.x + c.height / 2, + y: e, + fillStyle: s.line.title.fillStyle || s.line.strokeStyle, + rotationRads: Math.PI / 2 + }) + } + } + } else { + if (u === "radial") { + for (q = 0, f = d.length; q < f; q++) { + s = k(d[q]); + !s.line && (s.line = {}); + l = Ext.isString(s.value) ? a.getCoordFor(s.value) : s.value; + if (l > m.max) { + continue + } + l = l / m.max * m.length; + s.line.cx = m.centerX; + s.line.cy = m.centerY; + s.line.scalingX = l; + s.line.scalingY = l; + s.line.strokeStyle = s.line.strokeStyle || m.strokeStyle; + t.putMarker("circular-limit-lines", s.line, q, true); + if (s.line.title) { + v.createInstance(s.line.title); + c = v.getBBoxFor(v.position - 1); + v.setAttributesFor(v.position - 1, { + x: m.centerX, + y: m.centerY - l - c.height / 2, + fillStyle: s.line.title.fillStyle || s.line.strokeStyle + }) + } + } + } else { + if (u === "angular") { + for (q = 0, f = d.length; q < f; q++) { + s = k(d[q]); + !s.line && (s.line = {}); + l = Ext.isString(s.value) ? a.getCoordFor(s.value) : s.value; + l = l / (m.max + 1) * Math.PI * 2 + m.baseRotation; + s.line.translationX = m.centerX; + s.line.translationY = m.centerY; + s.line.rotationRads = l; + s.line.rotationCenterX = 0; + s.line.rotationCenterY = 0; + s.line.scalingX = m.length; + s.line.scalingY = m.length; + s.line.strokeStyle = s.line.strokeStyle || m.strokeStyle; + t.putMarker("radial-limit-lines", s.line, q, true); + if (s.line.title) { + v.createInstance(s.line.title); + c = v.getBBoxFor(v.position - 1); + b = ((l > -0.5 * Math.PI && l < 0.5 * Math.PI) || (l > 1.5 * Math.PI && l < 2 * Math.PI)) ? 1 : -1; + v.setAttributesFor(v.position - 1, { + x: m.centerX + 0.5 * m.length * Math.cos(l) + b * c.height / 2 * Math.sin(l), + y: m.centerY + 0.5 * m.length * Math.sin(l) - b * c.height / 2 * Math.cos(l), + rotationRads: b === 1 ? l : l - Math.PI, + fillStyle: s.line.title.fillStyle || s.line.strokeStyle + }) + } + } + } else { + if (u === "gauge") {} + } + } + } + } + }, + doThicknessChanged: function() { + var a = this.getAxis(); + if (a) { + a.onThicknessChanged() + } + }, + render: function(a, c, d) { + var e = this, + b = e.getLayoutContext(); + if (b) { + if (false === e.renderLabels(a, c, b, d)) { + return false + } + c.beginPath(); + e.renderTicks(a, c, b, d); + e.renderAxisLine(a, c, b, d); + e.renderGridLines(a, c, b, d); + e.renderLimits(d); + c.stroke() + } + } +}); +Ext.define("Ext.chart.axis.segmenter.Segmenter", { + config: { + axis: null + }, + constructor: function(a) { + this.initConfig(a) + }, + renderer: function(b, a) { + return String(b) + }, + from: function(a) { + return a + }, + diff: Ext.emptyFn, + align: Ext.emptyFn, + add: Ext.emptyFn, + preferredStep: Ext.emptyFn +}); +Ext.define("Ext.chart.axis.segmenter.Names", { + extend: "Ext.chart.axis.segmenter.Segmenter", + alias: "segmenter.names", + renderer: function(b, a) { + return b + }, + diff: function(b, a, c) { + return Math.floor(a - b) + }, + align: function(c, b, a) { + return Math.floor(c) + }, + add: function(c, b, a) { + return c + b + }, + preferredStep: function(c, a, b, d) { + return { + unit: 1, + step: 1 + } + } +}); +Ext.define("Ext.chart.axis.segmenter.Numeric", { + extend: "Ext.chart.axis.segmenter.Segmenter", + alias: "segmenter.numeric", + isNumeric: true, + renderer: function(b, a) { + return b.toFixed(Math.max(0, a.majorTicks.unit.fixes)) + }, + diff: function(b, a, c) { + return Math.floor((a - b) / c.scale) + }, + align: function(c, b, a) { + return Math.floor(c / (a.scale * b)) * a.scale * b + }, + add: function(c, b, a) { + return c + b * a.scale + }, + preferredStep: function(c, b) { + var a = Math.floor(Math.log(b) * Math.LOG10E), + d = Math.pow(10, a); + b /= d; + if (b < 2) { + b = 2 + } else { + if (b < 5) { + b = 5 + } else { + if (b < 10) { + b = 10; + a++ + } + } + } + return { + unit: { + fixes: -a, + scale: d + }, + step: b + } + }, + exactStep: function(c, b) { + var a = Math.floor(Math.log(b) * Math.LOG10E), + d = Math.pow(10, a); + return { + unit: { + fixes: -a + (b % d === 0 ? 0 : 1), + scale: 1 + }, + step: b + } + }, + adjustByMajorUnit: function(e, g, c) { + var d = c[0], + b = c[1], + a = e * g, + f = d % a; + if (f !== 0) { + c[0] = d - f + (d < 0 ? -a : 0) + } + f = b % a; + if (f !== 0) { + c[1] = b - f + (b > 0 ? a : 0) + } + } +}); +Ext.define("Ext.chart.axis.segmenter.Time", { + extend: "Ext.chart.axis.segmenter.Segmenter", + alias: "segmenter.time", + config: { + step: null + }, + renderer: function(c, b) { + var a = Ext.Date; + switch (b.majorTicks.unit) { + case "y": + return a.format(c, "Y"); + case "mo": + return a.format(c, "Y-m"); + case "d": + return a.format(c, "Y-m-d") + } + return a.format(c, "Y-m-d\nH:i:s") + }, + from: function(a) { + return new Date(a) + }, + diff: function(b, a, c) { + if (isFinite(b)) { + b = new Date(b) + } + if (isFinite(a)) { + a = new Date(a) + } + return Ext.Date.diff(b, a, c) + }, + align: function(a, c, b) { + if (b === "d" && c >= 7) { + a = Ext.Date.align(a, "d", c); + a.setDate(a.getDate() - a.getDay() + 1); + return a + } else { + return Ext.Date.align(a, b, c) + } + }, + add: function(c, b, a) { + return Ext.Date.add(new Date(c), a, b) + }, + stepUnits: [ + [Ext.Date.YEAR, 1, 2, 5, 10, 20, 50, 100, 200, 500], + [Ext.Date.MONTH, 1, 3, 6], + [Ext.Date.DAY, 1, 7, 14], + [Ext.Date.HOUR, 1, 6, 12], + [Ext.Date.MINUTE, 1, 5, 15, 30], + [Ext.Date.SECOND, 1, 5, 15, 30], + [Ext.Date.MILLI, 1, 2, 5, 10, 20, 50, 100, 200, 500] + ], + preferredStep: function(b, e) { + if (this.getStep()) { + return this.getStep() + } + var f = new Date(+b), + g = new Date(+b + Math.ceil(e)), + d = this.stepUnits, + l, k, h, c, a; + for (c = 0; c < d.length; c++) { + k = d[c][0]; + h = this.diff(f, g, k); + if (h > 0) { + for (a = 1; a < d[c].length; a++) { + if (h <= d[c][a]) { + l = { + unit: k, + step: d[c][a] + }; + break + } + } + if (!l) { + c--; + l = { + unit: d[c][0], + step: 1 + } + } + break + } + } + if (!l) { + l = { + unit: Ext.Date.DAY, + step: 1 + } + } + return l + } +}); +Ext.define("Ext.chart.axis.layout.Layout", { + mixins: { + observable: "Ext.mixin.Observable" + }, + config: { + axis: null + }, + constructor: function(a) { + this.mixins.observable.constructor.call(this, a) + }, + processData: function(b) { + var e = this, + c = e.getAxis(), + f = c.getDirection(), + g = c.boundSeries, + a, d; + if (b) { + b["coordinate" + f]() + } else { + for (a = 0, d = g.length; a < d; a++) { + g[a]["coordinate" + f]() + } + } + }, + calculateMajorTicks: function(a) { + var f = this, + e = a.attr, + d = e.max - e.min, + i = d / Math.max(1, e.length) * (e.visibleMax - e.visibleMin), + h = e.min + d * e.visibleMin, + b = e.min + d * e.visibleMax, + g = e.estStepSize * i, + c = f.snapEnds(a, e.min, e.max, g); + if (c) { + f.trimByRange(a, c, h, b); + a.majorTicks = c + } + }, + calculateMinorTicks: function(a) { + if (this.snapMinorEnds) { + a.minorTicks = this.snapMinorEnds(a) + } + }, + calculateLayout: function(b) { + var c = this, + a = b.attr; + if (a.length === 0) { + return null + } + if (a.majorTicks) { + c.calculateMajorTicks(b); + if (a.minorTicks) { + c.calculateMinorTicks(b) + } + } + }, + snapEnds: Ext.emptyFn, + trimByRange: function(b, f, i, a) { + var g = b.segmenter, + j = f.unit, + h = g.diff(f.from, i, j), + d = g.diff(f.from, a, j), + c = Math.max(0, Math.ceil(h / f.step)), + e = Math.min(f.steps, Math.floor(d / f.step)); + if (e < f.steps) { + f.to = g.add(f.from, e * f.step, j) + } + if (f.max > a) { + f.max = f.to + } + if (f.from < i) { + f.from = g.add(f.from, c * f.step, j); + while (f.from < i) { + c++; + f.from = g.add(f.from, f.step, j) + } + } + if (f.min < i) { + f.min = f.from + } + f.steps = e - c + } +}); +Ext.define("Ext.chart.axis.layout.Discrete", { + extend: "Ext.chart.axis.layout.Layout", + alias: "axisLayout.discrete", + isDiscrete: true, + processData: function() { + var f = this, + d = f.getAxis(), + c = d.boundSeries, + g = d.getDirection(), + b, e, a; + f.labels = []; + f.labelMap = {}; + for (b = 0, e = c.length; b < e; b++) { + a = c[b]; + if (a["get" + g + "Axis"]() === d) { + a["coordinate" + g]() + } + } + d.getSprites()[0].setAttributes({ + data: f.labels + }); + f.fireEvent("datachange", f.labels) + }, + calculateLayout: function(a) { + a.data = this.labels; + this.callParent([a]) + }, + calculateMajorTicks: function(a) { + var g = this, + f = a.attr, + d = a.data, + e = f.max - f.min, + j = e / Math.max(1, f.length) * (f.visibleMax - f.visibleMin), + i = f.min + e * f.visibleMin, + b = f.min + e * f.visibleMax, + h = f.estStepSize * j; + var c = g.snapEnds(a, Math.max(0, f.min), Math.min(f.max, d.length - 1), h); + if (c) { + g.trimByRange(a, c, i, b); + a.majorTicks = c + } + }, + snapEnds: function(e, d, a, b) { + b = Math.ceil(b); + var c = Math.floor((a - d) / b), + f = e.data; + return { + min: d, + max: a, + from: d, + to: c * b + d, + step: b, + steps: c, + unit: 1, + getLabel: function(g) { + return f[this.from + this.step * g] + }, + get: function(g) { + return this.from + this.step * g + } + } + }, + trimByRange: function(b, f, h, a) { + var i = f.unit, + g = Math.ceil((h - f.from) / i) * i, + d = Math.floor((a - f.from) / i) * i, + c = Math.max(0, Math.ceil(g / f.step)), + e = Math.min(f.steps, Math.floor(d / f.step)); + if (e < f.steps) { + f.to = e + } + if (f.max > a) { + f.max = f.to + } + if (f.from < h && f.step > 0) { + f.from = f.from + c * f.step * i; + while (f.from < h) { + c++; + f.from += f.step * i + } + } + if (f.min < h) { + f.min = f.from + } + f.steps = e - c + }, + getCoordFor: function(c, d, a, b) { + this.labels.push(c); + return this.labels.length - 1 + } +}); +Ext.define("Ext.chart.axis.layout.CombineDuplicate", { + extend: "Ext.chart.axis.layout.Discrete", + alias: "axisLayout.combineDuplicate", + getCoordFor: function(d, e, b, c) { + if (!(d in this.labelMap)) { + var a = this.labelMap[d] = this.labels.length; + this.labels.push(d); + return a + } + return this.labelMap[d] + } +}); +Ext.define("Ext.chart.axis.layout.Continuous", { + extend: "Ext.chart.axis.layout.Layout", + alias: "axisLayout.continuous", + isContinuous: true, + config: { + adjustMinimumByMajorUnit: false, + adjustMaximumByMajorUnit: false + }, + getCoordFor: function(c, d, a, b) { + return +c + }, + snapEnds: function(a, d, i, h) { + var f = a.segmenter, + c = this.getAxis(), + l = c.getMajorTickSteps(), + e = l && f.exactStep ? f.exactStep(d, (i - d) / l) : f.preferredStep(d, h), + k = e.unit, + b = e.step, + j = f.align(d, b, k), + g = (l || f.diff(d, i, k)) + 1; + return { + min: f.from(d), + max: f.from(i), + from: j, + to: f.add(j, g * b, k), + step: b, + steps: g, + unit: k, + get: function(m) { + return f.add(this.from, this.step * m, k) + } + } + }, + snapMinorEnds: function(a) { + var e = a.majorTicks, + m = this.getAxis().getMinorTickSteps(), + f = a.segmenter, + d = e.min, + i = e.max, + k = e.from, + l = e.unit, + b = e.step / m, + n = b * l.scale, + j = k - d, + c = Math.floor(j / n), + h = c + Math.floor((i - e.to) / n) + 1, + g = e.steps * m + h; + return { + min: d, + max: i, + from: d + j % n, + to: f.add(k, g * b, l), + step: b, + steps: g, + unit: l, + get: function(o) { + return (o % m + c + 1 !== 0) ? f.add(this.from, this.step * o, l) : null + } + } + } +}); +Ext.define("Ext.chart.axis.Axis", { + xtype: "axis", + mixins: { + observable: "Ext.mixin.Observable" + }, + requires: ["Ext.chart.axis.sprite.Axis", "Ext.chart.axis.segmenter.*", "Ext.chart.axis.layout.*"], + isAxis: true, + config: { + position: "bottom", + fields: [], + label: undefined, + grid: false, + limits: null, + renderer: null, + chart: null, + style: null, + margin: 0, + titleMargin: 4, + background: null, + minimum: NaN, + maximum: NaN, + reconcileRange: false, + minZoom: 1, + maxZoom: 10000, + layout: "continuous", + segmenter: "numeric", + hidden: false, + majorTickSteps: 0, + minorTickSteps: 0, + adjustByMajorUnit: true, + title: null, + increment: 0.5, + length: 0, + center: null, + radius: null, + totalAngle: Math.PI, + rotation: null, + labelInSpan: null, + visibleRange: [0, 1], + needHighPrecision: false, + linkedTo: null, + floating: null + }, + titleOffset: 0, + spriteAnimationCount: 0, + prevMin: 0, + prevMax: 1, + boundSeries: [], + sprites: null, + surface: null, + range: null, + xValues: [], + yValues: [], + masterAxis: null, + applyRotation: function(b) { + var a = Math.PI * 2; + return (b % a + Math.PI) % a - Math.PI + }, + updateRotation: function(b) { + var c = this.getSprites(), + a = this.getPosition(); + if (!this.getHidden() && a === "angular" && c[0]) { + c[0].setAttributes({ + baseRotation: b + }) + } + }, + applyTitle: function(c, b) { + var a; + if (Ext.isString(c)) { + c = { + text: c + } + } + if (!b) { + b = Ext.create("sprite.text", c); + if ((a = this.getSurface())) { + a.add(b) + } + } else { + b.setAttributes(c) + } + return b + }, + applyFloating: function(b, a) { + if (b === null) { + b = { + value: null, + alongAxis: null + } + } else { + if (Ext.isNumber(b)) { + b = { + value: b, + alongAxis: null + } + } + } + if (Ext.isObject(b)) { + if (a && a.alongAxis) { + delete this.getChart().getAxis(a.alongAxis).floatingAxes[this.getId()] + } + return b + } + return a + }, + constructor: function(a) { + var b = this, + c; + b.sprites = []; + b.labels = []; + b.floatingAxes = {}; + a = a || {}; + if (a.position === "angular") { + a.style = a.style || {}; + a.style.estStepSize = 1 + } + if ("id" in a) { + c = a.id + } else { + if ("id" in b.config) { + c = b.config.id + } else { + c = b.getId() + } + } + b.setId(c); + b.mixins.observable.constructor.apply(b, arguments) + }, + getAlignment: function() { + switch (this.getPosition()) { + case "left": + case "right": + return "vertical"; + case "top": + case "bottom": + return "horizontal"; + case "radial": + return "radial"; + case "angular": + return "angular" + } + }, + getGridAlignment: function() { + switch (this.getPosition()) { + case "left": + case "right": + return "horizontal"; + case "top": + case "bottom": + return "vertical"; + case "radial": + return "circular"; + case "angular": + return "radial" + } + }, + getSurface: function() { + var e = this, + d = e.getChart(); + if (d && !e.surface) { + var b = e.surface = d.getSurface(e.getId(), "axis"), + c = e.gridSurface = d.getSurface("main"), + a = e.getSprites()[0], + f = e.getGridAlignment(); + c.waitFor(b); + e.getGrid(); + if (e.getLimits() && f) { + f = f.replace("3d", ""); + e.limits = { + surface: d.getSurface("overlay"), + lines: new Ext.chart.Markers(), + titles: new Ext.draw.sprite.Instancing() + }; + e.limits.lines.setTemplate({ + xclass: "grid." + f + }); + e.limits.lines.getTemplate().setAttributes({ + strokeStyle: "black" + }, true); + e.limits.surface.add(e.limits.lines); + a.bindMarker(f + "-limit-lines", e.limits.lines); + e.limitTitleTpl = new Ext.draw.sprite.Text(); + e.limits.titles.setTemplate(e.limitTitleTpl); + e.limits.surface.add(e.limits.titles); + d.on("redraw", e.renderLimits, e) + } + } + return e.surface + }, + applyGrid: function(a) { + if (a === true) { + return {} + } + return a + }, + updateGrid: function(b) { + var e = this, + d = e.getChart(); + if (!d) { + e.on({ + chartattached: Ext.bind(e.updateGrid, e, [b]), + single: true + }); + return + } + var c = e.gridSurface, + a = e.getSprites()[0], + f = e.getGridAlignment(), + g; + if (b) { + g = e.gridSpriteEven; + if (!g) { + g = e.gridSpriteEven = new Ext.chart.Markers(); + g.setTemplate({ + xclass: "grid." + f + }); + c.add(g); + a.bindMarker(f + "-even", g) + } + if (Ext.isObject(b)) { + g.getTemplate().setAttributes(b); + if (Ext.isObject(b.even)) { + g.getTemplate().setAttributes(b.even) + } + } + g = e.gridSpriteOdd; + if (!g) { + g = e.gridSpriteOdd = new Ext.chart.Markers(); + g.setTemplate({ + xclass: "grid." + f + }); + c.add(g); + a.bindMarker(f + "-odd", g) + } + if (Ext.isObject(b)) { + g.getTemplate().setAttributes(b); + if (Ext.isObject(b.odd)) { + g.getTemplate().setAttributes(b.odd) + } + } + } + }, + renderLimits: function() { + this.getSprites()[0].renderLimits() + }, + getCoordFor: function(c, d, a, b) { + return this.getLayout().getCoordFor(c, d, a, b) + }, + applyPosition: function(a) { + return a.toLowerCase() + }, + applyLength: function(b, a) { + return b > 0 ? b : a + }, + applyLabel: function(b, a) { + if (!a) { + a = new Ext.draw.sprite.Text({}) + } + if (this.limitTitleTpl) { + this.limitTitleTpl.setAttributes(b) + } + a.setAttributes(b); + return a + }, + applyLayout: function(b, a) { + b = Ext.factory(b, null, a, "axisLayout"); + b.setAxis(this); + return b + }, + applySegmenter: function(a, b) { + a = Ext.factory(a, null, b, "segmenter"); + a.setAxis(this); + return a + }, + updateMinimum: function() { + this.range = null + }, + updateMaximum: function() { + this.range = null + }, + hideLabels: function() { + this.getSprites()[0].setDirty(true); + this.setLabel({ + hidden: true + }) + }, + showLabels: function() { + this.getSprites()[0].setDirty(true); + this.setLabel({ + hidden: false + }) + }, + renderFrame: function() { + this.getSurface().renderFrame() + }, + updateChart: function(d, b) { + var c = this, + a; + if (b) { + b.unregister(c); + b.un("serieschange", c.onSeriesChange, c); + b.un("redraw", c.renderLimits, c); + c.linkAxis(); + c.fireEvent("chartdetached", b, c) + } + if (d) { + d.on("serieschange", c.onSeriesChange, c); + c.surface = null; + a = c.getSurface(); + c.getLabel().setSurface(a); + a.add(c.getSprites()); + a.add(c.getTitle()); + d.register(c); + c.fireEvent("chartattached", d, c) + } + }, + applyBackground: function(a) { + var b = Ext.ClassManager.getByAlias("sprite.rect"); + return b.def.normalize(a) + }, + processData: function() { + this.getLayout().processData(); + this.range = null + }, + getDirection: function() { + return this.getChart().getDirectionForAxis(this.getPosition()) + }, + isSide: function() { + var a = this.getPosition(); + return a === "left" || a === "right" + }, + applyFields: function(a) { + return Ext.Array.from(a) + }, + applyVisibleRange: function(a, c) { + this.getChart(); + if (a[0] > a[1]) { + var b = a[0]; + a[0] = a[1]; + a[0] = b + } + if (a[1] === a[0]) { + a[1] += 1 / this.getMaxZoom() + } + if (a[1] > a[0] + 1) { + a[0] = 0; + a[1] = 1 + } else { + if (a[0] < 0) { + a[1] -= a[0]; + a[0] = 0 + } else { + if (a[1] > 1) { + a[0] -= a[1] - 1; + a[1] = 1 + } + } + } + if (c && a[0] === c[0] && a[1] === c[1]) { + return undefined + } + return a + }, + updateVisibleRange: function(a) { + this.fireEvent("visiblerangechange", this, a) + }, + onSeriesChange: function(e) { + var f = this, + b = e.getSeries(), + j = "get" + f.getDirection() + "Axis", + g = [], + c, d = b.length, + a, h; + for (c = 0; c < d; c++) { + if (this === b[c][j]()) { + g.push(b[c]) + } + } + f.boundSeries = g; + a = f.getLinkedTo(); + h = !Ext.isEmpty(a) && e.getAxis(a); + if (h) { + f.linkAxis(h) + } else { + f.getLayout().processData() + } + }, + linkAxis: function(a) { + var c = this; + + function b(f, d, e) { + e.getLayout()[f]("datachange", "onDataChange", d); + e[f]("rangechange", "onMasterAxisRangeChange", d) + } + if (c.masterAxis) { + b("un", c, c.masterAxis); + c.masterAxis = null + } + if (a) { + if (a.type !== this.type) { + Ext.Error.raise("Linked axes must be of the same type.") + } + b("on", c, a); + c.onDataChange(a.getLayout().labels); + c.onMasterAxisRangeChange(a, a.range); + c.setStyle(Ext.apply({}, c.config.style, a.config.style)); + c.setTitle(Ext.apply({}, c.config.title, a.config.title)); + c.setLabel(Ext.apply({}, c.config.label, a.config.label)); + c.masterAxis = a + } + }, + onDataChange: function(a) { + this.getLayout().labels = a + }, + onMasterAxisRangeChange: function(b, a) { + this.range = a + }, + applyRange: function(a) { + if (!a) { + return this.dataRange.slice(0) + } else { + return [a[0] === null ? this.dataRange[0] : a[0], a[1] === null ? this.dataRange[1] : a[1]] + } + }, + getRange: function() { + var m = this; + if (m.range) { + return m.range + } else { + if (m.masterAxis) { + return m.masterAxis.range + } + } + if (Ext.isNumber(m.getMinimum() + m.getMaximum())) { + return m.range = [m.getMinimum(), m.getMaximum()] + } + var d = Infinity, + n = -Infinity, + o = m.boundSeries, + h = m.getLayout(), + l = m.getSegmenter(), + p = m.getVisibleRange(), + b = "get" + m.getDirection() + "Range", + a, j, g, f, e, k; + for (e = 0, k = o.length; e < k; e++) { + f = o[e]; + var c = f[b](); + if (c) { + if (c[0] < d) { + d = c[0] + } + if (c[1] > n) { + n = c[1] + } + } + } + if (!isFinite(n)) { + n = m.prevMax + } + if (!isFinite(d)) { + d = m.prevMin + } + if (m.getLabelInSpan() || d === n) { + n += m.getIncrement(); + d -= m.getIncrement() + } + if (Ext.isNumber(m.getMinimum())) { + d = m.getMinimum() + } else { + m.prevMin = d + } + if (Ext.isNumber(m.getMaximum())) { + n = m.getMaximum() + } else { + m.prevMax = n + } + m.range = [Ext.Number.correctFloat(d), Ext.Number.correctFloat(n)]; + if (m.getReconcileRange()) { + m.reconcileRange() + } + if (m.getAdjustByMajorUnit() && l.adjustByMajorUnit && !m.getMajorTickSteps()) { + j = Ext.Object.chain(m.getSprites()[0].attr); + j.min = m.range[0]; + j.max = m.range[1]; + j.visibleMin = p[0]; + j.visibleMax = p[1]; + a = { + attr: j, + segmenter: l + }; + h.calculateLayout(a); + g = a.majorTicks; + if (g) { + l.adjustByMajorUnit(g.step, g.unit.scale, m.range); + j.min = m.range[0]; + j.max = m.range[1]; + delete a.majorTicks; + h.calculateLayout(a); + g = a.majorTicks; + l.adjustByMajorUnit(g.step, g.unit.scale, m.range) + } else { + if (!m.hasClearRangePending) { + m.hasClearRangePending = true; + m.getChart().on("layout", "clearRange", m) + } + } + } + if (!Ext.Array.equals(m.range, m.oldRange || [])) { + m.fireEvent("rangechange", m, m.range); + m.oldRange = m.range + } + return m.range + }, + clearRange: function() { + delete this.hasClearRangePending; + this.range = null + }, + reconcileRange: function() { + var e = this, + g = e.getChart().getAxes(), + f = e.getDirection(), + b, d, c, a; + if (!g) { + return + } + for (b = 0, d = g.length; b < d; b++) { + c = g[b]; + a = c.getRange(); + if (c === e || c.getDirection() !== f || !a || !c.getReconcileRange()) { + continue + } + if (a[0] < e.range[0]) { + e.range[0] = a[0] + } + if (a[1] > e.range[1]) { + e.range[1] = a[1] + } + } + }, + applyStyle: function(c, b) { + var a = Ext.ClassManager.getByAlias("sprite." + this.seriesType); + if (a && a.def) { + c = a.def.normalize(c) + } + b = Ext.apply(b || {}, c); + return b + }, + themeOnlyIfConfigured: { + grid: true + }, + updateTheme: function(d) { + var i = this, + k = d.getAxis(), + e = i.getPosition(), + o = i.getInitialConfig(), + c = i.defaultConfig, + g = i.getConfigurator().configs, + a = k.defaults, + n = k[e], + h = i.themeOnlyIfConfigured, + l, j, p, b, m, f; + k = Ext.merge({}, a, n); + for (l in k) { + j = k[l]; + f = g[l]; + if (j !== null && j !== undefined && f) { + m = o[l]; + p = Ext.isObject(j); + b = m === c[l]; + if (p) { + if (b && h[l]) { + continue + } + j = Ext.merge({}, j, m) + } + if (b || p) { + i[f.names.set](j) + } + } + } + }, + updateCenter: function(b) { + var e = this.getSprites(), + a = e[0], + d = b[0], + c = b[1]; + if (a) { + a.setAttributes({ + centerX: d, + centerY: c + }) + } + if (this.gridSpriteEven) { + this.gridSpriteEven.getTemplate().setAttributes({ + translationX: d, + translationY: c, + rotationCenterX: d, + rotationCenterY: c + }) + } + if (this.gridSpriteOdd) { + this.gridSpriteOdd.getTemplate().setAttributes({ + translationX: d, + translationY: c, + rotationCenterX: d, + rotationCenterY: c + }) + } + }, + getSprites: function() { + if (!this.getChart()) { + return + } + var i = this, + e = i.getRange(), + f = i.getPosition(), + g = i.getChart(), + c = g.getAnimation(), + d, a, b = i.getLength(), + h = i.superclass; + if (c === false) { + c = { + duration: 0 + } + } + if (e) { + a = Ext.applyIf({ + position: f, + axis: i, + min: e[0], + max: e[1], + length: b, + grid: i.getGrid(), + hidden: i.getHidden(), + titleOffset: i.titleOffset, + layout: i.getLayout(), + segmenter: i.getSegmenter(), + totalAngle: i.getTotalAngle(), + label: i.getLabel() + }, i.getStyle()); + if (!i.sprites.length) { + while (!h.xtype) { + h = h.superclass + } + d = Ext.create("sprite." + h.xtype, a); + d.fx.setCustomDurations({ + baseRotation: 0 + }); + d.fx.on("animationstart", "onAnimationStart", i); + d.fx.on("animationend", "onAnimationEnd", i); + d.setLayout(i.getLayout()); + d.setSegmenter(i.getSegmenter()); + d.setLabel(i.getLabel()); + i.sprites.push(d); + i.updateTitleSprite() + } else { + d = i.sprites[0]; + d.setAnimation(c); + d.setAttributes(a) + } + if (i.getRenderer()) { + d.setRenderer(i.getRenderer()) + } + } + return i.sprites + }, + updateTitleSprite: function() { + var f = this, + b = f.getLength(); + if (!f.sprites[0] || !Ext.isNumber(b)) { + return + } + var h = this.sprites[0].thickness, + a = f.getSurface(), + g = f.getTitle(), + e = f.getPosition(), + c = f.getMargin(), + i = f.getTitleMargin(), + d = a.roundPixel(b / 2); + if (g) { + switch (e) { + case "top": + g.setAttributes({ + x: d, + y: c + i / 2, + textBaseline: "top", + textAlign: "center" + }, true); + g.applyTransformations(); + f.titleOffset = g.getBBox().height + i; + break; + case "bottom": + g.setAttributes({ + x: d, + y: h + i / 2, + textBaseline: "top", + textAlign: "center" + }, true); + g.applyTransformations(); + f.titleOffset = g.getBBox().height + i; + break; + case "left": + g.setAttributes({ + x: c + i / 2, + y: d, + textBaseline: "top", + textAlign: "center", + rotationCenterX: c + i / 2, + rotationCenterY: d, + rotationRads: -Math.PI / 2 + }, true); + g.applyTransformations(); + f.titleOffset = g.getBBox().width + i; + break; + case "right": + g.setAttributes({ + x: h - c + i / 2, + y: d, + textBaseline: "bottom", + textAlign: "center", + rotationCenterX: h + i / 2, + rotationCenterY: d, + rotationRads: Math.PI / 2 + }, true); + g.applyTransformations(); + f.titleOffset = g.getBBox().width + i; + break + } + } + }, + onThicknessChanged: function() { + this.getChart().onThicknessChanged() + }, + getThickness: function() { + if (this.getHidden()) { + return 0 + } + return (this.sprites[0] && this.sprites[0].thickness || 1) + this.titleOffset + this.getMargin() + }, + onAnimationStart: function() { + this.spriteAnimationCount++; + if (this.spriteAnimationCount === 1) { + this.fireEvent("animationstart", this) + } + }, + onAnimationEnd: function() { + this.spriteAnimationCount--; + if (this.spriteAnimationCount === 0) { + this.fireEvent("animationend", this) + } + }, + getItemId: function() { + return this.getId() + }, + getAncestorIds: function() { + return [this.getChart().getId()] + }, + isXType: function(a) { + return a === "axis" + }, + resolveListenerScope: function(e) { + var d = this, + a = Ext._namedScopes[e], + c = d.getChart(), + b; + if (!a) { + b = c ? c.resolveListenerScope(e, false) : (e || d) + } else { + if (a.isThis) { + b = d + } else { + if (a.isController) { + b = c ? c.resolveListenerScope(e, false) : d + } else { + if (a.isSelf) { + b = c ? c.resolveListenerScope(e, false) : d; + if (b === c && !c.getInheritedConfig("defaultListenerScope")) { + b = d + } + } + } + } + } + return b + }, + destroy: function() { + var a = this; + a.setChart(null); + a.surface.destroy(); + a.surface = null; + a.callParent() + } +}); +Ext.define("Ext.chart.LegendBase", { + extend: "Ext.view.View", + config: { + tpl: ['
', '', '
', "', "{name}", "
", "", "
"], + nodeContainerSelector: "div." + Ext.baseCSSPrefix + "legend-container", + itemSelector: "div." + Ext.baseCSSPrefix + "legend-item", + docked: "bottom" + }, + setDocked: function(d) { + var c = this, + a = c.ownerCt, + b; + c.docked = d; + switch (d) { + case "top": + case "bottom": + c.addCls(Ext.baseCSSPrefix + "horizontal"); + b = "hbox"; + break; + case "left": + case "right": + c.removeCls(Ext.baseCSSPrefix + "horizontal"); + b = "vbox"; + break + } + if (a) { + a.setDocked(d) + } + }, + setStore: function(a) { + this.bindStore(a) + }, + clearViewEl: function() { + this.callParent(arguments); + Ext.removeNode(this.getNodeContainer()) + }, + onItemClick: function(a, c, b, d) { + this.callParent(arguments); + this.toggleItem(b) + } +}); +Ext.define("Ext.chart.Legend", { + xtype: "legend", + extend: "Ext.chart.LegendBase", + config: { + baseCls: Ext.baseCSSPrefix + "legend", + padding: 5, + rect: null, + disableSelection: true, + toggleable: true + }, + toggleItem: function(c) { + if (!this.getToggleable()) { + return + } + var b = this.getStore(), + h = 0, + e, g = true, + d, f, a; + if (b) { + f = b.getCount(); + for (d = 0; d < f; d++) { + a = b.getAt(d); + if (a.get("disabled")) { + h++ + } + } + g = f - h > 1; + a = b.getAt(c); + if (a) { + e = a.get("disabled"); + if (e || g) { + a.set("disabled", !e) + } + } + } + } +}); +Ext.define("Ext.chart.AbstractChart", { + extend: "Ext.draw.Container", + requires: ["Ext.chart.theme.Default", "Ext.chart.series.Series", "Ext.chart.interactions.Abstract", "Ext.chart.axis.Axis", "Ext.data.StoreManager", "Ext.chart.Legend", "Ext.data.Store"], + isChart: true, + defaultBindProperty: "store", + config: { + store: "ext-empty-store", + theme: "default", + style: null, + animation: !Ext.isIE8, + series: [], + axes: [], + legend: null, + colors: null, + insetPadding: { + top: 10, + left: 10, + right: 10, + bottom: 10 + }, + background: null, + interactions: [], + mainRect: null, + resizeHandler: null, + highlightItem: null + }, + animationSuspendCount: 0, + chartLayoutSuspendCount: 0, + axisThicknessSuspendCount: 0, + isThicknessChanged: false, + surfaceZIndexes: { + background: 0, + main: 1, + grid: 2, + series: 3, + axis: 4, + chart: 5, + overlay: 6, + events: 7 + }, + constructor: function(a) { + var b = this; + b.itemListeners = {}; + b.surfaceMap = {}; + b.chartComponents = {}; + b.isInitializing = true; + b.suspendChartLayout(); + b.animationSuspendCount++; + b.callParent(arguments); + delete b.isInitializing; + b.getSurface("main"); + b.getSurface("chart").setFlipRtlText(b.getInherited().rtl); + b.getSurface("overlay").waitFor(b.getSurface("series")); + b.animationSuspendCount--; + b.resumeChartLayout() + }, + applyAnimation: function(a, b) { + if (!a) { + a = { + duration: 0 + } + } else { + if (a === true) { + a = { + easing: "easeInOut", + duration: 500 + } + } + } + return b ? Ext.apply({}, a, b) : a + }, + getAnimation: function() { + if (this.animationSuspendCount) { + return { + duration: 0 + } + } else { + return this.callParent() + } + }, + applyInsetPadding: function(b, a) { + if (!Ext.isObject(b)) { + return Ext.util.Format.parseBox(b) + } else { + if (!a) { + return b + } else { + return Ext.apply(a, b) + } + } + }, + suspendAnimation: function() { + var d = this, + c = d.getSeries(), + e = c.length, + b = -1, + a; + d.animationSuspendCount++; + if (d.animationSuspendCount === 1) { + while (++b < e) { + a = c[b]; + a.setAnimation(a.getAnimation()) + } + } + }, + resumeAnimation: function() { + var d = this, + c = d.getSeries(), + f = c.length, + b = -1, + a, e; + d.animationSuspendCount--; + if (d.animationSuspendCount === 0) { + while (++b < f) { + a = c[b]; + e = a.getAnimation(); + a.setAnimation(e.duration && e || d.getAnimation()) + } + } + }, + suspendChartLayout: function() { + this.chartLayoutSuspendCount++; + if (this.chartLayoutSuspendCount === 1) { + if (this.scheduledLayoutId) { + this.layoutInSuspension = true; + this.cancelChartLayout() + } else { + this.layoutInSuspension = false + } + } + }, + resumeChartLayout: function() { + this.chartLayoutSuspendCount--; + if (this.chartLayoutSuspendCount === 0) { + if (this.layoutInSuspension) { + this.scheduleLayout() + } + } + }, + cancelChartLayout: function() { + if (this.scheduledLayoutId) { + Ext.draw.Animator.cancel(this.scheduledLayoutId); + this.scheduledLayoutId = null + } + }, + scheduleLayout: function() { + var a = this; + if (a.allowSchedule() && !a.scheduledLayoutId) { + a.scheduledLayoutId = Ext.draw.Animator.schedule("doScheduleLayout", a) + } + }, + allowSchedule: function() { + return true + }, + doScheduleLayout: function() { + if (this.chartLayoutSuspendCount) { + this.layoutInSuspension = true + } else { + this.performLayout() + } + }, + suspendThicknessChanged: function() { + this.axisThicknessSuspendCount++ + }, + resumeThicknessChanged: function() { + if (this.axisThicknessSuspendCount > 0) { + this.axisThicknessSuspendCount--; + if (this.axisThicknessSuspendCount === 0 && this.isThicknessChanged) { + this.onThicknessChanged() + } + } + }, + onThicknessChanged: function() { + if (this.axisThicknessSuspendCount === 0) { + this.isThicknessChanged = false; + this.performLayout() + } else { + this.isThicknessChanged = true + } + }, + applySprites: function(b) { + var a = this.getSurface("chart"); + b = Ext.Array.from(b); + a.removeAll(true); + a.add(b); + return b + }, + initItems: function() { + var a = this.items, + b, d, c; + if (a && !a.isMixedCollection) { + this.items = []; + a = Ext.Array.from(a); + for (b = 0, d = a.length; b < d; b++) { + c = a[b]; + if (c.type) { + Ext.raise("To add custom sprites to the chart use the 'sprites' config.") + } else { + this.items.push(c) + } + } + } + this.callParent() + }, + applyBackground: function(c, e) { + var b = this.getSurface("background"), + d, a, f; + if (c) { + if (e) { + d = e.attr.width; + a = e.attr.height; + f = e.type === (c.type || "rect") + } + if (c.isSprite) { + e = c + } else { + if (c.type === "image" && Ext.isString(c.src)) { + if (f) { + e.setAttributes({ + src: c.src + }) + } else { + b.remove(e, true); + e = b.add(c) + } + } else { + if (f) { + e.setAttributes({ + fillStyle: c + }) + } else { + b.remove(e, true); + e = b.add({ + type: "rect", + fillStyle: c, + fx: { + customDurations: { + x: 0, + y: 0, + width: 0, + height: 0 + } + } + }) + } + } + } + } + if (d && a) { + e.setAttributes({ + width: d, + height: a + }) + } + e.setAnimation(this.getAnimation()); + return e + }, + getLegendStore: function() { + return this.legendStore + }, + refreshLegendStore: function() { + if (this.getLegendStore()) { + var d, e, c = this.getSeries(), + b, a = []; + if (c) { + for (d = 0, e = c.length; d < e; d++) { + b = c[d]; + if (b.getShowInLegend()) { + b.provideLegendInfo(a) + } + } + } + this.getLegendStore().setData(a) + } + }, + resetLegendStore: function() { + var c = this.getLegendStore(), + e, d, a, b; + if (c) { + e = this.getLegendStore().getData().items; + for (d = 0, a = e.length; d < a; d++) { + b = e[d]; + b.beginEdit(); + b.set("disabled", false); + b.commit() + } + } + }, + onUpdateLegendStore: function(b, a) { + var d = this.getSeries(), + c; + if (a && d) { + c = d.map[a.get("series")]; + if (c) { + c.setHiddenByIndex(a.get("index"), a.get("disabled")); + this.redraw() + } + } + }, + defaultResizeHandler: function(a) { + this.scheduleLayout(); + return false + }, + applyMainRect: function(a, b) { + if (!b) { + return a + } + this.getSeries(); + this.getAxes(); + if (a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3]) { + return b + } else { + return a + } + }, + register: function(a) { + var b = this.chartComponents, + c = a.getId(); + b[c] = a + }, + unregister: function(a) { + var b = this.chartComponents, + c = a.getId(); + delete b[c] + }, + get: function(a) { + return this.chartComponents[a] + }, + getAxis: function(a) { + if (a instanceof Ext.chart.axis.Axis) { + return a + } else { + if (Ext.isNumber(a)) { + return this.getAxes()[a] + } else { + if (Ext.isString(a)) { + return this.get(a) + } + } + } + }, + getSurface: function(b, c) { + b = b || "main"; + c = c || b; + var d = this, + a = this.callParent([b]), + f = d.surfaceZIndexes, + e = d.surfaceMap; + if (c in f) { + a.element.setStyle("zIndex", f[c]) + } + if (!e[c]) { + e[c] = [] + } + if (Ext.Array.indexOf(e[c], a) < 0) { + a.type = c; + e[c].push(a); + a.on("destroy", d.forgetSurface, d) + } + return a + }, + forgetSurface: function(a) { + var d = this.surfaceMap; + if (!d || this.isDestroying) { + return + } + var c = d[a.type], + b = c ? Ext.Array.indexOf(c, a) : -1; + if (b >= 0) { + c.splice(b, 1) + } + }, + applyAxes: function(b, k) { + var l = this, + g = { + left: "right", + right: "left" + }, + m = [], + c, d, e, a, f, h, j; + l.animationSuspendCount++; + l.getStore(); + if (!k) { + k = []; + k.map = {} + } + j = k.map; + m.map = {}; + b = Ext.Array.from(b, true); + for (f = 0, h = b.length; f < h; f++) { + c = b[f]; + if (!c) { + continue + } + if (c instanceof Ext.chart.axis.Axis) { + d = j[c.getId()]; + c.setChart(l) + } else { + c = Ext.Object.chain(c); + e = c.linkedTo; + a = c.id; + if (Ext.isNumber(e)) { + c = Ext.merge({}, b[e], c) + } else { + if (Ext.isString(e)) { + Ext.Array.each(b, function(i) { + if (i.id === c.linkedTo) { + c = Ext.merge({}, i, c); + return false + } + }) + } + } + c.id = a; + c.chart = l; + if (l.getInherited().rtl) { + c.position = g[c.position] || c.position + } + a = c.getId && c.getId() || c.id; + c = Ext.factory(c, null, d = j[a], "axis") + } + if (c) { + m.push(c); + m.map[c.getId()] = c; + if (!d) { + c.on("animationstart", "onAnimationStart", l); + c.on("animationend", "onAnimationEnd", l) + } + } + } + for (f in j) { + if (!m.map[f]) { + j[f].destroy() + } + } + l.animationSuspendCount--; + return m + }, + updateAxes: function() { + if (!this.isDestroying) { + this.scheduleLayout() + } + }, + circularCopyArray: function(e, f, d) { + var c = [], + b, a = e && e.length; + if (a) { + for (b = 0; b < d; b++) { + c.push(e[(f + b) % a]) + } + } + return c + }, + circularCopyObject: function(f, g, d) { + var c = this, + b, e, a = {}; + if (d) { + for (b in f) { + if (f.hasOwnProperty(b)) { + e = f[b]; + if (Ext.isArray(e)) { + a[b] = c.circularCopyArray(e, g, d) + } else { + a[b] = e + } + } + } + } + return a + }, + getColors: function() { + var b = this, + a = b.config.colors, + c = b.getTheme(); + if (Ext.isArray(a) && a.length > 0) { + a = b.applyColors(a) + } + return a || (c && c.getColors()) + }, + applyColors: function(a) { + a = Ext.Array.map(a, function(b) { + if (Ext.isString(b)) { + return b + } else { + return b.toString() + } + }); + return a + }, + updateColors: function(c) { + var k = this, + e = k.getTheme(), + a = c || (e && e.getColors()), + l = 0, + f = k.getSeries(), + d = f && f.length, + g, j, b, h; + if (a.length) { + for (g = 0; g < d; g++) { + j = f[g]; + h = j.themeColorCount(); + b = k.circularCopyArray(a, l, h); + l += h; + j.updateChartColors(b) + } + } + k.refreshLegendStore() + }, + applyTheme: function(a) { + if (a && a.isTheme) { + return a + } + return Ext.Factory.chartTheme(a) + }, + updateTheme: function(g) { + var e = this, + f = e.getAxes(), + d = e.getSeries(), + a = e.getColors(), + c, b; + e.updateChartTheme(g); + for (b = 0; b < f.length; b++) { + f[b].updateTheme(g) + } + for (b = 0; b < d.length; b++) { + c = d[b]; + c.updateTheme(g) + } + e.updateSpriteTheme(g); + e.updateColors(a); + e.redraw() + }, + themeOnlyIfConfigured: {}, + updateChartTheme: function(c) { + var i = this, + k = c.getChart(), + n = i.getInitialConfig(), + b = i.defaultConfig, + e = i.getConfigurator().configs, + f = k.defaults, + g = k[i.xtype], + h = i.themeOnlyIfConfigured, + l, j, o, a, m, d; + k = Ext.merge({}, f, g); + for (l in k) { + j = k[l]; + d = e[l]; + if (j !== null && j !== undefined && d) { + m = n[l]; + o = Ext.isObject(j); + a = m === b[l]; + if (o) { + if (a && h[l]) { + continue + } + j = Ext.merge({}, j, m) + } + if (a || o) { + i[d.names.set](j) + } + } + } + }, + updateSpriteTheme: function(c) { + this.getSprites(); + var j = this, + e = j.getSurface("chart"), + h = e.getItems(), + m = c.getSprites(), + k, a, l, f, d, b, g; + for (b = 0, g = h.length; b < g; b++) { + k = h[b]; + a = m[k.type]; + if (a) { + f = {}; + d = k.type === "text"; + for (l in a) { + if (!(l in k.config)) { + if (!(d && l.indexOf("font") === 0 && k.config.font)) { + f[l] = a[l] + } + } + } + k.setAttributes(f) + } + } + }, + addSeries: function(b) { + var a = this.getSeries(); + Ext.Array.push(a, b); + this.setSeries(a) + }, + removeSeries: function(d) { + d = Ext.Array.from(d); + var b = this.getSeries(), + f = [], + a = d.length, + g = {}, + c, e; + for (c = 0; c < a; c++) { + e = d[c]; + if (typeof e !== "string") { + e = e.getId() + } + g[e] = true + } + for (c = 0, a = b.length; c < a; c++) { + if (!g[b[c].getId()]) { + f.push(b[c]) + } + } + this.setSeries(f) + }, + applySeries: function(e, d) { + var g = this, + j = [], + h, a, c, f, b; + g.animationSuspendCount++; + g.getAxes(); + if (d) { + h = d.map + } else { + d = []; + h = d.map = {} + } + j.map = {}; + e = Ext.Array.from(e, true); + for (c = 0, f = e.length; c < f; c++) { + b = e[c]; + if (!b) { + continue + } + a = h[b.getId && b.getId() || b.id]; + if (b instanceof Ext.chart.series.Series) { + if (a && a !== b) { + a.destroy() + } + b.setChart(g) + } else { + if (Ext.isObject(b)) { + if (a) { + a.setConfig(b); + b = a + } else { + if (Ext.isString(b)) { + b = { + type: b + } + } + b.chart = g; + b = Ext.create(b.xclass || ("series." + b.type), b); + b.on("animationstart", "onAnimationStart", g); + b.on("animationend", "onAnimationEnd", g) + } + } + } + j.push(b); + j.map[b.getId()] = b + } + for (c in h) { + if (!j.map[h[c].getId()]) { + h[c].destroy() + } + } + g.animationSuspendCount--; + return j + }, + applyLegend: function(b, a) { + return Ext.factory(b, Ext.chart.Legend, a) + }, + updateLegend: function(b, a) { + if (a) { + a.destroy() + } + if (b) { + this.getItems(); + this.legendStore = new Ext.data.Store({ + autoDestroy: true, + fields: ["id", "name", "mark", "disabled", "series", "index"] + }); + b.setStore(this.legendStore); + this.refreshLegendStore(); + this.legendStore.on("update", "onUpdateLegendStore", this) + } + }, + updateSeries: function(b, a) { + var c = this; + if (c.isDestroying) { + return + } + c.animationSuspendCount++; + c.fireEvent("serieschange", c, b, a); + c.refreshLegendStore(); + if (!Ext.isEmpty(b)) { + c.updateTheme(c.getTheme()) + } + c.scheduleLayout(); + c.animationSuspendCount-- + }, + applyInteractions: function(h, d) { + if (!d) { + d = []; + d.map = {} + } + var g = this, + a = [], + c = d.map, + e, f, b; + a.map = {}; + h = Ext.Array.from(h, true); + for (e = 0, f = h.length; e < f; e++) { + b = h[e]; + if (!b) { + continue + } + b = Ext.factory(b, null, c[b.getId && b.getId() || b.id], "interaction"); + if (b) { + b.setChart(g); + a.push(b); + a.map[b.getId()] = b + } + } + for (e in c) { + if (!a.map[e]) { + c[e].destroy() + } + } + return a + }, + getInteraction: function(e) { + var f = this.getInteractions(), + a = f && f.length, + c = null, + b, d; + if (a) { + for (d = 0; d < a; ++d) { + b = f[d]; + if (b.type === e) { + c = b; + break + } + } + } + return c + }, + applyStore: function(a) { + return a && Ext.StoreManager.lookup(a) + }, + updateStore: function(a, c) { + var b = this; + if (c) { + c.un({ + datachanged: "onDataChanged", + update: "onDataChanged", + scope: b, + order: "after" + }); + if (c.autoDestroy) { + c.destroy() + } + } + if (a) { + a.on({ + datachanged: "onDataChanged", + update: "onDataChanged", + scope: b, + order: "after" + }) + } + b.fireEvent("storechange", b, a, c); + b.onDataChanged() + }, + redraw: function() { + this.fireEvent("redraw", this) + }, + performLayout: function() { + var d = this, + b = d.getChartSize(true), + c = [0, 0, b.width, b.height], + a = d.getBackground(); + d.hasFirstLayout = true; + d.fireEvent("layout", d); + d.cancelChartLayout(); + d.getSurface("background").setRect(c); + d.getSurface("chart").setRect(c); + a.setAttributes({ + width: b.width, + height: b.height + }) + }, + getChartSize: function(b) { + var a = this; + if (b) { + a.chartSize = null + } + return a.chartSize || (a.chartSize = a.innerElement.getSize()) + }, + getEventXY: function(a) { + return this.getSurface().getEventXY(a) + }, + getItemForPoint: function(h, g) { + var f = this, + a = f.getSeries(), + e = f.getMainRect(), + d = a.length, + b = f.hasFirstLayout ? d - 1 : -1, + c, j; + if (!(e && h >= 0 && h <= e[2] && g >= 0 && g <= e[3])) { + return null + } + for (; b >= 0; b--) { + c = a[b]; + j = c.getItemForPoint(h, g); + if (j) { + return j + } + } + return null + }, + getItemsForPoint: function(h, g) { + var f = this, + a = f.getSeries(), + d = a.length, + b = f.hasFirstLayout ? d - 1 : -1, + e = [], + c, j; + for (; b >= 0; b--) { + c = a[b]; + j = c.getItemForPoint(h, g); + if (j) { + e.push(j) + } + } + return e + }, + onAnimationStart: function() { + this.fireEvent("animationstart", this) + }, + onAnimationEnd: function() { + this.fireEvent("animationend", this) + }, + onDataChanged: function() { + var d = this; + if (d.isInitializing) { + return + } + var c = d.getMainRect(), + a = d.getStore(), + b = d.getSeries(), + e = d.getAxes(); + if (!a || !e || !b) { + return + } + if (!c) { + d.on({ + redraw: d.onDataChanged, + scope: d, + single: true + }); + return + } + d.processData(); + d.redraw() + }, + recordCount: 0, + processData: function() { + var g = this, + e = g.getStore().getCount(), + c = g.getSeries(), + f = c.length, + d = false, + b = 0, + a; + for (; b < f; b++) { + a = c[b]; + a.processData(); + if (!d && a.isStoreDependantColorCount) { + d = true + } + } + if (d && e > g.recordCount) { + g.updateColors(g.getColors()); + g.recordCount = e + } + }, + bindStore: function(a) { + this.setStore(a) + }, + applyHighlightItem: function(f, a) { + if (f === a) { + return + } + if (Ext.isObject(f) && Ext.isObject(a)) { + var e = f, + d = a, + c = e.sprite && (e.sprite[0] || e.sprite), + b = d.sprite && (d.sprite[0] || d.sprite); + if (c === b && e.index === d.index) { + return + } + } + return f + }, + updateHighlightItem: function(b, a) { + if (a) { + a.series.setAttributesForItem(a, { + highlighted: false + }) + } + if (b) { + b.series.setAttributesForItem(b, { + highlighted: true + }); + this.fireEvent("itemhighlight", this, b, a) + } + this.fireEvent("itemhighlightchange", this, b, a) + }, + destroyChart: function() { + var f = this, + d = f.getLegend(), + g = f.getAxes(), + c = f.getSeries(), + h = f.getInteractions(), + b = [], + a, e; + f.surfaceMap = null; + for (a = 0, e = h.length; a < e; a++) { + h[a].destroy() + } + for (a = 0, e = g.length; a < e; a++) { + g[a].destroy() + } + for (a = 0, e = c.length; a < e; a++) { + c[a].destroy() + } + f.setInteractions(b); + f.setAxes(b); + f.setSeries(b); + if (d) { + d.destroy(); + f.setLegend(null) + } + f.legendStore = null; + f.setStore(null); + f.cancelChartLayout() + }, + getRefItems: function(b) { + var g = this, + e = g.getSeries(), + h = g.getAxes(), + a = g.getInteractions(), + c = [], + d, f; + for (d = 0, f = e.length; d < f; d++) { + c.push(e[d]); + if (e[d].getRefItems) { + c.push.apply(c, e[d].getRefItems(b)) + } + } + for (d = 0, f = h.length; d < f; d++) { + c.push(h[d]); + if (h[d].getRefItems) { + c.push.apply(c, h[d].getRefItems(b)) + } + } + for (d = 0, f = a.length; d < f; d++) { + c.push(a[d]); + if (a[d].getRefItems) { + c.push.apply(c, a[d].getRefItems(b)) + } + } + return c + } +}); +Ext.define("Ext.chart.overrides.AbstractChart", { + override: "Ext.chart.AbstractChart", + updateLegend: function(b, a) { + var c; + this.callParent([b, a]); + if (b) { + c = b.docked; + this.addDocked({ + dock: c, + xtype: "panel", + shrinkWrap: true, + scrollable: true, + layout: { + type: c === "top" || c === "bottom" ? "hbox" : "vbox", + pack: "center" + }, + items: b, + cls: Ext.baseCSSPrefix + "legend-panel" + }) + } + }, + performLayout: function() { + if (this.isVisible(true)) { + return this.callParent() + } + this.cancelChartLayout(); + return false + }, + afterComponentLayout: function(c, a, b, d) { + this.callParent([c, a, b, d]); + this.scheduleLayout() + }, + allowSchedule: function() { + return this.rendered + }, + onDestroy: function() { + this.destroyChart(); + this.callParent(arguments) + } +}); +Ext.define("Ext.chart.grid.HorizontalGrid", { + extend: "Ext.draw.sprite.Sprite", + alias: "grid.horizontal", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + width: "number", + height: "number" + }, + defaults: { + x: 0, + y: 0, + width: 1, + height: 1, + strokeStyle: "#DDD" + } + } + }, + render: function(b, c, e) { + var a = this.attr, + f = b.roundPixel(a.y), + d = c.lineWidth * 0.5; + c.beginPath(); + c.rect(e[0] - b.matrix.getDX(), f + d, +e[2], a.height); + c.fill(); + c.beginPath(); + c.moveTo(e[0] - b.matrix.getDX(), f + d); + c.lineTo(e[0] + e[2] - b.matrix.getDX(), f + d); + c.stroke() + } +}); +Ext.define("Ext.chart.grid.VerticalGrid", { + extend: "Ext.draw.sprite.Sprite", + alias: "grid.vertical", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + width: "number", + height: "number" + }, + defaults: { + x: 0, + y: 0, + width: 1, + height: 1, + strokeStyle: "#DDD" + } + } + }, + render: function(c, d, f) { + var b = this.attr, + a = c.roundPixel(b.x), + e = d.lineWidth * 0.5; + d.beginPath(); + d.rect(a - e, f[1] - c.matrix.getDY(), b.width, f[3]); + d.fill(); + d.beginPath(); + d.moveTo(a - e, f[1] - c.matrix.getDY()); + d.lineTo(a - e, f[1] + f[3] - c.matrix.getDY()); + d.stroke() + } +}); +Ext.define("Ext.chart.CartesianChart", { + extend: "Ext.chart.AbstractChart", + alternateClassName: "Ext.chart.Chart", + requires: ["Ext.chart.grid.HorizontalGrid", "Ext.chart.grid.VerticalGrid"], + xtype: ["cartesian", "chart"], + isCartesian: true, + config: { + flipXY: false, + innerRect: [0, 0, 1, 1], + innerPadding: { + top: 0, + left: 0, + right: 0, + bottom: 0 + } + }, + applyInnerPadding: function(b, a) { + if (!Ext.isObject(b)) { + return Ext.util.Format.parseBox(b) + } else { + if (!a) { + return b + } else { + return Ext.apply(a, b) + } + } + }, + getDirectionForAxis: function(a) { + var b = this.getFlipXY(); + if (a === "left" || a === "right") { + if (b) { + return "X" + } else { + return "Y" + } + } else { + if (b) { + return "Y" + } else { + return "X" + } + } + }, + performLayout: function() { + var A = this; + A.animationSuspendCount++; + if (A.callParent() === false) { + --A.animationSuspendCount; + return + } + A.suspendThicknessChanged(); + var d = A.getSurface("chart").getRect(), + o = d[2], + n = d[3], + z = A.getAxes(), + b, q = A.getSeries(), + h, l, a, f = A.getInsetPadding(), + v = A.getInnerPadding(), + r, c, e = Ext.apply({}, f), + u, p, s, k, m, y, t, x, g, j = A.getInherited().rtl, + w = A.getFlipXY(); + if (o <= 0 || n <= 0) { + return + } + for (x = 0; x < z.length; x++) { + b = z[x]; + l = b.getSurface(); + m = b.getFloating(); + y = m ? m.value : null; + a = b.getThickness(); + switch (b.getPosition()) { + case "top": + l.setRect([0, e.top + 1, o, a]); + break; + case "bottom": + l.setRect([0, n - (e.bottom + a), o, a]); + break; + case "left": + l.setRect([e.left, 0, a, n]); + break; + case "right": + l.setRect([o - (e.right + a), 0, a, n]); + break + } + if (y === null) { + e[b.getPosition()] += a + } + } + o -= e.left + e.right; + n -= e.top + e.bottom; + u = [e.left, e.top, o, n]; + e.left += v.left; + e.top += v.top; + e.right += v.right; + e.bottom += v.bottom; + p = o - v.left - v.right; + s = n - v.top - v.bottom; + A.setInnerRect([e.left, e.top, p, s]); + if (p <= 0 || s <= 0) { + return + } + A.setMainRect(u); + A.getSurface().setRect(u); + for (x = 0, g = A.surfaceMap.grid && A.surfaceMap.grid.length; x < g; x++) { + c = A.surfaceMap.grid[x]; + c.setRect(u); + c.matrix.set(1, 0, 0, 1, v.left, v.top); + c.matrix.inverse(c.inverseMatrix) + } + for (x = 0; x < z.length; x++) { + b = z[x]; + l = b.getSurface(); + t = l.matrix; + k = t.elements; + switch (b.getPosition()) { + case "top": + case "bottom": + k[4] = e.left; + b.setLength(p); + break; + case "left": + case "right": + k[5] = e.top; + b.setLength(s); + break + } + b.updateTitleSprite(); + t.inverse(l.inverseMatrix) + } + for (x = 0, g = q.length; x < g; x++) { + h = q[x]; + r = h.getSurface(); + r.setRect(u); + if (w) { + if (j) { + r.matrix.set(0, -1, -1, 0, v.left + p, v.top + s) + } else { + r.matrix.set(0, -1, 1, 0, v.left, v.top + s) + } + } else { + r.matrix.set(1, 0, 0, -1, v.left, v.top + s) + } + r.matrix.inverse(r.inverseMatrix); + h.getOverlaySurface().setRect(u) + } + A.redraw(); + A.animationSuspendCount--; + A.resumeThicknessChanged() + }, + refloatAxes: function() { + var h = this, + g = h.getAxes(), + o = (g && g.length) || 0, + c, d, n, f, l, b, k, r = h.getChartSize(), + q = h.getInsetPadding(), + p = h.getInnerPadding(), + a = r.width - q.left - q.right, + m = r.height - q.top - q.bottom, + j, e; + for (e = 0; e < o; e++) { + c = g[e]; + f = c.getFloating(); + l = f ? f.value : null; + if (l === null) { + delete c.floatingAtCoord; + continue + } + d = c.getSurface(); + n = d.getRect(); + if (!n) { + continue + } + n = n.slice(); + b = h.getAxis(f.alongAxis); + if (b) { + j = b.getAlignment() === "horizontal"; + if (Ext.isString(l)) { + l = b.getCoordFor(l) + } + b.floatingAxes[c.getId()] = l; + k = b.getSprites()[0].attr.matrix; + if (j) { + l = l * k.getXX() + k.getDX(); + c.floatingAtCoord = l + p.left + p.right + } else { + l = l * k.getYY() + k.getDY(); + c.floatingAtCoord = l + p.top + p.bottom + } + } else { + j = c.getAlignment() === "horizontal"; + if (j) { + c.floatingAtCoord = l + p.top + p.bottom + } else { + c.floatingAtCoord = l + p.left + p.right + } + l = d.roundPixel(0.01 * l * (j ? m : a)) + } + switch (c.getPosition()) { + case "top": + n[1] = q.top + p.top + l - n[3] + 1; + break; + case "bottom": + n[1] = q.top + p.top + (b ? l : m - l); + break; + case "left": + n[0] = q.left + p.left + l - n[2]; + break; + case "right": + n[0] = q.left + p.left + (b ? l : a - l) - 1; + break + } + d.setRect(n) + } + }, + redraw: function() { + var C = this, + r = C.getSeries(), + z = C.getAxes(), + b = C.getMainRect(), + p, t, w = C.getInnerPadding(), + f, l, s, e, q, A, v, g, d, c, a, k, n, y = C.getFlipXY(), + x = 1000, + m, u, h, o, B; + if (!b) { + return + } + p = b[2] - w.left - w.right; + t = b[3] - w.top - w.bottom; + for (A = 0; A < r.length; A++) { + h = r[A]; + if ((c = h.getXAxis())) { + n = c.getVisibleRange(); + l = c.getRange(); + l = [l[0] + (l[1] - l[0]) * n[0], l[0] + (l[1] - l[0]) * n[1]] + } else { + l = h.getXRange() + } + if ((a = h.getYAxis())) { + n = a.getVisibleRange(); + s = a.getRange(); + s = [s[0] + (s[1] - s[0]) * n[0], s[0] + (s[1] - s[0]) * n[1]] + } else { + s = h.getYRange() + } + q = { + visibleMinX: l[0], + visibleMaxX: l[1], + visibleMinY: s[0], + visibleMaxY: s[1], + innerWidth: p, + innerHeight: t, + flipXY: y + }; + f = h.getSprites(); + for (v = 0, g = f.length; v < g; v++) { + o = f[v]; + m = o.attr.zIndex; + if (m < x) { + m += (A + 1) * 100 + x; + o.attr.zIndex = m; + B = o.getMarker("items"); + if (B) { + u = B.attr.zIndex; + if (u === Number.MAX_VALUE) { + B.attr.zIndex = m + } else { + if (u < x) { + B.attr.zIndex = m + u + } + } + } + } + o.setAttributes(q, true) + } + } + for (A = 0; A < z.length; A++) { + d = z[A]; + e = d.isSide(); + f = d.getSprites(); + k = d.getRange(); + n = d.getVisibleRange(); + q = { + dataMin: k[0], + dataMax: k[1], + visibleMin: n[0], + visibleMax: n[1] + }; + if (e) { + q.length = t; + q.startGap = w.bottom; + q.endGap = w.top + } else { + q.length = p; + q.startGap = w.left; + q.endGap = w.right + } + for (v = 0, g = f.length; v < g; v++) { + f[v].setAttributes(q, true) + } + } + C.renderFrame(); + C.callParent(arguments) + }, + renderFrame: function() { + this.refloatAxes(); + this.callParent() + } +}); +Ext.define("Ext.chart.grid.CircularGrid", { + extend: "Ext.draw.sprite.Circle", + alias: "grid.circular", + inheritableStatics: { + def: { + defaults: { + r: 1, + strokeStyle: "#DDD" + } + } + } +}); +Ext.define("Ext.chart.grid.RadialGrid", { + extend: "Ext.draw.sprite.Path", + alias: "grid.radial", + inheritableStatics: { + def: { + processors: { + startRadius: "number", + endRadius: "number" + }, + defaults: { + startRadius: 0, + endRadius: 1, + scalingCenterX: 0, + scalingCenterY: 0, + strokeStyle: "#DDD" + }, + triggers: { + startRadius: "path,bbox", + endRadius: "path,bbox" + } + } + }, + render: function() { + this.callParent(arguments) + }, + updatePath: function(d, a) { + var b = a.startRadius, + c = a.endRadius; + d.moveTo(b, 0); + d.lineTo(c, 0) + } +}); +Ext.define("Ext.chart.PolarChart", { + extend: "Ext.chart.AbstractChart", + requires: ["Ext.chart.grid.CircularGrid", "Ext.chart.grid.RadialGrid"], + xtype: "polar", + isPolar: true, + config: { + center: [0, 0], + radius: 0, + innerPadding: 0 + }, + getDirectionForAxis: function(a) { + return a === "radial" ? "Y" : "X" + }, + applyCenter: function(a, b) { + if (b && a[0] === b[0] && a[1] === b[1]) { + return + } + return [+a[0], +a[1]] + }, + updateCenter: function(a) { + var g = this, + h = g.getAxes(), + d = g.getSeries(), + c, f, e, b; + for (c = 0, f = h.length; c < f; c++) { + e = h[c]; + e.setCenter(a) + } + for (c = 0, f = d.length; c < f; c++) { + b = d[c]; + b.setCenter(a) + } + }, + applyInnerPadding: function(b, a) { + return Ext.isNumber(b) ? b : a + }, + doSetSurfaceRect: function(b, c) { + var a = this.getMainRect(); + b.setRect(c); + b.matrix.set(1, 0, 0, 1, a[0] - c[0], a[1] - c[1]); + b.inverseMatrix.set(1, 0, 0, 1, c[0] - a[0], c[1] - a[1]) + }, + applyAxes: function(f, h) { + var e = this, + g = Ext.Array.from(e.config.series)[0], + b, d, c, a; + if (g.type === "radar" && f && f.length) { + for (b = 0, d = f.length; b < d; b++) { + c = f[b]; + if (c.position === "angular") { + a = true; + break + } + } + if (!a) { + f.push({ + type: "category", + position: "angular", + fields: g.xField || g.angleField, + style: { + estStepSize: 1 + }, + grid: true + }) + } + } + return this.callParent(arguments) + }, + performLayout: function() { + var F = this, + g = true; + try { + F.animationSuspendCount++; + if (this.callParent() === false) { + g = false; + return + } + F.suspendThicknessChanged(); + var h = F.getSurface("chart").getRect(), + v = F.getInsetPadding(), + G = F.getInnerPadding(), + l = Ext.apply({}, v), + d, s = h[2] - v.left - v.right, + r = h[3] - v.top - v.bottom, + x = [v.left, v.top, s, r], + u = F.getSeries(), + p, t = s - G * 2, + w = r - G * 2, + D = [t * 0.5 + G, w * 0.5 + G], + j = Math.min(t, w) * 0.5, + A = F.getAxes(), + f, a, k, m = [], + o = [], + E = j - G, + z, n, b, q, y, c, C; + F.setMainRect(x); + F.doSetSurfaceRect(F.getSurface(), x); + for (z = 0, n = F.surfaceMap.grid && F.surfaceMap.grid.length; z < n; z++) { + F.doSetSurfaceRect(F.surfaceMap.grid[z], h) + } + for (z = 0, n = A.length; z < n; z++) { + f = A[z]; + switch (f.getPosition()) { + case "angular": + m.push(f); + break; + case "radial": + o.push(f); + break + } + } + for (z = 0, n = m.length; z < n; z++) { + f = m[z]; + q = f.getFloating(); + y = q ? q.value : null; + F.doSetSurfaceRect(f.getSurface(), h); + a = f.getThickness(); + for (d in l) { + l[d] += a + } + s = h[2] - l.left - l.right; + r = h[3] - l.top - l.bottom; + b = Math.min(s, r) * 0.5; + if (z === 0) { + E = b - G + } + f.setMinimum(0); + f.setLength(b); + f.getSprites(); + k = f.sprites[0].attr.lineWidth * 0.5; + for (d in l) { + l[d] += k + } + } + for (z = 0, n = o.length; z < n; z++) { + f = o[z]; + F.doSetSurfaceRect(f.getSurface(), h); + f.setMinimum(0); + f.setLength(E); + f.getSprites() + } + for (z = 0, n = u.length; z < n; z++) { + p = u[z]; + if (p.type === "gauge" && !c) { + c = p + } else { + p.setRadius(E) + } + F.doSetSurfaceRect(p.getSurface(), x) + } + F.doSetSurfaceRect(F.getSurface("overlay"), h); + if (c) { + c.setRect(x); + C = c.getRadius() - G; + F.setRadius(C); + F.setCenter(c.getCenter()); + c.setRadius(C); + if (A.length && A[0].getPosition() === "gauge") { + f = A[0]; + F.doSetSurfaceRect(f.getSurface(), h); + f.setTotalAngle(c.getTotalAngle()); + f.setLength(C) + } + } else { + F.setRadius(j); + F.setCenter(D) + } + F.redraw() + } catch (B) { + throw B + } finally { + F.animationSuspendCount--; + if (g) { + F.resumeThicknessChanged() + } + } + }, + refloatAxes: function() { + var j = this, + g = j.getAxes(), + h = j.getMainRect(), + f, k, b, d, a, c, e; + if (!h) { + return + } + e = 0.5 * Math.min(h[2], h[3]); + for (d = 0, a = g.length; d < a; d++) { + c = g[d]; + f = c.getFloating(); + k = f ? f.value : null; + if (k !== null) { + b = j.getAxis(f.alongAxis); + if (c.getPosition() === "angular") { + if (b) { + k = b.getLength() * k / b.getRange()[1] + } else { + k = 0.01 * k * e + } + c.sprites[0].setAttributes({ + length: k + }, true) + } else { + if (b) { + if (Ext.isString(k)) { + k = b.getCoordFor(k) + } + k = k / (b.getRange()[1] + 1) * Math.PI * 2 - Math.PI * 1.5 + c.getRotation() + } else { + k = Ext.draw.Draw.rad(k) + } + c.sprites[0].setAttributes({ + baseRotation: k + }, true) + } + } + } + }, + redraw: function() { + var f = this, + g = f.getAxes(), + d, c = f.getSeries(), + b, a, e; + for (a = 0, e = g.length; a < e; a++) { + d = g[a]; + d.getSprites() + } + for (a = 0, e = c.length; a < e; a++) { + b = c[a]; + b.getSprites() + } + f.renderFrame(); + f.callParent(arguments) + }, + renderFrame: function() { + this.refloatAxes(); + this.callParent() + } +}); +Ext.define("Ext.chart.SpaceFillingChart", { + extend: "Ext.chart.AbstractChart", + xtype: "spacefilling", + config: {}, + performLayout: function() { + var j = this; + try { + j.animationSuspendCount++; + if (j.callParent() === false) { + return + } + var k = j.getSurface("chart").getRect(), + l = j.getInsetPadding(), + a = k[2] - l.left - l.right, + m = k[3] - l.top - l.bottom, + h = [l.left, l.top, a, m], + b = j.getSeries(), + d, c, g; + j.getSurface().setRect(h); + j.setMainRect(h); + for (c = 0, g = b.length; c < g; c++) { + d = b[c]; + d.getSurface().setRect(h); + if (d.setRect) { + d.setRect(h) + } + d.getOverlaySurface().setRect(k) + } + j.redraw() + } catch (f) { + throw f + } finally { + j.animationSuspendCount-- + } + }, + redraw: function() { + var e = this, + c = e.getSeries(), + b, a, d; + for (a = 0, d = c.length; a < d; a++) { + b = c[a]; + b.getSprites() + } + e.renderFrame(); + e.callParent(arguments) + } +}); +Ext.define("Ext.chart.axis.sprite.Axis3D", { + extend: "Ext.chart.axis.sprite.Axis", + alias: "sprite.axis3d", + type: "axis3d", + inheritableStatics: { + def: { + processors: { + depth: "number" + }, + defaults: { + depth: 0 + }, + triggers: { + depth: "layout" + } + } + }, + config: { + fx: { + customDurations: { + depth: 0 + } + } + }, + layoutUpdater: function() { + var h = this, + f = h.getAxis().getChart(); + if (f.isInitializing) { + return + } + var e = h.attr, + d = h.getLayout(), + c = d.isDiscrete ? 0 : e.depth, + g = f.getInherited().rtl, + b = e.dataMin + (e.dataMax - e.dataMin) * e.visibleMin, + i = e.dataMin + (e.dataMax - e.dataMin) * e.visibleMax, + a = { + attr: e, + segmenter: h.getSegmenter(), + renderer: h.defaultRenderer + }; + if (e.position === "left" || e.position === "right") { + e.translationX = 0; + e.translationY = i * (e.length - c) / (i - b) + c; + e.scalingX = 1; + e.scalingY = (-e.length + c) / (i - b); + e.scalingCenterY = 0; + e.scalingCenterX = 0; + h.applyTransformations(true) + } else { + if (e.position === "top" || e.position === "bottom") { + if (g) { + e.translationX = e.length + b * e.length / (i - b) + 1 + } else { + e.translationX = -b * e.length / (i - b) + } + e.translationY = 0; + e.scalingX = (g ? -1 : 1) * (e.length - c) / (i - b); + e.scalingY = 1; + e.scalingCenterY = 0; + e.scalingCenterX = 0; + h.applyTransformations(true) + } + } + if (d) { + d.calculateLayout(a); + h.setLayoutContext(a) + } + }, + renderAxisLine: function(a, j, f, c) { + var i = this, + h = i.attr, + b = h.lineWidth * 0.5, + f = i.getLayout(), + d = f.isDiscrete ? 0 : h.depth, + k = h.position, + e, g; + if (h.axisLine && h.length) { + switch (k) { + case "left": + e = a.roundPixel(c[2]) - b; + j.moveTo(e, -h.endGap + d); + j.lineTo(e, h.length + h.startGap); + break; + case "right": + j.moveTo(b, -h.endGap); + j.lineTo(b, h.length + h.startGap); + break; + case "bottom": + j.moveTo(-h.startGap, b); + j.lineTo(h.length - d + h.endGap, b); + break; + case "top": + e = a.roundPixel(c[3]) - b; + j.moveTo(-h.startGap, e); + j.lineTo(h.length + h.endGap, e); + break; + case "angular": + j.moveTo(h.centerX + h.length, h.centerY); + j.arc(h.centerX, h.centerY, h.length, 0, Math.PI * 2, true); + break; + case "gauge": + g = i.getGaugeAngles(); + j.moveTo(h.centerX + Math.cos(g.start) * h.length, h.centerY + Math.sin(g.start) * h.length); + j.arc(h.centerX, h.centerY, h.length, g.start, g.end, true); + break + } + } + } +}); +Ext.define("Ext.chart.axis.Axis3D", { + extend: "Ext.chart.axis.Axis", + xtype: "axis3d", + requires: ["Ext.chart.axis.sprite.Axis3D"], + config: { + depth: 0 + }, + onSeriesChange: function(e) { + var g = this, + b = "depthchange", + f = "onSeriesDepthChange", + d, c; + + function a(h) { + var i = g.boundSeries; + for (d = 0; d < i.length; d++) { + c = i[d]; + c[h](b, f, g) + } + } + a("un"); + g.callParent(arguments); + a("on") + }, + onSeriesDepthChange: function(b, f) { + var d = this, + g = f, + e = d.boundSeries, + a, c; + if (f > d.getDepth()) { + g = f + } else { + for (a = 0; a < e.length; a++) { + c = e[a]; + if (c !== b && c.getDepth) { + f = c.getDepth(); + if (f > g) { + g = f + } + } + } + } + d.setDepth(g) + }, + updateDepth: function(d) { + var b = this, + c = b.getSprites(), + a = { + depth: d + }; + if (c && c.length) { + c[0].setAttributes(a) + } + if (b.gridSpriteEven && b.gridSpriteOdd) { + b.gridSpriteEven.getTemplate().setAttributes(a); + b.gridSpriteOdd.getTemplate().setAttributes(a) + } + }, + getGridAlignment: function() { + switch (this.getPosition()) { + case "left": + case "right": + return "horizontal3d"; + case "top": + case "bottom": + return "vertical3d" + } + } +}); +Ext.define("Ext.chart.axis.Category", { + requires: ["Ext.chart.axis.layout.CombineDuplicate", "Ext.chart.axis.segmenter.Names"], + extend: "Ext.chart.axis.Axis", + alias: "axis.category", + type: "category", + config: { + layout: "combineDuplicate", + segmenter: "names" + } +}); +Ext.define("Ext.chart.axis.Category3D", { + requires: ["Ext.chart.axis.layout.CombineDuplicate", "Ext.chart.axis.segmenter.Names"], + extend: "Ext.chart.axis.Axis3D", + alias: "axis.category3d", + type: "category3d", + config: { + layout: "combineDuplicate", + segmenter: "names" + } +}); +Ext.define("Ext.chart.axis.Numeric", { + extend: "Ext.chart.axis.Axis", + type: "numeric", + alias: ["axis.numeric", "axis.radial"], + requires: ["Ext.chart.axis.layout.Continuous", "Ext.chart.axis.segmenter.Numeric"], + config: { + layout: "continuous", + segmenter: "numeric", + aggregator: "double" + } +}); +Ext.define("Ext.chart.axis.Numeric3D", { + extend: "Ext.chart.axis.Axis3D", + alias: ["axis.numeric3d"], + type: "numeric3d", + requires: ["Ext.chart.axis.layout.Continuous", "Ext.chart.axis.segmenter.Numeric"], + config: { + layout: "continuous", + segmenter: "numeric", + aggregator: "double" + } +}); +Ext.define("Ext.chart.axis.Time", { + extend: "Ext.chart.axis.Numeric", + alias: "axis.time", + type: "time", + requires: ["Ext.chart.axis.layout.Continuous", "Ext.chart.axis.segmenter.Time"], + config: { + calculateByLabelSize: true, + dateFormat: null, + fromDate: null, + toDate: null, + step: [Ext.Date.DAY, 1], + layout: "continuous", + segmenter: "time", + aggregator: "time" + }, + updateDateFormat: function(a) { + this.setRenderer(function(c, b) { + return Ext.Date.format(new Date(b), a) + }) + }, + updateFromDate: function(a) { + this.setMinimum(+a) + }, + updateToDate: function(a) { + this.setMaximum(+a) + }, + getCoordFor: function(a) { + if (Ext.isString(a)) { + a = new Date(a) + } + return +a + } +}); +Ext.define("Ext.chart.axis.Time3D", { + extend: "Ext.chart.axis.Numeric3D", + alias: "axis.time3d", + type: "time3d", + requires: ["Ext.chart.axis.layout.Continuous", "Ext.chart.axis.segmenter.Time"], + config: { + calculateByLabelSize: true, + dateFormat: null, + fromDate: null, + toDate: null, + step: [Ext.Date.DAY, 1], + layout: "continuous", + segmenter: "time", + aggregator: "time" + }, + updateDateFormat: function(a) { + this.setRenderer(function(c, b) { + return Ext.Date.format(new Date(b), a) + }) + }, + updateFromDate: function(a) { + this.setMinimum(+a) + }, + updateToDate: function(a) { + this.setMaximum(+a) + }, + getCoordFor: function(a) { + if (Ext.isString(a)) { + a = new Date(a) + } + return +a + } +}); +Ext.define("Ext.chart.grid.HorizontalGrid3D", { + extend: "Ext.chart.grid.HorizontalGrid", + alias: "grid.horizontal3d", + inheritableStatics: { + def: { + processors: { + depth: "number" + }, + defaults: { + depth: 0 + } + } + }, + render: function(a, k, d) { + var f = this.attr, + i = a.roundPixel(f.x), + h = a.roundPixel(f.y), + l = a.matrix.getDX(), + c = k.lineWidth * 0.5, + j = f.height, + e = f.depth, + b, g; + if (h <= d[1]) { + return + } + b = d[0] + e - l; + g = h + c - e; + k.beginPath(); + k.rect(b, g, d[2], j); + k.fill(); + k.beginPath(); + k.moveTo(b, g); + k.lineTo(b + d[2], g); + k.stroke(); + b = d[0] + i - l; + g = h + c; + k.beginPath(); + k.moveTo(b, g); + k.lineTo(b + e, g - e); + k.lineTo(b + e, g - e + j); + k.lineTo(b, g + j); + k.closePath(); + k.fill(); + k.beginPath(); + k.moveTo(b, g); + k.lineTo(b + e, g - e); + k.stroke() + } +}); +Ext.define("Ext.chart.grid.VerticalGrid3D", { + extend: "Ext.chart.grid.VerticalGrid", + alias: "grid.vertical3d", + inheritableStatics: { + def: { + processors: { + depth: "number" + }, + defaults: { + depth: 0 + } + } + }, + render_: function(c, d, f) { + var b = this.attr, + a = c.roundPixel(b.x), + e = d.lineWidth * 0.5; + d.beginPath(); + d.rect(a - e, f[1] - c.matrix.getDY(), b.width, f[3]); + d.fill(); + d.beginPath(); + d.moveTo(a - e, f[1] - c.matrix.getDY()); + d.lineTo(a - e, f[1] + f[3] - c.matrix.getDY()); + d.stroke() + }, + render: function(b, j, e) { + var g = this.attr, + i = b.roundPixel(g.x), + k = b.matrix.getDY(), + d = j.lineWidth * 0.5, + a = g.width, + f = g.depth, + c, h; + if (i >= e[2]) { + return + } + c = i - d + f; + h = e[1] - f - k; + j.beginPath(); + j.rect(c, h, a, e[3]); + j.fill(); + j.beginPath(); + j.moveTo(c, h); + j.lineTo(c, h + e[3]); + j.stroke(); + c = i - d; + h = e[3]; + j.beginPath(); + j.moveTo(c, h); + j.lineTo(c + f, h - f); + j.lineTo(c + f + a, h - f); + j.lineTo(c + a, h); + j.closePath(); + j.fill(); + c = i - d; + h = e[3]; + j.beginPath(); + j.moveTo(c, h); + j.lineTo(c + f, h - f); + j.stroke() + } +}); +Ext.define("Ext.chart.interactions.CrossZoom", { + extend: "Ext.chart.interactions.Abstract", + type: "crosszoom", + alias: "interaction.crosszoom", + isCrossZoom: true, + config: { + axes: true, + gestures: { + dragstart: "onGestureStart", + drag: "onGesture", + dragend: "onGestureEnd", + dblclick: "onDoubleTap" + }, + undoButton: {} + }, + stopAnimationBeforeSync: false, + zoomAnimationInProgress: false, + constructor: function() { + this.callParent(arguments); + this.zoomHistory = [] + }, + applyAxes: function(b) { + var a = {}; + if (b === true) { + return { + top: {}, + right: {}, + bottom: {}, + left: {} + } + } else { + if (Ext.isArray(b)) { + a = {}; + Ext.each(b, function(c) { + a[c] = {} + }) + } else { + if (Ext.isObject(b)) { + Ext.iterate(b, function(c, d) { + if (d === true) { + a[c] = {} + } else { + if (d !== false) { + a[c] = d + } + } + }) + } + } + } + return a + }, + applyUndoButton: function(b, a) { + var c = this; + if (a) { + a.destroy() + } + if (b) { + return Ext.create("Ext.Button", Ext.apply({ + cls: [], + text: "Undo Zoom", + disabled: true, + handler: function() { + c.undoZoom() + } + }, b)) + } + }, + getSurface: function() { + return this.getChart() && this.getChart().getSurface("main") + }, + setSeriesOpacity: function(b) { + var a = this.getChart() && this.getChart().getSurface("series"); + if (a) { + a.element.setStyle("opacity", b) + } + }, + onGestureStart: function(h) { + var j = this, + i = j.getChart(), + d = j.getSurface(), + l = i.getInnerRect(), + c = i.getInnerPadding(), + g = c.left, + b = g + l[2], + f = c.top, + a = f + l[3], + n = i.getEventXY(h), + m = n[0], + k = n[1]; + if (j.zoomAnimationInProgress) { + return + } + if (m > g && m < b && k > f && k < a) { + j.gestureEvent = "drag"; + j.lockEvents(j.gestureEvent); + j.startX = m; + j.startY = k; + j.selectionRect = d.add({ + type: "rect", + globalAlpha: 0.5, + fillStyle: "rgba(80,80,140,0.5)", + strokeStyle: "rgba(80,80,140,1)", + lineWidth: 2, + x: m, + y: k, + width: 0, + height: 0, + zIndex: 10000 + }); + j.setSeriesOpacity(0.8); + return false + } + }, + onGesture: function(h) { + var j = this; + if (j.zoomAnimationInProgress) { + return + } + if (j.getLocks()[j.gestureEvent] === j) { + var i = j.getChart(), + d = j.getSurface(), + l = i.getInnerRect(), + c = i.getInnerPadding(), + g = c.left, + b = g + l[2], + f = c.top, + a = f + l[3], + n = i.getEventXY(h), + m = n[0], + k = n[1]; + if (m < g) { + m = g + } else { + if (m > b) { + m = b + } + } + if (k < f) { + k = f + } else { + if (k > a) { + k = a + } + } + j.selectionRect.setAttributes({ + width: m - j.startX, + height: k - j.startY + }); + if (Math.abs(j.startX - m) < 11 || Math.abs(j.startY - k) < 11) { + j.selectionRect.setAttributes({ + globalAlpha: 0.5 + }) + } else { + j.selectionRect.setAttributes({ + globalAlpha: 1 + }) + } + d.renderFrame(); + return false + } + }, + onGestureEnd: function(i) { + var l = this; + if (l.zoomAnimationInProgress) { + return + } + if (l.getLocks()[l.gestureEvent] === l) { + var k = l.getChart(), + d = l.getSurface(), + n = k.getInnerRect(), + c = k.getInnerPadding(), + g = c.left, + b = g + n[2], + f = c.top, + a = f + n[3], + h = n[2], + j = n[3], + p = k.getEventXY(i), + o = p[0], + m = p[1]; + if (o < g) { + o = g + } else { + if (o > b) { + o = b + } + } + if (m < f) { + m = f + } else { + if (m > a) { + m = a + } + } + if (Math.abs(l.startX - o) < 11 || Math.abs(l.startY - m) < 11) { + d.remove(l.selectionRect) + } else { + l.zoomBy([Math.min(l.startX, o) / h, 1 - Math.max(l.startY, m) / j, Math.max(l.startX, o) / h, 1 - Math.min(l.startY, m) / j]); + l.selectionRect.setAttributes({ + x: Math.min(l.startX, o), + y: Math.min(l.startY, m), + width: Math.abs(l.startX - o), + height: Math.abs(l.startY - m) + }); + l.selectionRect.setAnimation(k.getAnimation() || { + duration: 0 + }); + l.selectionRect.setAttributes({ + globalAlpha: 0, + x: 0, + y: 0, + width: h, + height: j + }); + l.zoomAnimationInProgress = true; + k.suspendThicknessChanged(); + l.selectionRect.fx.on("animationend", function() { + k.resumeThicknessChanged(); + d.remove(l.selectionRect); + l.selectionRect = null; + l.zoomAnimationInProgress = false + }) + } + d.renderFrame(); + l.sync(); + l.unlockEvents(l.gestureEvent); + l.setSeriesOpacity(1); + if (!l.zoomAnimationInProgress) { + d.remove(l.selectionRect); + l.selectionRect = null + } + } + }, + zoomBy: function(o) { + var n = this, + a = n.getAxes(), + k = n.getChart(), + j = k.getAxes(), + l = k.getInherited().rtl, + f, d = {}, + c, b; + if (l) { + o = o.slice(); + c = 1 - o[0]; + b = 1 - o[2]; + o[0] = Math.min(c, b); + o[2] = Math.max(c, b) + } + for (var h = 0; h < j.length; h++) { + var g = j[h]; + f = a[g.getPosition()]; + if (f && f.allowZoom !== false) { + var e = g.isSide(), + m = g.getVisibleRange(); + d[g.getId()] = m.slice(0); + if (!e) { + g.setVisibleRange([(m[1] - m[0]) * o[0] + m[0], (m[1] - m[0]) * o[2] + m[0]]) + } else { + g.setVisibleRange([(m[1] - m[0]) * o[1] + m[0], (m[1] - m[0]) * o[3] + m[0]]) + } + } + } + n.zoomHistory.push(d); + n.getUndoButton().setDisabled(false) + }, + undoZoom: function() { + var c = this.zoomHistory.pop(), + d = this.getChart().getAxes(); + if (c) { + for (var a = 0; a < d.length; a++) { + var b = d[a]; + if (c[b.getId()]) { + b.setVisibleRange(c[b.getId()]) + } + } + } + this.getUndoButton().setDisabled(this.zoomHistory.length === 0); + this.sync() + }, + onDoubleTap: function(a) { + this.undoZoom() + }, + destroy: function() { + this.setUndoButton(null); + this.callParent(arguments) + } +}); +Ext.define("Ext.chart.interactions.Crosshair", { + extend: "Ext.chart.interactions.Abstract", + requires: ["Ext.chart.grid.HorizontalGrid", "Ext.chart.grid.VerticalGrid", "Ext.chart.CartesianChart", "Ext.chart.axis.layout.Discrete"], + type: "crosshair", + alias: "interaction.crosshair", + config: { + axes: { + top: { + label: {}, + rect: {} + }, + right: { + label: {}, + rect: {} + }, + bottom: { + label: {}, + rect: {} + }, + left: { + label: {}, + rect: {} + } + }, + lines: { + horizontal: { + strokeStyle: "black", + lineDash: [5, 5] + }, + vertical: { + strokeStyle: "black", + lineDash: [5, 5] + } + }, + gesture: "drag" + }, + applyAxes: function(b, a) { + return Ext.merge(a || {}, b) + }, + applyLines: function(a, b) { + return Ext.merge(b || {}, a) + }, + updateChart: function(a) { + if (a && !a.isCartesian) { + Ext.raise("Crosshair interaction can only be used on cartesian charts.") + } + this.callParent(arguments) + }, + getGestures: function() { + var a = this, + b = {}; + b[a.getGesture()] = "onGesture"; + b[a.getGesture() + "start"] = "onGestureStart"; + b[a.getGesture() + "end"] = "onGestureEnd"; + return b + }, + onGestureStart: function(N) { + var m = this, + O = m.getChart(), + B = O.getTheme().getAxis(), + A, F = O.getSurface("overlay"), + s = O.getInnerRect(), + n = s[2], + M = s[3], + r = O.getEventXY(N), + D = r[0], + C = r[1], + E = O.getAxes(), + u = m.getAxes(), + h = m.getLines(), + q, v, b, d, k, z, G, L, J, o, I, w, l, f, p, j, t, a, g, H, c, K; + if (D > 0 && D < n && C > 0 && C < M) { + m.lockEvents(m.getGesture()); + H = Ext.apply({ + xclass: "Ext.chart.grid.HorizontalGrid", + x: 0, + y: C, + width: n + }, h.horizontal); + c = Ext.apply({ + xclass: "Ext.chart.grid.VerticalGrid", + x: D, + y: 0, + height: M + }, h.vertical); + m.axesLabels = m.axesLabels || {}; + for (K = 0; K < E.length; K++) { + q = E[K]; + v = q.getSurface(); + b = v.getRect(); + w = q.getSprites()[0]; + d = b[2]; + k = b[3]; + z = q.getPosition(); + G = q.getAlignment(); + t = q.getTitle(); + a = t && t.attr.text !== "" && t.getBBox(); + l = w.attr; + f = w.thickness; + p = l.axisLine ? l.lineWidth : 0; + j = p / 2; + I = Math.max(l.majorTickSize, l.minorTickSize) + p; + L = m.axesLabels[z] = v.add({ + type: "composite" + }); + L.labelRect = L.add(Ext.apply({ + type: "rect", + fillStyle: "white", + x: z === "right" ? p : 0, + y: z === "bottom" ? p : 0, + width: d - p - (G === "vertical" && a ? a.width : 0), + height: k - p - (G === "horizontal" && a ? a.height : 0), + translationX: z === "left" && a ? a.width : 0, + translationY: z === "top" && a ? a.height : 0 + }, u.rect || u[z].rect)); + if (G === "vertical" && !c.strokeStyle) { + c.strokeStyle = l.strokeStyle + } + if (G === "horizontal" && !H.strokeStyle) { + H.strokeStyle = l.strokeStyle + } + A = Ext.merge({}, B.defaults, B[z]); + J = Ext.apply({}, q.config.label, A.label); + o = u.label || u[z].label; + L.labelText = L.add(Ext.apply(J, o, { + type: "text", + x: (function() { + switch (z) { + case "left": + g = a ? a.x + a.width : 0; + return g + (d - g - I) / 2 - j; + case "right": + g = a ? d - a.x : 0; + return I + (d - I - g) / 2 + j; + default: + return 0 + } + })(), + y: (function() { + switch (z) { + case "top": + g = a ? a.y + a.height : 0; + return g + (k - g - I) / 2 - j; + case "bottom": + g = a ? k - a.y : 0; + return I + (k - I - g) / 2 + j; + default: + return 0 + } + })() + })) + } + m.horizontalLine = F.add(H); + m.verticalLine = F.add(c); + return false + } + }, + onGesture: function(G) { + var K = this; + if (K.getLocks()[K.getGesture()] !== K) { + return + } + var u = K.getChart(), + z = u.getSurface("overlay"), + a = Ext.Array.slice(u.getInnerRect()), + r = u.getInnerPadding(), + t = r.left, + q = r.top, + E = a[2], + f = a[3], + d = u.getEventXY(G), + k = d[0], + j = d[1], + D = u.getAxes(), + c, h, m, p, J, w, I, H, s, b, C, g, v, n, l, A, F, o, B; + if (k < 0) { + k = 0 + } else { + if (k > E) { + k = E + } + } + if (j < 0) { + j = 0 + } else { + if (j > f) { + j = f + } + } + k += t; + j += q; + for (B = 0; B < D.length; B++) { + c = D[B]; + h = c.getPosition(); + m = c.getAlignment(); + p = c.getSurface(); + J = c.getSprites()[0]; + w = J.attr.matrix; + C = J.attr.textPadding * 2; + s = K.axesLabels[h]; + I = J.getLayoutContext(); + H = c.getSegmenter(); + if (s) { + if (m === "vertical") { + v = w.getYY(); + l = w.getDY(); + F = (j - l - q) / v; + if (c.getLayout() instanceof Ext.chart.axis.layout.Discrete) { + j = Math.round(F) * v + l + q; + F = H.from(Math.round(F)); + F = J.attr.data[F] + } else { + F = H.from(F) + } + o = H.renderer(F, I); + s.setAttributes({ + translationY: j - q + }); + s.labelText.setAttributes({ + text: o + }); + b = s.labelText.getBBox(); + s.labelRect.setAttributes({ + height: b.height + C, + y: -(b.height + C) / 2 + }); + p.renderFrame() + } else { + g = w.getXX(); + n = w.getDX(); + A = (k - n - t) / g; + if (c.getLayout() instanceof Ext.chart.axis.layout.Discrete) { + k = Math.round(A) * g + n + t; + A = H.from(Math.round(A)); + A = J.attr.data[A] + } else { + A = H.from(A) + } + o = H.renderer(A, I); + s.setAttributes({ + translationX: k - t + }); + s.labelText.setAttributes({ + text: o + }); + b = s.labelText.getBBox(); + s.labelRect.setAttributes({ + width: b.width + C, + x: -(b.width + C) / 2 + }); + p.renderFrame() + } + } + } + K.horizontalLine.setAttributes({ + y: j, + strokeStyle: J.attr.strokeStyle + }); + K.verticalLine.setAttributes({ + x: k, + strokeStyle: J.attr.strokeStyle + }); + z.renderFrame(); + return false + }, + onGestureEnd: function(h) { + var l = this, + k = l.getChart(), + a = k.getSurface("overlay"), + j = k.getAxes(), + c, g, d, b, f; + a.remove(l.verticalLine); + a.remove(l.horizontalLine); + for (f = 0; f < j.length; f++) { + c = j[f]; + g = c.getPosition(); + d = c.getSurface(); + b = l.axesLabels[g]; + if (b) { + delete l.axesLabels[g]; + d.remove(b) + } + d.renderFrame() + } + a.renderFrame(); + l.unlockEvents(l.getGesture()) + } +}); +Ext.define("Ext.chart.interactions.ItemHighlight", { + extend: "Ext.chart.interactions.Abstract", + type: "itemhighlight", + alias: "interaction.itemhighlight", + isItemHighlight: true, + config: { + gestures: { + tap: "onTapGesture", + mousemove: "onMouseMoveGesture", + mousedown: "onMouseDownGesture", + mouseup: "onMouseUpGesture", + mouseleave: "onMouseUpGesture" + }, + sticky: false + }, + stickyHighlightItem: null, + onMouseMoveGesture: function(g) { + var d = this, + h = d.tipItem, + a = g.pointerType === "mouse", + c, f, b; + if (d.getSticky()) { + return true + } + if (d.isDragging) { + if (h && a) { + h.series.hideTooltip(h); + d.tipItem = null + } + } else { + if (!d.stickyHighlightItem) { + c = d.getItemForEvent(g); + b = d.getChart(); + if (c !== b.getHighlightItem()) { + d.highlight(c); + d.sync() + } + if (a) { + if (h && (!c || h.field !== c.field || h.record !== c.record)) { + h.series.hideTooltip(h); + d.tipItem = h = null + } + if (c && (f = c.series.getTooltip())) { + if (f.trackMouse || !h) { + c.series.showTooltip(c, g.getXY()) + } + d.tipItem = c + } + } + return false + } + } + }, + highlight: function(a) { + this.getChart().setHighlightItem(a) + }, + showTooltip: function(b, a) { + a.series.showTooltip(a, b.getXY()); + this.tipItem = a + }, + onMouseDownGesture: function() { + this.isDragging = true + }, + onMouseUpGesture: function() { + this.isDragging = false + }, + onTapGesture: function(c) { + var b = this; + if (c.pointerType === "mouse" && !b.getSticky()) { + return + } + var a = b.getItemForEvent(c); + if (b.stickyHighlightItem && a && (b.stickyHighlightItem.index === a.index)) { + a = null + } + b.stickyHighlightItem = a; + b.highlight(a) + } +}); +Ext.define("Ext.chart.interactions.ItemEdit", { + extend: "Ext.chart.interactions.ItemHighlight", + requires: ["Ext.tip.ToolTip"], + type: "itemedit", + alias: "interaction.itemedit", + isItemEdit: true, + config: { + style: null, + renderer: null, + tooltip: true, + gestures: { + dragstart: "onDragStart", + drag: "onDrag", + dragend: "onDragEnd" + }, + cursors: { + ewResize: "ew-resize", + nsResize: "ns-resize", + move: "move" + } + }, + item: null, + applyTooltip: function(b) { + if (b) { + var a = Ext.apply({}, b, { + renderer: this.defaultTooltipRenderer, + constrainPosition: true, + shrinkWrapDock: true, + autoHide: true, + offsetX: 10, + offsetY: 10 + }); + b = new Ext.tip.ToolTip(a) + } + return b + }, + defaultTooltipRenderer: function(b, a, f, d) { + var c = []; + if (f.xField) { + c.push(f.xField + ": " + f.xValue) + } + if (f.yField) { + c.push(f.yField + ": " + f.yValue) + } + b.setHtml(c.join("
")) + }, + onDragStart: function(d) { + var c = this, + a = c.getChart(), + b = a.getHighlightItem(); + if (b) { + a.fireEvent("beginitemedit", a, c, c.item = b); + return false + } + }, + onDrag: function(f) { + var d = this, + b = d.getChart(), + c = b.getHighlightItem(), + a = c && c.sprite.type; + if (c) { + switch (a) { + case "barSeries": + return d.onDragBar(f); + break; + case "scatterSeries": + return d.onDragScatter(f); + break + } + } + }, + highlight: function(f) { + var e = this, + d = e.getChart(), + a = d.getFlipXY(), + g = e.getCursors(), + c = f && f.sprite.type, + b = d.el.dom.style; + e.callParent([f]); + if (f) { + switch (c) { + case "barSeries": + if (a) { + b.cursor = g.ewResize + } else { + b.cursor = g.nsResize + } + break; + case "scatterSeries": + b.cursor = g.move; + break + } + } else { + d.el.dom.style.cursor = "default" + } + }, + onDragBar: function(i) { + var m = this, + k = m.getChart(), + l = k.getInherited().rtl, + f = k.isCartesian && k.getFlipXY(), + q = k.getHighlightItem(), + g = q.sprite.getMarker("items"), + p = g.getMarkerFor(q.sprite.getId(), q.index), + b = q.sprite.getSurface(), + c = b.getRect(), + r = b.getEventXY(i), + o = q.sprite.attr.matrix, + j = m.getRenderer(), + a, n, d, h; + if (f) { + h = l ? c[2] - r[0] : r[0] + } else { + h = c[3] - r[1] + } + a = { + x: p.x, + y: h, + width: p.width, + height: p.height + (p.y - h), + radius: p.radius, + fillStyle: "none", + lineDash: [4, 4], + zIndex: 100 + }; + Ext.apply(a, m.getStyle()); + if (Ext.isArray(q.series.getYField())) { + h = h - p.y - p.height + } + m.target = { + index: q.index, + yField: q.field, + yValue: (h - o.getDY()) / o.getYY() + }; + d = [k, { + target: m.target, + style: a, + item: q + }]; + n = Ext.callback(j, null, d, 0, k); + if (n) { + Ext.apply(a, n) + } + q.sprite.putMarker("items", a, "itemedit"); + m.showTooltip(i, m.target, q); + b.renderFrame() + }, + onDragScatter: function(n) { + var t = this, + g = t.getChart(), + d = g.getInherited().rtl, + l = g.isCartesian && g.getFlipXY(), + o = g.getHighlightItem(), + b = o.sprite.getMarker("items"), + p = b.getMarkerFor(o.sprite.getId(), o.index), + j = o.sprite.getSurface(), + h = j.getRect(), + a = j.getEventXY(n), + k = o.sprite.attr.matrix, + c = o.series.getXAxis(), + f = c && c.getLayout().isContinuous, + i = t.getRenderer(), + m, u, q, s, r; + if (l) { + r = d ? h[2] - a[0] : a[0] + } else { + r = h[3] - a[1] + } + if (f) { + if (l) { + s = h[3] - a[1] + } else { + s = a[0] + } + } else { + s = p.translationX + } + m = { + translationX: s, + translationY: r, + scalingX: p.scalingX, + scalingY: p.scalingY, + r: p.r, + fillStyle: "none", + lineDash: [4, 4], + zIndex: 100 + }; + Ext.apply(m, t.getStyle()); + t.target = { + index: o.index, + yField: o.field, + yValue: (r - k.getDY()) / k.getYY() + }; + if (f) { + Ext.apply(t.target, { + xField: o.series.getXField(), + xValue: (s - k.getDX()) / k.getXX() + }) + } + q = [g, { + target: t.target, + style: m, + item: o + }]; + u = Ext.callback(i, null, q, 0, g); + if (u) { + Ext.apply(m, u) + } + o.sprite.putMarker("items", m, "itemedit"); + t.showTooltip(n, t.target, o); + j.renderFrame() + }, + showTooltip: function(g, f, c) { + var d = this.getTooltip(), + a, b; + if (d && Ext.toolkit !== "modern") { + a = d.config; + b = this.getChart(); + Ext.callback(a.renderer, null, [d, c, f, g], 0, b); + d.show([g.x + a.offsetX, g.y + a.offsetY]) + } + }, + hideTooltip: function() { + var a = this.getTooltip(); + if (a && Ext.toolkit !== "modern") { + a.hide() + } + }, + onDragEnd: function(g) { + var d = this, + f = d.target, + c = d.getChart(), + b = c.getStore(), + a; + if (f) { + a = b.getAt(f.index); + if (f.yField) { + a.set(f.yField, f.yValue, { + convert: false + }) + } + if (f.xField) { + a.set(f.xField, f.xValue, { + convert: false + }) + } + if (f.yField || f.xField) { + d.getChart().onDataChanged() + } + d.target = null + } + d.hideTooltip(); + if (d.item) { + c.fireEvent("enditemedit", c, d, d.item, f) + } + d.highlight(d.item = null) + }, + destroy: function() { + var a = this.getConfig("tooltip", true); + Ext.destroy(a); + this.callParent() + } +}); +Ext.define("Ext.chart.interactions.PanZoom", { + extend: "Ext.chart.interactions.Abstract", + type: "panzoom", + alias: "interaction.panzoom", + requires: ["Ext.draw.Animator"], + config: { + axes: { + top: {}, + right: {}, + bottom: {}, + left: {} + }, + minZoom: null, + maxZoom: null, + showOverflowArrows: true, + panGesture: "drag", + zoomGesture: "pinch", + zoomOnPanGesture: false, + modeToggleButton: { + xtype: "segmentedbutton", + width: 200, + defaults: { + ui: "default-toolbar" + }, + cls: Ext.baseCSSPrefix + "panzoom-toggle", + items: [{ + text: "Pan" + }, { + text: "Zoom" + }] + }, + hideLabelInGesture: false + }, + stopAnimationBeforeSync: true, + applyAxes: function(b, a) { + return Ext.merge(a || {}, b) + }, + applyZoomOnPanGesture: function(a) { + this.getChart(); + if (this.isMultiTouch()) { + return false + } + return a + }, + updateZoomOnPanGesture: function(b) { + var a = this.getModeToggleButton(); + if (!this.isMultiTouch()) { + a.show(); + a.setValue(b ? 1 : 0) + } else { + a.hide() + } + }, + toggleMode: function() { + var a = this; + if (!a.isMultiTouch()) { + a.setZoomOnPanGesture(!a.getZoomOnPanGesture()) + } + }, + applyModeToggleButton: function(c, b) { + var d = this, + a = Ext.factory(c, "Ext.button.Segmented", b); + if (!a && b) { + b.destroy() + } + if (a && !b) { + a.addListener("toggle", function(e) { + d.setZoomOnPanGesture(e.getValue() === 1) + }) + } + return a + }, + getGestures: function() { + var c = this, + e = {}, + d = c.getPanGesture(), + b = c.getZoomGesture(), + a = Ext.supports.Touch; + e[b] = "onZoomGestureMove"; + e[b + "start"] = "onZoomGestureStart"; + e[b + "end"] = "onZoomGestureEnd"; + e[d] = "onPanGestureMove"; + e[d + "start"] = "onPanGestureStart"; + e[d + "end"] = "onPanGestureEnd"; + e.doubletap = "onDoubleTap"; + return e + }, + onDoubleTap: function(h) { + var f = this, + c = f.getChart(), + g = c.getAxes(), + b, a, d; + for (a = 0, d = g.length; a < d; a++) { + b = g[a]; + b.setVisibleRange([0, 1]) + } + c.redraw() + }, + onPanGestureStart: function(d) { + if (!d || !d.touches || d.touches.length < 2) { + var b = this, + a = b.getChart().getInnerRect(), + c = b.getChart().element.getXY(); + b.startX = d.getX() - c[0] - a[0]; + b.startY = d.getY() - c[1] - a[1]; + b.oldVisibleRanges = null; + b.hideLabels(); + b.getChart().suspendThicknessChanged(); + b.lockEvents(b.getPanGesture()); + return false + } + }, + onPanGestureMove: function(d) { + var b = this; + if (b.getLocks()[b.getPanGesture()] === b) { + var a = b.getChart().getInnerRect(), + c = b.getChart().element.getXY(); + if (b.getZoomOnPanGesture()) { + b.transformAxesBy(b.getZoomableAxes(d), 0, 0, (d.getX() - c[0] - a[0]) / b.startX, b.startY / (d.getY() - c[1] - a[1])) + } else { + b.transformAxesBy(b.getPannableAxes(d), d.getX() - c[0] - a[0] - b.startX, d.getY() - c[1] - a[1] - b.startY, 1, 1) + } + b.sync(); + return false + } + }, + onPanGestureEnd: function(b) { + var a = this, + c = a.getPanGesture(); + if (a.getLocks()[c] === a) { + a.getChart().resumeThicknessChanged(); + a.showLabels(); + a.sync(); + a.unlockEvents(c); + return false + } + }, + onZoomGestureStart: function(b) { + if (b.touches && b.touches.length === 2) { + var c = this, + i = c.getChart().element.getXY(), + f = c.getChart().getInnerRect(), + h = i[0] + f[0], + d = i[1] + f[1], + j = [b.touches[0].point.x - h, b.touches[0].point.y - d, b.touches[1].point.x - h, b.touches[1].point.y - d], + g = Math.max(44, Math.abs(j[2] - j[0])), + a = Math.max(44, Math.abs(j[3] - j[1])); + c.getChart().suspendThicknessChanged(); + c.lastZoomDistances = [g, a]; + c.lastPoints = j; + c.oldVisibleRanges = null; + c.hideLabels(); + c.lockEvents(c.getZoomGesture()); + return false + } + }, + onZoomGestureMove: function(d) { + var f = this; + if (f.getLocks()[f.getZoomGesture()] === f) { + var i = f.getChart().getInnerRect(), + n = f.getChart().element.getXY(), + k = n[0] + i[0], + h = n[1] + i[1], + o = Math.abs, + c = f.lastPoints, + m = [d.touches[0].point.x - k, d.touches[0].point.y - h, d.touches[1].point.x - k, d.touches[1].point.y - h], + g = Math.max(44, o(m[2] - m[0])), + b = Math.max(44, o(m[3] - m[1])), + a = this.lastZoomDistances || [g, b], + l = g / a[0], + j = b / a[1]; + f.transformAxesBy(f.getZoomableAxes(d), i[2] * (l - 1) / 2 + m[2] - c[2] * l, i[3] * (j - 1) / 2 + m[3] - c[3] * j, l, j); + f.sync(); + return false + } + }, + onZoomGestureEnd: function(c) { + var b = this, + a = b.getZoomGesture(); + if (b.getLocks()[a] === b) { + b.getChart().resumeThicknessChanged(); + b.showLabels(); + b.sync(); + b.unlockEvents(a); + return false + } + }, + hideLabels: function() { + if (this.getHideLabelInGesture()) { + this.eachInteractiveAxes(function(a) { + a.hideLabels() + }) + } + }, + showLabels: function() { + if (this.getHideLabelInGesture()) { + this.eachInteractiveAxes(function(a) { + a.showLabels() + }) + } + }, + isEventOnAxis: function(c, a) { + var b = a.getSurface().getRect(); + return b[0] <= c.getX() && c.getX() <= b[0] + b[2] && b[1] <= c.getY() && c.getY() <= b[1] + b[3] + }, + getPannableAxes: function(d) { + var h = this, + a = h.getAxes(), + f = h.getChart().getAxes(), + c, g = f.length, + k = [], + j = false, + b; + if (d) { + for (c = 0; c < g; c++) { + if (this.isEventOnAxis(d, f[c])) { + j = true; + break + } + } + } + for (c = 0; c < g; c++) { + b = a[f[c].getPosition()]; + if (b && b.allowPan !== false && (!j || this.isEventOnAxis(d, f[c]))) { + k.push(f[c]) + } + } + return k + }, + getZoomableAxes: function(f) { + var j = this, + a = j.getAxes(), + g = j.getChart().getAxes(), + l = [], + d, h = g.length, + c, k = false, + b; + if (f) { + for (d = 0; d < h; d++) { + if (this.isEventOnAxis(f, g[d])) { + k = true; + break + } + } + } + for (d = 0; d < h; d++) { + c = g[d]; + b = a[c.getPosition()]; + if (b && b.allowZoom !== false && (!k || this.isEventOnAxis(f, c))) { + l.push(c) + } + } + return l + }, + eachInteractiveAxes: function(c) { + var d = this, + b = d.getAxes(), + e = d.getChart().getAxes(); + for (var a = 0; a < e.length; a++) { + if (b[e[a].getPosition()]) { + if (false === c.call(this, e[a])) { + return + } + } + } + }, + transformAxesBy: function(d, j, g, h, e) { + var f = this.getChart().getInnerRect(), + a = this.getAxes(), + k, b = this.oldVisibleRanges, + l = false; + if (!b) { + this.oldVisibleRanges = b = {}; + this.eachInteractiveAxes(function(i) { + b[i.getId()] = i.getVisibleRange() + }) + } + if (!f) { + return + } + for (var c = 0; c < d.length; c++) { + k = a[d[c].getPosition()]; + l = this.transformAxisBy(d[c], b[d[c].getId()], j, g, h, e, this.minZoom || k.minZoom, this.maxZoom || k.maxZoom) || l + } + return l + }, + transformAxisBy: function(c, o, r, q, k, i, h, m) { + var s = this, + b = o[1] - o[0], + l = c.getVisibleRange(), + g = h || s.getMinZoom() || c.config.minZoom, + j = m || s.getMaxZoom() || c.config.maxZoom, + a = s.getChart().getInnerRect(), + f, p; + if (!a) { + return + } + var d = c.isSide(), + e = d ? a[3] : a[2], + n = d ? -q : r; + b /= d ? i : k; + if (b < 0) { + b = -b + } + if (b * g > 1) { + b = 1 + } + if (b * j < 1) { + b = 1 / j + } + f = o[0]; + p = o[1]; + l = l[1] - l[0]; + if (b === l && l === 1) { + return + } + c.setVisibleRange([(o[0] + o[1] - b) * 0.5 - n / e * b, (o[0] + o[1] + b) * 0.5 - n / e * b]); + return (Math.abs(f - c.getVisibleRange()[0]) > 1e-10 || Math.abs(p - c.getVisibleRange()[1]) > 1e-10) + }, + destroy: function() { + this.setModeToggleButton(null); + this.callParent() + } +}); +Ext.define("Ext.chart.interactions.Rotate", { + extend: "Ext.chart.interactions.Abstract", + type: "rotate", + alias: "interaction.rotate", + config: { + gesture: "rotate", + gestures: { + rotate: "onRotate", + rotateend: "onRotate", + dragstart: "onGestureStart", + drag: "onGesture", + dragend: "onGestureEnd" + }, + rotation: 0 + }, + oldRotations: null, + getAngle: function(f) { + var c = this, + b = c.getChart(), + d = b.getEventXY(f), + a = b.getCenter(); + return Math.atan2(d[1] - a[1], d[0] - a[0]) + }, + getRadius: function(a) { + return this.getChart().getRadius() + }, + getEventRadius: function(h) { + var f = this, + d = f.getChart(), + g = d.getEventXY(h), + a = d.getCenter(), + c = g[0] - a[0], + b = g[1] - a[1]; + return Math.sqrt(c * c + b * b) + }, + onGestureStart: function(d) { + var c = this, + b = c.getRadius(d), + a = c.getEventRadius(d); + if (b >= a) { + c.lockEvents("drag"); + c.angle = c.getAngle(d); + c.oldRotations = {}; + return false + } + }, + onGesture: function(b) { + var a = this, + c = a.getAngle(b) - a.angle; + if (a.getLocks().drag === a) { + a.doRotateTo(c, true); + return false + } + }, + doRotateTo: function(d, a, b) { + var n = this, + l = n.getChart(), + k = l.getAxes(), + f = l.getSeries(), + m = n.oldRotations, + c, j, g, e, h; + if (!b) { + l.suspendAnimation() + } + for (e = 0, h = k.length; e < h; e++) { + c = k[e]; + g = m[c.getId()] || (m[c.getId()] = c.getRotation()); + c.setRotation(d + (a ? g : 0)) + } + for (e = 0, h = f.length; e < h; e++) { + j = f[e]; + g = m[j.getId()] || (m[j.getId()] = j.getRotation()); + j.setRotation(d + (a ? g : 0)) + } + n.setRotation(d + (a ? g : 0)); + n.fireEvent("rotate", n, n.getRotation()); + n.sync(); + if (!b) { + l.resumeAnimation() + } + }, + rotateTo: function(c, b, a) { + this.doRotateTo(c, b, a); + this.oldRotations = {} + }, + onGestureEnd: function(b) { + var a = this; + if (a.getLocks().drag === a) { + a.onGesture(b); + a.unlockEvents("drag"); + a.fireEvent("rotationEnd", a, a.getRotation()); + return false + } + }, + onRotate: function(a) {} +}); +Ext.define("Ext.chart.interactions.RotatePie3D", { + extend: "Ext.chart.interactions.Rotate", + type: "rotatePie3d", + alias: "interaction.rotatePie3d", + getAngle: function(g) { + var a = this.getChart(), + f = a.getInherited().rtl, + d = f ? -1 : 1, + h = g.getXY(), + c = a.element.getXY(), + b = a.getMainRect(); + return d * Math.atan2(h[1] - c[1] - b[3] * 0.5, h[0] - c[0] - b[2] * 0.5) + }, + getRadius: function(j) { + var f = this.getChart(), + a = f.getRadius(), + d = f.getSeries(), + h = d.length, + c = 0, + b, g; + for (; c < h; c++) { + b = d[c]; + if (b.isPie3D) { + g = b.getRadius(); + if (g > a) { + a = g + } + } + } + return a + } +}); +Ext.define("Ext.chart.plugin.ItemEvents", { + extend: "Ext.plugin.Abstract", + alias: "plugin.chartitemevents", + moveEvents: false, + mouseMoveEvents: { + mousemove: true, + mouseover: true, + mouseout: true + }, + itemMouseMoveEvents: { + itemmousemove: true, + itemmouseover: true, + itemmouseout: true + }, + init: function(b) { + var a = "handleEvent"; + this.chart = b; + b.addElementListener({ + click: a, + dblclick: a, + mousedown: a, + mousemove: a, + mouseup: a, + mouseover: a, + mouseout: a, + priority: 1001, + scope: this + }) + }, + hasItemMouseMoveListeners: function() { + var b = this.chart.hasListeners, + a; + for (a in this.itemMouseMoveEvents) { + if (a in b) { + return true + } + } + return false + }, + handleEvent: function(g) { + var d = this, + a = d.chart, + h = g.type in d.mouseMoveEvents, + c = d.lastItem, + f, b; + if (h && !d.hasItemMouseMoveListeners() && !d.moveEvents) { + return + } + f = a.getEventXY(g); + b = a.getItemForPoint(f[0], f[1]); + if (h && !Ext.Object.equals(b, c)) { + if (c) { + a.fireEvent("itemmouseout", a, c, g); + c.series.fireEvent("itemmouseout", c.series, c, g) + } + if (b) { + a.fireEvent("itemmouseover", a, b, g); + b.series.fireEvent("itemmouseover", b.series, b, g) + } + } + if (b) { + a.fireEvent("item" + g.type, a, b, g); + b.series.fireEvent("item" + g.type, b.series, b, g) + } + d.lastItem = b + } +}); +Ext.define("Ext.chart.series.Cartesian", { + extend: "Ext.chart.series.Series", + config: { + xField: null, + yField: null, + xAxis: null, + yAxis: null + }, + directions: ["X", "Y"], + fieldCategoryX: ["X"], + fieldCategoryY: ["Y"], + applyXAxis: function(a, b) { + return this.getChart().getAxis(a) || b + }, + applyYAxis: function(a, b) { + return this.getChart().getAxis(a) || b + }, + updateXAxis: function(a) { + a.processData(this) + }, + updateYAxis: function(a) { + a.processData(this) + }, + coordinateX: function() { + return this.coordinate("X", 0, 2) + }, + coordinateY: function() { + return this.coordinate("Y", 1, 2) + }, + getItemForPoint: function(a, g) { + if (this.getSprites()) { + var f = this, + d = f.getSprites()[0], + b = f.getStore(), + e, c; + if (f.getHidden()) { + return null + } + if (d) { + c = d.getIndexNearPoint(a, g); + if (c !== -1) { + e = { + series: f, + category: f.getItemInstancing() ? "items" : "markers", + index: c, + record: b.getData().items[c], + field: f.getYField(), + sprite: d + }; + return e + } + } + } + }, + createSprite: function() { + var c = this, + a = c.callParent(), + b = c.getChart(), + d = c.getXAxis(); + a.setAttributes({ + flipXY: b.getFlipXY(), + xAxis: d + }); + if (a.setAggregator && d && d.getAggregator) { + if (d.getAggregator) { + a.setAggregator({ + strategy: d.getAggregator() + }) + } else { + a.setAggregator({}) + } + } + return a + }, + getSprites: function() { + var d = this, + c = this.getChart(), + e = d.getAnimation() || c && c.getAnimation(), + b = d.getItemInstancing(), + f = d.sprites, + a; + if (!c) { + return [] + } + if (!f.length) { + a = d.createSprite() + } else { + a = f[0] + } + if (e) { + if (b) { + a.itemsMarker.getTemplate().setAnimation(e) + } + a.setAnimation(e) + } + return f + }, + provideLegendInfo: function(d) { + var b = this, + a = b.getSubStyleWithTheme(), + c = a.fillStyle; + if (Ext.isArray(c)) { + c = c[0] + } + d.push({ + name: b.getTitle() || b.getYField() || b.getId(), + mark: (Ext.isObject(c) ? c.stops && c.stops[0].color : c) || a.strokeStyle || "black", + disabled: b.getHidden(), + series: b.getId(), + index: 0 + }) + }, + getXRange: function() { + return [this.dataRange[0], this.dataRange[2]] + }, + getYRange: function() { + return [this.dataRange[1], this.dataRange[3]] + } +}); +Ext.define("Ext.chart.series.StackedCartesian", { + extend: "Ext.chart.series.Cartesian", + config: { + stacked: true, + splitStacks: true, + fullStack: false, + fullStackTotal: 100, + hidden: [] + }, + spriteAnimationCount: 0, + themeColorCount: function() { + var b = this, + a = b.getYField(); + return Ext.isArray(a) ? a.length : 1 + }, + updateStacked: function() { + this.processData() + }, + updateSplitStacks: function() { + this.processData() + }, + coordinateY: function() { + return this.coordinateStacked("Y", 1, 2) + }, + coordinateStacked: function(D, e, m) { + var F = this, + f = F.getStore(), + r = f.getData().items, + B = r.length, + c = F["get" + D + "Axis"](), + x = F.getHidden(), + a = F.getSplitStacks(), + z = F.getFullStack(), + l = F.getFullStackTotal(), + p = { + min: 0, + max: 0 + }, + n = F["fieldCategory" + D], + C = [], + o = [], + E = [], + h, A = F.getStacked(), + g = F.getSprites(), + q = [], + w, v, u, s, H, y, b, d, G, t; + if (!g.length) { + return + } + for (w = 0; w < n.length; w++) { + d = n[w]; + s = F.getFields([d]); + H = s.length; + for (v = 0; v < B; v++) { + C[v] = 0; + o[v] = 0; + E[v] = 0 + } + for (v = 0; v < H; v++) { + if (!x[v]) { + q[v] = F.coordinateData(r, s[v], c) + } + } + if (A && z) { + y = []; + if (a) { + b = [] + } + for (v = 0; v < B; v++) { + y[v] = 0; + if (a) { + b[v] = 0 + } + for (u = 0; u < H; u++) { + G = q[u]; + if (!G) { + continue + } + G = G[v]; + if (G >= 0 || !a) { + y[v] += G + } else { + if (G < 0) { + b[v] += G + } + } + } + } + } + for (v = 0; v < H; v++) { + t = {}; + if (x[v]) { + t["dataStart" + d] = C; + t["data" + d] = C; + g[v].setAttributes(t); + continue + } + G = q[v]; + if (A) { + h = []; + for (u = 0; u < B; u++) { + if (!G[u]) { + G[u] = 0 + } + if (G[u] >= 0 || !a) { + if (z && y[u]) { + G[u] *= l / y[u] + } + C[u] = o[u]; + o[u] += G[u]; + h[u] = o[u] + } else { + if (z && b[u]) { + G[u] *= l / b[u] + } + C[u] = E[u]; + E[u] += G[u]; + h[u] = E[u] + } + } + t["dataStart" + d] = C; + t["data" + d] = h; + F.getRangeOfData(C, p); + F.getRangeOfData(h, p) + } else { + t["dataStart" + d] = C; + t["data" + d] = G; + F.getRangeOfData(G, p) + } + g[v].setAttributes(t) + } + } + F.dataRange[e] = p.min; + F.dataRange[e + m] = p.max; + t = {}; + t["dataMin" + D] = p.min; + t["dataMax" + D] = p.max; + for (w = 0; w < g.length; w++) { + g[w].setAttributes(t) + } + }, + getFields: function(f) { + var e = this, + a = [], + c, b, d; + for (b = 0, d = f.length; b < d; b++) { + c = e["get" + f[b] + "Field"](); + if (Ext.isArray(c)) { + a.push.apply(a, c) + } else { + a.push(c) + } + } + return a + }, + updateLabelOverflowPadding: function(a) { + this.getLabel().setAttributes({ + labelOverflowPadding: a + }) + }, + getSprites: function() { + var k = this, + j = k.getChart(), + c = k.getAnimation() || j && j.getAnimation(), + f = k.getFields(k.fieldCategoryY), + b = k.getItemInstancing(), + h = k.sprites, + l, e = k.getHidden(), + g = false, + d, a = f.length; + if (!j) { + return [] + } + for (d = 0; d < a; d++) { + l = h[d]; + if (!l) { + l = k.createSprite(); + l.setAttributes({ + zIndex: -d + }); + l.setField(f[d]); + g = true; + e.push(false); + if (b) { + l.itemsMarker.getTemplate().setAttributes(k.getStyleByIndex(d)) + } else { + l.setAttributes(k.getStyleByIndex(d)) + } + } + if (c) { + if (b) { + l.itemsMarker.getTemplate().setAnimation(c) + } + l.setAnimation(c) + } + } + if (g) { + k.updateHidden(e) + } + return h + }, + getItemForPoint: function(k, j) { + if (this.getSprites()) { + var h = this, + b, g, m, a = h.getItemInstancing(), + f = h.getSprites(), + l = h.getStore(), + c = h.getHidden(), + n, d, e; + for (b = 0, g = f.length; b < g; b++) { + if (!c[b]) { + m = f[b]; + d = m.getIndexNearPoint(k, j); + if (d !== -1) { + e = h.getYField(); + n = { + series: h, + index: d, + category: a ? "items" : "markers", + record: l.getData().items[d], + field: typeof e === "string" ? e : e[b], + sprite: m + }; + return n + } + } + } + return null + } + }, + provideLegendInfo: function(e) { + var g = this, + f = g.getSprites(), + h = g.getTitle(), + j = g.getYField(), + d = g.getHidden(), + k = f.length === 1, + b, l, c, a; + for (c = 0; c < f.length; c++) { + b = g.getStyleByIndex(c); + l = b.fillStyle; + if (h) { + if (Ext.isArray(h)) { + a = h[c] + } else { + if (k) { + a = h + } + } + } else { + if (Ext.isArray(j)) { + a = j[c] + } else { + a = g.getId() + } + } + e.push({ + name: a, + mark: (Ext.isObject(l) ? l.stops && l.stops[0].color : l) || b.strokeStyle || "black", + disabled: d[c], + series: g.getId(), + index: c + }) + } + }, + onSpriteAnimationStart: function(a) { + this.spriteAnimationCount++; + if (this.spriteAnimationCount === 1) { + this.fireEvent("animationstart") + } + }, + onSpriteAnimationEnd: function(a) { + this.spriteAnimationCount--; + if (this.spriteAnimationCount === 0) { + this.fireEvent("animationend") + } + } +}); +Ext.define("Ext.chart.series.sprite.Series", { + extend: "Ext.draw.sprite.Sprite", + mixins: { + markerHolder: "Ext.chart.MarkerHolder" + }, + inheritableStatics: { + def: { + processors: { + dataMinX: "number", + dataMaxX: "number", + dataMinY: "number", + dataMaxY: "number", + rangeX: "data", + rangeY: "data", + dataX: "data", + dataY: "data" + }, + defaults: { + dataMinX: 0, + dataMaxX: 1, + dataMinY: 0, + dataMaxY: 1, + rangeX: null, + rangeY: null, + dataX: null, + dataY: null + }, + triggers: { + dataX: "bbox", + dataY: "bbox", + dataMinX: "bbox", + dataMaxX: "bbox", + dataMinY: "bbox", + dataMaxY: "bbox" + } + } + }, + config: { + store: null, + series: null, + field: null + } +}); +Ext.define("Ext.chart.series.sprite.Cartesian", { + extend: "Ext.chart.series.sprite.Series", + inheritableStatics: { + def: { + processors: { + labels: "default", + labelOverflowPadding: "number", + selectionTolerance: "number", + flipXY: "bool", + renderer: "default", + visibleMinX: "number", + visibleMinY: "number", + visibleMaxX: "number", + visibleMaxY: "number", + innerWidth: "number", + innerHeight: "number" + }, + defaults: { + labels: null, + labelOverflowPadding: 10, + selectionTolerance: 20, + flipXY: false, + renderer: null, + transformFillStroke: false, + visibleMinX: 0, + visibleMinY: 0, + visibleMaxX: 1, + visibleMaxY: 1, + innerWidth: 1, + innerHeight: 1 + }, + triggers: { + dataX: "dataX,bbox", + dataY: "dataY,bbox", + visibleMinX: "panzoom", + visibleMinY: "panzoom", + visibleMaxX: "panzoom", + visibleMaxY: "panzoom", + innerWidth: "panzoom", + innerHeight: "panzoom" + }, + updaters: { + dataX: function(a) { + this.processDataX(); + this.scheduleUpdater(a, "dataY", ["dataY"]) + }, + dataY: function() { + this.processDataY() + }, + panzoom: function(c) { + var e = c.visibleMaxX - c.visibleMinX, + d = c.visibleMaxY - c.visibleMinY, + b = c.flipXY ? c.innerHeight : c.innerWidth, + g = !c.flipXY ? c.innerHeight : c.innerWidth, + a = this.getSurface(), + f = a ? a.getInherited().rtl : false; + if (f && !c.flipXY) { + c.translationX = b + c.visibleMinX * b / e + } else { + c.translationX = -c.visibleMinX * b / e + } + c.translationY = -c.visibleMinY * g / d; + c.scalingX = (f && !c.flipXY ? -1 : 1) * b / e; + c.scalingY = g / d; + c.scalingCenterX = 0; + c.scalingCenterY = 0; + this.applyTransformations(true) + } + } + } + }, + processDataY: Ext.emptyFn, + processDataX: Ext.emptyFn, + updatePlainBBox: function(b) { + var a = this.attr; + b.x = a.dataMinX; + b.y = a.dataMinY; + b.width = a.dataMaxX - a.dataMinX; + b.height = a.dataMaxY - a.dataMinY + }, + binarySearch: function(d) { + var b = this.attr.dataX, + f = 0, + a = b.length; + if (d <= b[0]) { + return f + } + if (d >= b[a - 1]) { + return a - 1 + } + while (f + 1 < a) { + var c = (f + a) >> 1, + e = b[c]; + if (e === d) { + return c + } else { + if (e < d) { + f = c + } else { + a = c + } + } + } + return f + }, + render: function(b, c, g) { + var f = this, + a = f.attr, + e = a.inverseMatrix.clone(); + e.appendMatrix(b.inverseMatrix); + if (a.dataX === null || a.dataX === undefined) { + return + } + if (a.dataY === null || a.dataY === undefined) { + return + } + if (e.getXX() * e.getYX() || e.getXY() * e.getYY()) { + console.log("Cartesian Series sprite does not support rotation/sheering"); + return + } + var d = e.transformList([ + [g[0] - 1, g[3] + 1], + [g[0] + g[2] + 1, -1] + ]); + d = d[0].concat(d[1]); + f.renderClipped(b, c, d, g) + }, + renderClipped: Ext.emptyFn, + getIndexNearPoint: function(f, e) { + var w = this, + q = w.attr.matrix, + h = w.attr.dataX, + g = w.attr.dataY, + k = w.attr.selectionTolerance, + t, r, c = -1, + j = q.clone().prependMatrix(w.surfaceMatrix).inverse(), + u = j.transformPoint([f, e]), + b = j.transformPoint([f - k, e - k]), + n = j.transformPoint([f + k, e + k]), + a = Math.min(b[0], n[0]), + s = Math.max(b[0], n[0]), + l = Math.min(b[1], n[1]), + d = Math.max(b[1], n[1]), + m, v, o, p; + for (o = 0, p = h.length; o < p; o++) { + m = h[o]; + v = g[o]; + if (m > a && m < s && v > l && v < d) { + if (c === -1 || (Math.abs(m - u[0]) < t) && (Math.abs(v - u[1]) < r)) { + t = Math.abs(m - u[0]); + r = Math.abs(v - u[1]); + c = o + } + } + } + return c + } +}); +Ext.define("Ext.chart.series.sprite.StackedCartesian", { + extend: "Ext.chart.series.sprite.Cartesian", + inheritableStatics: { + def: { + processors: { + groupCount: "number", + groupOffset: "number", + dataStartY: "data" + }, + defaults: { + selectionTolerance: 20, + groupCount: 1, + groupOffset: 0, + dataStartY: null + }, + triggers: { + dataStartY: "dataY,bbox" + } + } + }, + getIndexNearPoint: function(e, d) { + var o = this, + q = o.attr.matrix, + h = o.attr.dataX, + f = o.attr.dataY, + u = o.attr.dataStartY, + l = o.attr.selectionTolerance, + s = 0.5, + r = Infinity, + b = -1, + k = q.clone().prependMatrix(this.surfaceMatrix).inverse(), + t = k.transformPoint([e, d]), + a = k.transformPoint([e - l, d - l]), + n = k.transformPoint([e + l, d + l]), + m = Math.min(a[1], n[1]), + c = Math.max(a[1], n[1]), + j, g; + for (var p = 0; p < h.length; p++) { + if (Math.min(u[p], f[p]) <= c && m <= Math.max(u[p], f[p])) { + j = Math.abs(h[p] - t[0]); + g = Math.max(-Math.min(f[p] - t[1], t[1] - u[p]), 0); + if (j < s && g <= r) { + s = j; + r = g; + b = p + } + } + } + return b + } +}); +Ext.define("Ext.chart.series.sprite.Area", { + alias: "sprite.areaSeries", + extend: "Ext.chart.series.sprite.StackedCartesian", + inheritableStatics: { + def: { + processors: { + step: "bool" + }, + defaults: { + step: false + } + } + }, + renderClipped: function(q, s, A) { + var B = this, + p = B.attr, + l = p.dataX, + j = p.dataY, + C = p.dataStartY, + t = p.matrix, + h, g, v, f, d, z, w, e = t.elements[0], + m = t.elements[4], + o = t.elements[3], + k = t.elements[5], + c = B.surfaceMatrix, + n = {}, + r = Math.min(A[0], A[2]), + u = Math.max(A[0], A[2]), + b = Math.max(0, this.binarySearch(r)), + a = Math.min(l.length - 1, this.binarySearch(u) + 1); + s.beginPath(); + z = l[b] * e + m; + w = j[b] * o + k; + s.moveTo(z, w); + if (p.step) { + d = w; + for (v = b; v <= a; v++) { + h = l[v] * e + m; + g = j[v] * o + k; + s.lineTo(h, d); + s.lineTo(h, d = g) + } + } else { + for (v = b; v <= a; v++) { + h = l[v] * e + m; + g = j[v] * o + k; + s.lineTo(h, g) + } + } + if (C) { + if (p.step) { + f = l[a] * e + m; + for (v = a; v >= b; v--) { + h = l[v] * e + m; + g = C[v] * o + k; + s.lineTo(f, g); + s.lineTo(f = h, g) + } + } else { + for (v = a; v >= b; v--) { + h = l[v] * e + m; + g = C[v] * o + k; + s.lineTo(h, g) + } + } + } else { + s.lineTo(l[a] * e + m, g); + s.lineTo(l[a] * e + m, k); + s.lineTo(z, k); + s.lineTo(z, j[v] * o + k) + } + if (p.transformFillStroke) { + p.matrix.toContext(s) + } + s.fill(); + if (p.transformFillStroke) { + p.inverseMatrix.toContext(s) + } + s.beginPath(); + s.moveTo(z, w); + if (p.step) { + for (v = b; v <= a; v++) { + h = l[v] * e + m; + g = j[v] * o + k; + s.lineTo(h, d); + s.lineTo(h, d = g); + n.translationX = c.x(h, g); + n.translationY = c.y(h, g); + B.putMarker("markers", n, v, !p.renderer) + } + } else { + for (v = b; v <= a; v++) { + h = l[v] * e + m; + g = j[v] * o + k; + s.lineTo(h, g); + n.translationX = c.x(h, g); + n.translationY = c.y(h, g); + B.putMarker("markers", n, v, !p.renderer) + } + } + if (p.transformFillStroke) { + p.matrix.toContext(s) + } + s.stroke() + } +}); +Ext.define("Ext.chart.series.Area", { + extend: "Ext.chart.series.StackedCartesian", + alias: "series.area", + type: "area", + seriesType: "areaSeries", + requires: ["Ext.chart.series.sprite.Area"], + config: { + splitStacks: false + } +}); +Ext.define("Ext.chart.series.sprite.Bar", { + alias: "sprite.barSeries", + extend: "Ext.chart.series.sprite.StackedCartesian", + inheritableStatics: { + def: { + processors: { + minBarWidth: "number", + maxBarWidth: "number", + minGapWidth: "number", + radius: "number", + inGroupGapWidth: "number" + }, + defaults: { + minBarWidth: 2, + maxBarWidth: 100, + minGapWidth: 5, + inGroupGapWidth: 3, + radius: 0 + } + } + }, + drawLabel: function(k, i, s, h, o) { + var q = this, + n = q.attr, + f = q.getMarker("labels"), + d = f.getTemplate(), + l = q.labelCfg || (q.labelCfg = {}), + c = q.surfaceMatrix, + j = n.labelOverflowPadding, + b = d.attr.display, + m = d.attr.orientation, + g, e, a, r, t, p; + l.x = c.x(i, h); + l.y = c.y(i, h); + if (!n.flipXY) { + l.rotationRads = -Math.PI * 0.5 + } else { + l.rotationRads = 0 + } + l.calloutVertical = !n.flipXY; + switch (m) { + case "horizontal": + l.rotationRads = 0; + l.calloutVertical = false; + break; + case "vertical": + l.rotationRads = -Math.PI * 0.5; + l.calloutVertical = true; + break + } + l.text = k; + if (d.attr.renderer) { + p = [k, f, l, { + store: q.getStore() + }, o]; + r = Ext.callback(d.attr.renderer, null, p, 0, q.getSeries()); + if (typeof r === "string") { + l.text = r + } else { + if (typeof r === "object") { + if ("text" in r) { + l.text = r.text + } + t = true + } + } + } + a = q.getMarkerBBox("labels", o, true); + if (!a) { + q.putMarker("labels", l, o); + a = q.getMarkerBBox("labels", o, true) + } + e = (a.width / 2 + j); + if (s > h) { + e = -e + } + if ((m === "horizontal" && n.flipXY) || (m === "vertical" && !n.flipXY) || !m) { + g = (b === "insideStart") ? s + e : h - e + } else { + g = (b === "insideStart") ? s + j * 2 : h - j * 2 + } + l.x = c.x(i, g); + l.y = c.y(i, g); + g = (b === "insideStart") ? s - e : h + e; + l.calloutPlaceX = c.x(i, g); + l.calloutPlaceY = c.y(i, g); + g = (b === "insideStart") ? s : h; + l.calloutStartX = c.x(i, g); + l.calloutStartY = c.y(i, g); + if (s > h) { + e = -e + } + if (Math.abs(h - s) <= e * 2 || b === "outside") { + l.callout = 1 + } else { + l.callout = 0 + } + if (t) { + Ext.apply(l, r) + } + q.putMarker("labels", l, o) + }, + drawBar: function(l, b, d, c, h, k, a, e) { + var g = this, + j = {}, + f = g.attr.renderer, + i; + j.x = c; + j.y = h; + j.width = k - c; + j.height = a - h; + j.radius = g.attr.radius; + if (f) { + i = Ext.callback(f, null, [g, j, { + store: g.getStore() + }, e], 0, g.getSeries()); + Ext.apply(j, i) + } + g.putMarker("items", j, e, !f) + }, + renderClipped: function(G, u, F, C) { + if (this.cleanRedraw) { + return + } + var q = this, + o = q.attr, + w = o.dataX, + v = o.dataY, + H = o.labels, + n = o.dataStartY, + m = o.groupCount, + E = o.groupOffset - (m - 1) * 0.5, + z = o.inGroupGapWidth, + t = u.lineWidth, + D = o.matrix, + B = D.elements[0], + j = D.elements[3], + e = D.elements[4], + d = G.roundPixel(D.elements[5]) - 1, + J = (B < 0 ? -1 : 1) * B - o.minGapWidth, + k = (Math.min(J, o.maxBarWidth) - z * (m - 1)) / m, + A = G.roundPixel(Math.max(o.minBarWidth, k)), + c = q.surfaceMatrix, + g, I, b, h, K, a, l = 0.5 * o.lineWidth, + L = Math.min(F[0], F[2]), + x = Math.max(F[0], F[2]), + y = Math.max(0, Math.floor(L)), + p = Math.min(w.length - 1, Math.ceil(x)), + f = H && q.getMarker("labels"), + s, r; + for (K = y; K <= p; K++) { + s = n ? n[K] : 0; + r = v[K]; + a = w[K] * B + e + E * (A + z); + g = G.roundPixel(a - A / 2) + l; + h = G.roundPixel(r * j + d + t); + I = G.roundPixel(a + A / 2) - l; + b = G.roundPixel(s * j + d + t); + q.drawBar(u, G, F, g, h - l, I, b - l, K); + if (f && H[K] != null) { + q.drawLabel(H[K], a, b, h, K) + } + q.putMarker("markers", { + translationX: c.x(a, h), + translationY: c.y(a, h) + }, K, true) + } + }, + getIndexNearPoint: function(l, k) { + var m = this, + g = m.attr, + h = g.dataX, + a = m.getSurface(), + b = a.getRect() || [0, 0, 0, 0], + j = b[3], + e, d, c, n, f = -1; + if (g.flipXY) { + e = j - k; + if (a.getInherited().rtl) { + d = b[2] - l + } else { + d = l + } + } else { + e = l; + d = j - k + } + for (c = 0; c < h.length; c++) { + n = m.getMarkerBBox("items", c); + if (Ext.draw.Draw.isPointInBBox(e, d, n)) { + f = c; + break + } + } + return f + } +}); +Ext.define("Ext.chart.series.Bar", { + extend: "Ext.chart.series.StackedCartesian", + alias: "series.bar", + type: "bar", + seriesType: "barSeries", + requires: ["Ext.chart.series.sprite.Bar", "Ext.draw.sprite.Rect"], + config: { + itemInstancing: { + type: "rect", + fx: { + customDurations: { + x: 0, + y: 0, + width: 0, + height: 0, + radius: 0 + } + } + } + }, + getItemForPoint: function(a, f) { + if (this.getSprites()) { + var d = this, + c = d.getChart(), + e = c.getInnerPadding(), + b = c.getInherited().rtl; + arguments[0] = a + (b ? e.right : -e.left); + arguments[1] = f + e.bottom; + return d.callParent(arguments) + } + }, + updateXAxis: function(a) { + a.setLabelInSpan(true); + this.callParent(arguments) + }, + updateHidden: function(a) { + this.callParent(arguments); + this.updateStacked() + }, + updateStacked: function(c) { + var e = this, + g = e.getSprites(), + d = g.length, + f = [], + a = {}, + b; + for (b = 0; b < d; b++) { + if (!g[b].attr.hidden) { + f.push(g[b]) + } + } + d = f.length; + if (e.getStacked()) { + a.groupCount = 1; + a.groupOffset = 0; + for (b = 0; b < d; b++) { + f[b].setAttributes(a) + } + } else { + a.groupCount = f.length; + for (b = 0; b < d; b++) { + a.groupOffset = b; + f[b].setAttributes(a) + } + } + e.callParent(arguments) + } +}); +Ext.define("Ext.chart.series.sprite.Bar3D", { + extend: "Ext.chart.series.sprite.Bar", + alias: "sprite.bar3dSeries", + requires: ["Ext.draw.gradient.Linear"], + inheritableStatics: { + def: { + processors: { + depthWidthRatio: "number", + saturationFactor: "number", + brightnessFactor: "number", + colorSpread: "number" + }, + defaults: { + depthWidthRatio: 1 / 3, + saturationFactor: 1, + brightnessFactor: 1, + colorSpread: 1, + transformFillStroke: true + }, + triggers: { + groupCount: "panzoom" + }, + updaters: { + panzoom: function(c) { + var g = this, + e = c.visibleMaxX - c.visibleMinX, + d = c.visibleMaxY - c.visibleMinY, + b = c.flipXY ? c.innerHeight : c.innerWidth, + h = !c.flipXY ? c.innerHeight : c.innerWidth, + a = g.getSurface(), + f = a ? a.getInherited().rtl : false; + if (f && !c.flipXY) { + c.translationX = b + c.visibleMinX * b / e + } else { + c.translationX = -c.visibleMinX * b / e + } + c.translationY = -c.visibleMinY * (h - g.depth) / d; + c.scalingX = (f && !c.flipXY ? -1 : 1) * b / e; + c.scalingY = (h - g.depth) / d; + c.scalingCenterX = 0; + c.scalingCenterY = 0; + g.applyTransformations(true) + } + } + } + }, + config: { + showStroke: false + }, + depth: 0, + drawBar: function(p, b, d, c, l, o, a, h) { + var k = this, + i = k.attr, + n = {}, + j = i.renderer, + m, g, f, e; + n.x = (c + o) * 0.5; + n.y = l; + n.width = (o - c) * 0.75; + n.height = a - l; + n.depth = g = n.width * i.depthWidthRatio; + n.orientation = i.flipXY ? "horizontal" : "vertical"; + n.saturationFactor = i.saturationFactor; + n.brightnessFactor = i.brightnessFactor; + n.colorSpread = i.colorSpread; + if (g !== k.depth) { + k.depth = g; + f = k.getSeries(); + f.fireEvent("depthchange", f, g) + } + if (j) { + e = [k, n, { + store: k.getStore() + }, h]; + m = Ext.callback(j, null, e, 0, k.getSeries()); + Ext.apply(n, m) + } + k.putMarker("items", n, h, !j) + } +}); +Ext.define("Ext.chart.series.sprite.Box", { + extend: "Ext.draw.sprite.Sprite", + alias: "sprite.box", + type: "box", + inheritableStatics: { + def: { + processors: { + x: "number", + y: "number", + width: "number", + height: "number", + depth: "number", + orientation: "enums(vertical,horizontal)", + showStroke: "bool", + saturationFactor: "number", + brightnessFactor: "number", + colorSpread: "number" + }, + triggers: { + x: "bbox", + y: "bbox", + width: "bbox", + height: "bbox", + depth: "bbox", + orientation: "bbox" + }, + defaults: { + x: 0, + y: 0, + width: 8, + height: 8, + depth: 8, + orientation: "vertical", + showStroke: false, + saturationFactor: 1, + brightnessFactor: 1, + colorSpread: 1, + lineJoin: "bevel" + } + } + }, + constructor: function(a) { + this.callParent([a]); + this.topGradient = new Ext.draw.gradient.Linear({}); + this.rightGradient = new Ext.draw.gradient.Linear({}); + this.frontGradient = new Ext.draw.gradient.Linear({}) + }, + updatePlainBBox: function(d) { + var c = this.attr, + b = c.x, + g = c.y, + e = c.width, + a = c.height, + f = c.depth; + d.x = b - e * 0.5; + d.width = e + f; + if (a > 0) { + d.y = g; + d.height = a + f + } else { + d.y = g + f; + d.height = a - f + } + }, + render: function(l, m) { + var u = this, + k = u.attr, + r = k.x, + j = k.y, + f = j + k.height, + i = j < f, + e = k.width * 0.5, + v = k.depth, + d = k.orientation === "horizontal", + g = k.globalAlpha < 1, + c = k.fillStyle, + n = Ext.draw.Color.create(c.isGradient ? c.getStops()[0].color : c), + h = k.saturationFactor, + o = k.brightnessFactor, + t = k.colorSpread, + b = n.getHSV(), + a = {}, + s, q, p; + if (!k.showStroke) { + m.strokeStyle = Ext.draw.Color.RGBA_NONE + } + if (i) { + p = j; + j = f; + f = p + } + u.topGradient.setDegrees(d ? 0 : 80); + u.topGradient.setStops([{ + offset: 0, + color: Ext.draw.Color.fromHSV(b[0], Ext.Number.constrain(b[1] * h, 0, 1), Ext.Number.constrain((0.5 + t * 0.1) * o, 0, 1)) + }, { + offset: 1, + color: Ext.draw.Color.fromHSV(b[0], Ext.Number.constrain(b[1] * h, 0, 1), Ext.Number.constrain((0.5 - t * 0.11) * o, 0, 1)) + }]); + u.rightGradient.setDegrees(d ? 45 : 90); + u.rightGradient.setStops([{ + offset: 0, + color: Ext.draw.Color.fromHSV(b[0], Ext.Number.constrain(b[1] * h, 0, 1), Ext.Number.constrain((0.5 - t * 0.14) * o, 0, 1)) + }, { + offset: 1, + color: Ext.draw.Color.fromHSV(b[0], Ext.Number.constrain(b[1] * (1 + t * 0.4) * h, 0, 1), Ext.Number.constrain((0.5 - t * 0.32) * o, 0, 1)) + }]); + if (d) { + u.frontGradient.setDegrees(0) + } else { + u.frontGradient.setRadians(Math.atan2(j - f, e * 2)) + } + u.frontGradient.setStops([{ + offset: 0, + color: Ext.draw.Color.fromHSV(b[0], Ext.Number.constrain(b[1] * (1 - t * 0.1) * h, 0, 1), Ext.Number.constrain((0.5 + t * 0.1) * o, 0, 1)) + }, { + offset: 1, + color: Ext.draw.Color.fromHSV(b[0], Ext.Number.constrain(b[1] * (1 + t * 0.1) * h, 0, 1), Ext.Number.constrain((0.5 - t * 0.23) * o, 0, 1)) + }]); + if (g || i) { + m.beginPath(); + m.moveTo(r - e, f); + m.lineTo(r - e + v, f + v); + m.lineTo(r + e + v, f + v); + m.lineTo(r + e, f); + m.closePath(); + a.x = r - e; + a.y = j; + a.width = e + v; + a.height = v; + m.fillStyle = (d ? u.rightGradient : u.topGradient).generateGradient(m, a); + m.fillStroke(k) + } + if (g) { + m.beginPath(); + m.moveTo(r - e, j); + m.lineTo(r - e + v, j + v); + m.lineTo(r - e + v, f + v); + m.lineTo(r - e, f); + m.closePath(); + a.x = r + e; + a.y = f; + a.width = v; + a.height = j + v - f; + m.fillStyle = (d ? u.topGradient : u.rightGradient).generateGradient(m, a); + m.fillStroke(k) + } + q = l.roundPixel(j); + m.beginPath(); + m.moveTo(r - e, q); + m.lineTo(r - e + v, j + v); + m.lineTo(r + e + v, j + v); + m.lineTo(r + e, q); + m.closePath(); + a.x = r - e; + a.y = j; + a.width = e + v; + a.height = v; + m.fillStyle = (d ? u.rightGradient : u.topGradient).generateGradient(m, a); + m.fillStroke(k); + s = l.roundPixel(r + e); + m.beginPath(); + m.moveTo(s, l.roundPixel(j)); + m.lineTo(r + e + v, j + v); + m.lineTo(r + e + v, f + v); + m.lineTo(s, f); + m.closePath(); + a.x = r + e; + a.y = f; + a.width = v; + a.height = j + v - f; + m.fillStyle = (d ? u.topGradient : u.rightGradient).generateGradient(m, a); + m.fillStroke(k); + s = l.roundPixel(r + e); + q = l.roundPixel(j); + m.beginPath(); + m.moveTo(r - e, f); + m.lineTo(r - e, q); + m.lineTo(s, q); + m.lineTo(s, f); + m.closePath(); + a.x = r - e; + a.y = f; + a.width = e * 2; + a.height = j - f; + m.fillStyle = u.frontGradient.generateGradient(m, a); + m.fillStroke(k) + } +}); +Ext.define("Ext.chart.series.Bar3D", { + extend: "Ext.chart.series.Bar", + requires: ["Ext.chart.series.sprite.Bar3D", "Ext.chart.series.sprite.Box"], + alias: "series.bar3d", + type: "bar3d", + seriesType: "bar3dSeries", + config: { + itemInstancing: { + type: "box", + fx: { + customDurations: { + x: 0, + y: 0, + width: 0, + height: 0, + depth: 0 + } + } + }, + highlightCfg: { + opacity: 0.8 + } + }, + getSprites: function() { + var c = this.callParent(arguments), + b, d, a; + for (a = 0; a < c.length; a++) { + b = c[a]; + d = b.attr.zIndex; + if (d < 0) { + b.setAttributes({ + zIndex: -d + }) + } + if (b.setSeries) { + b.setSeries(this) + } + } + return c + }, + getDepth: function() { + var a = this.getSprites()[0]; + return a ? (a.depth || 0) : 0 + }, + getItemForPoint: function(m, k) { + if (this.getSprites()) { + var j = this, + b, o, a = j.getItemInstancing(), + h = j.getSprites(), + n = j.getStore(), + c = j.getHidden(), + g = j.getChart(), + l = g.getInnerPadding(), + f = g.getInherited().rtl, + p, d, e; + m = m + (f ? l.right : -l.left); + k = k + l.bottom; + for (b = h.length - 1; b >= 0; b--) { + if (!c[b]) { + o = h[b]; + d = o.getIndexNearPoint(m, k); + if (d !== -1) { + e = j.getYField(); + p = { + series: j, + index: d, + category: a ? "items" : "markers", + record: n.getData().items[d], + field: typeof e === "string" ? e : e[b], + sprite: o + }; + return p + } + } + } + return null + } + } +}); +Ext.define("Ext.draw.LimitedCache", { + config: { + limit: 40, + feeder: function() { + return 0 + }, + scope: null + }, + cache: null, + constructor: function(a) { + this.cache = {}; + this.cache.list = []; + this.cache.tail = 0; + this.initConfig(a) + }, + get: function(e) { + var c = this.cache, + b = this.getLimit(), + a = this.getFeeder(), + d = this.getScope() || this; + if (c[e]) { + return c[e].value + } + if (c.list[c.tail]) { + delete c[c.list[c.tail].cacheId] + } + c[e] = c.list[c.tail] = { + value: a.apply(d, Array.prototype.slice.call(arguments, 1)), + cacheId: e + }; + c.tail++; + if (c.tail === b) { + c.tail = 0 + } + return c[e].value + }, + clear: function() { + this.cache = {}; + this.cache.list = []; + this.cache.tail = 0 + } +}); +Ext.define("Ext.draw.SegmentTree", { + config: { + strategy: "double" + }, + time: function(m, l, n, c, E, d, e) { + var f = 0, + o, A, s = new Date(n[m.startIdx[0]]), + x = new Date(n[m.endIdx[l - 1]]), + D = Ext.Date, + u = [ + [D.MILLI, 1, "ms1", null], + [D.MILLI, 2, "ms2", "ms1"], + [D.MILLI, 5, "ms5", "ms1"], + [D.MILLI, 10, "ms10", "ms5"], + [D.MILLI, 50, "ms50", "ms10"], + [D.MILLI, 100, "ms100", "ms50"], + [D.MILLI, 500, "ms500", "ms100"], + [D.SECOND, 1, "s1", "ms500"], + [D.SECOND, 10, "s10", "s1"], + [D.SECOND, 30, "s30", "s10"], + [D.MINUTE, 1, "mi1", "s10"], + [D.MINUTE, 5, "mi5", "mi1"], + [D.MINUTE, 10, "mi10", "mi5"], + [D.MINUTE, 30, "mi30", "mi10"], + [D.HOUR, 1, "h1", "mi30"], + [D.HOUR, 6, "h6", "h1"], + [D.HOUR, 12, "h12", "h6"], + [D.DAY, 1, "d1", "h12"], + [D.DAY, 7, "d7", "d1"], + [D.MONTH, 1, "mo1", "d1"], + [D.MONTH, 3, "mo3", "mo1"], + [D.MONTH, 6, "mo6", "mo3"], + [D.YEAR, 1, "y1", "mo3"], + [D.YEAR, 5, "y5", "y1"], + [D.YEAR, 10, "y10", "y5"], + [D.YEAR, 100, "y100", "y10"] + ], + z, b, k = f, + F = l, + j = false, + r = m.startIdx, + h = m.endIdx, + w = m.minIdx, + C = m.maxIdx, + a = m.open, + y = m.close, + g = m.minX, + q = m.minY, + p = m.maxX, + B = m.maxY, + v, t; + for (z = 0; l > f + 1 && z < u.length; z++) { + s = new Date(n[r[0]]); + b = u[z]; + s = D.align(s, b[0], b[1]); + if (D.diff(s, x, b[0]) > n.length * 2 * b[1]) { + continue + } + if (b[3] && m.map["time_" + b[3]]) { + o = m.map["time_" + b[3]][0]; + A = m.map["time_" + b[3]][1] + } else { + o = k; + A = F + } + f = l; + t = s; + j = true; + r[l] = r[o]; + h[l] = h[o]; + w[l] = w[o]; + C[l] = C[o]; + a[l] = a[o]; + y[l] = y[o]; + g[l] = g[o]; + q[l] = q[o]; + p[l] = p[o]; + B[l] = B[o]; + t = Ext.Date.add(t, b[0], b[1]); + for (v = o + 1; v < A; v++) { + if (n[h[v]] < +t) { + h[l] = h[v]; + y[l] = y[v]; + if (B[v] > B[l]) { + B[l] = B[v]; + p[l] = p[v]; + C[l] = C[v] + } + if (q[v] < q[l]) { + q[l] = q[v]; + g[l] = g[v]; + w[l] = w[v] + } + } else { + l++; + r[l] = r[v]; + h[l] = h[v]; + w[l] = w[v]; + C[l] = C[v]; + a[l] = a[v]; + y[l] = y[v]; + g[l] = g[v]; + q[l] = q[v]; + p[l] = p[v]; + B[l] = B[v]; + t = Ext.Date.add(t, b[0], b[1]) + } + } + if (l > f) { + m.map["time_" + b[2]] = [f, l] + } + } + }, + "double": function(h, u, j, a, t, b, c) { + var e = 0, + k, f = 1, + n, d, v, g, s, l, m, r, q, p, o; + while (u > e + 1) { + k = e; + e = u; + f += f; + for (n = k; n < e; n += 2) { + if (n === e - 1) { + d = h.startIdx[n]; + v = h.endIdx[n]; + g = h.minIdx[n]; + s = h.maxIdx[n]; + l = h.open[n]; + m = h.close[n]; + r = h.minX[n]; + q = h.minY[n]; + p = h.maxX[n]; + o = h.maxY[n] + } else { + d = h.startIdx[n]; + v = h.endIdx[n + 1]; + l = h.open[n]; + m = h.close[n]; + if (h.minY[n] <= h.minY[n + 1]) { + g = h.minIdx[n]; + r = h.minX[n]; + q = h.minY[n] + } else { + g = h.minIdx[n + 1]; + r = h.minX[n + 1]; + q = h.minY[n + 1] + } + if (h.maxY[n] >= h.maxY[n + 1]) { + s = h.maxIdx[n]; + p = h.maxX[n]; + o = h.maxY[n] + } else { + s = h.maxIdx[n + 1]; + p = h.maxX[n + 1]; + o = h.maxY[n + 1] + } + } + h.startIdx[u] = d; + h.endIdx[u] = v; + h.minIdx[u] = g; + h.maxIdx[u] = s; + h.open[u] = l; + h.close[u] = m; + h.minX[u] = r; + h.minY[u] = q; + h.maxX[u] = p; + h.maxY[u] = o; + u++ + } + h.map["double_" + f] = [e, u] + } + }, + none: Ext.emptyFn, + aggregateData: function(h, a, r, c, d) { + var b = h.length, + e = [], + s = [], + f = [], + q = [], + j = [], + p = [], + n = [], + o = [], + m = [], + k = [], + g = { + startIdx: e, + endIdx: s, + minIdx: f, + maxIdx: q, + open: j, + minX: p, + minY: n, + maxX: o, + maxY: m, + close: k + }, + l; + for (l = 0; l < b; l++) { + e[l] = l; + s[l] = l; + f[l] = l; + q[l] = l; + j[l] = a[l]; + p[l] = h[l]; + n[l] = c[l]; + o[l] = h[l]; + m[l] = r[l]; + k[l] = d[l] + } + g.map = { + original: [0, b] + }; + if (b) { + this[this.getStrategy()](g, b, h, a, r, c, d) + } + return g + }, + binarySearchMin: function(c, g, a, e) { + var b = this.dataX; + if (e <= b[c.startIdx[0]]) { + return g + } + if (e >= b[c.startIdx[a - 1]]) { + return a - 1 + } + while (g + 1 < a) { + var d = (g + a) >> 1, + f = b[c.startIdx[d]]; + if (f === e) { + return d + } else { + if (f < e) { + g = d + } else { + a = d + } + } + } + return g + }, + binarySearchMax: function(c, g, a, e) { + var b = this.dataX; + if (e <= b[c.endIdx[0]]) { + return g + } + if (e >= b[c.endIdx[a - 1]]) { + return a - 1 + } + while (g + 1 < a) { + var d = (g + a) >> 1, + f = b[c.endIdx[d]]; + if (f === e) { + return d + } else { + if (f < e) { + g = d + } else { + a = d + } + } + } + return a + }, + constructor: function(a) { + this.initConfig(a) + }, + setData: function(d, a, b, c, e) { + if (!b) { + e = c = b = a + } + this.dataX = d; + this.dataOpen = a; + this.dataHigh = b; + this.dataLow = c; + this.dataClose = e; + if (d.length === b.length && d.length === c.length) { + this.cache = this.aggregateData(d, a, b, c, e) + } + }, + getAggregation: function(d, k, i) { + if (!this.cache) { + return null + } + var c = Infinity, + g = this.dataX[this.dataX.length - 1] - this.dataX[0], + l = this.cache.map, + m = l.original, + a, e, j, b, f, h; + for (a in l) { + e = l[a]; + j = e[1] - e[0] - 1; + b = g / j; + if (i <= b && b < c) { + m = e; + c = b + } + } + f = Math.max(this.binarySearchMin(this.cache, m[0], m[1], d), m[0]); + h = Math.min(this.binarySearchMax(this.cache, m[0], m[1], k) + 1, m[1]); + return { + data: this.cache, + start: f, + end: h + } + } +}); +Ext.define("Ext.chart.series.sprite.Aggregative", { + extend: "Ext.chart.series.sprite.Cartesian", + requires: ["Ext.draw.LimitedCache", "Ext.draw.SegmentTree"], + inheritableStatics: { + def: { + processors: { + dataHigh: "data", + dataLow: "data", + dataClose: "data" + }, + aliases: { + dataOpen: "dataY" + }, + defaults: { + dataHigh: null, + dataLow: null, + dataClose: null + } + } + }, + config: { + aggregator: {} + }, + applyAggregator: function(b, a) { + return Ext.factory(b, Ext.draw.SegmentTree, a) + }, + constructor: function() { + this.callParent(arguments) + }, + processDataY: function() { + var d = this, + b = d.attr, + e = b.dataHigh, + a = b.dataLow, + f = b.dataClose, + c = b.dataY; + d.callParent(arguments); + if (b.dataX && c && c.length > 0) { + if (e) { + d.getAggregator().setData(b.dataX, b.dataY, e, a, f) + } else { + d.getAggregator().setData(b.dataX, b.dataY) + } + } + }, + getGapWidth: function() { + return 1 + }, + renderClipped: function(b, c, g, f) { + var e = this, + d = Math.min(g[0], g[2]), + a = Math.max(g[0], g[2]), + h = e.getAggregator() && e.getAggregator().getAggregation(d, a, (a - d) / f[2] * e.getGapWidth()); + if (h) { + e.dataStart = h.data.startIdx[h.start]; + e.dataEnd = h.data.endIdx[h.end - 1]; + e.renderAggregates(h.data, h.start, h.end, b, c, g, f) + } + } +}); +Ext.define("Ext.chart.series.sprite.CandleStick", { + alias: "sprite.candlestickSeries", + extend: "Ext.chart.series.sprite.Aggregative", + inheritableStatics: { + def: { + processors: { + raiseStyle: function(b, a) { + return Ext.merge({}, a || {}, b) + }, + dropStyle: function(b, a) { + return Ext.merge({}, a || {}, b) + }, + barWidth: "number", + padding: "number", + ohlcType: "enums(candlestick,ohlc)" + }, + defaults: { + raiseStyle: { + strokeStyle: "green", + fillStyle: "green" + }, + dropStyle: { + strokeStyle: "red", + fillStyle: "red" + }, + planar: false, + barWidth: 15, + padding: 3, + lineJoin: "miter", + miterLimit: 5, + ohlcType: "candlestick" + }, + triggers: { + raiseStyle: "raiseStyle", + dropStyle: "dropStyle" + }, + updaters: { + raiseStyle: function() { + this.raiseTemplate && this.raiseTemplate.setAttributes(this.attr.raiseStyle) + }, + dropStyle: function() { + this.dropTemplate && this.dropTemplate.setAttributes(this.attr.dropStyle) + } + } + } + }, + candlestick: function(i, c, a, e, h, f, b) { + var d = Math.min(c, h), + g = Math.max(c, h); + i.moveTo(f, e); + i.lineTo(f, g); + i.moveTo(f + b, g); + i.lineTo(f + b, d); + i.lineTo(f - b, d); + i.lineTo(f - b, g); + i.closePath(); + i.moveTo(f, a); + i.lineTo(f, d) + }, + ohlc: function(b, d, e, a, f, c, g) { + b.moveTo(c, e); + b.lineTo(c, a); + b.moveTo(c, d); + b.lineTo(c - g, d); + b.moveTo(c, f); + b.lineTo(c + g, f) + }, + constructor: function() { + this.callParent(arguments); + this.raiseTemplate = new Ext.draw.sprite.Rect({ + parent: this + }); + this.dropTemplate = new Ext.draw.sprite.Rect({ + parent: this + }) + }, + getGapWidth: function() { + var a = this.attr, + b = a.barWidth, + c = a.padding; + return b + c + }, + renderAggregates: function(d, c, b, t, u, z) { + var D = this, + s = this.attr, + j = s.dataX, + v = s.matrix, + e = v.getXX(), + r = v.getYY(), + l = v.getDX(), + h = v.getDY(), + o = s.barWidth / e, + C, k = s.ohlcType, + f = Math.round(o * 0.5 * e), + a = d.open, + y = d.close, + B = d.maxY, + p = d.minY, + q = d.startIdx, + m, g, E, n, A, x, w = s.lineWidth * t.devicePixelRatio / 2; + w -= Math.floor(w); + u.save(); + C = this.raiseTemplate; + C.useAttributes(u, z); + u.beginPath(); + for (x = c; x < b; x++) { + if (a[x] <= y[x]) { + m = Math.round(a[x] * r + h) + w; + g = Math.round(B[x] * r + h) + w; + E = Math.round(p[x] * r + h) + w; + n = Math.round(y[x] * r + h) + w; + A = Math.round(j[q[x]] * e + l) + w; + D[k](u, m, g, E, n, A, f) + } + } + u.fillStroke(C.attr); + u.restore(); + u.save(); + C = this.dropTemplate; + C.useAttributes(u, z); + u.beginPath(); + for (x = c; x < b; x++) { + if (a[x] > y[x]) { + m = Math.round(a[x] * r + h) + w; + g = Math.round(B[x] * r + h) + w; + E = Math.round(p[x] * r + h) + w; + n = Math.round(y[x] * r + h) + w; + A = Math.round(j[q[x]] * e + l) + w; + D[k](u, m, g, E, n, A, f) + } + } + u.fillStroke(C.attr); + u.restore() + } +}); +Ext.define("Ext.chart.series.CandleStick", { + extend: "Ext.chart.series.Cartesian", + requires: ["Ext.chart.series.sprite.CandleStick"], + alias: "series.candlestick", + type: "candlestick", + seriesType: "candlestickSeries", + config: { + openField: null, + highField: null, + lowField: null, + closeField: null + }, + fieldCategoryY: ["Open", "High", "Low", "Close"], + themeColorCount: function() { + return 2 + } +}); +Ext.define("Ext.chart.series.Polar", { + extend: "Ext.chart.series.Series", + config: { + rotation: 0, + radius: null, + center: [0, 0], + offsetX: 0, + offsetY: 0, + showInLegend: true, + xField: null, + yField: null, + angleField: null, + radiusField: null, + xAxis: null, + yAxis: null + }, + directions: ["X", "Y"], + fieldCategoryX: ["X"], + fieldCategoryY: ["Y"], + deprecatedConfigs: { + field: "angleField", + lengthField: "radiusField" + }, + constructor: function(b) { + var c = this, + a = c.getConfigurator(), + e = a.configs, + d; + if (b) { + for (d in c.deprecatedConfigs) { + if (d in b && !(b in e)) { + Ext.raise("'" + d + "' config has been deprecated. Please use the '" + c.deprecatedConfigs[d] + "' config instead.") + } + } + } + c.callParent([b]) + }, + getXField: function() { + return this.getAngleField() + }, + updateXField: function(a) { + this.setAngleField(a) + }, + getYField: function() { + return this.getRadiusField() + }, + updateYField: function(a) { + this.setRadiusField(a) + }, + applyXAxis: function(a, b) { + return this.getChart().getAxis(a) || b + }, + applyYAxis: function(a, b) { + return this.getChart().getAxis(a) || b + }, + getXRange: function() { + return [this.dataRange[0], this.dataRange[2]] + }, + getYRange: function() { + return [this.dataRange[1], this.dataRange[3]] + }, + themeColorCount: function() { + var c = this, + a = c.getStore(), + b = a && a.getCount() || 0; + return b + }, + isStoreDependantColorCount: true, + getDefaultSpriteConfig: function() { + return { + type: this.seriesType, + renderer: this.getRenderer(), + centerX: 0, + centerY: 0, + rotationCenterX: 0, + rotationCenterY: 0 + } + }, + applyRotation: function(a) { + return Ext.draw.sprite.AttributeParser.angle(a) + }, + updateRotation: function(a) { + var b = this.getSprites(); + if (b && b[0]) { + b[0].setAttributes({ + baseRotation: a + }) + } + } +}); +Ext.define("Ext.chart.series.Gauge", { + alias: "series.gauge", + extend: "Ext.chart.series.Polar", + type: "gauge", + seriesType: "pieslice", + requires: ["Ext.draw.sprite.Sector"], + config: { + needle: false, + needleLength: 90, + needleWidth: 4, + donut: 30, + showInLegend: false, + value: null, + colors: null, + sectors: null, + minimum: 0, + maximum: 100, + rotation: 0, + totalAngle: Math.PI / 2, + rect: [0, 0, 1, 1], + center: [0.5, 0.75], + radius: 0.5, + wholeDisk: false + }, + coordinateX: function() { + return this.coordinate("X", 0, 2) + }, + coordinateY: function() { + return this.coordinate("Y", 1, 2) + }, + updateNeedle: function(b) { + var a = this, + d = a.getSprites(), + c = a.valueToAngle(a.getValue()); + if (d && d.length) { + d[0].setAttributes({ + startAngle: (b ? c : 0), + endAngle: c, + strokeOpacity: (b ? 1 : 0), + lineWidth: (b ? a.getNeedleWidth() : 0) + }); + a.doUpdateStyles() + } + }, + themeColorCount: function() { + var c = this, + a = c.getStore(), + b = a && a.getCount() || 0; + return b + (c.getNeedle() ? 0 : 1) + }, + updateColors: function(a, b) { + var f = this, + h = f.getSectors(), + j = h && h.length, + e = f.getSprites(), + c = Ext.Array.clone(a), + g = a && a.length, + d; + if (!g || !a[0]) { + return + } + for (d = 0; d < j; d++) { + c[d + 1] = h[d].color || c[d + 1] || a[d % g] + } + if (e.length) { + e[0].setAttributes({ + strokeStyle: c[0] + }) + } + this.setSubStyle({ + fillStyle: c, + strokeStyle: c + }); + this.doUpdateStyles() + }, + updateRect: function(f) { + var d = this.getWholeDisk(), + c = d ? Math.PI : this.getTotalAngle() / 2, + g = this.getDonut() / 100, + e, b, a; + if (c <= Math.PI / 2) { + e = 2 * Math.sin(c); + b = 1 - g * Math.cos(c) + } else { + e = 2; + b = 1 - Math.cos(c) + } + a = Math.min(f[2] / e, f[3] / b); + this.setRadius(a); + this.setCenter([f[2] / 2, a + (f[3] - b * a) / 2]) + }, + updateCenter: function(a) { + this.setStyle({ + centerX: a[0], + centerY: a[1], + rotationCenterX: a[0], + rotationCenterY: a[1] + }); + this.doUpdateStyles() + }, + updateRotation: function(a) { + this.setStyle({ + rotationRads: a - (this.getTotalAngle() + Math.PI) / 2 + }); + this.doUpdateStyles() + }, + doUpdateShape: function(b, f) { + var a, d = this.getSectors(), + c = (d && d.length) || 0, + e = this.getNeedleLength() / 100; + a = [b * e, b]; + while (c--) { + a.push(b) + } + this.setSubStyle({ + endRho: a, + startRho: b / 100 * f + }); + this.doUpdateStyles() + }, + updateRadius: function(a) { + var b = this.getDonut(); + this.doUpdateShape(a, b) + }, + updateDonut: function(b) { + var a = this.getRadius(); + this.doUpdateShape(a, b) + }, + valueToAngle: function(a) { + a = this.applyValue(a); + return this.getTotalAngle() * (a - this.getMinimum()) / (this.getMaximum() - this.getMinimum()) + }, + applyValue: function(a) { + return Math.min(this.getMaximum(), Math.max(a, this.getMinimum())) + }, + updateValue: function(b) { + var a = this, + c = a.getNeedle(), + e = a.valueToAngle(b), + d = a.getSprites(); + d[0].rendererData.value = b; + d[0].setAttributes({ + startAngle: (c ? e : 0), + endAngle: e + }); + a.doUpdateStyles() + }, + processData: function() { + var f = this, + j = f.getStore(), + a, d, h, b, g, e = j && j.first(), + c, i; + if (e) { + c = f.getXField(); + if (c) { + i = e.get(c) + } + } + if (a = f.getXAxis()) { + d = a.getMinimum(); + h = a.getMaximum(); + b = a.getSprites()[0].fx; + g = b.getDuration(); + b.setDuration(0); + if (Ext.isNumber(d)) { + f.setMinimum(d) + } else { + a.setMinimum(f.getMinimum()) + } + if (Ext.isNumber(h)) { + f.setMaximum(h) + } else { + a.setMaximum(f.getMaximum()) + } + b.setDuration(g) + } + if (!Ext.isNumber(i)) { + i = f.getMinimum() + } + f.setValue(i) + }, + getDefaultSpriteConfig: function() { + return { + type: this.seriesType, + renderer: this.getRenderer(), + fx: { + customDurations: { + translationX: 0, + translationY: 0, + rotationCenterX: 0, + rotationCenterY: 0, + centerX: 0, + centerY: 0, + startRho: 0, + endRho: 0, + baseRotation: 0 + } + } + } + }, + normalizeSectors: function(f) { + var d = this, + c = (f && f.length) || 0, + b, e, g, a; + if (c) { + for (b = 0; b < c; b++) { + e = f[b]; + if (typeof e === "number") { + f[b] = { + start: (b > 0 ? f[b - 1].end : d.getMinimum()), + end: Math.min(e, d.getMaximum()) + }; + if (b == (c - 1) && f[b].end < d.getMaximum()) { + f[b + 1] = { + start: f[b].end, + end: d.getMaximum() + } + } + } else { + if (typeof e.start === "number") { + g = Math.max(e.start, d.getMinimum()) + } else { + g = (b > 0 ? f[b - 1].end : d.getMinimum()) + } + if (typeof e.end === "number") { + a = Math.min(e.end, d.getMaximum()) + } else { + a = d.getMaximum() + } + f[b].start = g; + f[b].end = a + } + } + } else { + f = [{ + start: d.getMinimum(), + end: d.getMaximum() + }] + } + return f + }, + getSprites: function() { + var j = this, + m = j.getStore(), + l = j.getValue(), + c, g; + if (!m && !Ext.isNumber(l)) { + return [] + } + var h = j.getChart(), + b = j.getAnimation() || h && h.getAnimation(), + f = j.sprites, + k = 0, + o, n, e, d, a = []; + if (f && f.length) { + f[0].setAnimation(b); + return f + } + d = { + store: m, + field: j.getXField(), + angleField: j.getXField(), + value: l, + series: j + }; + o = j.createSprite(); + o.setAttributes({ + zIndex: 10 + }, true); + o.rendererData = d; + o.rendererIndex = k++; + a.push(j.getNeedleWidth()); + j.getLabel().getTemplate().setField(true); + n = j.normalizeSectors(j.getSectors()); + for (c = 0, g = n.length; c < g; c++) { + e = { + startAngle: j.valueToAngle(n[c].start), + endAngle: j.valueToAngle(n[c].end), + label: n[c].label, + fillStyle: n[c].color, + strokeOpacity: 0, + doCallout: false, + labelOverflowPadding: -1 + }; + Ext.apply(e, n[c].style); + o = j.createSprite(); + o.rendererData = d; + o.rendererIndex = k++; + o.setAttributes(e, true); + a.push(e.lineWidth) + } + j.setSubStyle({ + lineWidth: a + }); + j.doUpdateStyles(); + return f + } +}); +Ext.define("Ext.chart.series.sprite.Line", { + alias: "sprite.lineSeries", + extend: "Ext.chart.series.sprite.Aggregative", + inheritableStatics: { + def: { + processors: { + smooth: "bool", + fillArea: "bool", + step: "bool", + preciseStroke: "bool", + xAxis: "default", + yCap: "default" + }, + defaults: { + smooth: false, + fillArea: false, + step: false, + preciseStroke: true, + xAxis: null, + yCap: Math.pow(2, 20), + yJump: 50 + }, + triggers: { + dataX: "dataX,bbox,smooth", + dataY: "dataY,bbox,smooth", + smooth: "smooth" + }, + updaters: { + smooth: function(a) { + var c = a.dataX, + b = a.dataY; + if (a.smooth && c && b && c.length > 2 && b.length > 2) { + this.smoothX = Ext.draw.Draw.spline(c); + this.smoothY = Ext.draw.Draw.spline(b) + } else { + delete this.smoothX; + delete this.smoothY + } + } + } + } + }, + list: null, + updatePlainBBox: function(d) { + var b = this.attr, + c = Math.min(0, b.dataMinY), + a = Math.max(0, b.dataMaxY); + d.x = b.dataMinX; + d.y = c; + d.width = b.dataMaxX - b.dataMinX; + d.height = a - c + }, + drawStrip: function(a, c) { + a.moveTo(c[0], c[1]); + for (var b = 2, d = c.length; b < d; b += 2) { + a.lineTo(c[b], c[b + 1]) + } + }, + drawStraightStroke: function(p, q, e, d, u, h) { + var w = this, + o = w.attr, + n = o.renderer, + g = o.step, + a = true, + l = { + type: "line", + smooth: false, + step: g + }, + m = [], + l, z, v, f, k, j, t, c, s, b, r; + for (r = 3; r < u.length; r += 3) { + t = u[r - 3]; + c = u[r - 2]; + k = u[r]; + j = u[r + 1]; + s = u[r + 3]; + b = u[r + 4]; + if (n) { + l.x = k; + l.y = j; + l.x0 = t; + l.y0 = c; + v = [w, l, w.rendererData, e + r / 3]; + z = Ext.callback(n, null, v, 0, w.getSeries()) + } + if (Ext.isNumber(k + j + t + c)) { + if (a) { + q.beginPath(); + q.moveTo(t, c); + m.push(t, c); + f = t; + a = false + } + } else { + continue + } + if (g) { + q.lineTo(k, c); + m.push(k, c) + } + q.lineTo(k, j); + m.push(k, j); + if (z || !(Ext.isNumber(s + b))) { + q.save(); + Ext.apply(q, z); + if (o.fillArea) { + q.lineTo(k, h); + q.lineTo(f, h); + q.closePath(); + q.fill() + } + q.beginPath(); + w.drawStrip(q, m); + m = []; + q.stroke(); + q.restore(); + q.beginPath(); + a = true + } + } + }, + calculateScale: function(c, a) { + var b = 0, + d = c; + while (d < a && c > 0) { + b++; + d += c >> b + } + return Math.pow(2, b > 0 ? b - 1 : b) + }, + drawSmoothStroke: function(u, v, c, b, C, f) { + var G = this, + t = G.attr, + d = t.step, + z = t.matrix, + s = t.renderer, + e = z.getXX(), + p = z.getYY(), + m = z.getDX(), + k = z.getDY(), + r = G.smoothX, + q = G.smoothY, + I = G.calculateScale(t.dataX.length, b), + o, F, n, E, h, g, B, a, A, w, H, D, l = { + type: "line", + smooth: true, + step: d + }; + v.beginPath(); + v.moveTo(r[c * 3] * e + m, q[c * 3] * p + k); + for (A = 0, w = c * 3 + 1; A < C.length - 3; A += 3, w += 3 * I) { + o = r[w] * e + m; + F = q[w] * p + k; + n = r[w + 1] * e + m; + E = q[w + 1] * p + k; + h = u.roundPixel(C[A + 3]); + g = C[A + 4]; + B = u.roundPixel(C[A]); + a = C[A + 1]; + if (s) { + l.x0 = B; + l.y0 = a; + l.cx1 = o; + l.cy1 = F; + l.cx2 = n; + l.cy2 = E; + l.x = h; + l.y = g; + D = [G, l, G.rendererData, c + A / 3 + 1]; + H = Ext.callback(s, null, D, 0, G.getSeries()); + v.save(); + Ext.apply(v, H) + } + if (t.fillArea) { + v.moveTo(B, a); + v.bezierCurveTo(o, F, n, E, h, g); + v.lineTo(h, f); + v.lineTo(B, f); + v.lineTo(B, a); + v.closePath(); + v.fill(); + v.beginPath() + } + v.moveTo(B, a); + v.bezierCurveTo(o, F, n, E, h, g); + v.stroke(); + v.moveTo(B, a); + v.closePath(); + if (s) { + v.restore() + } + v.beginPath(); + v.moveTo(h, g) + } + v.beginPath() + }, + drawLabel: function(k, i, h, o, a) { + var q = this, + n = q.attr, + e = q.getMarker("labels"), + d = e.getTemplate(), + m = q.labelCfg || (q.labelCfg = {}), + c = q.surfaceMatrix, + g, f, j = n.labelOverflowPadding, + l, b, r, p, s; + m.x = c.x(i, h); + m.y = c.y(i, h); + if (n.flipXY) { + m.rotationRads = Math.PI * 0.5 + } else { + m.rotationRads = 0 + } + m.text = k; + if (d.attr.renderer) { + p = [k, e, m, q.rendererData, o]; + r = Ext.callback(d.attr.renderer, null, p, 0, q.getSeries()); + if (typeof r === "string") { + m.text = r + } else { + if (typeof r === "object") { + if ("text" in r) { + m.text = r.text + } + s = true + } + } + } + b = q.getMarkerBBox("labels", o, true); + if (!b) { + q.putMarker("labels", m, o); + b = q.getMarkerBBox("labels", o, true) + } + l = b.height / 2; + g = i; + switch (d.attr.display) { + case "under": + f = h - l - j; + break; + case "rotate": + g += j; + f = h - j; + m.rotationRads = -Math.PI / 4; + break; + default: + f = h + l + j + } + m.x = c.x(g, f); + m.y = c.y(g, f); + if (s) { + Ext.apply(m, r) + } + q.putMarker("labels", m, o) + }, + drawMarker: function(j, h, d) { + var g = this, + e = g.attr, + f = e.renderer, + c = g.surfaceMatrix, + b = {}, + i, a; + if (f && g.getMarker("markers")) { + b.type = "marker"; + b.x = j; + b.y = h; + a = [g, b, g.rendererData, d]; + i = Ext.callback(f, null, a, 0, g.getSeries()); + if (i) { + Ext.apply(b, i) + } + } + b.translationX = c.x(j, h); + b.translationY = c.y(j, h); + delete b.x; + delete b.y; + g.putMarker("markers", b, d, !f) + }, + drawStroke: function(a, c, h, b, f, e) { + var d = this, + g = d.attr.smooth && d.smoothX && d.smoothY; + if (g) { + d.drawSmoothStroke(a, c, h, b, f, e) + } else { + d.drawStraightStroke(a, c, h, b, f, e) + } + }, + renderAggregates: function(B, w, l, N, o, I, D) { + var m = this, + k = m.attr, + s = k.dataX, + r = k.dataY, + h = k.labels, + v = k.xAxis, + a = k.yCap, + g = k.smooth && m.smoothX && m.smoothY, + d = h && m.getMarker("labels"), + t = m.getMarker("markers"), + E = k.matrix, + u = N.devicePixelRatio, + C = E.getXX(), + f = E.getYY(), + c = E.getDX(), + b = E.getDY(), + q = m.list || (m.list = []), + F = B.minX, + e = B.maxX, + j = B.minY, + P = B.maxY, + U = B.startIdx, + S = true, + Q, T, L, K, R, G; + m.rendererData = { + store: m.getStore() + }; + q.length = 0; + for (R = w; R < l; R++) { + var O = F[R], + p = e[R], + M = j[R], + n = P[R]; + if (O < p) { + q.push(O * C + c, M * f + b, U[R]); + q.push(p * C + c, n * f + b, U[R]) + } else { + if (O > p) { + q.push(p * C + c, n * f + b, U[R]); + q.push(O * C + c, M * f + b, U[R]) + } else { + q.push(p * C + c, n * f + b, U[R]) + } + } + } + if (q.length) { + for (R = 0; R < q.length; R += 3) { + L = q[R]; + K = q[R + 1]; + if (Ext.isNumber(L + K)) { + if (K > a) { + K = a + } else { + if (K < -a) { + K = -a + } + } + q[R + 1] = K + } else { + S = false; + continue + } + G = q[R + 2]; + if (t) { + m.drawMarker(L, K, G) + } + if (d && h[G]) { + m.drawLabel(h[G], L, K, G, D) + } + } + m.isContinuousLine = S; + if (g && !S) { + Ext.raise("Line smoothing in only supported for gapless data, where all data points are finite numbers.") + } + if (v) { + T = v.getAlignment() === "vertical"; + if (Ext.isNumber(v.floatingAtCoord)) { + Q = (T ? D[2] : D[3]) - v.floatingAtCoord + } else { + Q = T ? D[0] : D[1] + } + } else { + Q = k.flipXY ? D[0] : D[1] + } + if (k.preciseStroke) { + if (k.fillArea) { + o.fill() + } + if (k.transformFillStroke) { + k.inverseMatrix.toContext(o) + } + m.drawStroke(N, o, w, l, q, Q); + if (k.transformFillStroke) { + k.matrix.toContext(o) + } + o.stroke() + } else { + m.drawStroke(N, o, w, l, q, Q); + if (S && g && k.fillArea && !k.renderer) { + var A = s[s.length - 1] * C + c + u, + z = r[r.length - 1] * f + b, + J = s[0] * C + c - u, + H = r[0] * f + b; + o.lineTo(A, z); + o.lineTo(A, Q - k.lineWidth); + o.lineTo(J, Q - k.lineWidth); + o.lineTo(J, H) + } + if (k.transformFillStroke) { + k.matrix.toContext(o) + } + if (k.fillArea) { + o.fillStroke(k, true) + } else { + o.stroke(true) + } + } + } + } +}); +Ext.define("Ext.chart.series.Line", { + extend: "Ext.chart.series.Cartesian", + alias: "series.line", + type: "line", + seriesType: "lineSeries", + requires: ["Ext.chart.series.sprite.Line"], + config: { + selectionTolerance: 20, + smooth: false, + step: false, + fill: undefined, + aggregator: { + strategy: "double" + } + }, + defaultSmoothness: 3, + overflowBuffer: 1, + themeMarkerCount: function() { + return 1 + }, + getDefaultSpriteConfig: function() { + var d = this, + e = d.callParent(arguments), + c = Ext.apply({}, d.getStyle()), + b, a = false; + if (typeof d.config.fill != "undefined") { + if (d.config.fill) { + a = true; + if (typeof c.fillStyle == "undefined") { + if (typeof c.strokeStyle == "undefined") { + b = d.getStyleWithTheme(); + c.fillStyle = b.fillStyle; + c.strokeStyle = b.strokeStyle + } else { + c.fillStyle = c.strokeStyle + } + } + } + } else { + if (c.fillStyle) { + a = true + } + } + if (!a) { + delete c.fillStyle + } + c = Ext.apply(e || {}, c); + return Ext.apply(c, { + fillArea: a, + step: d.config.step, + smooth: d.config.smooth, + selectionTolerance: d.config.selectionTolerance + }) + }, + updateStep: function(b) { + var a = this.getSprites()[0]; + if (a && a.attr.step !== b) { + a.setAttributes({ + step: b + }) + } + }, + updateFill: function(b) { + var a = this.getSprites()[0]; + if (a && a.attr.fillArea !== b) { + a.setAttributes({ + fillArea: b + }) + } + }, + updateSmooth: function(a) { + var b = this.getSprites()[0]; + if (b && b.attr.smooth !== a) { + b.setAttributes({ + smooth: a + }) + } + } +}); +Ext.define("Ext.chart.series.sprite.PieSlice", { + extend: "Ext.draw.sprite.Sector", + mixins: { + markerHolder: "Ext.chart.MarkerHolder" + }, + alias: "sprite.pieslice", + inheritableStatics: { + def: { + processors: { + doCallout: "bool", + label: "string", + rotateLabels: "bool", + labelOverflowPadding: "number", + renderer: "default" + }, + defaults: { + doCallout: true, + rotateLabels: true, + label: "", + labelOverflowPadding: 10, + renderer: null + } + } + }, + config: { + rendererData: null, + rendererIndex: 0, + series: null + }, + setGradientBBox: function(q, k) { + var j = this, + i = j.attr, + g = (i.fillStyle && i.fillStyle.isGradient) || (i.strokeStyle && i.strokeStyle.isGradient); + if (g && !i.constrainGradients) { + var b = j.getMidAngle(), + d = i.margin, + e = i.centerX, + c = i.centerY, + a = i.endRho, + l = i.matrix, + o = l.getScaleX(), + n = l.getScaleY(), + m = o * a, + f = n * a, + p = { + width: m + m, + height: f + f + }; + if (d) { + e += d * Math.cos(b); + c += d * Math.sin(b) + } + p.x = l.x(e, c) - m; + p.y = l.y(e, c) - f; + q.setGradientBBox(p) + } else { + j.callParent([q, k]) + } + }, + render: function(b, c, g, f) { + var e = this, + a = e.attr, + h = {}, + d; + if (a.renderer) { + h = { + type: "sector", + text: a.text, + centerX: a.centerX, + centerY: a.centerY, + margin: a.margin, + startAngle: Math.min(a.startAngle, a.endAngle), + endAngle: Math.max(a.startAngle, a.endAngle), + startRho: Math.min(a.startRho, a.endRho), + endRho: Math.max(a.startRho, a.endRho) + }; + d = Ext.callback(a.renderer, null, [e, h, e.rendererData, e.rendererIndex], 0, e.getSeries()); + e.setAttributes(d); + e.useAttributes(c, g) + } + e.callParent([b, c, g, f]); + if (a.label && e.getMarker("labels")) { + e.placeLabel() + } + }, + placeLabel: function() { + var z = this, + s = z.attr, + r = s.attributeId, + t = Math.min(s.startAngle, s.endAngle), + p = Math.max(s.startAngle, s.endAngle), + k = (t + p) * 0.5, + n = s.margin, + h = s.centerX, + g = s.centerY, + f = Math.sin(k), + c = Math.cos(k), + v = Math.min(s.startRho, s.endRho) + n, + m = Math.max(s.startRho, s.endRho) + n, + l = (v + m) * 0.5, + b = z.surfaceMatrix, + o = z.labelCfg || (z.labelCfg = {}), + e = z.getMarker("labels"), + d = e.getTemplate(), + a = d.getCalloutLine(), + q = a && a.length || 40, + u, j, i, A, w; + b.appendMatrix(s.matrix); + o.text = s.label; + j = h + c * l; + i = g + f * l; + o.x = b.x(j, i); + o.y = b.y(j, i); + j = h + c * m; + i = g + f * m; + o.calloutStartX = b.x(j, i); + o.calloutStartY = b.y(j, i); + j = h + c * (m + q); + i = g + f * (m + q); + o.calloutPlaceX = b.x(j, i); + o.calloutPlaceY = b.y(j, i); + if (!s.rotateLabels) { + o.rotationRads = 0 + } else { + switch (d.attr.orientation) { + case "horizontal": + o.rotationRads = k + Math.atan2(b.y(1, 0) - b.y(0, 0), b.x(1, 0) - b.x(0, 0)) + Math.PI / 2; + break; + case "vertical": + o.rotationRads = k + Math.atan2(b.y(1, 0) - b.y(0, 0), b.x(1, 0) - b.x(0, 0)); + break + } + } + o.calloutColor = (a && a.color) || z.attr.fillStyle; + if (a) { + if (a.width) { + o.calloutWidth = a.width + } + } else { + o.calloutHasLine = false + } + o.globalAlpha = s.globalAlpha * s.fillOpacity; + o.hidden = (s.startAngle == s.endAngle); + if (d.attr.renderer) { + w = [z.attr.label, e, o, z.rendererData, z.rendererIndex]; + A = Ext.callback(d.attr.renderer, null, w, 0, z.getSeries()); + if (typeof A === "string") { + o.text = A + } else { + Ext.apply(o, A) + } + } + z.putMarker("labels", o, r); + u = z.getMarkerBBox("labels", r, true); + if (u) { + if (s.doCallout) { + if (d.attr.display === "outside") { + z.putMarker("labels", { + callout: 1 + }, r) + } else { + if (d.attr.display === "inside") { + z.putMarker("labels", { + callout: 0 + }, r) + } else { + z.putMarker("labels", { + callout: 1 - z.sliceContainsLabel(s, u) + }, r) + } + } + } else { + z.putMarker("labels", { + globalAlpha: z.sliceContainsLabel(s, u) + }, r) + } + } + }, + sliceContainsLabel: function(d, f) { + var e = d.labelOverflowPadding, + h = (d.endRho + d.startRho) / 2, + g = h + (f.width + e) / 2, + i = h - (f.width + e) / 2, + j, c, b, a; + if (e < 0) { + return 1 + } + if (f.width + e * 2 > (d.endRho - d.startRho)) { + return 0 + } + c = Math.sqrt(d.endRho * d.endRho - g * g); + b = Math.sqrt(d.endRho * d.endRho - i * i); + j = Math.abs(d.endAngle - d.startAngle); + a = (j > Math.PI / 2 ? i : Math.abs(Math.tan(j / 2)) * i); + if (f.height + e * 2 > Math.min(c, b, a) * 2) { + return 0 + } + return 1 + } +}); +Ext.define("Ext.chart.series.Pie", { + extend: "Ext.chart.series.Polar", + requires: ["Ext.chart.series.sprite.PieSlice"], + type: "pie", + alias: "series.pie", + seriesType: "pieslice", + config: { + donut: 0, + rotation: 0, + clockwise: true, + totalAngle: 2 * Math.PI, + hidden: [], + radiusFactor: 100, + highlightCfg: { + margin: 20 + }, + style: {} + }, + directions: ["X"], + applyLabel: function(a, b) { + if (Ext.isObject(a) && !Ext.isString(a.orientation)) { + Ext.apply(a = Ext.Object.chain(a), { + orientation: "vertical" + }) + } + return this.callParent([a, b]) + }, + updateLabelData: function() { + var h = this, + j = h.getStore(), + g = j.getData().items, + e = h.getSprites(), + a = h.getLabel().getTemplate().getField(), + d = h.getHidden(), + b, f, c, k; + if (e.length && a) { + c = []; + for (b = 0, f = g.length; b < f; b++) { + c.push(g[b].get(a)) + } + for (b = 0, f = e.length; b < f; b++) { + k = e[b]; + k.setAttributes({ + label: c[b] + }); + k.putMarker("labels", { + hidden: d[b] + }, k.attr.attributeId) + } + } + }, + coordinateX: function() { + var t = this, + f = t.getStore(), + q = f.getData().items, + c = q.length, + b = t.getXField(), + e = t.getYField(), + l, a = 0, + m, k, s = 0, + o = t.getHidden(), + d = [], + p, g = 0, + h = t.getTotalAngle(), + r = t.getClockwise() ? 1 : -1, + j = t.getSprites(), + n; + if (!j) { + return + } + for (p = 0; p < c; p++) { + l = Math.abs(Number(q[p].get(b))) || 0; + k = e && Math.abs(Number(q[p].get(e))) || 0; + if (!o[p]) { + a += l; + if (k > s) { + s = k + } + } + d[p] = a; + if (p >= o.length) { + o[p] = false + } + } + o.length = c; + t.maxY = s; + if (a !== 0) { + m = h / a + } + for (p = 0; p < c; p++) { + j[p].setAttributes({ + startAngle: g, + endAngle: g = (m ? r * d[p] * m : 0), + globalAlpha: 1 + }) + } + if (c < t.sprites.length) { + for (p = c; p < t.sprites.length; p++) { + n = t.sprites[p]; + n.getMarker("labels").clear(n.getId()); + n.releaseMarker("labels"); + n.destroy() + } + t.sprites.length = c + } + for (p = c; p < t.sprites.length; p++) { + j[p].setAttributes({ + startAngle: h, + endAngle: h, + globalAlpha: 0 + }) + } + t.getChart().refreshLegendStore() + }, + updateCenter: function(a) { + this.setStyle({ + translationX: a[0] + this.getOffsetX(), + translationY: a[1] + this.getOffsetY() + }); + this.doUpdateStyles() + }, + updateRadius: function(a) { + this.setStyle({ + startRho: a * this.getDonut() * 0.01, + endRho: a * this.getRadiusFactor() * 0.01 + }); + this.doUpdateStyles() + }, + getStyleByIndex: function(c) { + var g = this, + j = g.getStore(), + k = j.getAt(c), + f = g.getYField(), + d = g.getRadius(), + a = {}, + e, b, h; + if (k) { + h = f && Math.abs(Number(k.get(f))) || 0; + e = d * g.getDonut() * 0.01; + b = d * g.getRadiusFactor() * 0.01; + a = g.callParent([c]); + a.startRho = e; + a.endRho = g.maxY ? (e + (b - e) * h / g.maxY) : b + } + return a + }, + updateDonut: function(b) { + var a = this.getRadius(); + this.setStyle({ + startRho: a * b * 0.01, + endRho: a * this.getRadiusFactor() * 0.01 + }); + this.doUpdateStyles() + }, + rotationOffset: -Math.PI / 2, + updateRotation: function(a) { + this.setStyle({ + rotationRads: a + this.rotationOffset + }); + this.doUpdateStyles() + }, + updateTotalAngle: function(a) { + this.processData() + }, + getSprites: function() { + var k = this, + h = k.getChart(), + n = k.getStore(); + if (!h || !n) { + return [] + } + k.getColors(); + k.getSubStyle(); + var j = n.getData().items, + b = j.length, + d = k.getAnimation() || h && h.getAnimation(), + g = k.sprites, + o, l = 0, + f, e, c = false, + m = k.getLabel(), + a = m.getTemplate(); + f = { + store: n, + field: k.getXField(), + angleField: k.getXField(), + radiusField: k.getYField(), + series: k + }; + for (e = 0; e < b; e++) { + o = g[e]; + if (!o) { + o = k.createSprite(); + if (k.getHighlight()) { + o.config.highlight = k.getHighlight(); + o.addModifier("highlight", true) + } + if (a.getField()) { + a.setAttributes({ + labelOverflowPadding: k.getLabelOverflowPadding() + }); + a.fx.setCustomDurations({ + callout: 200 + }) + } + o.setAttributes(k.getStyleByIndex(e)); + o.rendererData = f; + o.rendererIndex = l++; + c = true + } + o.setAnimation(d) + } + if (c) { + k.doUpdateStyles() + } + return k.sprites + }, + betweenAngle: function(d, f, c) { + var e = Math.PI * 2, + g = this.rotationOffset; + if (!this.getClockwise()) { + d *= -1; + f *= -1; + c *= -1; + f -= g; + c -= g + } else { + f += g; + c += g + } + d -= f; + c -= f; + d %= e; + c %= e; + d += e; + c += e; + d %= e; + c %= e; + return d < c || c === 0 + }, + getItemForAngle: function(a) { + var h = this, + f = h.getSprites(), + d; + a %= Math.PI * 2; + while (a < 0) { + a += Math.PI * 2 + } + if (f) { + var j = h.getStore(), + g = j.getData().items, + c = h.getHidden(), + b = 0, + e = j.getCount(); + for (; b < e; b++) { + if (!c[b]) { + d = f[b].attr; + if (d.startAngle <= a && d.endAngle >= a) { + return { + series: h, + sprite: f[b], + index: b, + record: g[b], + field: h.getXField() + } + } + } + } + } + return null + }, + getItemForPoint: function(f, e) { + var t = this, + c = t.getSprites(); + if (c) { + var s = t.getCenter(), + q = t.getOffsetX(), + p = t.getOffsetY(), + j = f - s[0] + q, + h = e - s[1] + p, + b = t.getStore(), + g = t.getDonut(), + o = b.getData().items, + r = Math.atan2(h, j) - t.getRotation(), + a = Math.sqrt(j * j + h * h), + l = t.getRadius() * g * 0.01, + m = t.getHidden(), + n, d, k; + for (n = 0, d = o.length; n < d; n++) { + if (!m[n]) { + k = c[n].attr; + if (a >= l + k.margin && a <= k.endRho + k.margin) { + if (t.betweenAngle(r, k.startAngle, k.endAngle)) { + return { + series: t, + sprite: c[n], + index: n, + record: o[n], + field: t.getXField() + } + } + } + } + } + return null + } + }, + provideLegendInfo: function(f) { + var h = this, + j = h.getStore(); + if (j) { + var g = j.getData().items, + b = h.getLabel().getTemplate().getField(), + c = h.getXField(), + e = h.getHidden(), + d, a, k; + for (d = 0; d < g.length; d++) { + a = h.getStyleByIndex(d); + k = a.fillStyle; + if (Ext.isObject(k)) { + k = k.stops && k.stops[0].color + } + f.push({ + name: b ? String(g[d].get(b)) : c + " " + d, + mark: k || a.strokeStyle || "black", + disabled: e[d], + series: h.getId(), + index: d + }) + } + } + } +}); +Ext.define("Ext.chart.series.sprite.Pie3DPart", { + extend: "Ext.draw.sprite.Path", + mixins: { + markerHolder: "Ext.chart.MarkerHolder" + }, + alias: "sprite.pie3dPart", + inheritableStatics: { + def: { + processors: { + centerX: "number", + centerY: "number", + startAngle: "number", + endAngle: "number", + startRho: "number", + endRho: "number", + margin: "number", + thickness: "number", + bevelWidth: "number", + distortion: "number", + baseColor: "color", + colorSpread: "number", + baseRotation: "number", + part: "enums(top,bottom,start,end,innerFront,innerBack,outerFront,outerBack)", + label: "string" + }, + aliases: { + rho: "endRho" + }, + triggers: { + centerX: "path,bbox", + centerY: "path,bbox", + startAngle: "path,partZIndex", + endAngle: "path,partZIndex", + startRho: "path", + endRho: "path,bbox", + margin: "path,bbox", + thickness: "path", + distortion: "path", + baseRotation: "path,partZIndex", + baseColor: "partZIndex,partColor", + colorSpread: "partColor", + part: "path,partZIndex", + globalAlpha: "canvas,alpha" + }, + defaults: { + centerX: 0, + centerY: 0, + startAngle: Math.PI * 2, + endAngle: Math.PI * 2, + startRho: 0, + endRho: 150, + margin: 0, + thickness: 35, + distortion: 0.5, + baseRotation: 0, + baseColor: "white", + colorSpread: 1, + miterLimit: 1, + bevelWidth: 5, + strokeOpacity: 0, + part: "top", + label: "" + }, + updaters: { + alpha: "alphaUpdater", + partColor: "partColorUpdater", + partZIndex: "partZIndexUpdater" + } + } + }, + bevelParams: [], + constructor: function(a) { + this.callParent([a]); + this.bevelGradient = new Ext.draw.gradient.Linear({ + stops: [{ + offset: 0, + color: "rgba(255,255,255,0)" + }, { + offset: 0.7, + color: "rgba(255,255,255,0.6)" + }, { + offset: 1, + color: "rgba(255,255,255,0)" + }] + }) + }, + alphaUpdater: function(a) { + var d = this, + c = a.globalAlpha, + b = d.oldOpacity; + if (c !== b && (c === 1 || b === 1)) { + d.scheduleUpdater(a, "path", ["globalAlpha"]); + d.oldOpacity = c + } + }, + partColorUpdater: function(a) { + var d = Ext.draw.Color.fly(a.baseColor), + b = d.toString(), + e = a.colorSpread, + c; + switch (a.part) { + case "top": + c = new Ext.draw.gradient.Radial({ + start: { + x: 0, + y: 0, + r: 0 + }, + end: { + x: 0, + y: 0, + r: 1 + }, + stops: [{ + offset: 0, + color: d.createLighter(0.1 * e) + }, { + offset: 1, + color: d.createDarker(0.1 * e) + }] + }); + break; + case "bottom": + c = new Ext.draw.gradient.Radial({ + start: { + x: 0, + y: 0, + r: 0 + }, + end: { + x: 0, + y: 0, + r: 1 + }, + stops: [{ + offset: 0, + color: d.createDarker(0.2 * e) + }, { + offset: 1, + color: d.toString() + }] + }); + break; + case "outerFront": + case "outerBack": + c = new Ext.draw.gradient.Linear({ + stops: [{ + offset: 0, + color: d.createDarker(0.15 * e).toString() + }, { + offset: 0.3, + color: b + }, { + offset: 0.8, + color: d.createLighter(0.2 * e).toString() + }, { + offset: 1, + color: d.createDarker(0.25 * e).toString() + }] + }); + break; + case "start": + c = new Ext.draw.gradient.Linear({ + stops: [{ + offset: 0, + color: d.createDarker(0.1 * e).toString() + }, { + offset: 1, + color: d.createLighter(0.2 * e).toString() + }] + }); + break; + case "end": + c = new Ext.draw.gradient.Linear({ + stops: [{ + offset: 0, + color: d.createDarker(0.1 * e).toString() + }, { + offset: 1, + color: d.createLighter(0.2 * e).toString() + }] + }); + break; + case "innerFront": + case "innerBack": + c = new Ext.draw.gradient.Linear({ + stops: [{ + offset: 0, + color: d.createDarker(0.1 * e).toString() + }, { + offset: 0.2, + color: d.createLighter(0.2 * e).toString() + }, { + offset: 0.7, + color: b + }, { + offset: 1, + color: d.createDarker(0.1 * e).toString() + }] + }); + break + } + a.fillStyle = c; + a.canvasAttributes.fillStyle = c + }, + partZIndexUpdater: function(a) { + var c = Ext.draw.sprite.AttributeParser.angle, + e = a.baseRotation, + d = a.startAngle, + b = a.endAngle, + f; + switch (a.part) { + case "top": + a.zIndex = 5; + break; + case "outerFront": + d = c(d + e); + b = c(b + e); + if (d >= 0 && b < 0) { + f = Math.sin(d) + } else { + if (d <= 0 && b > 0) { + f = Math.sin(b) + } else { + if (d >= 0 && b > 0) { + if (d > b) { + f = 0 + } else { + f = Math.max(Math.sin(d), Math.sin(b)) + } + } else { + f = 1 + } + } + } + a.zIndex = 4 + f; + break; + case "outerBack": + a.zIndex = 1; + break; + case "start": + a.zIndex = 4 + Math.sin(c(d + e)); + break; + case "end": + a.zIndex = 4 + Math.sin(c(b + e)); + break; + case "innerFront": + a.zIndex = 2; + break; + case "innerBack": + a.zIndex = 4 + Math.sin(c((d + b) / 2 + e)); + break; + case "bottom": + a.zIndex = 0; + break + } + a.dirtyZIndex = true + }, + updatePlainBBox: function(k) { + var f = this.attr, + a = f.part, + b = f.baseRotation, + e = f.centerX, + d = f.centerY, + j, c, i, h, g, l; + if (a === "start") { + c = f.startAngle + b + } else { + if (a === "end") { + c = f.endAngle + b + } + } + if (Ext.isNumber(c)) { + g = Math.sin(c); + l = Math.cos(c); + i = Math.min(e + l * f.startRho, e + l * f.endRho); + h = d + g * f.startRho * f.distortion; + k.x = i; + k.y = h; + k.width = l * (f.endRho - f.startRho); + k.height = f.thickness + g * (f.endRho - f.startRho) * 2; + return + } + if (a === "innerFront" || a === "innerBack") { + j = f.startRho + } else { + j = f.endRho + } + k.width = j * 2; + k.height = j * f.distortion * 2 + f.thickness; + k.x = f.centerX - j; + k.y = f.centerY - j * f.distortion + }, + updateTransformedBBox: function(a) { + if (this.attr.part === "start" || this.attr.part === "end") { + return this.callParent(arguments) + } + return this.updatePlainBBox(a) + }, + updatePath: function(a) { + if (!this.attr.globalAlpha) { + return + } + if (this.attr.endAngle < this.attr.startAngle) { + return + } + this[this.attr.part + "Renderer"](a) + }, + render: function(b, c) { + var d = this, + a = d.attr; + if (!a.globalAlpha) { + return + } + d.callParent([b, c]); + d.bevelRenderer(b, c); + if (a.label && d.getMarker("labels")) { + d.placeLabel() + } + }, + placeLabel: function() { + var z = this, + u = z.attr, + t = u.attributeId, + p = u.margin, + c = u.distortion, + i = u.centerX, + h = u.centerY, + j = u.baseRotation, + v = u.startAngle + j, + r = u.endAngle + j, + m = (v + r) / 2, + w = u.startRho + p, + o = u.endRho + p, + n = (w + o) / 2, + a = Math.sin(m), + b = Math.cos(m), + e = z.surfaceMatrix, + g = z.getMarker("labels"), + f = g.getTemplate(), + d = f.getCalloutLine(), + s = d && d.length || 40, + q = {}, + l, k; + e.appendMatrix(u.matrix); + q.text = u.label; + l = i + b * n; + k = h + a * n * c; + q.x = e.x(l, k); + q.y = e.y(l, k); + l = i + b * o; + k = h + a * o * c; + q.calloutStartX = e.x(l, k); + q.calloutStartY = e.y(l, k); + l = i + b * (o + s); + k = h + a * (o + s) * c; + q.calloutPlaceX = e.x(l, k); + q.calloutPlaceY = e.y(l, k); + q.calloutWidth = 2; + z.putMarker("labels", q, t); + z.putMarker("labels", { + callout: 1 + }, t) + }, + bevelRenderer: function(b, c) { + var f = this, + a = f.attr, + e = a.bevelWidth, + g = f.bevelParams, + d; + for (d = 0; d < g.length; d++) { + c.beginPath(); + c.ellipse.apply(c, g[d]); + c.save(); + c.lineWidth = e; + c.strokeOpacity = e ? 1 : 0; + c.strokeGradient = f.bevelGradient; + c.stroke(a); + c.restore() + } + }, + lidRenderer: function(o, m) { + var k = this.attr, + g = k.margin, + c = k.distortion, + i = k.centerX, + h = k.centerY, + f = k.baseRotation, + j = k.startAngle + f, + e = k.endAngle + f, + d = (j + e) / 2, + l = k.startRho, + b = k.endRho, + n = Math.sin(e), + a = Math.cos(e); + i += Math.cos(d) * g; + h += Math.sin(d) * g * c; + o.ellipse(i, h + m, l, l * c, 0, j, e, false); + o.lineTo(i + a * b, h + m + n * b * c); + o.ellipse(i, h + m, b, b * c, 0, e, j, true); + o.closePath() + }, + topRenderer: function(a) { + this.lidRenderer(a, 0) + }, + bottomRenderer: function(b) { + var a = this.attr; + if (a.globalAlpha < 1 || a.shadowColor !== Ext.draw.Color.RGBA_NONE) { + this.lidRenderer(b, a.thickness) + } + }, + sideRenderer: function(l, s) { + var o = this.attr, + k = o.margin, + g = o.centerX, + f = o.centerY, + e = o.distortion, + h = o.baseRotation, + p = o.startAngle + h, + m = o.endAngle + h, + a = o.thickness, + q = o.startRho, + j = o.endRho, + r = (s === "start" && p) || (s === "end" && m), + b = Math.sin(r), + d = Math.cos(r), + c = o.globalAlpha < 1, + n = s === "start" && d < 0 || s === "end" && d > 0 || c, + i; + if (n) { + i = (p + m) / 2; + g += Math.cos(i) * k; + f += Math.sin(i) * k * e; + l.moveTo(g + d * q, f + b * q * e); + l.lineTo(g + d * j, f + b * j * e); + l.lineTo(g + d * j, f + b * j * e + a); + l.lineTo(g + d * q, f + b * q * e + a); + l.closePath() + } + }, + startRenderer: function(a) { + this.sideRenderer(a, "start") + }, + endRenderer: function(a) { + this.sideRenderer(a, "end") + }, + rimRenderer: function(q, e, o, j) { + var w = this, + s = w.attr, + p = s.margin, + h = s.centerX, + g = s.centerY, + d = s.distortion, + i = s.baseRotation, + t = Ext.draw.sprite.AttributeParser.angle, + u = s.startAngle + i, + r = s.endAngle + i, + k = t((u + r) / 2), + a = s.thickness, + b = s.globalAlpha < 1, + c, n, v; + w.bevelParams = []; + u = t(u); + r = t(r); + h += Math.cos(k) * p; + g += Math.sin(k) * p * d; + c = u >= 0 && r >= 0; + n = u <= 0 && r <= 0; + + function l() { + q.ellipse(h, g + a, e, e * d, 0, Math.PI, u, true); + q.lineTo(h + Math.cos(u) * e, g + Math.sin(u) * e * d); + v = [h, g, e, e * d, 0, u, Math.PI, false]; + if (!o) { + w.bevelParams.push(v) + } + q.ellipse.apply(q, v); + q.closePath() + } + + function f() { + q.ellipse(h, g + a, e, e * d, 0, 0, r, false); + q.lineTo(h + Math.cos(r) * e, g + Math.sin(r) * e * d); + v = [h, g, e, e * d, 0, r, 0, true]; + if (!o) { + w.bevelParams.push(v) + } + q.ellipse.apply(q, v); + q.closePath() + } + + function x() { + q.ellipse(h, g + a, e, e * d, 0, Math.PI, r, false); + q.lineTo(h + Math.cos(r) * e, g + Math.sin(r) * e * d); + v = [h, g, e, e * d, 0, r, Math.PI, true]; + if (o) { + w.bevelParams.push(v) + } + q.ellipse.apply(q, v); + q.closePath() + } + + function m() { + q.ellipse(h, g + a, e, e * d, 0, u, 0, false); + q.lineTo(h + e, g); + v = [h, g, e, e * d, 0, 0, u, true]; + if (o) { + w.bevelParams.push(v) + } + q.ellipse.apply(q, v); + q.closePath() + } + if (j) { + if (!o || b) { + if (u >= 0 && r < 0) { + l() + } else { + if (u <= 0 && r > 0) { + f() + } else { + if (u <= 0 && r < 0) { + if (u > r) { + q.ellipse(h, g + a, e, e * d, 0, 0, Math.PI, false); + q.lineTo(h - e, g); + v = [h, g, e, e * d, 0, Math.PI, 0, true]; + if (!o) { + w.bevelParams.push(v) + } + q.ellipse.apply(q, v); + q.closePath() + } + } else { + if (u > r) { + l(); + f() + } else { + v = [h, g, e, e * d, 0, u, r, false]; + if (c && !o || n && o) { + w.bevelParams.push(v) + } + q.ellipse.apply(q, v); + q.lineTo(h + Math.cos(r) * e, g + Math.sin(r) * e * d + a); + q.ellipse(h, g + a, e, e * d, 0, r, u, true); + q.closePath() + } + } + } + } + } + } else { + if (o || b) { + if (u >= 0 && r < 0) { + x() + } else { + if (u <= 0 && r > 0) { + m() + } else { + if (u <= 0 && r < 0) { + if (u > r) { + x(); + m() + } else { + q.ellipse(h, g + a, e, e * d, 0, u, r, false); + q.lineTo(h + Math.cos(r) * e, g + Math.sin(r) * e * d); + v = [h, g, e, e * d, 0, r, u, true]; + if (o) { + w.bevelParams.push(v) + } + q.ellipse.apply(q, v); + q.closePath() + } + } else { + if (u > r) { + q.ellipse(h, g + a, e, e * d, 0, -Math.PI, 0, false); + q.lineTo(h + e, g); + v = [h, g, e, e * d, 0, 0, -Math.PI, true]; + if (o) { + w.bevelParams.push(v) + } + q.ellipse.apply(q, v); + q.closePath() + } + } + } + } + } + } + }, + innerFrontRenderer: function(a) { + this.rimRenderer(a, this.attr.startRho, true, true) + }, + innerBackRenderer: function(a) { + this.rimRenderer(a, this.attr.startRho, true, false) + }, + outerFrontRenderer: function(a) { + this.rimRenderer(a, this.attr.endRho, false, true) + }, + outerBackRenderer: function(a) { + this.rimRenderer(a, this.attr.endRho, false, false) + } +}); +Ext.define("Ext.draw.PathUtil", function() { + var a = Math.abs, + c = Math.pow, + e = Math.cos, + b = Math.acos, + d = Math.sqrt, + f = Math.PI; + return { + singleton: true, + requires: ["Ext.draw.overrides.Path", "Ext.draw.overrides.sprite.Path", "Ext.draw.overrides.sprite.Instancing", "Ext.draw.overrides.Surface"], + cubicRoots: function(m) { + var z = m[0], + x = m[1], + w = m[2], + v = m[3]; + if (z === 0) { + return this.quadraticRoots(x, w, v) + } + var s = x / z, + r = w / z, + q = v / z, + k = (3 * r - c(s, 2)) / 9, + j = (9 * s * r - 27 * q - 2 * c(s, 3)) / 54, + p = c(k, 3) + c(j, 2), + n = [], + h, g, o, l, u, y = Ext.Number.sign; + if (p >= 0) { + h = y(j + d(p)) * c(a(j + d(p)), 1 / 3); + g = y(j - d(p)) * c(a(j - d(p)), 1 / 3); + n[0] = -s / 3 + (h + g); + n[1] = -s / 3 - (h + g) / 2; + n[2] = n[1]; + o = a(d(3) * (h - g) / 2); + if (o !== 0) { + n[1] = -1; + n[2] = -1 + } + } else { + l = b(j / d(-c(k, 3))); + n[0] = 2 * d(-k) * e(l / 3) - s / 3; + n[1] = 2 * d(-k) * e((l + 2 * f) / 3) - s / 3; + n[2] = 2 * d(-k) * e((l + 4 * f) / 3) - s / 3 + } + for (u = 0; u < 3; u++) { + if (n[u] < 0 || n[u] > 1) { + n[u] = -1 + } + } + return n + }, + quadraticRoots: function(h, g, n) { + var m, l, k, j; + if (h === 0) { + return this.linearRoot(g, n) + } + m = g * g - 4 * h * n; + if (m === 0) { + k = [-g / (2 * h)] + } else { + if (m > 0) { + l = d(m); + k = [(-g - l) / (2 * h), (-g + l) / (2 * h)] + } else { + return [] + } + } + for (j = 0; j < k.length; j++) { + if (k[j] < 0 || k[j] > 1) { + k[j] = -1 + } + } + return k + }, + linearRoot: function(h, g) { + var i = -g / h; + if (h === 0 || i < 0 || i > 1) { + return [] + } + return [i] + }, + bezierCoeffs: function(h, g, k, j) { + var i = []; + i[0] = -h + 3 * g - 3 * k + j; + i[1] = 3 * h - 6 * g + 3 * k; + i[2] = -3 * h + 3 * g; + i[3] = h; + return i + }, + cubicLineIntersections: function(I, G, F, E, l, k, j, h, M, p, K, n) { + var u = [], + N = [], + D = p - n, + z = K - M, + y = M * (n - p) - p * (K - M), + L = this.bezierCoeffs(I, G, F, E), + J = this.bezierCoeffs(l, k, j, h), + H, x, w, v, g, q, o, m; + u[0] = D * L[0] + z * J[0]; + u[1] = D * L[1] + z * J[1]; + u[2] = D * L[2] + z * J[2]; + u[3] = D * L[3] + z * J[3] + y; + x = this.cubicRoots(u); + for (H = 0; H < x.length; H++) { + v = x[H]; + if (v < 0 || v > 1) { + continue + } + g = v * v; + q = g * v; + o = L[0] * q + L[1] * g + L[2] * v + L[3]; + m = J[0] * q + J[1] * g + J[2] * v + J[3]; + if ((K - M) !== 0) { + w = (o - M) / (K - M) + } else { + w = (m - p) / (n - p) + } + if (!(w < 0 || w > 1)) { + N.push([o, m]) + } + } + return N + }, + splitCubic: function(g, q, p, o, m) { + var j = m * m, + n = m * j, + i = m - 1, + h = i * i, + k = i * h, + l = n * o - 3 * j * i * p + 3 * m * h * q - k * g; + return [ + [g, m * q - i * g, j * p - 2 * m * i * q + h * g, l], + [l, j * o - 2 * m * i * p + h * q, m * o - i * p, o] + ] + }, + cubicDimension: function(p, o, l, k) { + var j = 3 * (-p + 3 * (o - l) + k), + i = 6 * (p - 2 * o + l), + h = -3 * (p - o), + q, n, g = Math.min(p, k), + m = Math.max(p, k), + r; + if (j === 0) { + if (i === 0) { + return [g, m] + } else { + q = -h / i; + if (0 < q && q < 1) { + n = this.interpolateCubic(p, o, l, k, q); + g = Math.min(g, n); + m = Math.max(m, n) + } + } + } else { + r = i * i - 4 * j * h; + if (r >= 0) { + r = d(r); + q = (r - i) / 2 / j; + if (0 < q && q < 1) { + n = this.interpolateCubic(p, o, l, k, q); + g = Math.min(g, n); + m = Math.max(m, n) + } + if (r > 0) { + q -= r / j; + if (0 < q && q < 1) { + n = this.interpolateCubic(p, o, l, k, q); + g = Math.min(g, n); + m = Math.max(m, n) + } + } + } + } + return [g, m] + }, + interpolateCubic: function(h, g, l, k, i) { + if (i === 0) { + return h + } + if (i === 1) { + return k + } + var j = (1 - i) / i; + return i * i * i * (k + j * (3 * l + j * (3 * g + j * h))) + }, + cubicsIntersections: function(r, q, p, o, A, z, y, v, g, F, E, D, m, l, k, i) { + var C = this, + x = C.cubicDimension(r, q, p, o), + B = C.cubicDimension(A, z, y, v), + n = C.cubicDimension(g, F, E, D), + s = C.cubicDimension(m, l, k, i), + j, h, u, t, w = []; + if (x[0] > n[1] || x[1] < n[0] || B[0] > s[1] || B[1] < s[0]) { + return [] + } + if (a(A - z) < 1 && a(y - v) < 1 && a(r - o) < 1 && a(q - p) < 1 && a(m - l) < 1 && a(k - i) < 1 && a(g - D) < 1 && a(F - E) < 1) { + return [ + [(r + o) * 0.5, (A + z) * 0.5] + ] + } + j = C.splitCubic(r, q, p, o, 0.5); + h = C.splitCubic(A, z, y, v, 0.5); + u = C.splitCubic(g, F, E, D, 0.5); + t = C.splitCubic(m, l, k, i, 0.5); + w.push.apply(w, C.cubicsIntersections.apply(C, j[0].concat(h[0], u[0], t[0]))); + w.push.apply(w, C.cubicsIntersections.apply(C, j[0].concat(h[0], u[1], t[1]))); + w.push.apply(w, C.cubicsIntersections.apply(C, j[1].concat(h[1], u[0], t[0]))); + w.push.apply(w, C.cubicsIntersections.apply(C, j[1].concat(h[1], u[1], t[1]))); + return w + }, + linesIntersection: function(k, p, j, o, h, n, q, m) { + var l = (j - k) * (m - n) - (o - p) * (q - h), + i, g; + if (l === 0) { + return null + } + i = ((q - h) * (p - n) - (k - h) * (m - n)) / l; + g = ((j - k) * (p - n) - (o - p) * (k - h)) / l; + if (i >= 0 && i <= 1 && g >= 0 && g <= 1) { + return [k + i * (j - k), p + i * (o - p)] + } + return null + }, + pointOnLine: function(j, m, h, l, g, n) { + var k, i; + if (a(h - j) < a(l - m)) { + i = j; + j = m; + m = i; + i = h; + h = l; + l = i; + i = g; + g = n; + n = i + } + k = (g - j) / (h - j); + if (k < 0 || k > 1) { + return false + } + return a(m + k * (l - m) - n) < 4 + }, + pointOnCubic: function(w, u, s, r, l, k, h, g, p, o) { + var C = this, + B = C.bezierCoeffs(w, u, s, r), + A = C.bezierCoeffs(l, k, h, g), + z, v, n, m, q; + B[3] -= p; + A[3] -= o; + n = C.cubicRoots(B); + m = C.cubicRoots(A); + for (z = 0; z < n.length; z++) { + q = n[z]; + for (v = 0; v < m.length; v++) { + if (q >= 0 && q <= 1 && a(q - m[v]) < 0.05) { + return true + } + } + } + return false + } + } +}); +Ext.define("Ext.chart.series.Pie3D", { + extend: "Ext.chart.series.Polar", + requires: ["Ext.chart.series.sprite.Pie3DPart", "Ext.draw.PathUtil"], + type: "pie3d", + seriesType: "pie3d", + alias: "series.pie3d", + isPie3D: true, + config: { + rect: [0, 0, 0, 0], + thickness: 35, + distortion: 0.5, + donut: false, + hidden: [], + highlightCfg: { + margin: 20 + }, + shadow: false + }, + rotationOffset: -Math.PI / 2, + setField: function(a) { + return this.setXField(a) + }, + getField: function() { + return this.getXField() + }, + updateRotation: function(a) { + this.setStyle({ + baseRotation: a + this.rotationOffset + }); + this.doUpdateStyles() + }, + updateDistortion: function() { + this.setRadius() + }, + updateThickness: function() { + this.setRadius() + }, + updateColors: function(a) { + this.setSubStyle({ + baseColor: a + }) + }, + applyShadow: function(a) { + if (a === true) { + a = { + shadowColor: "rgba(0,0,0,0.8)", + shadowBlur: 30 + } + } else { + if (!Ext.isObject(a)) { + a = { + shadowColor: Ext.draw.Color.RGBA_NONE + } + } + } + return a + }, + updateShadow: function(g) { + var e = this, + f = e.getSprites(), + d = e.spritesPerSlice, + c = f && f.length, + b, a; + for (b = 1; b < c; b += d) { + a = f[b]; + if (a.attr.part = "bottom") { + a.setAttributes(g) + } + } + }, + getStyleByIndex: function(b) { + var d = this.callParent([b]), + c = this.getStyle(), + a = d.fillStyle || d.fill || d.color, + e = c.strokeStyle || c.stroke; + if (a) { + d.baseColor = a; + delete d.fillStyle; + delete d.fill; + delete d.color + } + if (e) { + d.strokeStyle = e + } + return d + }, + doUpdateStyles: function() { + var g = this, + h = g.getSprites(), + f = g.spritesPerSlice, + e = h && h.length, + c = 0, + b = 0, + a, d; + for (; c < e; c += f, b++) { + d = g.getStyleByIndex(b); + for (a = 0; a < f; a++) { + h[c + a].setAttributes(d) + } + } + }, + coordinateX: function() { + var w = this, + m = w.getChart(), + u = m && m.getAnimation(), + f = w.getStore(), + t = f.getData().items, + d = t.length, + b = w.getXField(), + p = w.getRotation(), + s = w.getHidden(), + n, c = 0, + h, e = [], + k = w.getSprites(), + a = k.length, + l = w.spritesPerSlice, + g = 0, + o = Math.PI * 2, + v = 1e-10, + r, q; + for (r = 0; r < d; r++) { + n = Math.abs(Number(t[r].get(b))) || 0; + if (!s[r]) { + c += n + } + e[r] = c; + if (r >= s.length) { + s[r] = false + } + } + s.length = d; + if (c === 0) { + return + } + h = 2 * Math.PI / c; + for (r = 0; r < d; r++) { + e[r] *= h + } + for (r = 0; r < a; r++) { + k[r].setAnimation(u) + } + for (r = 0; r < d; r++) { + for (q = 0; q < l; q++) { + k[r * l + q].setAttributes({ + startAngle: g, + endAngle: e[r] - v, + globalAlpha: 1, + baseRotation: p + }) + } + g = e[r] + } + for (r *= l; r < a; r++) { + k[r].setAnimation(u); + k[r].setAttributes({ + startAngle: o, + endAngle: o, + globalAlpha: 0, + baseRotation: p + }) + } + }, + updateLabelData: function() { + var l = this, + m = l.getStore(), + k = m.getData().items, + h = l.getSprites(), + b = l.getLabel().getTemplate().getField(), + f = l.getHidden(), + a = l.spritesPerSlice, + d, c, g, e, n; + if (h.length && b) { + e = []; + for (d = 0, g = k.length; d < g; d++) { + e.push(k[d].get(b)) + } + for (d = 0, c = 0, g = h.length; d < g; d += a, c++) { + n = h[d]; + n.setAttributes({ + label: e[c] + }); + n.putMarker("labels", { + hidden: f[c] + }, n.attr.attributeId) + } + } + }, + applyRadius: function() { + var f = this, + d = f.getChart(), + h = d.getInnerPadding(), + e = d.getMainRect() || [0, 0, 1, 1], + c = e[2] - h * 2, + a = e[3] - h * 2 - f.getThickness(), + g = c / 2, + b = g * f.getDistortion(); + if (b > a / 2) { + return a / (f.getDistortion() * 2) + } else { + return g + } + }, + getSprites: function() { + var y = this, + e = y.getStore(); + if (!e) { + return [] + } + var n = y.getChart(), + p = y.getSurface(), + t = e.getData().items, + l = y.spritesPerSlice, + a = t.length, + v = y.getAnimation() || n && n.getAnimation(), + x = y.getCenter(), + w = y.getOffsetX(), + u = y.getOffsetY(), + b = y.getRadius(), + q = y.getRotation(), + d = y.getHighlight(), + c = { + centerX: x[0] + w, + centerY: x[1] + u - y.getThickness() / 2, + endRho: b, + startRho: b * y.getDonut() / 100, + thickness: y.getThickness(), + distortion: y.getDistortion() + }, + k = y.sprites, + h = y.getLabel(), + f = h.getTemplate(), + m, g, o, s, r; + for (s = 0; s < a; s++) { + g = Ext.apply({}, this.getStyleByIndex(s), c); + if (!k[s * l]) { + for (r = 0; r < y.partNames.length; r++) { + o = p.add({ + type: "pie3dPart", + part: y.partNames[r] + }); + if (r === 0 && f.getField()) { + o.bindMarker("labels", h) + } + o.fx.setDurationOn("baseRotation", q); + if (d) { + o.config.highlight = d; + o.addModifier("highlight", true) + } + o.setAttributes(g); + k.push(o) + } + } else { + m = k.slice(s * l, (s + 1) * l); + for (r = 0; r < m.length; r++) { + o = m[r]; + if (v) { + o.setAnimation(v) + } + o.setAttributes(g) + } + } + } + return k + }, + betweenAngle: function(d, f, c) { + var e = Math.PI * 2, + g = this.rotationOffset; + f += g; + c += g; + d -= f; + c -= f; + d %= e; + c %= e; + d += e; + c += e; + d %= e; + c %= e; + return d < c || c === 0 + }, + getItemForPoint: function(k, j) { + var h = this, + g = h.getSprites(); + if (g) { + var l = h.getStore(), + b = l.getData().items, + a = h.spritesPerSlice, + e = h.getHidden(), + c, f, m, d; + for (c = 0, f = b.length; c < f; c++) { + if (!e[c]) { + d = c * a; + m = g[d]; + if (m.hitTest([k, j])) { + return { + series: h, + sprite: g.slice(d, d + a), + index: c, + record: b[c], + category: "sprites", + field: h.getXField() + } + } + } + } + return null + } + }, + provideLegendInfo: function(f) { + var h = this, + k = h.getStore(); + if (k) { + var g = k.getData().items, + b = h.getLabel().getTemplate().getField(), + j = h.getField(), + e = h.getHidden(), + d, a, c; + for (d = 0; d < g.length; d++) { + a = h.getStyleByIndex(d); + c = a.baseColor; + f.push({ + name: b ? String(g[d].get(b)) : j + " " + d, + mark: c || "black", + disabled: e[d], + series: h.getId(), + index: d + }) + } + } + } +}, function() { + var b = this.prototype, + a = Ext.chart.series.sprite.Pie3DPart.def.getInitialConfig().processors.part; + b.partNames = a.replace(/^enums\(|\)/g, "").split(","); + b.spritesPerSlice = b.partNames.length +}); +Ext.define("Ext.chart.series.sprite.Polar", { + extend: "Ext.chart.series.sprite.Series", + inheritableStatics: { + def: { + processors: { + centerX: "number", + centerY: "number", + startAngle: "number", + endAngle: "number", + startRho: "number", + endRho: "number", + baseRotation: "number", + labels: "default", + labelOverflowPadding: "number" + }, + defaults: { + centerX: 0, + centerY: 0, + startAngle: 0, + endAngle: Math.PI, + startRho: 0, + endRho: 150, + baseRotation: 0, + labels: null, + labelOverflowPadding: 10 + }, + triggers: { + centerX: "bbox", + centerY: "bbox", + startAngle: "bbox", + endAngle: "bbox", + startRho: "bbox", + endRho: "bbox", + baseRotation: "bbox" + } + } + }, + updatePlainBBox: function(b) { + var a = this.attr; + b.x = a.centerX - a.endRho; + b.y = a.centerY + a.endRho; + b.width = a.endRho * 2; + b.height = a.endRho * 2 + } +}); +Ext.define("Ext.chart.series.sprite.Radar", { + alias: "sprite.radar", + extend: "Ext.chart.series.sprite.Polar", + getDataPointXY: function(d) { + var u = this, + n = u.attr, + f = n.centerX, + e = n.centerY, + o = n.matrix, + t = n.dataMinX, + s = n.dataMaxX, + k = n.dataX, + j = n.dataY, + l = n.endRho, + p = n.startRho, + g = n.baseRotation, + i, h, m, c, b, a, q; + if (n.rangeY) { + q = n.rangeY[1] + } else { + q = n.dataMaxY + } + c = (k[d] - t) / (s - t + 1) * 2 * Math.PI + g; + m = j[d] / q * (l - p) + p; + b = f + Math.cos(c) * m; + a = e + Math.sin(c) * m; + i = o.x(b, a); + h = o.y(b, a); + return [i, h] + }, + render: function(a, l) { + var h = this, + f = h.attr, + g = f.dataX, + b = g.length, + e = h.surfaceMatrix, + d = {}, + c, k, j, m; + l.beginPath(); + for (c = 0; c < b; c++) { + m = h.getDataPointXY(c); + k = m[0]; + j = m[1]; + if (c === 0) { + l.moveTo(k, j) + } + l.lineTo(k, j); + d.translationX = e.x(k, j); + d.translationY = e.y(k, j); + h.putMarker("markers", d, c, true) + } + l.closePath(); + l.fillStroke(f) + } +}); +Ext.define("Ext.chart.series.Radar", { + extend: "Ext.chart.series.Polar", + type: "radar", + seriesType: "radar", + alias: "series.radar", + requires: ["Ext.chart.series.sprite.Radar"], + themeColorCount: function() { + return 1 + }, + isStoreDependantColorCount: false, + themeMarkerCount: function() { + return 1 + }, + updateAngularAxis: function(a) { + a.processData(this) + }, + updateRadialAxis: function(a) { + a.processData(this) + }, + coordinateX: function() { + return this.coordinate("X", 0, 2) + }, + coordinateY: function() { + return this.coordinate("Y", 1, 2) + }, + updateCenter: function(a) { + this.setStyle({ + translationX: a[0] + this.getOffsetX(), + translationY: a[1] + this.getOffsetY() + }); + this.doUpdateStyles() + }, + updateRadius: function(a) { + this.setStyle({ + endRho: a + }); + this.doUpdateStyles() + }, + updateRotation: function(a) { + this.setStyle({ + rotationRads: a + }); + this.doUpdateStyles() + }, + updateTotalAngle: function(a) { + this.processData() + }, + getItemForPoint: function(k, j) { + var h = this, + m = h.sprites && h.sprites[0], + f = m.attr, + g = f.dataX, + a = g.length, + l = h.getStore(), + e = h.getMarker(), + b, o, p, d, n, c; + if (h.getHidden()) { + return null + } + if (m && e) { + c = m.getMarker("markers"); + for (d = 0; d < a; d++) { + n = c.getBBoxFor(d); + b = (n.width + n.height) * 0.25; + p = m.getDataPointXY(d); + if (Math.abs(p[0] - k) < b && Math.abs(p[1] - j) < b) { + o = { + series: h, + sprite: m, + index: d, + category: "markers", + record: l.getData().items[d], + field: h.getYField() + }; + return o + } + } + } + return h.callParent(arguments) + }, + getDefaultSpriteConfig: function() { + var a = this.callParent(), + b = { + customDurations: { + translationX: 0, + translationY: 0, + rotationRads: 0, + dataMinX: 0, + dataMaxX: 0 + } + }; + if (a.fx) { + Ext.apply(a.fx, b) + } else { + a.fx = b + } + return a + }, + getSprites: function() { + var d = this, + c = d.getChart(), + e = d.getAnimation() || c && c.getAnimation(), + b = d.sprites[0], + a; + if (!c) { + return [] + } + if (!b) { + b = d.createSprite() + } + if (e) { + a = b.getMarker("markers"); + if (a) { + a.getTemplate().setAnimation(e) + } + b.setAnimation(e) + } + return d.sprites + }, + provideLegendInfo: function(d) { + var b = this, + a = b.getSubStyleWithTheme(), + c = a.fillStyle; + if (Ext.isArray(c)) { + c = c[0] + } + d.push({ + name: b.getTitle() || b.getYField() || b.getId(), + mark: (Ext.isObject(c) ? c.stops && c.stops[0].color : c) || a.strokeStyle || "black", + disabled: b.getHidden(), + series: b.getId(), + index: 0 + }) + } +}); +Ext.define("Ext.chart.series.sprite.Scatter", { + alias: "sprite.scatterSeries", + extend: "Ext.chart.series.sprite.Cartesian", + renderClipped: function(r, s, w, u) { + if (this.cleanRedraw) { + return + } + var C = this, + q = C.attr, + l = q.dataX, + h = q.dataY, + z = q.labels, + j = C.getSeries(), + b = z && C.getMarker("labels"), + t = C.attr.matrix, + c = t.getXX(), + p = t.getYY(), + m = t.getDX(), + k = t.getDY(), + n = {}, + D, B, d = r.getInherited().rtl && !q.flipXY ? -1 : 1, + a, A, o, e, g, f, v; + if (q.flipXY) { + a = u[1] - c * d; + A = u[1] + u[3] + c * d; + o = u[0] - p; + e = u[0] + u[2] + p + } else { + a = u[0] - c * d; + A = u[0] + u[2] + c * d; + o = u[1] - p; + e = u[1] + u[3] + p + } + for (v = 0; v < l.length; v++) { + g = l[v]; + f = h[v]; + g = g * c + m; + f = f * p + k; + if (a <= g && g <= A && o <= f && f <= e) { + if (q.renderer) { + n = { + type: "items", + translationX: g, + translationY: f + }; + B = [C, n, { + store: C.getStore() + }, v]; + D = Ext.callback(q.renderer, null, B, 0, j); + n = Ext.apply(n, D) + } else { + n.translationX = g; + n.translationY = f + } + C.putMarker("items", n, v, !q.renderer); + if (b && z[v]) { + C.drawLabel(z[v], g, f, v, u) + } + } + } + }, + drawLabel: function(j, h, g, p, a) { + var r = this, + m = r.attr, + d = r.getMarker("labels"), + c = d.getTemplate(), + l = r.labelCfg || (r.labelCfg = {}), + b = r.surfaceMatrix, + f, e, i = m.labelOverflowPadding, + o = m.flipXY, + k, n, s, q; + l.text = j; + n = r.getMarkerBBox("labels", p, true); + if (!n) { + r.putMarker("labels", l, p); + n = r.getMarkerBBox("labels", p, true) + } + if (o) { + l.rotationRads = Math.PI * 0.5 + } else { + l.rotationRads = 0 + } + k = n.height / 2; + f = h; + switch (c.attr.display) { + case "under": + e = g - k - i; + break; + case "rotate": + f += i; + e = g - i; + l.rotationRads = -Math.PI / 4; + break; + default: + e = g + k + i + } + l.x = b.x(f, e); + l.y = b.y(f, e); + if (c.attr.renderer) { + q = [j, d, l, { + store: r.getStore() + }, p]; + s = Ext.callback(c.attr.renderer, null, q, 0, r.getSeries()); + if (typeof s === "string") { + l.text = s + } else { + Ext.apply(l, s) + } + } + r.putMarker("labels", l, p) + } +}); +Ext.define("Ext.chart.series.Scatter", { + extend: "Ext.chart.series.Cartesian", + alias: "series.scatter", + type: "scatter", + seriesType: "scatterSeries", + requires: ["Ext.chart.series.sprite.Scatter"], + config: { + itemInstancing: { + fx: { + customDurations: { + translationX: 0, + translationY: 0 + } + } + } + }, + themeMarkerCount: function() { + return 1 + }, + applyMarker: function(b, a) { + this.getItemInstancing(); + this.setItemInstancing(b); + return this.callParent(arguments) + }, + provideLegendInfo: function(d) { + var b = this, + a = b.getMarkerStyleByIndex(0), + c = a.fillStyle; + d.push({ + name: b.getTitle() || b.getYField() || b.getId(), + mark: (Ext.isObject(c) ? c.stops && c.stops[0].color : c) || a.strokeStyle || "black", + disabled: b.getHidden(), + series: b.getId(), + index: 0 + }) + } +}); +Ext.define("Ext.chart.theme.Blue", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.blue", "chart.theme.Blue"], + config: { + baseColor: "#4d7fe6" + } +}); +Ext.define("Ext.chart.theme.BlueGradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.blue-gradients", "chart.theme.Blue:gradients"], + config: { + baseColor: "#4d7fe6", + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Category1", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category1", "chart.theme.Category1"], + config: { + colors: ["#f0a50a", "#c20024", "#2044ba", "#810065", "#7eae29"] + } +}); +Ext.define("Ext.chart.theme.Category1Gradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category1-gradients", "chart.theme.Category1:gradients"], + config: { + colors: ["#f0a50a", "#c20024", "#2044ba", "#810065", "#7eae29"], + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Category2", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category2", "chart.theme.Category2"], + config: { + colors: ["#6d9824", "#87146e", "#2a9196", "#d39006", "#1e40ac"] + } +}); +Ext.define("Ext.chart.theme.Category2Gradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category2-gradients", "chart.theme.Category2:gradients"], + config: { + colors: ["#6d9824", "#87146e", "#2a9196", "#d39006", "#1e40ac"], + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Category3", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category3", "chart.theme.Category3"], + config: { + colors: ["#fbbc29", "#ce2e4e", "#7e0062", "#158b90", "#57880e"] + } +}); +Ext.define("Ext.chart.theme.Category3Gradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category3-gradients", "chart.theme.Category3:gradients"], + config: { + colors: ["#fbbc29", "#ce2e4e", "#7e0062", "#158b90", "#57880e"], + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Category4", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category4", "chart.theme.Category4"], + config: { + colors: ["#ef5773", "#fcbd2a", "#4f770d", "#1d3eaa", "#9b001f"] + } +}); +Ext.define("Ext.chart.theme.Category4Gradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category4-gradients", "chart.theme.Category4:gradients"], + config: { + colors: ["#ef5773", "#fcbd2a", "#4f770d", "#1d3eaa", "#9b001f"], + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Category5", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category5", "chart.theme.Category5"], + config: { + colors: ["#7eae29", "#fdbe2a", "#910019", "#27b4bc", "#d74dbc"] + } +}); +Ext.define("Ext.chart.theme.Category5Gradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category5-gradients", "chart.theme.Category5:gradients"], + config: { + colors: ["#7eae29", "#fdbe2a", "#910019", "#27b4bc", "#d74dbc"], + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Category6", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category6", "chart.theme.Category6"], + config: { + colors: ["#44dce1", "#0b2592", "#996e05", "#7fb325", "#b821a1"] + } +}); +Ext.define("Ext.chart.theme.Category6Gradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.category6-gradients", "chart.theme.Category6:gradients"], + config: { + colors: ["#44dce1", "#0b2592", "#996e05", "#7fb325", "#b821a1"], + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.DefaultGradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.default-gradients", "chart.theme.Base:gradients"], + config: { + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Green", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.green", "chart.theme.Green"], + config: { + baseColor: "#b1da5a" + } +}); +Ext.define("Ext.chart.theme.GreenGradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.green-gradients", "chart.theme.Green:gradients"], + config: { + baseColor: "#b1da5a", + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Midnight", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.midnight", "chart.theme.Midnight"], + config: { + colors: ["#A837FF", "#4AC0F2", "#FF4D35", "#FF8809", "#61C102", "#FF37EA"], + chart: { + defaults: { + background: "rgb(52, 52, 53)" + } + }, + axis: { + defaults: { + style: { + strokeStyle: "rgb(224, 224, 227)" + }, + label: { + fillStyle: "rgb(224, 224, 227)" + }, + title: { + fillStyle: "rgb(224, 224, 227)" + }, + grid: { + strokeStyle: "rgb(112, 112, 115)" + } + } + }, + series: { + defaults: { + label: { + fillStyle: "rgb(224, 224, 227)" + } + } + }, + sprites: { + text: { + fillStyle: "rgb(224, 224, 227)" + } + } + } +}); +Ext.define("Ext.chart.theme.Muted", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.muted", "chart.theme.Muted"], + config: { + colors: ["#8ca640", "#974144", "#4091ba", "#8e658e", "#3b8d8b", "#b86465", "#d2af69", "#6e8852", "#3dcc7e", "#a6bed1", "#cbaa4b", "#998baa"] + } +}); +Ext.define("Ext.chart.theme.Purple", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.purple", "chart.theme.Purple"], + config: { + baseColor: "#da5abd" + } +}); +Ext.define("Ext.chart.theme.PurpleGradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.purple-gradients", "chart.theme.Purple:gradients"], + config: { + baseColor: "#da5abd", + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Red", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.red", "chart.theme.Red"], + config: { + baseColor: "#e84b67" + } +}); +Ext.define("Ext.chart.theme.RedGradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.red-gradients", "chart.theme.Red:gradients"], + config: { + baseColor: "#e84b67", + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Sky", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.sky", "chart.theme.Sky"], + config: { + baseColor: "#4ce0e7" + } +}); +Ext.define("Ext.chart.theme.SkyGradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.sky-gradients", "chart.theme.Sky:gradients"], + config: { + baseColor: "#4ce0e7", + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.chart.theme.Yellow", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.yellow", "chart.theme.Yellow"], + config: { + baseColor: "#fec935" + } +}); +Ext.define("Ext.chart.theme.YellowGradients", { + extend: "Ext.chart.theme.Base", + singleton: true, + alias: ["chart.theme.yellow-gradients", "chart.theme.Yellow:gradients"], + config: { + baseColor: "#fec935", + gradients: { + type: "linear", + degrees: 90 + } + } +}); +Ext.define("Ext.draw.Point", { + requires: ["Ext.draw.Draw", "Ext.draw.Matrix"], + isPoint: true, + x: 0, + y: 0, + length: 0, + angle: 0, + angleUnits: "degrees", + statics: { + fly: (function() { + var a = null; + return function(b, c) { + if (!a) { + a = new Ext.draw.Point() + } + a.constructor(b, c); + return a + } + })() + }, + constructor: function(a, c) { + var b = this; + if (typeof a === "number") { + b.x = a; + if (typeof c === "number") { + b.y = c + } else { + b.y = a + } + } else { + if (Ext.isArray(a)) { + b.x = a[0]; + b.y = a[1] + } else { + if (a) { + b.x = a.x; + b.y = a.y + } + } + } + b.calculatePolar() + }, + calculateCartesian: function() { + var b = this, + a = b.length, + c = b.angle; + if (b.angleUnits === "degrees") { + c = Ext.draw.Draw.rad(c) + } + b.x = Math.cos(c) * a; + b.y = Math.sin(c) * a + }, + calculatePolar: function() { + var b = this, + a = b.x, + c = b.y; + b.length = Math.sqrt(a * a + c * c); + b.angle = Math.atan2(c, a); + if (b.angleUnits === "degrees") { + b.angle = Ext.draw.Draw.degrees(b.angle) + } + }, + setX: function(a) { + this.x = a; + this.calculatePolar() + }, + setY: function(a) { + this.y = a; + this.calculatePolar() + }, + set: function(a, b) { + this.constructor(a, b) + }, + setAngle: function(a) { + this.angle = a; + this.calculateCartesian() + }, + setLength: function(a) { + this.length = a; + this.calculateCartesian() + }, + setPolar: function(b, a) { + this.angle = b; + this.length = a; + this.calculateCartesian() + }, + clone: function() { + return new Ext.draw.Point(this.x, this.y) + }, + add: function(a, c) { + var b = Ext.draw.Point.fly(a, c); + return new Ext.draw.Point(this.x + b.x, this.y + b.y) + }, + sub: function(a, c) { + var b = Ext.draw.Point.fly(a, c); + return new Ext.draw.Point(this.x - b.x, this.y - b.y) + }, + mul: function(a) { + return new Ext.draw.Point(this.x * a, this.y * a) + }, + div: function(a) { + return new Ext.draw.Point(this.x / a, this.y / a) + }, + dot: function(a, c) { + var b = Ext.draw.Point.fly(a, c); + return this.x * b.x + this.y * b.y + }, + equals: function(a, c) { + var b = Ext.draw.Point.fly(a, c); + return this.x === b.x && this.y === b.y + }, + rotate: function(f, c) { + var d, e, b, g, a; + if (this.angleUnits === "degrees") { + f = Ext.draw.Draw.rad(f); + d = Math.sin(f); + e = Math.cos(f) + } + if (c) { + b = c.x; + g = c.y + } else { + b = 0; + g = 0 + } + a = Ext.draw.Matrix.fly([e, d, -d, e, b - e * b + g * d, g - e * g + b * -d]).transformPoint(this); + return new Ext.draw.Point(a) + }, + transform: function(a) { + if (a && a.isMatrix) { + return new Ext.draw.Point(a.transformPoint(this)) + } else { + if (arguments.length === 6) { + return new Ext.draw.Point(Ext.draw.Matrix.fly(arguments).transformPoint(this)) + } else { + Ext.raise("Invalid parameters.") + } + } + }, + round: function() { + return new Ext.draw.Point(Math.round(this.x), Math.round(this.y)) + }, + ceil: function() { + return new Ext.draw.Point(Math.ceil(this.x), Math.ceil(this.y)) + }, + floor: function() { + return new Ext.draw.Point(Math.floor(this.x), Math.floor(this.y)) + }, + abs: function(a, b) { + return new Ext.draw.Point(Math.abs(this.x), Math.abs(this.y)) + }, + normalize: function(c) { + var b = this.x, + f = this.y, + a, e, d; + c = c || 1; + if (b === 0) { + a = 0; + e = c * Ext.Number.sign(f) + } else { + d = f / b; + a = c / Math.sqrt(1 + d * d); + e = a * d + } + return new Ext.draw.Point(a, e) + }, + getDistanceToLine: function(c, b) { + if (arguments.length === 4) { + c = new Ext.draw.Point(arguments[0], arguments[1]); + b = new Ext.draw.Point(arguments[2], arguments[3]) + } + var d = b.sub(c).normalize(), + a = c.sub(this); + return a.sub(d.mul(a.dot(d))) + }, + isZero: function() { + return this.x === 0 && this.y === 0 + }, + isNumber: function() { + return Ext.isNumber(this.x + this.y) + } +}); +Ext.define("Ext.draw.plugin.SpriteEvents", { + extend: "Ext.plugin.Abstract", + alias: "plugin.spriteevents", + requires: ["Ext.draw.PathUtil"], + mouseMoveEvents: { + mousemove: true, + mouseover: true, + mouseout: true + }, + spriteMouseMoveEvents: { + spritemousemove: true, + spritemouseover: true, + spritemouseout: true + }, + init: function(a) { + var b = "handleEvent"; + this.drawContainer = a; + a.addElementListener({ + click: b, + dblclick: b, + mousedown: b, + mousemove: b, + mouseup: b, + mouseover: b, + mouseout: b, + priority: 1001, + scope: this + }) + }, + hasSpriteMouseMoveListeners: function() { + var b = this.drawContainer.hasListeners, + a; + for (a in this.spriteMouseMoveEvents) { + if (a in b) { + return true + } + } + return false + }, + hitTestEvent: function(f) { + var b = this.drawContainer.getItems(), + a, d, c; + for (c = b.length - 1; c >= 0; c--) { + a = b.get(c); + d = a.hitTestEvent(f); + if (d) { + return d + } + } + return null + }, + handleEvent: function(f) { + var d = this, + b = d.drawContainer, + g = f.type in d.mouseMoveEvents, + a = d.lastSprite, + c; + if (g && !d.hasSpriteMouseMoveListeners()) { + return + } + c = d.hitTestEvent(f); + if (g && !Ext.Object.equals(c, a)) { + if (a) { + b.fireEvent("spritemouseout", a, f) + } + if (c) { + b.fireEvent("spritemouseover", c, f) + } + } + if (c) { + b.fireEvent("sprite" + f.type, c, f) + } + d.lastSprite = c + } +}); +Ext.define("Ext.chart.TipSurface", { + extend: "Ext.draw.Container", + spriteArray: false, + renderFirst: true, + constructor: function(a) { + this.callParent([a]); + if (a.sprites) { + this.spriteArray = [].concat(a.sprites); + delete a.sprites + } + }, + onRender: function() { + var c = this, + b = 0, + a = 0, + d, e; + this.callParent(arguments); + e = c.spriteArray; + if (c.renderFirst && e) { + c.renderFirst = false; + for (a = e.length; b < a; b++) { + d = c.surface.add(e[b]); + d.setAttributes({ + hidden: false + }, true) + } + } + } +}); +Ext.define("Ext.chart.interactions.ItemInfo", { + extend: "Ext.chart.interactions.Abstract", + type: "iteminfo", + alias: "interaction.iteminfo", + config: { + extjsGestures: { + start: { + event: "click", + handler: "onInfoGesture" + }, + move: { + event: "mousemove", + handler: "onInfoGesture" + }, + end: { + event: "mouseleave", + handler: "onInfoGesture" + } + } + }, + item: null, + onInfoGesture: function(f, a) { + var c = this, + b = c.getItemForEvent(f), + d = b && b.series.tooltip; + if (d) { + d.onMouseMove.call(d, f) + } + if (b !== c.item) { + if (b) { + b.series.showTip(b) + } else { + c.item.series.hideTip(c.item) + } + c.item = b + } + return false + } +});