2738 lines
68 KiB
JavaScript
2738 lines
68 KiB
JavaScript
/* Javascript plotting library for jQuery, v. 0.7.
|
|
*
|
|
* Released under the MIT license by IOLA, December 2007.
|
|
*
|
|
*/
|
|
(function (b) {
|
|
b.color = {};
|
|
b.color.make = function (d, e, g, f) {
|
|
var c = {};
|
|
c.r = d || 0;
|
|
c.g = e || 0;
|
|
c.b = g || 0;
|
|
c.a = f != null ? f : 1;
|
|
c.add = function (h, j) {
|
|
for (var k = 0; k < h.length; ++k) {
|
|
c[h.charAt(k)] += j;
|
|
}
|
|
return c.normalize();
|
|
};
|
|
c.scale = function (h, j) {
|
|
for (var k = 0; k < h.length; ++k) {
|
|
c[h.charAt(k)] *= j;
|
|
}
|
|
return c.normalize();
|
|
};
|
|
c.toString = function () {
|
|
if (c.a >= 1) {
|
|
return "rgb(" + [c.r, c.g, c.b].join(",") + ")";
|
|
} else {
|
|
return "rgba(" + [c.r, c.g, c.b, c.a].join(",") + ")";
|
|
}
|
|
};
|
|
c.normalize = function () {
|
|
function h(k, j, l) {
|
|
return j < k ? k : j > l ? l : j;
|
|
}
|
|
c.r = h(0, parseInt(c.r), 255);
|
|
c.g = h(0, parseInt(c.g), 255);
|
|
c.b = h(0, parseInt(c.b), 255);
|
|
c.a = h(0, c.a, 1);
|
|
return c;
|
|
};
|
|
c.clone = function () {
|
|
return b.color.make(c.r, c.b, c.g, c.a);
|
|
};
|
|
return c.normalize();
|
|
};
|
|
b.color.extract = function (d, e) {
|
|
var c;
|
|
do {
|
|
c = d.css(e).toLowerCase();
|
|
if (c != "" && c != "transparent") {
|
|
break;
|
|
}
|
|
d = d.parent();
|
|
} while (!b.nodeName(d.get(0), "body"));
|
|
if (c == "rgba(0, 0, 0, 0)") {
|
|
c = "transparent";
|
|
}
|
|
return b.color.parse(c);
|
|
};
|
|
b.color.parse = function (c) {
|
|
var d,
|
|
f = b.color.make;
|
|
if (
|
|
(d =
|
|
/rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(
|
|
c
|
|
))
|
|
) {
|
|
return f(parseInt(d[1], 10), parseInt(d[2], 10), parseInt(d[3], 10));
|
|
}
|
|
if (
|
|
(d =
|
|
/rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(
|
|
c
|
|
))
|
|
) {
|
|
return f(
|
|
parseInt(d[1], 10),
|
|
parseInt(d[2], 10),
|
|
parseInt(d[3], 10),
|
|
parseFloat(d[4])
|
|
);
|
|
}
|
|
if (
|
|
(d =
|
|
/rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(
|
|
c
|
|
))
|
|
) {
|
|
return f(
|
|
parseFloat(d[1]) * 2.55,
|
|
parseFloat(d[2]) * 2.55,
|
|
parseFloat(d[3]) * 2.55
|
|
);
|
|
}
|
|
if (
|
|
(d =
|
|
/rgba\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(
|
|
c
|
|
))
|
|
) {
|
|
return f(
|
|
parseFloat(d[1]) * 2.55,
|
|
parseFloat(d[2]) * 2.55,
|
|
parseFloat(d[3]) * 2.55,
|
|
parseFloat(d[4])
|
|
);
|
|
}
|
|
if ((d = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(c))) {
|
|
return f(parseInt(d[1], 16), parseInt(d[2], 16), parseInt(d[3], 16));
|
|
}
|
|
if ((d = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(c))) {
|
|
return f(
|
|
parseInt(d[1] + d[1], 16),
|
|
parseInt(d[2] + d[2], 16),
|
|
parseInt(d[3] + d[3], 16)
|
|
);
|
|
}
|
|
var e = b.trim(c).toLowerCase();
|
|
if (e == "transparent") {
|
|
return f(255, 255, 255, 0);
|
|
} else {
|
|
d = a[e] || [0, 0, 0];
|
|
return f(d[0], d[1], d[2]);
|
|
}
|
|
};
|
|
var a = {
|
|
aqua: [0, 255, 255],
|
|
azure: [240, 255, 255],
|
|
beige: [245, 245, 220],
|
|
black: [0, 0, 0],
|
|
blue: [0, 0, 255],
|
|
brown: [165, 42, 42],
|
|
cyan: [0, 255, 255],
|
|
darkblue: [0, 0, 139],
|
|
darkcyan: [0, 139, 139],
|
|
darkgrey: [169, 169, 169],
|
|
darkgreen: [0, 100, 0],
|
|
darkkhaki: [189, 183, 107],
|
|
darkmagenta: [139, 0, 139],
|
|
darkolivegreen: [85, 107, 47],
|
|
darkorange: [255, 140, 0],
|
|
darkorchid: [153, 50, 204],
|
|
darkred: [139, 0, 0],
|
|
darksalmon: [233, 150, 122],
|
|
darkviolet: [148, 0, 211],
|
|
fuchsia: [255, 0, 255],
|
|
gold: [255, 215, 0],
|
|
green: [0, 128, 0],
|
|
indigo: [75, 0, 130],
|
|
khaki: [240, 230, 140],
|
|
lightblue: [173, 216, 230],
|
|
lightcyan: [224, 255, 255],
|
|
lightgreen: [144, 238, 144],
|
|
lightgrey: [211, 211, 211],
|
|
lightpink: [255, 182, 193],
|
|
lightyellow: [255, 255, 224],
|
|
lime: [0, 255, 0],
|
|
magenta: [255, 0, 255],
|
|
maroon: [128, 0, 0],
|
|
navy: [0, 0, 128],
|
|
olive: [128, 128, 0],
|
|
orange: [255, 165, 0],
|
|
pink: [255, 192, 203],
|
|
purple: [128, 0, 128],
|
|
violet: [128, 0, 128],
|
|
red: [255, 0, 0],
|
|
silver: [192, 192, 192],
|
|
white: [255, 255, 255],
|
|
yellow: [255, 255, 0],
|
|
};
|
|
})(jQuery);
|
|
(function (c) {
|
|
function b(av, ai, J, af) {
|
|
var Q = [],
|
|
O = {
|
|
colors: ["#488c13", "#da4b0f", "#e9b104", "#97080e", "#1b55c0"],
|
|
legend: {
|
|
show: true,
|
|
noColumns: 1,
|
|
labelFormatter: null,
|
|
labelBoxBorderColor: "#ccc",
|
|
container: null,
|
|
position: "ne",
|
|
margin: 5,
|
|
backgroundColor: null,
|
|
backgroundOpacity: 0.85,
|
|
},
|
|
xaxis: {
|
|
show: null,
|
|
position: "bottom",
|
|
mode: null,
|
|
color: null,
|
|
tickColor: null,
|
|
transform: null,
|
|
inverseTransform: null,
|
|
min: null,
|
|
max: null,
|
|
autoscaleMargin: null,
|
|
ticks: null,
|
|
tickFormatter: null,
|
|
labelWidth: null,
|
|
labelHeight: null,
|
|
reserveSpace: null,
|
|
tickLength: null,
|
|
alignTicksWithAxis: null,
|
|
tickDecimals: null,
|
|
tickSize: null,
|
|
minTickSize: null,
|
|
monthNames: null,
|
|
timeformat: null,
|
|
twelveHourClock: false,
|
|
},
|
|
yaxis: { autoscaleMargin: 0.02, position: "left" },
|
|
xaxes: [],
|
|
yaxes: [],
|
|
series: {
|
|
points: {
|
|
show: false,
|
|
radius: 3,
|
|
lineWidth: 2,
|
|
fill: true,
|
|
fillColor: "#ffffff",
|
|
symbol: "circle",
|
|
},
|
|
lines: { lineWidth: 2, fill: false, fillColor: null, steps: false },
|
|
bars: {
|
|
show: false,
|
|
lineWidth: 2,
|
|
barWidth: 1,
|
|
fill: true,
|
|
fillColor: null,
|
|
align: "left",
|
|
horizontal: false,
|
|
},
|
|
shadowSize: 3,
|
|
},
|
|
grid: {
|
|
show: true,
|
|
aboveData: false,
|
|
color: "#545454",
|
|
backgroundColor: null,
|
|
borderColor: "#cdcdcd",
|
|
tickColor: "#ebebeb",
|
|
labelMargin: 5,
|
|
axisMargin: 8,
|
|
borderWidth: 1,
|
|
minBorderMargin: null,
|
|
markings: null,
|
|
markingsColor: "#f4f4f4",
|
|
markingsLineWidth: 2,
|
|
clickable: false,
|
|
hoverable: false,
|
|
autoHighlight: true,
|
|
mouseActiveRadius: 10,
|
|
},
|
|
hooks: {},
|
|
},
|
|
az = null,
|
|
ad = null,
|
|
y = null,
|
|
H = null,
|
|
A = null,
|
|
p = [],
|
|
aw = [],
|
|
q = { left: 0, right: 0, top: 0, bottom: 0 },
|
|
G = 0,
|
|
I = 0,
|
|
h = 0,
|
|
w = 0,
|
|
ak = {
|
|
processOptions: [],
|
|
processRawData: [],
|
|
processDatapoints: [],
|
|
drawSeries: [],
|
|
draw: [],
|
|
bindEvents: [],
|
|
drawOverlay: [],
|
|
shutdown: [],
|
|
},
|
|
aq = this;
|
|
aq.setData = aj;
|
|
aq.setupGrid = t;
|
|
aq.draw = W;
|
|
aq.getPlaceholder = function () {
|
|
return av;
|
|
};
|
|
aq.getCanvas = function () {
|
|
return az;
|
|
};
|
|
aq.getPlotOffset = function () {
|
|
return q;
|
|
};
|
|
aq.width = function () {
|
|
return h;
|
|
};
|
|
aq.height = function () {
|
|
return w;
|
|
};
|
|
aq.offset = function () {
|
|
var aB = y.offset();
|
|
aB.left += q.left;
|
|
aB.top += q.top;
|
|
return aB;
|
|
};
|
|
aq.getData = function () {
|
|
return Q;
|
|
};
|
|
aq.getAxes = function () {
|
|
var aC = {},
|
|
aB;
|
|
c.each(p.concat(aw), function (aD, aE) {
|
|
if (aE) {
|
|
aC[aE.direction + (aE.n != 1 ? aE.n : "") + "axis"] = aE;
|
|
}
|
|
});
|
|
return aC;
|
|
};
|
|
aq.getXAxes = function () {
|
|
return p;
|
|
};
|
|
aq.getYAxes = function () {
|
|
return aw;
|
|
};
|
|
aq.c2p = C;
|
|
aq.p2c = ar;
|
|
aq.getOptions = function () {
|
|
return O;
|
|
};
|
|
aq.highlight = x;
|
|
aq.unhighlight = T;
|
|
aq.triggerRedrawOverlay = f;
|
|
aq.pointOffset = function (aB) {
|
|
return {
|
|
left: parseInt(p[aA(aB, "x") - 1].p2c(+aB.x) + q.left),
|
|
top: parseInt(aw[aA(aB, "y") - 1].p2c(+aB.y) + q.top),
|
|
};
|
|
};
|
|
aq.shutdown = ag;
|
|
aq.resize = function () {
|
|
B();
|
|
g(az);
|
|
g(ad);
|
|
};
|
|
aq.hooks = ak;
|
|
F(aq);
|
|
Z(J);
|
|
X();
|
|
aj(ai);
|
|
t();
|
|
W();
|
|
ah();
|
|
|
|
function an(aD, aB) {
|
|
aB = [aq].concat(aB);
|
|
for (var aC = 0; aC < aD.length; ++aC) {
|
|
aD[aC].apply(this, aB);
|
|
}
|
|
}
|
|
|
|
function F() {
|
|
for (var aB = 0; aB < af.length; ++aB) {
|
|
var aC = af[aB];
|
|
aC.init(aq);
|
|
if (aC.options) {
|
|
c.extend(true, O, aC.options);
|
|
}
|
|
}
|
|
}
|
|
|
|
function Z(aC) {
|
|
var aB;
|
|
c.extend(true, O, aC);
|
|
if (O.xaxis.color == null) {
|
|
O.xaxis.color = O.grid.color;
|
|
}
|
|
if (O.yaxis.color == null) {
|
|
O.yaxis.color = O.grid.color;
|
|
}
|
|
if (O.xaxis.tickColor == null) {
|
|
O.xaxis.tickColor = O.grid.tickColor;
|
|
}
|
|
if (O.yaxis.tickColor == null) {
|
|
O.yaxis.tickColor = O.grid.tickColor;
|
|
}
|
|
if (O.grid.borderColor == null) {
|
|
O.grid.borderColor = O.grid.color;
|
|
}
|
|
if (O.grid.tickColor == null) {
|
|
O.grid.tickColor = c.color
|
|
.parse(O.grid.color)
|
|
.scale("a", 0.22)
|
|
.toString();
|
|
}
|
|
for (aB = 0; aB < Math.max(1, O.xaxes.length); ++aB) {
|
|
O.xaxes[aB] = c.extend(true, {}, O.xaxis, O.xaxes[aB]);
|
|
}
|
|
for (aB = 0; aB < Math.max(1, O.yaxes.length); ++aB) {
|
|
O.yaxes[aB] = c.extend(true, {}, O.yaxis, O.yaxes[aB]);
|
|
}
|
|
if (O.xaxis.noTicks && O.xaxis.ticks == null) {
|
|
O.xaxis.ticks = O.xaxis.noTicks;
|
|
}
|
|
if (O.yaxis.noTicks && O.yaxis.ticks == null) {
|
|
O.yaxis.ticks = O.yaxis.noTicks;
|
|
}
|
|
if (O.x2axis) {
|
|
O.xaxes[1] = c.extend(true, {}, O.xaxis, O.x2axis);
|
|
O.xaxes[1].position = "top";
|
|
}
|
|
if (O.y2axis) {
|
|
O.yaxes[1] = c.extend(true, {}, O.yaxis, O.y2axis);
|
|
O.yaxes[1].position = "right";
|
|
}
|
|
if (O.grid.coloredAreas) {
|
|
O.grid.markings = O.grid.coloredAreas;
|
|
}
|
|
if (O.grid.coloredAreasColor) {
|
|
O.grid.markingsColor = O.grid.coloredAreasColor;
|
|
}
|
|
if (O.lines) {
|
|
c.extend(true, O.series.lines, O.lines);
|
|
}
|
|
if (O.points) {
|
|
c.extend(true, O.series.points, O.points);
|
|
}
|
|
if (O.bars) {
|
|
c.extend(true, O.series.bars, O.bars);
|
|
}
|
|
if (O.shadowSize != null) {
|
|
O.series.shadowSize = O.shadowSize;
|
|
}
|
|
for (aB = 0; aB < O.xaxes.length; ++aB) {
|
|
V(p, aB + 1).options = O.xaxes[aB];
|
|
}
|
|
for (aB = 0; aB < O.yaxes.length; ++aB) {
|
|
V(aw, aB + 1).options = O.yaxes[aB];
|
|
}
|
|
for (var aD in ak) {
|
|
if (O.hooks[aD] && O.hooks[aD].length) {
|
|
ak[aD] = ak[aD].concat(O.hooks[aD]);
|
|
}
|
|
}
|
|
an(ak.processOptions, [O]);
|
|
}
|
|
|
|
function aj(aB) {
|
|
Q = Y(aB);
|
|
ax();
|
|
z();
|
|
}
|
|
|
|
function Y(aE) {
|
|
var aC = [];
|
|
for (var aB = 0; aB < aE.length; ++aB) {
|
|
var aD = c.extend(true, {}, O.series);
|
|
if (aE[aB].data != null) {
|
|
aD.data = aE[aB].data;
|
|
delete aE[aB].data;
|
|
c.extend(true, aD, aE[aB]);
|
|
aE[aB].data = aD.data;
|
|
} else {
|
|
aD.data = aE[aB];
|
|
}
|
|
aC.push(aD);
|
|
}
|
|
return aC;
|
|
}
|
|
|
|
function aA(aC, aD) {
|
|
var aB = aC[aD + "axis"];
|
|
if (typeof aB == "object") {
|
|
aB = aB.n;
|
|
}
|
|
if (typeof aB != "number") {
|
|
aB = 1;
|
|
}
|
|
return aB;
|
|
}
|
|
|
|
function m() {
|
|
return c.grep(p.concat(aw), function (aB) {
|
|
return aB;
|
|
});
|
|
}
|
|
|
|
function C(aE) {
|
|
var aC = {},
|
|
aB,
|
|
aD;
|
|
for (aB = 0; aB < p.length; ++aB) {
|
|
aD = p[aB];
|
|
if (aD && aD.used) {
|
|
aC["x" + aD.n] = aD.c2p(aE.left);
|
|
}
|
|
}
|
|
for (aB = 0; aB < aw.length; ++aB) {
|
|
aD = aw[aB];
|
|
if (aD && aD.used) {
|
|
aC["y" + aD.n] = aD.c2p(aE.top);
|
|
}
|
|
}
|
|
if (aC.x1 !== undefined) {
|
|
aC.x = aC.x1;
|
|
}
|
|
if (aC.y1 !== undefined) {
|
|
aC.y = aC.y1;
|
|
}
|
|
return aC;
|
|
}
|
|
|
|
function ar(aF) {
|
|
var aD = {},
|
|
aC,
|
|
aE,
|
|
aB;
|
|
for (aC = 0; aC < p.length; ++aC) {
|
|
aE = p[aC];
|
|
if (aE && aE.used) {
|
|
aB = "x" + aE.n;
|
|
if (aF[aB] == null && aE.n == 1) {
|
|
aB = "x";
|
|
}
|
|
if (aF[aB] != null) {
|
|
aD.left = aE.p2c(aF[aB]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (aC = 0; aC < aw.length; ++aC) {
|
|
aE = aw[aC];
|
|
if (aE && aE.used) {
|
|
aB = "y" + aE.n;
|
|
if (aF[aB] == null && aE.n == 1) {
|
|
aB = "y";
|
|
}
|
|
if (aF[aB] != null) {
|
|
aD.top = aE.p2c(aF[aB]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return aD;
|
|
}
|
|
|
|
function V(aC, aB) {
|
|
if (!aC[aB - 1]) {
|
|
aC[aB - 1] = {
|
|
n: aB,
|
|
direction: aC == p ? "x" : "y",
|
|
options: c.extend(true, {}, aC == p ? O.xaxis : O.yaxis),
|
|
};
|
|
}
|
|
return aC[aB - 1];
|
|
}
|
|
|
|
function ax() {
|
|
var aG;
|
|
var aM = Q.length,
|
|
aB = [],
|
|
aE = [];
|
|
for (aG = 0; aG < Q.length; ++aG) {
|
|
var aJ = Q[aG].color;
|
|
if (aJ != null) {
|
|
--aM;
|
|
if (typeof aJ == "number") {
|
|
aE.push(aJ);
|
|
} else {
|
|
aB.push(c.color.parse(Q[aG].color));
|
|
}
|
|
}
|
|
}
|
|
for (aG = 0; aG < aE.length; ++aG) {
|
|
aM = Math.max(aM, aE[aG] + 1);
|
|
}
|
|
var aC = [],
|
|
aF = 0;
|
|
aG = 0;
|
|
while (aC.length < aM) {
|
|
var aI;
|
|
if (O.colors.length == aG) {
|
|
aI = c.color.make(100, 100, 100);
|
|
} else {
|
|
aI = c.color.parse(O.colors[aG]);
|
|
}
|
|
var aD = aF % 2 == 1 ? -1 : 1;
|
|
aI.scale("rgb", 1 + aD * Math.ceil(aF / 2) * 0.2);
|
|
aC.push(aI);
|
|
++aG;
|
|
if (aG >= O.colors.length) {
|
|
aG = 0;
|
|
++aF;
|
|
}
|
|
}
|
|
var aH = 0,
|
|
aN;
|
|
for (aG = 0; aG < Q.length; ++aG) {
|
|
aN = Q[aG];
|
|
if (aN.color == null) {
|
|
aN.color = aC[aH].toString();
|
|
++aH;
|
|
} else {
|
|
if (typeof aN.color == "number") {
|
|
aN.color = aC[aN.color].toString();
|
|
}
|
|
}
|
|
if (aN.lines.show == null) {
|
|
var aL,
|
|
aK = true;
|
|
for (aL in aN) {
|
|
if (aN[aL] && aN[aL].show) {
|
|
aK = false;
|
|
break;
|
|
}
|
|
}
|
|
if (aK) {
|
|
aN.lines.show = true;
|
|
}
|
|
}
|
|
aN.xaxis = V(p, aA(aN, "x"));
|
|
aN.yaxis = V(aw, aA(aN, "y"));
|
|
}
|
|
}
|
|
|
|
function z() {
|
|
var aO = Number.POSITIVE_INFINITY,
|
|
aI = Number.NEGATIVE_INFINITY,
|
|
aB = Number.MAX_VALUE,
|
|
aU,
|
|
aS,
|
|
aR,
|
|
aN,
|
|
aD,
|
|
aJ,
|
|
aT,
|
|
aP,
|
|
aH,
|
|
aG,
|
|
aC,
|
|
a0,
|
|
aX,
|
|
aL;
|
|
|
|
function aF(a3, a2, a1) {
|
|
if (a2 < a3.datamin && a2 != -aB) {
|
|
a3.datamin = a2;
|
|
}
|
|
if (a1 > a3.datamax && a1 != aB) {
|
|
a3.datamax = a1;
|
|
}
|
|
}
|
|
c.each(m(), function (a1, a2) {
|
|
a2.datamin = aO;
|
|
a2.datamax = aI;
|
|
a2.used = false;
|
|
});
|
|
for (aU = 0; aU < Q.length; ++aU) {
|
|
aJ = Q[aU];
|
|
aJ.datapoints = { points: [] };
|
|
an(ak.processRawData, [aJ, aJ.data, aJ.datapoints]);
|
|
}
|
|
for (aU = 0; aU < Q.length; ++aU) {
|
|
aJ = Q[aU];
|
|
var aZ = aJ.data,
|
|
aW = aJ.datapoints.format;
|
|
if (!aW) {
|
|
aW = [];
|
|
aW.push({ x: true, number: true, required: true });
|
|
aW.push({ y: true, number: true, required: true });
|
|
if (aJ.bars.show || (aJ.lines.show && aJ.lines.fill)) {
|
|
aW.push({
|
|
y: true,
|
|
number: true,
|
|
required: false,
|
|
defaultValue: 0,
|
|
});
|
|
if (aJ.bars.horizontal) {
|
|
delete aW[aW.length - 1].y;
|
|
aW[aW.length - 1].x = true;
|
|
}
|
|
}
|
|
aJ.datapoints.format = aW;
|
|
}
|
|
if (aJ.datapoints.pointsize != null) {
|
|
continue;
|
|
}
|
|
aJ.datapoints.pointsize = aW.length;
|
|
aP = aJ.datapoints.pointsize;
|
|
aT = aJ.datapoints.points;
|
|
insertSteps = aJ.lines.show && aJ.lines.steps;
|
|
aJ.xaxis.used = aJ.yaxis.used = true;
|
|
for (aS = aR = 0; aS < aZ.length; ++aS, aR += aP) {
|
|
aL = aZ[aS];
|
|
var aE = aL == null;
|
|
if (!aE) {
|
|
for (aN = 0; aN < aP; ++aN) {
|
|
a0 = aL[aN];
|
|
aX = aW[aN];
|
|
if (aX) {
|
|
if (aX.number && a0 != null) {
|
|
a0 = +a0;
|
|
if (isNaN(a0)) {
|
|
a0 = null;
|
|
} else {
|
|
if (a0 == Infinity) {
|
|
a0 = aB;
|
|
} else {
|
|
if (a0 == -Infinity) {
|
|
a0 = -aB;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (a0 == null) {
|
|
if (aX.required) {
|
|
aE = true;
|
|
}
|
|
if (aX.defaultValue != null) {
|
|
a0 = aX.defaultValue;
|
|
}
|
|
}
|
|
}
|
|
aT[aR + aN] = a0;
|
|
}
|
|
}
|
|
if (aE) {
|
|
for (aN = 0; aN < aP; ++aN) {
|
|
a0 = aT[aR + aN];
|
|
if (a0 != null) {
|
|
aX = aW[aN];
|
|
if (aX.x) {
|
|
aF(aJ.xaxis, a0, a0);
|
|
}
|
|
if (aX.y) {
|
|
aF(aJ.yaxis, a0, a0);
|
|
}
|
|
}
|
|
aT[aR + aN] = null;
|
|
}
|
|
} else {
|
|
if (
|
|
insertSteps &&
|
|
aR > 0 &&
|
|
aT[aR - aP] != null &&
|
|
aT[aR - aP] != aT[aR] &&
|
|
aT[aR - aP + 1] != aT[aR + 1]
|
|
) {
|
|
for (aN = 0; aN < aP; ++aN) {
|
|
aT[aR + aP + aN] = aT[aR + aN];
|
|
}
|
|
aT[aR + 1] = aT[aR - aP + 1];
|
|
aR += aP;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (aU = 0; aU < Q.length; ++aU) {
|
|
aJ = Q[aU];
|
|
an(ak.processDatapoints, [aJ, aJ.datapoints]);
|
|
}
|
|
for (aU = 0; aU < Q.length; ++aU) {
|
|
aJ = Q[aU];
|
|
(aT = aJ.datapoints.points), (aP = aJ.datapoints.pointsize);
|
|
var aK = aO,
|
|
aQ = aO,
|
|
aM = aI,
|
|
aV = aI;
|
|
for (aS = 0; aS < aT.length; aS += aP) {
|
|
if (aT[aS] == null) {
|
|
continue;
|
|
}
|
|
for (aN = 0; aN < aP; ++aN) {
|
|
a0 = aT[aS + aN];
|
|
aX = aW[aN];
|
|
if (!aX || a0 == aB || a0 == -aB) {
|
|
continue;
|
|
}
|
|
if (aX.x) {
|
|
if (a0 < aK) {
|
|
aK = a0;
|
|
}
|
|
if (a0 > aM) {
|
|
aM = a0;
|
|
}
|
|
}
|
|
if (aX.y) {
|
|
if (a0 < aQ) {
|
|
aQ = a0;
|
|
}
|
|
if (a0 > aV) {
|
|
aV = a0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (aJ.bars.show) {
|
|
var aY = aJ.bars.align == "left" ? 0 : -aJ.bars.barWidth / 2;
|
|
if (aJ.bars.horizontal) {
|
|
aQ += aY;
|
|
aV += aY + aJ.bars.barWidth;
|
|
} else {
|
|
aK += aY;
|
|
aM += aY + aJ.bars.barWidth;
|
|
}
|
|
}
|
|
aF(aJ.xaxis, aK, aM);
|
|
aF(aJ.yaxis, aQ, aV);
|
|
}
|
|
c.each(m(), function (a1, a2) {
|
|
if (a2.datamin == aO) {
|
|
a2.datamin = null;
|
|
}
|
|
if (a2.datamax == aI) {
|
|
a2.datamax = null;
|
|
}
|
|
});
|
|
}
|
|
|
|
function j(aB, aC) {
|
|
var aD = document.createElement("canvas");
|
|
aD.className = aC;
|
|
aD.width = G;
|
|
aD.height = I;
|
|
if (!aB) {
|
|
c(aD).css({ position: "absolute", left: 0, top: 0 });
|
|
}
|
|
c(aD).appendTo(av);
|
|
if (!aD.getContext) {
|
|
aD = window.G_vmlCanvasManager.initElement(aD);
|
|
}
|
|
aD.getContext("2d").save();
|
|
return aD;
|
|
}
|
|
|
|
function B() {
|
|
G = av.width();
|
|
I = av.height();
|
|
if (G <= 0 || I <= 0) {
|
|
throw "Invalid dimensions for plot, width = " + G + ", height = " + I;
|
|
}
|
|
}
|
|
|
|
function g(aC) {
|
|
if (aC.width != G) {
|
|
aC.width = G;
|
|
}
|
|
if (aC.height != I) {
|
|
aC.height = I;
|
|
}
|
|
var aB = aC.getContext("2d");
|
|
aB.restore();
|
|
aB.save();
|
|
}
|
|
|
|
function X() {
|
|
var aC,
|
|
aB = av.children("canvas.base"),
|
|
aD = av.children("canvas.overlay");
|
|
if (aB.length == 0 || aD == 0) {
|
|
av.html("");
|
|
av.css({ padding: 0 });
|
|
if (av.css("position") == "static") {
|
|
av.css("position", "relative");
|
|
}
|
|
B();
|
|
az = j(true, "base");
|
|
ad = j(false, "overlay");
|
|
aC = false;
|
|
} else {
|
|
az = aB.get(0);
|
|
ad = aD.get(0);
|
|
aC = true;
|
|
}
|
|
H = az.getContext("2d");
|
|
A = ad.getContext("2d");
|
|
y = c([ad, az]);
|
|
if (aC) {
|
|
av.data("plot").shutdown();
|
|
aq.resize();
|
|
A.clearRect(0, 0, G, I);
|
|
y.unbind();
|
|
av.children().not([az, ad]).remove();
|
|
}
|
|
av.data("plot", aq);
|
|
}
|
|
|
|
function ah() {
|
|
if (O.grid.hoverable) {
|
|
y.mousemove(aa);
|
|
y.mouseleave(l);
|
|
}
|
|
if (O.grid.clickable) {
|
|
y.click(R);
|
|
}
|
|
an(ak.bindEvents, [y]);
|
|
}
|
|
|
|
function ag() {
|
|
if (M) {
|
|
clearTimeout(M);
|
|
}
|
|
y.unbind("mousemove", aa);
|
|
y.unbind("mouseleave", l);
|
|
y.unbind("click", R);
|
|
an(ak.shutdown, [y]);
|
|
}
|
|
|
|
function r(aG) {
|
|
function aC(aH) {
|
|
return aH;
|
|
}
|
|
var aF,
|
|
aB,
|
|
aD = aG.options.transform || aC,
|
|
aE = aG.options.inverseTransform;
|
|
if (aG.direction == "x") {
|
|
aF = aG.scale = h / Math.abs(aD(aG.max) - aD(aG.min));
|
|
aB = Math.min(aD(aG.max), aD(aG.min));
|
|
} else {
|
|
aF = aG.scale = w / Math.abs(aD(aG.max) - aD(aG.min));
|
|
aF = -aF;
|
|
aB = Math.max(aD(aG.max), aD(aG.min));
|
|
}
|
|
if (aD == aC) {
|
|
aG.p2c = function (aH) {
|
|
return (aH - aB) * aF;
|
|
};
|
|
} else {
|
|
aG.p2c = function (aH) {
|
|
return (aD(aH) - aB) * aF;
|
|
};
|
|
}
|
|
if (!aE) {
|
|
aG.c2p = function (aH) {
|
|
return aB + aH / aF;
|
|
};
|
|
} else {
|
|
aG.c2p = function (aH) {
|
|
return aE(aB + aH / aF);
|
|
};
|
|
}
|
|
}
|
|
|
|
function L(aD) {
|
|
var aB = aD.options,
|
|
aF,
|
|
aJ = aD.ticks || [],
|
|
aI = [],
|
|
aE,
|
|
aK = aB.labelWidth,
|
|
aG = aB.labelHeight,
|
|
aC;
|
|
|
|
function aH(aM, aL) {
|
|
return c(
|
|
'<div style="position:absolute;top:-10000px;' +
|
|
aL +
|
|
'font-size:smaller"><div class="' +
|
|
aD.direction +
|
|
"Axis " +
|
|
aD.direction +
|
|
aD.n +
|
|
'Axis">' +
|
|
aM.join("") +
|
|
"</div></div>"
|
|
).appendTo(av);
|
|
}
|
|
if (aD.direction == "x") {
|
|
if (aK == null) {
|
|
aK = Math.floor(G / (aJ.length > 0 ? aJ.length : 1));
|
|
}
|
|
if (aG == null) {
|
|
aI = [];
|
|
for (aF = 0; aF < aJ.length; ++aF) {
|
|
aE = aJ[aF].label;
|
|
if (aE) {
|
|
aI.push(
|
|
'<div class="tickLabel" style="float:left;width:' +
|
|
aK +
|
|
'px">' +
|
|
aE +
|
|
"</div>"
|
|
);
|
|
}
|
|
}
|
|
if (aI.length > 0) {
|
|
aI.push('<div style="clear:left"></div>');
|
|
aC = aH(aI, "width:10000px;");
|
|
aG = aC.height();
|
|
aC.remove();
|
|
}
|
|
}
|
|
} else {
|
|
if (aK == null || aG == null) {
|
|
for (aF = 0; aF < aJ.length; ++aF) {
|
|
aE = aJ[aF].label;
|
|
if (aE) {
|
|
aI.push('<div class="tickLabel">' + aE + "</div>");
|
|
}
|
|
}
|
|
if (aI.length > 0) {
|
|
aC = aH(aI, "");
|
|
if (aK == null) {
|
|
aK = aC.children().width();
|
|
}
|
|
if (aG == null) {
|
|
aG = aC.find("div.tickLabel").height();
|
|
}
|
|
aC.remove();
|
|
}
|
|
}
|
|
}
|
|
if (aK == null) {
|
|
aK = 0;
|
|
}
|
|
if (aG == null) {
|
|
aG = 0;
|
|
}
|
|
aD.labelWidth = aK;
|
|
aD.labelHeight = aG;
|
|
}
|
|
|
|
function au(aD) {
|
|
var aC = aD.labelWidth,
|
|
aL = aD.labelHeight,
|
|
aH = aD.options.position,
|
|
aF = aD.options.tickLength,
|
|
aG = O.grid.axisMargin,
|
|
aJ = O.grid.labelMargin,
|
|
aK = aD.direction == "x" ? p : aw,
|
|
aE;
|
|
var aB = c.grep(aK, function (aN) {
|
|
return aN && aN.options.position == aH && aN.reserveSpace;
|
|
});
|
|
if (c.inArray(aD, aB) == aB.length - 1) {
|
|
aG = 0;
|
|
}
|
|
if (aF == null) {
|
|
aF = "full";
|
|
}
|
|
var aI = c.grep(aK, function (aN) {
|
|
return aN && aN.reserveSpace;
|
|
});
|
|
var aM = c.inArray(aD, aI) == 0;
|
|
if (!aM && aF == "full") {
|
|
aF = 5;
|
|
}
|
|
if (!isNaN(+aF)) {
|
|
aJ += +aF;
|
|
}
|
|
if (aD.direction == "x") {
|
|
aL += aJ;
|
|
if (aH == "bottom") {
|
|
q.bottom += aL + aG;
|
|
aD.box = { top: I - q.bottom, height: aL };
|
|
} else {
|
|
aD.box = { top: q.top + aG, height: aL };
|
|
q.top += aL + aG;
|
|
}
|
|
} else {
|
|
aC += aJ;
|
|
if (aH == "left") {
|
|
aD.box = { left: q.left + aG, width: aC };
|
|
q.left += aC + aG;
|
|
} else {
|
|
q.right += aC + aG;
|
|
aD.box = { left: G - q.right, width: aC };
|
|
}
|
|
}
|
|
aD.position = aH;
|
|
aD.tickLength = aF;
|
|
aD.box.padding = aJ;
|
|
aD.innermost = aM;
|
|
}
|
|
|
|
function U(aB) {
|
|
if (aB.direction == "x") {
|
|
aB.box.left = q.left;
|
|
aB.box.width = h;
|
|
} else {
|
|
aB.box.top = q.top;
|
|
aB.box.height = w;
|
|
}
|
|
}
|
|
|
|
function t() {
|
|
var aC,
|
|
aE = m();
|
|
c.each(aE, function (aF, aG) {
|
|
aG.show = aG.options.show;
|
|
if (aG.show == null) {
|
|
aG.show = aG.used;
|
|
}
|
|
aG.reserveSpace = aG.show || aG.options.reserveSpace;
|
|
n(aG);
|
|
});
|
|
allocatedAxes = c.grep(aE, function (aF) {
|
|
return aF.reserveSpace;
|
|
});
|
|
q.left = q.right = q.top = q.bottom = 0;
|
|
if (O.grid.show) {
|
|
c.each(allocatedAxes, function (aF, aG) {
|
|
S(aG);
|
|
P(aG);
|
|
ap(aG, aG.ticks);
|
|
L(aG);
|
|
});
|
|
for (aC = allocatedAxes.length - 1; aC >= 0; --aC) {
|
|
au(allocatedAxes[aC]);
|
|
}
|
|
var aD = O.grid.minBorderMargin;
|
|
if (aD == null) {
|
|
aD = 0;
|
|
for (aC = 0; aC < Q.length; ++aC) {
|
|
aD = Math.max(aD, Q[aC].points.radius + Q[aC].points.lineWidth / 2);
|
|
}
|
|
}
|
|
for (var aB in q) {
|
|
q[aB] += O.grid.borderWidth;
|
|
q[aB] = Math.max(aD, q[aB]);
|
|
}
|
|
}
|
|
h = G - q.left - q.right;
|
|
w = I - q.bottom - q.top;
|
|
c.each(aE, function (aF, aG) {
|
|
r(aG);
|
|
});
|
|
if (O.grid.show) {
|
|
c.each(allocatedAxes, function (aF, aG) {
|
|
U(aG);
|
|
});
|
|
k();
|
|
}
|
|
o();
|
|
}
|
|
|
|
function n(aE) {
|
|
var aF = aE.options,
|
|
aD = +(aF.min != null ? aF.min : aE.datamin),
|
|
aB = +(aF.max != null ? aF.max : aE.datamax),
|
|
aH = aB - aD;
|
|
if (aH == 0) {
|
|
var aC = aB == 0 ? 1 : 0.01;
|
|
if (aF.min == null) {
|
|
aD -= aC;
|
|
}
|
|
if (aF.max == null || aF.min != null) {
|
|
aB += aC;
|
|
}
|
|
} else {
|
|
var aG = aF.autoscaleMargin;
|
|
if (aG != null) {
|
|
if (aF.min == null) {
|
|
aD -= aH * aG;
|
|
if (aD < 0 && aE.datamin != null && aE.datamin >= 0) {
|
|
aD = 0;
|
|
}
|
|
}
|
|
if (aF.max == null) {
|
|
aB += aH * aG;
|
|
if (aB > 0 && aE.datamax != null && aE.datamax <= 0) {
|
|
aB = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
aE.min = aD;
|
|
aE.max = aB;
|
|
}
|
|
|
|
function S(aG) {
|
|
var aM = aG.options;
|
|
var aH;
|
|
if (typeof aM.ticks == "number" && aM.ticks > 0) {
|
|
aH = aM.ticks;
|
|
} else {
|
|
aH = 0.3 * Math.sqrt(aG.direction == "x" ? G : I);
|
|
}
|
|
var aT = (aG.max - aG.min) / aH,
|
|
aO,
|
|
aB,
|
|
aN,
|
|
aR,
|
|
aS,
|
|
aQ,
|
|
aI;
|
|
if (aM.mode == "time") {
|
|
var aJ = {
|
|
second: 1000,
|
|
minute: 60 * 1000,
|
|
hour: 60 * 60 * 1000,
|
|
day: 24 * 60 * 60 * 1000,
|
|
month: 30 * 24 * 60 * 60 * 1000,
|
|
year: 365.2425 * 24 * 60 * 60 * 1000,
|
|
};
|
|
var aK = [
|
|
[1, "second"],
|
|
[2, "second"],
|
|
[5, "second"],
|
|
[10, "second"],
|
|
[30, "second"],
|
|
[1, "minute"],
|
|
[2, "minute"],
|
|
[5, "minute"],
|
|
[10, "minute"],
|
|
[30, "minute"],
|
|
[1, "hour"],
|
|
[2, "hour"],
|
|
[4, "hour"],
|
|
[8, "hour"],
|
|
[12, "hour"],
|
|
[1, "day"],
|
|
[2, "day"],
|
|
[3, "day"],
|
|
[0.25, "month"],
|
|
[0.5, "month"],
|
|
[1, "month"],
|
|
[2, "month"],
|
|
[3, "month"],
|
|
[6, "month"],
|
|
[1, "year"],
|
|
];
|
|
var aC = 0;
|
|
if (aM.minTickSize != null) {
|
|
if (typeof aM.tickSize == "number") {
|
|
aC = aM.tickSize;
|
|
} else {
|
|
aC = aM.minTickSize[0] * aJ[aM.minTickSize[1]];
|
|
}
|
|
}
|
|
for (var aS = 0; aS < aK.length - 1; ++aS) {
|
|
if (
|
|
aT <
|
|
(aK[aS][0] * aJ[aK[aS][1]] + aK[aS + 1][0] * aJ[aK[aS + 1][1]]) /
|
|
2 &&
|
|
aK[aS][0] * aJ[aK[aS][1]] >= aC
|
|
) {
|
|
break;
|
|
}
|
|
}
|
|
aO = aK[aS][0];
|
|
aN = aK[aS][1];
|
|
if (aN == "year") {
|
|
aQ = Math.pow(10, Math.floor(Math.log(aT / aJ.year) / Math.LN10));
|
|
aI = aT / aJ.year / aQ;
|
|
if (aI < 1.5) {
|
|
aO = 1;
|
|
} else {
|
|
if (aI < 3) {
|
|
aO = 2;
|
|
} else {
|
|
if (aI < 7.5) {
|
|
aO = 5;
|
|
} else {
|
|
aO = 10;
|
|
}
|
|
}
|
|
}
|
|
aO *= aQ;
|
|
}
|
|
aG.tickSize = aM.tickSize || [aO, aN];
|
|
aB = function (aX) {
|
|
var a2 = [],
|
|
a0 = aX.tickSize[0],
|
|
a3 = aX.tickSize[1],
|
|
a1 = new Date(aX.min);
|
|
var aW = a0 * aJ[a3];
|
|
if (a3 == "second") {
|
|
a1.setUTCSeconds(a(a1.getUTCSeconds(), a0));
|
|
}
|
|
if (a3 == "minute") {
|
|
a1.setUTCMinutes(a(a1.getUTCMinutes(), a0));
|
|
}
|
|
if (a3 == "hour") {
|
|
a1.setUTCHours(a(a1.getUTCHours(), a0));
|
|
}
|
|
if (a3 == "month") {
|
|
a1.setUTCMonth(a(a1.getUTCMonth(), a0));
|
|
}
|
|
if (a3 == "year") {
|
|
a1.setUTCFullYear(a(a1.getUTCFullYear(), a0));
|
|
}
|
|
a1.setUTCMilliseconds(0);
|
|
if (aW >= aJ.minute) {
|
|
a1.setUTCSeconds(0);
|
|
}
|
|
if (aW >= aJ.hour) {
|
|
a1.setUTCMinutes(0);
|
|
}
|
|
if (aW >= aJ.day) {
|
|
a1.setUTCHours(0);
|
|
}
|
|
if (aW >= aJ.day * 4) {
|
|
a1.setUTCDate(1);
|
|
}
|
|
if (aW >= aJ.year) {
|
|
a1.setUTCMonth(0);
|
|
}
|
|
var a5 = 0,
|
|
a4 = Number.NaN,
|
|
aY;
|
|
do {
|
|
aY = a4;
|
|
a4 = a1.getTime();
|
|
a2.push(a4);
|
|
if (a3 == "month") {
|
|
if (a0 < 1) {
|
|
a1.setUTCDate(1);
|
|
var aV = a1.getTime();
|
|
a1.setUTCMonth(a1.getUTCMonth() + 1);
|
|
var aZ = a1.getTime();
|
|
a1.setTime(a4 + a5 * aJ.hour + (aZ - aV) * a0);
|
|
a5 = a1.getUTCHours();
|
|
a1.setUTCHours(0);
|
|
} else {
|
|
a1.setUTCMonth(a1.getUTCMonth() + a0);
|
|
}
|
|
} else {
|
|
if (a3 == "year") {
|
|
a1.setUTCFullYear(a1.getUTCFullYear() + a0);
|
|
} else {
|
|
a1.setTime(a4 + aW);
|
|
}
|
|
}
|
|
} while (a4 < aX.max && a4 != aY);
|
|
return a2;
|
|
};
|
|
aR = function (aV, aY) {
|
|
var a0 = new Date(aV);
|
|
if (aM.timeformat != null) {
|
|
return c.plot.formatDate(a0, aM.timeformat, aM.monthNames);
|
|
}
|
|
var aW = aY.tickSize[0] * aJ[aY.tickSize[1]];
|
|
var aX = aY.max - aY.min;
|
|
var aZ = aM.twelveHourClock ? " %p" : "";
|
|
if (aW < aJ.minute) {
|
|
fmt = "%h:%M:%S" + aZ;
|
|
} else {
|
|
if (aW < aJ.day) {
|
|
if (aX < 2 * aJ.day) {
|
|
fmt = "%h:%M" + aZ;
|
|
} else {
|
|
fmt = "%b %d %h:%M" + aZ;
|
|
}
|
|
} else {
|
|
if (aW < aJ.month) {
|
|
fmt = "%b %d";
|
|
} else {
|
|
if (aW < aJ.year) {
|
|
if (aX < aJ.year) {
|
|
fmt = "%b";
|
|
} else {
|
|
fmt = "%b %y";
|
|
}
|
|
} else {
|
|
fmt = "%y";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return c.plot.formatDate(a0, fmt, aM.monthNames);
|
|
};
|
|
} else {
|
|
var aU = aM.tickDecimals;
|
|
var aP = -Math.floor(Math.log(aT) / Math.LN10);
|
|
if (aU != null && aP > aU) {
|
|
aP = aU;
|
|
}
|
|
aQ = Math.pow(10, -aP);
|
|
aI = aT / aQ;
|
|
if (aI < 1.5) {
|
|
aO = 1;
|
|
} else {
|
|
if (aI < 3) {
|
|
aO = 2;
|
|
if (aI > 2.25 && (aU == null || aP + 1 <= aU)) {
|
|
aO = 2.5;
|
|
++aP;
|
|
}
|
|
} else {
|
|
if (aI < 7.5) {
|
|
aO = 5;
|
|
} else {
|
|
aO = 10;
|
|
}
|
|
}
|
|
}
|
|
aO *= aQ;
|
|
if (aM.minTickSize != null && aO < aM.minTickSize) {
|
|
aO = aM.minTickSize;
|
|
}
|
|
aG.tickDecimals = Math.max(0, aU != null ? aU : aP);
|
|
aG.tickSize = aM.tickSize || aO;
|
|
aB = function (aX) {
|
|
var aZ = [];
|
|
var a0 = a(aX.min, aX.tickSize),
|
|
aW = 0,
|
|
aV = Number.NaN,
|
|
aY;
|
|
do {
|
|
aY = aV;
|
|
aV = a0 + aW * aX.tickSize;
|
|
aZ.push(aV);
|
|
++aW;
|
|
} while (aV < aX.max && aV != aY);
|
|
return aZ;
|
|
};
|
|
aR = function (aV, aW) {
|
|
return aV.toFixed(aW.tickDecimals);
|
|
};
|
|
}
|
|
if (aM.alignTicksWithAxis != null) {
|
|
var aF = (aG.direction == "x" ? p : aw)[aM.alignTicksWithAxis - 1];
|
|
if (aF && aF.used && aF != aG) {
|
|
var aL = aB(aG);
|
|
if (aL.length > 0) {
|
|
if (aM.min == null) {
|
|
aG.min = Math.min(aG.min, aL[0]);
|
|
}
|
|
if (aM.max == null && aL.length > 1) {
|
|
aG.max = Math.max(aG.max, aL[aL.length - 1]);
|
|
}
|
|
}
|
|
aB = function (aX) {
|
|
var aY = [],
|
|
aV,
|
|
aW;
|
|
for (aW = 0; aW < aF.ticks.length; ++aW) {
|
|
aV = (aF.ticks[aW].v - aF.min) / (aF.max - aF.min);
|
|
aV = aX.min + aV * (aX.max - aX.min);
|
|
aY.push(aV);
|
|
}
|
|
return aY;
|
|
};
|
|
if (aG.mode != "time" && aM.tickDecimals == null) {
|
|
var aE = Math.max(0, -Math.floor(Math.log(aT) / Math.LN10) + 1),
|
|
aD = aB(aG);
|
|
if (
|
|
!(aD.length > 1 && /\..*0$/.test((aD[1] - aD[0]).toFixed(aE)))
|
|
) {
|
|
aG.tickDecimals = aE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
aG.tickGenerator = aB;
|
|
if (c.isFunction(aM.tickFormatter)) {
|
|
aG.tickFormatter = function (aV, aW) {
|
|
return "" + aM.tickFormatter(aV, aW);
|
|
};
|
|
} else {
|
|
aG.tickFormatter = aR;
|
|
}
|
|
}
|
|
|
|
function P(aF) {
|
|
var aH = aF.options.ticks,
|
|
aG = [];
|
|
if (aH == null || (typeof aH == "number" && aH > 0)) {
|
|
aG = aF.tickGenerator(aF);
|
|
} else {
|
|
if (aH) {
|
|
if (c.isFunction(aH)) {
|
|
aG = aH({ min: aF.min, max: aF.max });
|
|
} else {
|
|
aG = aH;
|
|
}
|
|
}
|
|
}
|
|
var aE, aB;
|
|
aF.ticks = [];
|
|
for (aE = 0; aE < aG.length; ++aE) {
|
|
var aC = null;
|
|
var aD = aG[aE];
|
|
if (typeof aD == "object") {
|
|
aB = +aD[0];
|
|
if (aD.length > 1) {
|
|
aC = aD[1];
|
|
}
|
|
} else {
|
|
aB = +aD;
|
|
}
|
|
if (aC == null) {
|
|
aC = aF.tickFormatter(aB, aF);
|
|
}
|
|
if (!isNaN(aB)) {
|
|
aF.ticks.push({ v: aB, label: aC });
|
|
}
|
|
}
|
|
}
|
|
|
|
function ap(aB, aC) {
|
|
if (aB.options.autoscaleMargin && aC.length > 0) {
|
|
if (aB.options.min == null) {
|
|
aB.min = Math.min(aB.min, aC[0].v);
|
|
}
|
|
if (aB.options.max == null && aC.length > 1) {
|
|
aB.max = Math.max(aB.max, aC[aC.length - 1].v);
|
|
}
|
|
}
|
|
}
|
|
|
|
function W() {
|
|
H.clearRect(0, 0, G, I);
|
|
var aC = O.grid;
|
|
if (aC.show && aC.backgroundColor) {
|
|
N();
|
|
}
|
|
if (aC.show && !aC.aboveData) {
|
|
ac();
|
|
}
|
|
for (var aB = 0; aB < Q.length; ++aB) {
|
|
an(ak.drawSeries, [H, Q[aB]]);
|
|
d(Q[aB]);
|
|
}
|
|
an(ak.draw, [H]);
|
|
if (aC.show && aC.aboveData) {
|
|
ac();
|
|
}
|
|
}
|
|
|
|
function D(aB, aI) {
|
|
var aE,
|
|
aH,
|
|
aG,
|
|
aD,
|
|
aF = m();
|
|
for (i = 0; i < aF.length; ++i) {
|
|
aE = aF[i];
|
|
if (aE.direction == aI) {
|
|
aD = aI + aE.n + "axis";
|
|
if (!aB[aD] && aE.n == 1) {
|
|
aD = aI + "axis";
|
|
}
|
|
if (aB[aD]) {
|
|
aH = aB[aD].from;
|
|
aG = aB[aD].to;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!aB[aD]) {
|
|
aE = aI == "x" ? p[0] : aw[0];
|
|
aH = aB[aI + "1"];
|
|
aG = aB[aI + "2"];
|
|
}
|
|
if (aH != null && aG != null && aH > aG) {
|
|
var aC = aH;
|
|
aH = aG;
|
|
aG = aC;
|
|
}
|
|
return { from: aH, to: aG, axis: aE };
|
|
}
|
|
|
|
function N() {
|
|
H.save();
|
|
H.translate(q.left, q.top);
|
|
H.fillStyle = am(O.grid.backgroundColor, w, 0, "rgba(255, 255, 255, 0)");
|
|
H.fillRect(0, 0, h, w);
|
|
H.restore();
|
|
}
|
|
|
|
function ac() {
|
|
var aF;
|
|
H.save();
|
|
H.translate(q.left, q.top);
|
|
var aH = O.grid.markings;
|
|
if (aH) {
|
|
if (c.isFunction(aH)) {
|
|
var aK = aq.getAxes();
|
|
aK.xmin = aK.xaxis.min;
|
|
aK.xmax = aK.xaxis.max;
|
|
aK.ymin = aK.yaxis.min;
|
|
aK.ymax = aK.yaxis.max;
|
|
aH = aH(aK);
|
|
}
|
|
for (aF = 0; aF < aH.length; ++aF) {
|
|
var aD = aH[aF],
|
|
aC = D(aD, "x"),
|
|
aI = D(aD, "y");
|
|
if (aC.from == null) {
|
|
aC.from = aC.axis.min;
|
|
}
|
|
if (aC.to == null) {
|
|
aC.to = aC.axis.max;
|
|
}
|
|
if (aI.from == null) {
|
|
aI.from = aI.axis.min;
|
|
}
|
|
if (aI.to == null) {
|
|
aI.to = aI.axis.max;
|
|
}
|
|
if (
|
|
aC.to < aC.axis.min ||
|
|
aC.from > aC.axis.max ||
|
|
aI.to < aI.axis.min ||
|
|
aI.from > aI.axis.max
|
|
) {
|
|
continue;
|
|
}
|
|
aC.from = Math.max(aC.from, aC.axis.min);
|
|
aC.to = Math.min(aC.to, aC.axis.max);
|
|
aI.from = Math.max(aI.from, aI.axis.min);
|
|
aI.to = Math.min(aI.to, aI.axis.max);
|
|
if (aC.from == aC.to && aI.from == aI.to) {
|
|
continue;
|
|
}
|
|
aC.from = aC.axis.p2c(aC.from);
|
|
aC.to = aC.axis.p2c(aC.to);
|
|
aI.from = aI.axis.p2c(aI.from);
|
|
aI.to = aI.axis.p2c(aI.to);
|
|
if (aC.from == aC.to || aI.from == aI.to) {
|
|
H.beginPath();
|
|
H.strokeStyle = aD.color || O.grid.markingsColor;
|
|
H.lineWidth = aD.lineWidth || O.grid.markingsLineWidth;
|
|
H.moveTo(aC.from, aI.from);
|
|
H.lineTo(aC.to, aI.to);
|
|
H.stroke();
|
|
} else {
|
|
H.fillStyle = aD.color || O.grid.markingsColor;
|
|
H.fillRect(aC.from, aI.to, aC.to - aC.from, aI.from - aI.to);
|
|
}
|
|
}
|
|
}
|
|
var aK = m(),
|
|
aM = O.grid.borderWidth;
|
|
for (var aE = 0; aE < aK.length; ++aE) {
|
|
var aB = aK[aE],
|
|
aG = aB.box,
|
|
aQ = aB.tickLength,
|
|
aN,
|
|
aL,
|
|
aP,
|
|
aJ;
|
|
if (!aB.show || aB.ticks.length == 0) {
|
|
continue;
|
|
}
|
|
H.strokeStyle =
|
|
aB.options.tickColor ||
|
|
c.color.parse(aB.options.color).scale("a", 0.22).toString();
|
|
H.lineWidth = 1;
|
|
if (aB.direction == "x") {
|
|
aN = 0;
|
|
if (aQ == "full") {
|
|
aL = aB.position == "top" ? 0 : w;
|
|
} else {
|
|
aL = aG.top - q.top + (aB.position == "top" ? aG.height : 0);
|
|
}
|
|
} else {
|
|
aL = 0;
|
|
if (aQ == "full") {
|
|
aN = aB.position == "left" ? 0 : h;
|
|
} else {
|
|
aN = aG.left - q.left + (aB.position == "left" ? aG.width : 0);
|
|
}
|
|
}
|
|
if (!aB.innermost) {
|
|
H.beginPath();
|
|
aP = aJ = 0;
|
|
if (aB.direction == "x") {
|
|
aP = h;
|
|
} else {
|
|
aJ = w;
|
|
}
|
|
if (H.lineWidth == 1) {
|
|
aN = Math.floor(aN) + 0.5;
|
|
aL = Math.floor(aL) + 0.5;
|
|
}
|
|
H.moveTo(aN, aL);
|
|
H.lineTo(aN + aP, aL + aJ);
|
|
H.stroke();
|
|
}
|
|
H.beginPath();
|
|
for (aF = 0; aF < aB.ticks.length; ++aF) {
|
|
var aO = aB.ticks[aF].v;
|
|
aP = aJ = 0;
|
|
if (
|
|
aO < aB.min ||
|
|
aO > aB.max ||
|
|
(aQ == "full" && aM > 0 && (aO == aB.min || aO == aB.max))
|
|
) {
|
|
continue;
|
|
}
|
|
if (aB.direction == "x") {
|
|
aN = aB.p2c(aO);
|
|
aJ = aQ == "full" ? -w : aQ;
|
|
if (aB.position == "top") {
|
|
aJ = -aJ;
|
|
}
|
|
} else {
|
|
aL = aB.p2c(aO);
|
|
aP = aQ == "full" ? -h : aQ;
|
|
if (aB.position == "left") {
|
|
aP = -aP;
|
|
}
|
|
}
|
|
if (H.lineWidth == 1) {
|
|
if (aB.direction == "x") {
|
|
aN = Math.floor(aN) + 0.5;
|
|
} else {
|
|
aL = Math.floor(aL) + 0.5;
|
|
}
|
|
}
|
|
H.moveTo(aN, aL);
|
|
H.lineTo(aN + aP, aL + aJ);
|
|
}
|
|
H.stroke();
|
|
}
|
|
if (aM) {
|
|
H.lineWidth = aM;
|
|
H.strokeStyle = O.grid.borderColor;
|
|
H.strokeRect(-aM / 2, -aM / 2, h + aM, w + aM);
|
|
}
|
|
H.restore();
|
|
}
|
|
|
|
function k() {
|
|
av.find(".tickLabels").remove();
|
|
var aG = ['<div class="tickLabels" style="font-size:smaller">'];
|
|
var aJ = m();
|
|
for (var aD = 0; aD < aJ.length; ++aD) {
|
|
var aC = aJ[aD],
|
|
aF = aC.box;
|
|
if (!aC.show) {
|
|
continue;
|
|
}
|
|
aG.push(
|
|
'<div class="' +
|
|
aC.direction +
|
|
"Axis " +
|
|
aC.direction +
|
|
aC.n +
|
|
'Axis" style="color:' +
|
|
aC.options.color +
|
|
'">'
|
|
);
|
|
for (var aE = 0; aE < aC.ticks.length; ++aE) {
|
|
var aH = aC.ticks[aE];
|
|
if (!aH.label || aH.v < aC.min || aH.v > aC.max) {
|
|
continue;
|
|
}
|
|
var aK = {},
|
|
aI;
|
|
if (aC.direction == "x") {
|
|
aI = "center";
|
|
aK.left = Math.round(q.left + aC.p2c(aH.v) - aC.labelWidth / 2);
|
|
if (aC.position == "bottom") {
|
|
aK.top = aF.top + aF.padding;
|
|
} else {
|
|
aK.bottom = I - (aF.top + aF.height - aF.padding);
|
|
}
|
|
} else {
|
|
aK.top = Math.round(q.top + aC.p2c(aH.v) - aC.labelHeight / 2);
|
|
if (aC.position == "left") {
|
|
aK.right = G - (aF.left + aF.width - aF.padding);
|
|
aI = "right";
|
|
} else {
|
|
aK.left = aF.left + aF.padding;
|
|
aI = "left";
|
|
}
|
|
}
|
|
aK.width = aC.labelWidth;
|
|
var aB = ["position:absolute", "text-align:" + aI];
|
|
for (var aL in aK) {
|
|
aB.push(aL + ":" + aK[aL] + "px");
|
|
}
|
|
aG.push(
|
|
'<div class="tickLabel" style="' +
|
|
aB.join(";") +
|
|
'">' +
|
|
aH.label +
|
|
"</div>"
|
|
);
|
|
}
|
|
aG.push("</div>");
|
|
}
|
|
aG.push("</div>");
|
|
av.append(aG.join(""));
|
|
}
|
|
|
|
function d(aB) {
|
|
if (aB.lines.show) {
|
|
at(aB);
|
|
}
|
|
if (aB.bars.show) {
|
|
e(aB);
|
|
}
|
|
if (aB.points.show) {
|
|
ao(aB);
|
|
}
|
|
}
|
|
|
|
function at(aE) {
|
|
function aD(aP, aQ, aI, aU, aT) {
|
|
var aV = aP.points,
|
|
aJ = aP.pointsize,
|
|
aN = null,
|
|
aM = null;
|
|
H.beginPath();
|
|
for (var aO = aJ; aO < aV.length; aO += aJ) {
|
|
var aL = aV[aO - aJ],
|
|
aS = aV[aO - aJ + 1],
|
|
aK = aV[aO],
|
|
aR = aV[aO + 1];
|
|
if (aL == null || aK == null) {
|
|
continue;
|
|
}
|
|
if (aS <= aR && aS < aT.min) {
|
|
if (aR < aT.min) {
|
|
continue;
|
|
}
|
|
aL = ((aT.min - aS) / (aR - aS)) * (aK - aL) + aL;
|
|
aS = aT.min;
|
|
} else {
|
|
if (aR <= aS && aR < aT.min) {
|
|
if (aS < aT.min) {
|
|
continue;
|
|
}
|
|
aK = ((aT.min - aS) / (aR - aS)) * (aK - aL) + aL;
|
|
aR = aT.min;
|
|
}
|
|
}
|
|
if (aS >= aR && aS > aT.max) {
|
|
if (aR > aT.max) {
|
|
continue;
|
|
}
|
|
aL = ((aT.max - aS) / (aR - aS)) * (aK - aL) + aL;
|
|
aS = aT.max;
|
|
} else {
|
|
if (aR >= aS && aR > aT.max) {
|
|
if (aS > aT.max) {
|
|
continue;
|
|
}
|
|
aK = ((aT.max - aS) / (aR - aS)) * (aK - aL) + aL;
|
|
aR = aT.max;
|
|
}
|
|
}
|
|
if (aL <= aK && aL < aU.min) {
|
|
if (aK < aU.min) {
|
|
continue;
|
|
}
|
|
aS = ((aU.min - aL) / (aK - aL)) * (aR - aS) + aS;
|
|
aL = aU.min;
|
|
} else {
|
|
if (aK <= aL && aK < aU.min) {
|
|
if (aL < aU.min) {
|
|
continue;
|
|
}
|
|
aR = ((aU.min - aL) / (aK - aL)) * (aR - aS) + aS;
|
|
aK = aU.min;
|
|
}
|
|
}
|
|
if (aL >= aK && aL > aU.max) {
|
|
if (aK > aU.max) {
|
|
continue;
|
|
}
|
|
aS = ((aU.max - aL) / (aK - aL)) * (aR - aS) + aS;
|
|
aL = aU.max;
|
|
} else {
|
|
if (aK >= aL && aK > aU.max) {
|
|
if (aL > aU.max) {
|
|
continue;
|
|
}
|
|
aR = ((aU.max - aL) / (aK - aL)) * (aR - aS) + aS;
|
|
aK = aU.max;
|
|
}
|
|
}
|
|
if (aL != aN || aS != aM) {
|
|
H.moveTo(aU.p2c(aL) + aQ, aT.p2c(aS) + aI);
|
|
}
|
|
aN = aK;
|
|
aM = aR;
|
|
H.lineTo(aU.p2c(aK) + aQ, aT.p2c(aR) + aI);
|
|
}
|
|
H.stroke();
|
|
}
|
|
|
|
function aF(aI, aQ, aP) {
|
|
var aW = aI.points,
|
|
aV = aI.pointsize,
|
|
aN = Math.min(Math.max(0, aP.min), aP.max),
|
|
aX = 0,
|
|
aU,
|
|
aT = false,
|
|
aM = 1,
|
|
aL = 0,
|
|
aR = 0;
|
|
while (true) {
|
|
if (aV > 0 && aX > aW.length + aV) {
|
|
break;
|
|
}
|
|
aX += aV;
|
|
var aZ = aW[aX - aV],
|
|
aK = aW[aX - aV + aM],
|
|
aY = aW[aX],
|
|
aJ = aW[aX + aM];
|
|
if (aT) {
|
|
if (aV > 0 && aZ != null && aY == null) {
|
|
aR = aX;
|
|
aV = -aV;
|
|
aM = 2;
|
|
continue;
|
|
}
|
|
if (aV < 0 && aX == aL + aV) {
|
|
H.fill();
|
|
aT = false;
|
|
aV = -aV;
|
|
aM = 1;
|
|
aX = aL = aR + aV;
|
|
continue;
|
|
}
|
|
}
|
|
if (aZ == null || aY == null) {
|
|
continue;
|
|
}
|
|
if (aZ <= aY && aZ < aQ.min) {
|
|
if (aY < aQ.min) {
|
|
continue;
|
|
}
|
|
aK = ((aQ.min - aZ) / (aY - aZ)) * (aJ - aK) + aK;
|
|
aZ = aQ.min;
|
|
} else {
|
|
if (aY <= aZ && aY < aQ.min) {
|
|
if (aZ < aQ.min) {
|
|
continue;
|
|
}
|
|
aJ = ((aQ.min - aZ) / (aY - aZ)) * (aJ - aK) + aK;
|
|
aY = aQ.min;
|
|
}
|
|
}
|
|
if (aZ >= aY && aZ > aQ.max) {
|
|
if (aY > aQ.max) {
|
|
continue;
|
|
}
|
|
aK = ((aQ.max - aZ) / (aY - aZ)) * (aJ - aK) + aK;
|
|
aZ = aQ.max;
|
|
} else {
|
|
if (aY >= aZ && aY > aQ.max) {
|
|
if (aZ > aQ.max) {
|
|
continue;
|
|
}
|
|
aJ = ((aQ.max - aZ) / (aY - aZ)) * (aJ - aK) + aK;
|
|
aY = aQ.max;
|
|
}
|
|
}
|
|
if (!aT) {
|
|
H.beginPath();
|
|
H.moveTo(aQ.p2c(aZ), aP.p2c(aN));
|
|
aT = true;
|
|
}
|
|
if (aK >= aP.max && aJ >= aP.max) {
|
|
H.lineTo(aQ.p2c(aZ), aP.p2c(aP.max));
|
|
H.lineTo(aQ.p2c(aY), aP.p2c(aP.max));
|
|
continue;
|
|
} else {
|
|
if (aK <= aP.min && aJ <= aP.min) {
|
|
H.lineTo(aQ.p2c(aZ), aP.p2c(aP.min));
|
|
H.lineTo(aQ.p2c(aY), aP.p2c(aP.min));
|
|
continue;
|
|
}
|
|
}
|
|
var aO = aZ,
|
|
aS = aY;
|
|
if (aK <= aJ && aK < aP.min && aJ >= aP.min) {
|
|
aZ = ((aP.min - aK) / (aJ - aK)) * (aY - aZ) + aZ;
|
|
aK = aP.min;
|
|
} else {
|
|
if (aJ <= aK && aJ < aP.min && aK >= aP.min) {
|
|
aY = ((aP.min - aK) / (aJ - aK)) * (aY - aZ) + aZ;
|
|
aJ = aP.min;
|
|
}
|
|
}
|
|
if (aK >= aJ && aK > aP.max && aJ <= aP.max) {
|
|
aZ = ((aP.max - aK) / (aJ - aK)) * (aY - aZ) + aZ;
|
|
aK = aP.max;
|
|
} else {
|
|
if (aJ >= aK && aJ > aP.max && aK <= aP.max) {
|
|
aY = ((aP.max - aK) / (aJ - aK)) * (aY - aZ) + aZ;
|
|
aJ = aP.max;
|
|
}
|
|
}
|
|
if (aZ != aO) {
|
|
H.lineTo(aQ.p2c(aO), aP.p2c(aK));
|
|
}
|
|
H.lineTo(aQ.p2c(aZ), aP.p2c(aK));
|
|
H.lineTo(aQ.p2c(aY), aP.p2c(aJ));
|
|
if (aY != aS) {
|
|
H.lineTo(aQ.p2c(aY), aP.p2c(aJ));
|
|
H.lineTo(aQ.p2c(aS), aP.p2c(aJ));
|
|
}
|
|
}
|
|
}
|
|
H.save();
|
|
H.translate(q.left, q.top);
|
|
H.lineJoin = "round";
|
|
var aG = aE.lines.lineWidth,
|
|
aB = aE.shadowSize;
|
|
if (aG > 0 && aB > 0) {
|
|
H.lineWidth = aB;
|
|
H.strokeStyle = "rgba(0,0,0,0.1)";
|
|
var aH = Math.PI / 18;
|
|
aD(
|
|
aE.datapoints,
|
|
Math.sin(aH) * (aG / 2 + aB / 2),
|
|
Math.cos(aH) * (aG / 2 + aB / 2),
|
|
aE.xaxis,
|
|
aE.yaxis
|
|
);
|
|
H.lineWidth = aB / 2;
|
|
aD(
|
|
aE.datapoints,
|
|
Math.sin(aH) * (aG / 2 + aB / 4),
|
|
Math.cos(aH) * (aG / 2 + aB / 4),
|
|
aE.xaxis,
|
|
aE.yaxis
|
|
);
|
|
}
|
|
H.lineWidth = aG;
|
|
H.strokeStyle = aE.color;
|
|
var aC = ae(aE.lines, aE.color, 0, w);
|
|
if (aC) {
|
|
H.fillStyle = aC;
|
|
aF(aE.datapoints, aE.xaxis, aE.yaxis);
|
|
}
|
|
if (aG > 0) {
|
|
aD(aE.datapoints, 0, 0, aE.xaxis, aE.yaxis);
|
|
}
|
|
H.restore();
|
|
}
|
|
|
|
function ao(aE) {
|
|
function aH(aN, aM, aU, aK, aS, aT, aQ, aJ) {
|
|
var aR = aN.points,
|
|
aI = aN.pointsize;
|
|
for (var aL = 0; aL < aR.length; aL += aI) {
|
|
var aP = aR[aL],
|
|
aO = aR[aL + 1];
|
|
if (
|
|
aP == null ||
|
|
aP < aT.min ||
|
|
aP > aT.max ||
|
|
aO < aQ.min ||
|
|
aO > aQ.max
|
|
) {
|
|
continue;
|
|
}
|
|
H.beginPath();
|
|
aP = aT.p2c(aP);
|
|
aO = aQ.p2c(aO) + aK;
|
|
if (aJ == "circle") {
|
|
H.arc(aP, aO, aM, 0, aS ? Math.PI : Math.PI * 2, false);
|
|
} else {
|
|
aJ(H, aP, aO, aM, aS);
|
|
}
|
|
H.closePath();
|
|
if (aU) {
|
|
H.fillStyle = aU;
|
|
H.fill();
|
|
}
|
|
H.stroke();
|
|
}
|
|
}
|
|
H.save();
|
|
H.translate(q.left, q.top);
|
|
var aG = aE.points.lineWidth,
|
|
aC = aE.shadowSize,
|
|
aB = aE.points.radius,
|
|
aF = aE.points.symbol;
|
|
if (aG > 0 && aC > 0) {
|
|
var aD = aC / 2;
|
|
H.lineWidth = aD;
|
|
H.strokeStyle = "rgba(0,0,0,0.1)";
|
|
aH(aE.datapoints, aB, null, aD + aD / 2, true, aE.xaxis, aE.yaxis, aF);
|
|
H.strokeStyle = "rgba(0,0,0,0.2)";
|
|
aH(aE.datapoints, aB, null, aD / 2, true, aE.xaxis, aE.yaxis, aF);
|
|
}
|
|
H.lineWidth = aG;
|
|
H.strokeStyle = aE.color;
|
|
aH(
|
|
aE.datapoints,
|
|
aB,
|
|
ae(aE.points, aE.color),
|
|
0,
|
|
false,
|
|
aE.xaxis,
|
|
aE.yaxis,
|
|
aF
|
|
);
|
|
H.restore();
|
|
}
|
|
|
|
function E(aN, aM, aV, aI, aQ, aF, aD, aL, aK, aU, aR, aC) {
|
|
var aE, aT, aJ, aP, aG, aB, aO, aH, aS;
|
|
if (aR) {
|
|
aH = aB = aO = true;
|
|
aG = false;
|
|
aE = aV;
|
|
aT = aN;
|
|
aP = aM + aI;
|
|
aJ = aM + aQ;
|
|
if (aT < aE) {
|
|
aS = aT;
|
|
aT = aE;
|
|
aE = aS;
|
|
aG = true;
|
|
aB = false;
|
|
}
|
|
} else {
|
|
aG = aB = aO = true;
|
|
aH = false;
|
|
aE = aN + aI;
|
|
aT = aN + aQ;
|
|
aJ = aV;
|
|
aP = aM;
|
|
if (aP < aJ) {
|
|
aS = aP;
|
|
aP = aJ;
|
|
aJ = aS;
|
|
aH = true;
|
|
aO = false;
|
|
}
|
|
}
|
|
if (aT < aL.min || aE > aL.max || aP < aK.min || aJ > aK.max) {
|
|
return;
|
|
}
|
|
if (aE < aL.min) {
|
|
aE = aL.min;
|
|
aG = false;
|
|
}
|
|
if (aT > aL.max) {
|
|
aT = aL.max;
|
|
aB = false;
|
|
}
|
|
if (aJ < aK.min) {
|
|
aJ = aK.min;
|
|
aH = false;
|
|
}
|
|
if (aP > aK.max) {
|
|
aP = aK.max;
|
|
aO = false;
|
|
}
|
|
aE = aL.p2c(aE);
|
|
aJ = aK.p2c(aJ);
|
|
aT = aL.p2c(aT);
|
|
aP = aK.p2c(aP);
|
|
if (aD) {
|
|
aU.beginPath();
|
|
aU.moveTo(aE, aJ);
|
|
aU.lineTo(aE, aP);
|
|
aU.lineTo(aT, aP);
|
|
aU.lineTo(aT, aJ);
|
|
aU.fillStyle = aD(aJ, aP);
|
|
aU.fill();
|
|
}
|
|
if (aC > 0 && (aG || aB || aO || aH)) {
|
|
aU.beginPath();
|
|
aU.moveTo(aE, aJ + aF);
|
|
if (aG) {
|
|
aU.lineTo(aE, aP + aF);
|
|
} else {
|
|
aU.moveTo(aE, aP + aF);
|
|
}
|
|
if (aO) {
|
|
aU.lineTo(aT, aP + aF);
|
|
} else {
|
|
aU.moveTo(aT, aP + aF);
|
|
}
|
|
if (aB) {
|
|
aU.lineTo(aT, aJ + aF);
|
|
} else {
|
|
aU.moveTo(aT, aJ + aF);
|
|
}
|
|
if (aH) {
|
|
aU.lineTo(aE, aJ + aF);
|
|
} else {
|
|
aU.moveTo(aE, aJ + aF);
|
|
}
|
|
aU.stroke();
|
|
}
|
|
}
|
|
|
|
function e(aD) {
|
|
function aC(aJ, aI, aL, aG, aK, aN, aM) {
|
|
var aO = aJ.points,
|
|
aF = aJ.pointsize;
|
|
for (var aH = 0; aH < aO.length; aH += aF) {
|
|
if (aO[aH] == null) {
|
|
continue;
|
|
}
|
|
E(
|
|
aO[aH],
|
|
aO[aH + 1],
|
|
aO[aH + 2],
|
|
aI,
|
|
aL,
|
|
aG,
|
|
aK,
|
|
aN,
|
|
aM,
|
|
H,
|
|
aD.bars.horizontal,
|
|
aD.bars.lineWidth
|
|
);
|
|
}
|
|
}
|
|
H.save();
|
|
H.translate(q.left, q.top);
|
|
H.lineWidth = aD.bars.lineWidth;
|
|
H.strokeStyle = aD.color;
|
|
var aB = aD.bars.align == "left" ? 0 : -aD.bars.barWidth / 2;
|
|
var aE = aD.bars.fill
|
|
? function (aF, aG) {
|
|
return ae(aD.bars, aD.color, aF, aG);
|
|
}
|
|
: null;
|
|
aC(aD.datapoints, aB, aB + aD.bars.barWidth, 0, aE, aD.xaxis, aD.yaxis);
|
|
H.restore();
|
|
}
|
|
|
|
function ae(aD, aB, aC, aF) {
|
|
var aE = aD.fill;
|
|
if (!aE) {
|
|
return null;
|
|
}
|
|
if (aD.fillColor) {
|
|
return am(aD.fillColor, aC, aF, aB);
|
|
}
|
|
var aG = c.color.parse(aB);
|
|
aG.a = typeof aE == "number" ? aE : 0.4;
|
|
aG.normalize();
|
|
return aG.toString();
|
|
}
|
|
|
|
function o() {
|
|
av.find(".legend").remove();
|
|
if (!O.legend.show) {
|
|
return;
|
|
}
|
|
var aH = [],
|
|
aF = false,
|
|
aN = O.legend.labelFormatter,
|
|
aM,
|
|
aJ;
|
|
for (var aE = 0; aE < Q.length; ++aE) {
|
|
aM = Q[aE];
|
|
aJ = aM.label;
|
|
if (!aJ) {
|
|
continue;
|
|
}
|
|
if (aE % O.legend.noColumns == 0) {
|
|
if (aF) {
|
|
aH.push("</tr>");
|
|
}
|
|
aH.push("<tr>");
|
|
aF = true;
|
|
}
|
|
if (aN) {
|
|
aJ = aN(aJ, aM);
|
|
}
|
|
aH.push(
|
|
'<td class="legendColorBox"><div style="border:1px solid ' +
|
|
O.legend.labelBoxBorderColor +
|
|
';padding:1px"><div style="width:4px;height:0;border:5px solid ' +
|
|
aM.color +
|
|
';overflow:hidden"></div></div></td><td class="legendLabel">' +
|
|
aJ +
|
|
"</td>"
|
|
);
|
|
}
|
|
if (aF) {
|
|
aH.push("</tr>");
|
|
}
|
|
if (aH.length == 0) {
|
|
return;
|
|
}
|
|
var aL =
|
|
'<table style="font-size:smaller;color:' +
|
|
O.grid.color +
|
|
'">' +
|
|
aH.join("") +
|
|
"</table>";
|
|
if (O.legend.container != null) {
|
|
c(O.legend.container).html(aL);
|
|
} else {
|
|
var aI = "",
|
|
aC = O.legend.position,
|
|
aD = O.legend.margin;
|
|
if (aD[0] == null) {
|
|
aD = [aD, aD];
|
|
}
|
|
if (aC.charAt(0) == "n") {
|
|
aI += "top:" + (aD[1] + q.top) + "px;";
|
|
} else {
|
|
if (aC.charAt(0) == "s") {
|
|
aI += "bottom:" + (aD[1] + q.bottom) + "px;";
|
|
}
|
|
}
|
|
if (aC.charAt(1) == "e") {
|
|
aI += "right:" + (aD[0] + q.right) + "px;";
|
|
} else {
|
|
if (aC.charAt(1) == "w") {
|
|
aI += "left:" + (aD[0] + q.left) + "px;";
|
|
}
|
|
}
|
|
var aK = c(
|
|
'<div class="legend">' +
|
|
aL.replace('style="', 'style="position:absolute;' + aI + ";") +
|
|
"</div>"
|
|
).appendTo(av);
|
|
if (O.legend.backgroundOpacity != 0) {
|
|
var aG = O.legend.backgroundColor;
|
|
if (aG == null) {
|
|
aG = O.grid.backgroundColor;
|
|
if (aG && typeof aG == "string") {
|
|
aG = c.color.parse(aG);
|
|
} else {
|
|
aG = c.color.extract(aK, "background-color");
|
|
}
|
|
aG.a = 1;
|
|
aG = aG.toString();
|
|
}
|
|
var aB = aK.children();
|
|
c(
|
|
'<div style="position:absolute;width:' +
|
|
aB.width() +
|
|
"px;height:" +
|
|
aB.height() +
|
|
"px;" +
|
|
aI +
|
|
"background-color:" +
|
|
aG +
|
|
';"> </div>'
|
|
)
|
|
.prependTo(aK)
|
|
.css("opacity", O.legend.backgroundOpacity);
|
|
}
|
|
}
|
|
}
|
|
var ab = [],
|
|
M = null;
|
|
|
|
function K(aI, aG, aD) {
|
|
var aO = O.grid.mouseActiveRadius,
|
|
a0 = aO * aO + 1,
|
|
aY = null,
|
|
aR = false,
|
|
aW,
|
|
aU;
|
|
for (aW = Q.length - 1; aW >= 0; --aW) {
|
|
if (!aD(Q[aW])) {
|
|
continue;
|
|
}
|
|
var aP = Q[aW],
|
|
aH = aP.xaxis,
|
|
aF = aP.yaxis,
|
|
aV = aP.datapoints.points,
|
|
aT = aP.datapoints.pointsize,
|
|
aQ = aH.c2p(aI),
|
|
aN = aF.c2p(aG),
|
|
aC = aO / aH.scale,
|
|
aB = aO / aF.scale;
|
|
if (aH.options.inverseTransform) {
|
|
aC = Number.MAX_VALUE;
|
|
}
|
|
if (aF.options.inverseTransform) {
|
|
aB = Number.MAX_VALUE;
|
|
}
|
|
if (aP.lines.show || aP.points.show) {
|
|
for (aU = 0; aU < aV.length; aU += aT) {
|
|
var aK = aV[aU],
|
|
aJ = aV[aU + 1];
|
|
if (aK == null) {
|
|
continue;
|
|
}
|
|
if (
|
|
aK - aQ > aC ||
|
|
aK - aQ < -aC ||
|
|
aJ - aN > aB ||
|
|
aJ - aN < -aB
|
|
) {
|
|
continue;
|
|
}
|
|
var aM = Math.abs(aH.p2c(aK) - aI),
|
|
aL = Math.abs(aF.p2c(aJ) - aG),
|
|
aS = aM * aM + aL * aL;
|
|
if (aS < a0) {
|
|
a0 = aS;
|
|
aY = [aW, aU / aT];
|
|
}
|
|
}
|
|
}
|
|
if (aP.bars.show && !aY) {
|
|
var aE = aP.bars.align == "left" ? 0 : -aP.bars.barWidth / 2,
|
|
aX = aE + aP.bars.barWidth;
|
|
for (aU = 0; aU < aV.length; aU += aT) {
|
|
var aK = aV[aU],
|
|
aJ = aV[aU + 1],
|
|
aZ = aV[aU + 2];
|
|
if (aK == null) {
|
|
continue;
|
|
}
|
|
if (
|
|
Q[aW].bars.horizontal
|
|
? aQ <= Math.max(aZ, aK) &&
|
|
aQ >= Math.min(aZ, aK) &&
|
|
aN >= aJ + aE &&
|
|
aN <= aJ + aX
|
|
: aQ >= aK + aE &&
|
|
aQ <= aK + aX &&
|
|
aN >= Math.min(aZ, aJ) &&
|
|
aN <= Math.max(aZ, aJ)
|
|
) {
|
|
aY = [aW, aU / aT];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (aY) {
|
|
aW = aY[0];
|
|
aU = aY[1];
|
|
aT = Q[aW].datapoints.pointsize;
|
|
return {
|
|
datapoint: Q[aW].datapoints.points.slice(aU * aT, (aU + 1) * aT),
|
|
dataIndex: aU,
|
|
series: Q[aW],
|
|
seriesIndex: aW,
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function aa(aB) {
|
|
if (O.grid.hoverable) {
|
|
u("plothover", aB, function (aC) {
|
|
return aC.hoverable != false;
|
|
});
|
|
}
|
|
}
|
|
|
|
function l(aB) {
|
|
if (O.grid.hoverable) {
|
|
u("plothover", aB, function (aC) {
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
|
|
function R(aB) {
|
|
u("plotclick", aB, function (aC) {
|
|
return aC.clickable != false;
|
|
});
|
|
}
|
|
|
|
function u(aC, aB, aD) {
|
|
var aE = y.offset(),
|
|
aH = aB.pageX - aE.left - q.left,
|
|
aF = aB.pageY - aE.top - q.top,
|
|
aJ = C({ left: aH, top: aF });
|
|
aJ.pageX = aB.pageX;
|
|
aJ.pageY = aB.pageY;
|
|
var aK = K(aH, aF, aD);
|
|
if (aK) {
|
|
aK.pageX = parseInt(
|
|
aK.series.xaxis.p2c(aK.datapoint[0]) + aE.left + q.left
|
|
);
|
|
aK.pageY = parseInt(
|
|
aK.series.yaxis.p2c(aK.datapoint[1]) + aE.top + q.top
|
|
);
|
|
}
|
|
if (O.grid.autoHighlight) {
|
|
for (var aG = 0; aG < ab.length; ++aG) {
|
|
var aI = ab[aG];
|
|
if (
|
|
aI.auto == aC &&
|
|
!(
|
|
aK &&
|
|
aI.series == aK.series &&
|
|
aI.point[0] == aK.datapoint[0] &&
|
|
aI.point[1] == aK.datapoint[1]
|
|
)
|
|
) {
|
|
T(aI.series, aI.point);
|
|
}
|
|
}
|
|
if (aK) {
|
|
x(aK.series, aK.datapoint, aC);
|
|
}
|
|
}
|
|
av.trigger(aC, [aJ, aK]);
|
|
}
|
|
|
|
function f() {
|
|
if (!M) {
|
|
M = setTimeout(s, 30);
|
|
}
|
|
}
|
|
|
|
function s() {
|
|
M = null;
|
|
A.save();
|
|
A.clearRect(0, 0, G, I);
|
|
A.translate(q.left, q.top);
|
|
var aC, aB;
|
|
for (aC = 0; aC < ab.length; ++aC) {
|
|
aB = ab[aC];
|
|
if (aB.series.bars.show) {
|
|
v(aB.series, aB.point);
|
|
} else {
|
|
ay(aB.series, aB.point);
|
|
}
|
|
}
|
|
A.restore();
|
|
an(ak.drawOverlay, [A]);
|
|
}
|
|
|
|
function x(aD, aB, aF) {
|
|
if (typeof aD == "number") {
|
|
aD = Q[aD];
|
|
}
|
|
if (typeof aB == "number") {
|
|
var aE = aD.datapoints.pointsize;
|
|
aB = aD.datapoints.points.slice(aE * aB, aE * (aB + 1));
|
|
}
|
|
var aC = al(aD, aB);
|
|
if (aC == -1) {
|
|
ab.push({ series: aD, point: aB, auto: aF });
|
|
f();
|
|
} else {
|
|
if (!aF) {
|
|
ab[aC].auto = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
function T(aD, aB) {
|
|
if (aD == null && aB == null) {
|
|
ab = [];
|
|
f();
|
|
}
|
|
if (typeof aD == "number") {
|
|
aD = Q[aD];
|
|
}
|
|
if (typeof aB == "number") {
|
|
aB = aD.data[aB];
|
|
}
|
|
var aC = al(aD, aB);
|
|
if (aC != -1) {
|
|
ab.splice(aC, 1);
|
|
f();
|
|
}
|
|
}
|
|
|
|
function al(aD, aE) {
|
|
for (var aB = 0; aB < ab.length; ++aB) {
|
|
var aC = ab[aB];
|
|
if (aC.series == aD && aC.point[0] == aE[0] && aC.point[1] == aE[1]) {
|
|
return aB;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
function ay(aE, aD) {
|
|
var aC = aD[0],
|
|
aI = aD[1],
|
|
aH = aE.xaxis,
|
|
aG = aE.yaxis;
|
|
if (aC < aH.min || aC > aH.max || aI < aG.min || aI > aG.max) {
|
|
return;
|
|
}
|
|
var aF = aE.points.radius + aE.points.lineWidth / 2;
|
|
A.lineWidth = aF;
|
|
A.strokeStyle = c.color.parse(aE.color).scale("a", 0.5).toString();
|
|
var aB = 1.5 * aF,
|
|
aC = aH.p2c(aC),
|
|
aI = aG.p2c(aI);
|
|
A.beginPath();
|
|
if (aE.points.symbol == "circle") {
|
|
A.arc(aC, aI, aB, 0, 2 * Math.PI, false);
|
|
} else {
|
|
aE.points.symbol(A, aC, aI, aB, false);
|
|
}
|
|
A.closePath();
|
|
A.stroke();
|
|
}
|
|
|
|
function v(aE, aB) {
|
|
A.lineWidth = aE.bars.lineWidth;
|
|
A.strokeStyle = c.color.parse(aE.color).scale("a", 0.5).toString();
|
|
var aD = c.color.parse(aE.color).scale("a", 0.5).toString();
|
|
var aC = aE.bars.align == "left" ? 0 : -aE.bars.barWidth / 2;
|
|
E(
|
|
aB[0],
|
|
aB[1],
|
|
aB[2] || 0,
|
|
aC,
|
|
aC + aE.bars.barWidth,
|
|
0,
|
|
function () {
|
|
return aD;
|
|
},
|
|
aE.xaxis,
|
|
aE.yaxis,
|
|
A,
|
|
aE.bars.horizontal,
|
|
aE.bars.lineWidth
|
|
);
|
|
}
|
|
|
|
function am(aJ, aB, aH, aC) {
|
|
if (typeof aJ == "string") {
|
|
return aJ;
|
|
} else {
|
|
var aI = H.createLinearGradient(0, aH, 0, aB);
|
|
for (var aE = 0, aD = aJ.colors.length; aE < aD; ++aE) {
|
|
var aF = aJ.colors[aE];
|
|
if (typeof aF != "string") {
|
|
var aG = c.color.parse(aC);
|
|
if (aF.brightness != null) {
|
|
aG = aG.scale("rgb", aF.brightness);
|
|
}
|
|
if (aF.opacity != null) {
|
|
aG.a *= aF.opacity;
|
|
}
|
|
aF = aG.toString();
|
|
}
|
|
aI.addColorStop(aE / (aD - 1), aF);
|
|
}
|
|
return aI;
|
|
}
|
|
}
|
|
}
|
|
c.plot = function (g, e, d) {
|
|
var f = new b(c(g), e, d, c.plot.plugins);
|
|
return f;
|
|
};
|
|
c.plot.version = "0.7";
|
|
c.plot.plugins = [];
|
|
c.plot.formatDate = function (l, f, h) {
|
|
var o = function (d) {
|
|
d = "" + d;
|
|
return d.length == 1 ? "0" + d : d;
|
|
};
|
|
var e = [];
|
|
var p = false,
|
|
j = false;
|
|
var n = l.getUTCHours();
|
|
var k = n < 12;
|
|
if (h == null) {
|
|
h = [
|
|
"Jan",
|
|
"Feb",
|
|
"Mar",
|
|
"Apr",
|
|
"May",
|
|
"Jun",
|
|
"Jul",
|
|
"Aug",
|
|
"Sep",
|
|
"Oct",
|
|
"Nov",
|
|
"Dec",
|
|
];
|
|
}
|
|
if (f.search(/%p|%P/) != -1) {
|
|
if (n > 12) {
|
|
n = n - 12;
|
|
} else {
|
|
if (n == 0) {
|
|
n = 12;
|
|
}
|
|
}
|
|
}
|
|
for (var g = 0; g < f.length; ++g) {
|
|
var m = f.charAt(g);
|
|
if (p) {
|
|
switch (m) {
|
|
case "h":
|
|
m = "" + n;
|
|
break;
|
|
case "H":
|
|
m = o(n);
|
|
break;
|
|
case "M":
|
|
m = o(l.getUTCMinutes());
|
|
break;
|
|
case "S":
|
|
m = o(l.getUTCSeconds());
|
|
break;
|
|
case "d":
|
|
m = "" + l.getUTCDate();
|
|
break;
|
|
case "m":
|
|
m = "" + (l.getUTCMonth() + 1);
|
|
break;
|
|
case "y":
|
|
m = "" + l.getUTCFullYear();
|
|
break;
|
|
case "b":
|
|
m = "" + h[l.getUTCMonth()];
|
|
break;
|
|
case "p":
|
|
m = k ? "am" : "pm";
|
|
break;
|
|
case "P":
|
|
m = k ? "AM" : "PM";
|
|
break;
|
|
case "0":
|
|
m = "";
|
|
j = true;
|
|
break;
|
|
}
|
|
if (m && j) {
|
|
m = o(m);
|
|
j = false;
|
|
}
|
|
e.push(m);
|
|
if (!j) {
|
|
p = false;
|
|
}
|
|
} else {
|
|
if (m == "%") {
|
|
p = true;
|
|
} else {
|
|
e.push(m);
|
|
}
|
|
}
|
|
}
|
|
return e.join("");
|
|
};
|
|
|
|
function a(e, d) {
|
|
return d * Math.floor(e / d);
|
|
}
|
|
})(jQuery);
|