Change-Id: I76880ba12037f1653c4c969e442738cc7f3eb185mr10.0
Alexander Lutay
5 years ago
parent
53408c2e94
commit
42e63e5711
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
@ -1,179 +0,0 @@
|
||||
/* Plugin for jQuery for working with colors.
|
||||
*
|
||||
* Version 1.1.
|
||||
*
|
||||
* Inspiration from jQuery color animation plugin by John Resig.
|
||||
*
|
||||
* Released under the MIT license by Ole Laursen, October 2009.
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* $.color.parse("#fff").scale('rgb', 0.25).add('a', -0.5).toString()
|
||||
* var c = $.color.extract($("#mydiv"), 'background-color');
|
||||
* console.log(c.r, c.g, c.b, c.a);
|
||||
* $.color.make(100, 50, 25, 0.4).toString() // returns "rgba(100,50,25,0.4)"
|
||||
*
|
||||
* Note that .scale() and .add() return the same modified object
|
||||
* instead of making a new one.
|
||||
*
|
||||
* V. 1.1: Fix error handling so e.g. parsing an empty string does
|
||||
* produce a color rather than just crashing.
|
||||
*/
|
||||
|
||||
(function($) {
|
||||
$.color = {};
|
||||
|
||||
// construct color object with some convenient chainable helpers
|
||||
$.color.make = function (r, g, b, a) {
|
||||
var o = {};
|
||||
o.r = r || 0;
|
||||
o.g = g || 0;
|
||||
o.b = b || 0;
|
||||
o.a = a != null ? a : 1;
|
||||
|
||||
o.add = function (c, d) {
|
||||
for (var i = 0; i < c.length; ++i)
|
||||
o[c.charAt(i)] += d;
|
||||
return o.normalize();
|
||||
};
|
||||
|
||||
o.scale = function (c, f) {
|
||||
for (var i = 0; i < c.length; ++i)
|
||||
o[c.charAt(i)] *= f;
|
||||
return o.normalize();
|
||||
};
|
||||
|
||||
o.toString = function () {
|
||||
if (o.a >= 1.0) {
|
||||
return "rgb("+[o.r, o.g, o.b].join(",")+")";
|
||||
} else {
|
||||
return "rgba("+[o.r, o.g, o.b, o.a].join(",")+")";
|
||||
}
|
||||
};
|
||||
|
||||
o.normalize = function () {
|
||||
function clamp(min, value, max) {
|
||||
return value < min ? min: (value > max ? max: value);
|
||||
}
|
||||
|
||||
o.r = clamp(0, parseInt(o.r), 255);
|
||||
o.g = clamp(0, parseInt(o.g), 255);
|
||||
o.b = clamp(0, parseInt(o.b), 255);
|
||||
o.a = clamp(0, o.a, 1);
|
||||
return o;
|
||||
};
|
||||
|
||||
o.clone = function () {
|
||||
return $.color.make(o.r, o.b, o.g, o.a);
|
||||
};
|
||||
|
||||
return o.normalize();
|
||||
}
|
||||
|
||||
// extract CSS color property from element, going up in the DOM
|
||||
// if it's "transparent"
|
||||
$.color.extract = function (elem, css) {
|
||||
var c;
|
||||
do {
|
||||
c = elem.css(css).toLowerCase();
|
||||
// keep going until we find an element that has color, or
|
||||
// we hit the body
|
||||
if (c != '' && c != 'transparent')
|
||||
break;
|
||||
elem = elem.parent();
|
||||
} while (!$.nodeName(elem.get(0), "body"));
|
||||
|
||||
// catch Safari's way of signalling transparent
|
||||
if (c == "rgba(0, 0, 0, 0)")
|
||||
c = "transparent";
|
||||
|
||||
return $.color.parse(c);
|
||||
}
|
||||
|
||||
// parse CSS color string (like "rgb(10, 32, 43)" or "#fff"),
|
||||
// returns color object, if parsing failed, you get black (0, 0,
|
||||
// 0) out
|
||||
$.color.parse = function (str) {
|
||||
var res, m = $.color.make;
|
||||
|
||||
// Look for rgb(num,num,num)
|
||||
if (res = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(str))
|
||||
return m(parseInt(res[1], 10), parseInt(res[2], 10), parseInt(res[3], 10));
|
||||
|
||||
// Look for rgba(num,num,num,num)
|
||||
if (res = /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(str))
|
||||
return m(parseInt(res[1], 10), parseInt(res[2], 10), parseInt(res[3], 10), parseFloat(res[4]));
|
||||
|
||||
// Look for rgb(num%,num%,num%)
|
||||
if (res = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(str))
|
||||
return m(parseFloat(res[1])*2.55, parseFloat(res[2])*2.55, parseFloat(res[3])*2.55);
|
||||
|
||||
// Look for rgba(num%,num%,num%,num)
|
||||
if (res = /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(str))
|
||||
return m(parseFloat(res[1])*2.55, parseFloat(res[2])*2.55, parseFloat(res[3])*2.55, parseFloat(res[4]));
|
||||
|
||||
// Look for #a0b1c2
|
||||
if (res = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(str))
|
||||
return m(parseInt(res[1], 16), parseInt(res[2], 16), parseInt(res[3], 16));
|
||||
|
||||
// Look for #fff
|
||||
if (res = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(str))
|
||||
return m(parseInt(res[1]+res[1], 16), parseInt(res[2]+res[2], 16), parseInt(res[3]+res[3], 16));
|
||||
|
||||
// Otherwise, we're most likely dealing with a named color
|
||||
var name = $.trim(str).toLowerCase();
|
||||
if (name == "transparent")
|
||||
return m(255, 255, 255, 0);
|
||||
else {
|
||||
// default to black
|
||||
res = lookupColors[name] || [0, 0, 0];
|
||||
return m(res[0], res[1], res[2]);
|
||||
}
|
||||
}
|
||||
|
||||
var lookupColors = {
|
||||
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);
|
||||
@ -1,21 +0,0 @@
|
||||
/* Plugin for jQuery for working with colors.
|
||||
*
|
||||
* Version 1.1.
|
||||
*
|
||||
* Inspiration from jQuery color animation plugin by John Resig.
|
||||
*
|
||||
* Released under the MIT license by Ole Laursen, October 2009.
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* $.color.parse("#fff").scale('rgb', 0.25).add('a', -0.5).toString()
|
||||
* var c = $.color.extract($("#mydiv"), 'background-color');
|
||||
* console.log(c.r, c.g, c.b, c.a);
|
||||
* $.color.make(100, 50, 25, 0.4).toString() // returns "rgba(100,50,25,0.4)"
|
||||
*
|
||||
* Note that .scale() and .add() return the same modified object
|
||||
* instead of making a new one.
|
||||
*
|
||||
* V. 1.1: Fix error handling so e.g. parsing an empty string does
|
||||
* produce a color rather than just crashing.
|
||||
*/(function(e){e.color={},e.color.make=function(t,n,r,i){var s={};return s.r=t||0,s.g=n||0,s.b=r||0,s.a=i!=null?i:1,s.add=function(e,t){for(var n=0;n<e.length;++n)s[e.charAt(n)]+=t;return s.normalize()},s.scale=function(e,t){for(var n=0;n<e.length;++n)s[e.charAt(n)]*=t;return s.normalize()},s.toString=function(){return s.a>=1?"rgb("+[s.r,s.g,s.b].join(",")+")":"rgba("+[s.r,s.g,s.b,s.a].join(",")+")"},s.normalize=function(){function e(e,t,n){return t<e?e:t>n?n:t}return s.r=e(0,parseInt(s.r),255),s.g=e(0,parseInt(s.g),255),s.b=e(0,parseInt(s.b),255),s.a=e(0,s.a,1),s},s.clone=function(){return e.color.make(s.r,s.b,s.g,s.a)},s.normalize()},e.color.extract=function(t,n){var r;do{r=t.css(n).toLowerCase();if(r!=""&&r!="transparent")break;t=t.parent()}while(!e.nodeName(t.get(0),"body"));return r=="rgba(0, 0, 0, 0)"&&(r="transparent"),e.color.parse(r)},e.color.parse=function(n){var r,i=e.color.make;if(r=/rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(n))return i(parseInt(r[1],10),parseInt(r[2],10),parseInt(r[3],10));if(r=/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(n))return i(parseInt(r[1],10),parseInt(r[2],10),parseInt(r[3],10),parseFloat(r[4]));if(r=/rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(n))return i(parseFloat(r[1])*2.55,parseFloat(r[2])*2.55,parseFloat(r[3])*2.55);if(r=/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(n))return i(parseFloat(r[1])*2.55,parseFloat(r[2])*2.55,parseFloat(r[3])*2.55,parseFloat(r[4]));if(r=/#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(n))return i(parseInt(r[1],16),parseInt(r[2],16),parseInt(r[3],16));if(r=/#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(n))return i(parseInt(r[1]+r[1],16),parseInt(r[2]+r[2],16),parseInt(r[3]+r[3],16));var s=e.trim(n).toLowerCase();return s=="transparent"?i(255,255,255,0):(r=t[s]||[0,0,0],i(r[0],r[1],r[2]))};var t={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);
|
||||
@ -1,345 +0,0 @@
|
||||
/* Flot plugin for drawing all elements of a plot on the canvas.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
Flot normally produces certain elements, like axis labels and the legend, using
|
||||
HTML elements. This permits greater interactivity and customization, and often
|
||||
looks better, due to cross-browser canvas text inconsistencies and limitations.
|
||||
|
||||
It can also be desirable to render the plot entirely in canvas, particularly
|
||||
if the goal is to save it as an image, or if Flot is being used in a context
|
||||
where the HTML DOM does not exist, as is the case within Node.js. This plugin
|
||||
switches out Flot's standard drawing operations for canvas-only replacements.
|
||||
|
||||
Currently the plugin supports only axis labels, but it will eventually allow
|
||||
every element of the plot to be rendered directly to canvas.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
{
|
||||
canvas: boolean
|
||||
}
|
||||
|
||||
The "canvas" option controls whether full canvas drawing is enabled, making it
|
||||
possible to toggle on and off. This is useful when a plot uses HTML text in the
|
||||
browser, but needs to redraw with canvas text when exporting as an image.
|
||||
|
||||
*/
|
||||
|
||||
(function($) {
|
||||
|
||||
var options = {
|
||||
canvas: true
|
||||
};
|
||||
|
||||
var render, getTextInfo, addText;
|
||||
|
||||
// Cache the prototype hasOwnProperty for faster access
|
||||
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
|
||||
function init(plot, classes) {
|
||||
|
||||
var Canvas = classes.Canvas;
|
||||
|
||||
// We only want to replace the functions once; the second time around
|
||||
// we would just get our new function back. This whole replacing of
|
||||
// prototype functions is a disaster, and needs to be changed ASAP.
|
||||
|
||||
if (render == null) {
|
||||
getTextInfo = Canvas.prototype.getTextInfo,
|
||||
addText = Canvas.prototype.addText,
|
||||
render = Canvas.prototype.render;
|
||||
}
|
||||
|
||||
// Finishes rendering the canvas, including overlaid text
|
||||
|
||||
Canvas.prototype.render = function() {
|
||||
|
||||
if (!plot.getOptions().canvas) {
|
||||
return render.call(this);
|
||||
}
|
||||
|
||||
var context = this.context,
|
||||
cache = this._textCache;
|
||||
|
||||
// For each text layer, render elements marked as active
|
||||
|
||||
context.save();
|
||||
context.textBaseline = "middle";
|
||||
|
||||
for (var layerKey in cache) {
|
||||
if (hasOwnProperty.call(cache, layerKey)) {
|
||||
var layerCache = cache[layerKey];
|
||||
for (var styleKey in layerCache) {
|
||||
if (hasOwnProperty.call(layerCache, styleKey)) {
|
||||
var styleCache = layerCache[styleKey],
|
||||
updateStyles = true;
|
||||
for (var key in styleCache) {
|
||||
if (hasOwnProperty.call(styleCache, key)) {
|
||||
|
||||
var info = styleCache[key],
|
||||
positions = info.positions,
|
||||
lines = info.lines;
|
||||
|
||||
// Since every element at this level of the cache have the
|
||||
// same font and fill styles, we can just change them once
|
||||
// using the values from the first element.
|
||||
|
||||
if (updateStyles) {
|
||||
context.fillStyle = info.font.color;
|
||||
context.font = info.font.definition;
|
||||
updateStyles = false;
|
||||
}
|
||||
|
||||
for (var i = 0, position; position = positions[i]; i++) {
|
||||
if (position.active) {
|
||||
for (var j = 0, line; line = position.lines[j]; j++) {
|
||||
context.fillText(lines[j].text, line[0], line[1]);
|
||||
}
|
||||
} else {
|
||||
positions.splice(i--, 1);
|
||||
}
|
||||
}
|
||||
|
||||
if (positions.length == 0) {
|
||||
delete styleCache[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
context.restore();
|
||||
};
|
||||
|
||||
// Creates (if necessary) and returns a text info object.
|
||||
//
|
||||
// When the canvas option is set, the object looks like this:
|
||||
//
|
||||
// {
|
||||
// width: Width of the text's bounding box.
|
||||
// height: Height of the text's bounding box.
|
||||
// positions: Array of positions at which this text is drawn.
|
||||
// lines: [{
|
||||
// height: Height of this line.
|
||||
// widths: Width of this line.
|
||||
// text: Text on this line.
|
||||
// }],
|
||||
// font: {
|
||||
// definition: Canvas font property string.
|
||||
// color: Color of the text.
|
||||
// },
|
||||
// }
|
||||
//
|
||||
// The positions array contains objects that look like this:
|
||||
//
|
||||
// {
|
||||
// active: Flag indicating whether the text should be visible.
|
||||
// lines: Array of [x, y] coordinates at which to draw the line.
|
||||
// x: X coordinate at which to draw the text.
|
||||
// y: Y coordinate at which to draw the text.
|
||||
// }
|
||||
|
||||
Canvas.prototype.getTextInfo = function(layer, text, font, angle, width) {
|
||||
|
||||
if (!plot.getOptions().canvas) {
|
||||
return getTextInfo.call(this, layer, text, font, angle, width);
|
||||
}
|
||||
|
||||
var textStyle, layerCache, styleCache, info;
|
||||
|
||||
// Cast the value to a string, in case we were given a number
|
||||
|
||||
text = "" + text;
|
||||
|
||||
// If the font is a font-spec object, generate a CSS definition
|
||||
|
||||
if (typeof font === "object") {
|
||||
textStyle = font.style + " " + font.variant + " " + font.weight + " " + font.size + "px " + font.family;
|
||||
} else {
|
||||
textStyle = font;
|
||||
}
|
||||
|
||||
// Retrieve (or create) the cache for the text's layer and styles
|
||||
|
||||
layerCache = this._textCache[layer];
|
||||
|
||||
if (layerCache == null) {
|
||||
layerCache = this._textCache[layer] = {};
|
||||
}
|
||||
|
||||
styleCache = layerCache[textStyle];
|
||||
|
||||
if (styleCache == null) {
|
||||
styleCache = layerCache[textStyle] = {};
|
||||
}
|
||||
|
||||
info = styleCache[text];
|
||||
|
||||
if (info == null) {
|
||||
|
||||
var context = this.context;
|
||||
|
||||
// If the font was provided as CSS, create a div with those
|
||||
// classes and examine it to generate a canvas font spec.
|
||||
|
||||
if (typeof font !== "object") {
|
||||
|
||||
var element = $("<div> </div>")
|
||||
.css("position", "absolute")
|
||||
.addClass(typeof font === "string" ? font : null)
|
||||
.appendTo(this.getTextLayer(layer));
|
||||
|
||||
font = {
|
||||
lineHeight: element.height(),
|
||||
style: element.css("font-style"),
|
||||
variant: element.css("font-variant"),
|
||||
weight: element.css("font-weight"),
|
||||
family: element.css("font-family"),
|
||||
color: element.css("color")
|
||||
};
|
||||
|
||||
// Setting line-height to 1, without units, sets it equal
|
||||
// to the font-size, even if the font-size is abstract,
|
||||
// like 'smaller'. This enables us to read the real size
|
||||
// via the element's height, working around browsers that
|
||||
// return the literal 'smaller' value.
|
||||
|
||||
font.size = element.css("line-height", 1).height();
|
||||
|
||||
element.remove();
|
||||
}
|
||||
|
||||
textStyle = font.style + " " + font.variant + " " + font.weight + " " + font.size + "px " + font.family;
|
||||
|
||||
// Create a new info object, initializing the dimensions to
|
||||
// zero so we can count them up line-by-line.
|
||||
|
||||
info = styleCache[text] = {
|
||||
width: 0,
|
||||
height: 0,
|
||||
positions: [],
|
||||
lines: [],
|
||||
font: {
|
||||
definition: textStyle,
|
||||
color: font.color
|
||||
}
|
||||
};
|
||||
|
||||
context.save();
|
||||
context.font = textStyle;
|
||||
|
||||
// Canvas can't handle multi-line strings; break on various
|
||||
// newlines, including HTML brs, to build a list of lines.
|
||||
// Note that we could split directly on regexps, but IE < 9 is
|
||||
// broken; revisit when we drop IE 7/8 support.
|
||||
|
||||
var lines = (text + "").replace(/<br ?\/?>|\r\n|\r/g, "\n").split("\n");
|
||||
|
||||
for (var i = 0; i < lines.length; ++i) {
|
||||
|
||||
var lineText = lines[i],
|
||||
measured = context.measureText(lineText);
|
||||
|
||||
info.width = Math.max(measured.width, info.width);
|
||||
info.height += font.lineHeight;
|
||||
|
||||
info.lines.push({
|
||||
text: lineText,
|
||||
width: measured.width,
|
||||
height: font.lineHeight
|
||||
});
|
||||
}
|
||||
|
||||
context.restore();
|
||||
}
|
||||
|
||||
return info;
|
||||
};
|
||||
|
||||
// Adds a text string to the canvas text overlay.
|
||||
|
||||
Canvas.prototype.addText = function(layer, x, y, text, font, angle, width, halign, valign) {
|
||||
|
||||
if (!plot.getOptions().canvas) {
|
||||
return addText.call(this, layer, x, y, text, font, angle, width, halign, valign);
|
||||
}
|
||||
|
||||
var info = this.getTextInfo(layer, text, font, angle, width),
|
||||
positions = info.positions,
|
||||
lines = info.lines;
|
||||
|
||||
// Text is drawn with baseline 'middle', which we need to account
|
||||
// for by adding half a line's height to the y position.
|
||||
|
||||
y += info.height / lines.length / 2;
|
||||
|
||||
// Tweak the initial y-position to match vertical alignment
|
||||
|
||||
if (valign == "middle") {
|
||||
y = Math.round(y - info.height / 2);
|
||||
} else if (valign == "bottom") {
|
||||
y = Math.round(y - info.height);
|
||||
} else {
|
||||
y = Math.round(y);
|
||||
}
|
||||
|
||||
// FIXME: LEGACY BROWSER FIX
|
||||
// AFFECTS: Opera < 12.00
|
||||
|
||||
// Offset the y coordinate, since Opera is off pretty
|
||||
// consistently compared to the other browsers.
|
||||
|
||||
if (!!(window.opera && window.opera.version().split(".")[0] < 12)) {
|
||||
y -= 2;
|
||||
}
|
||||
|
||||
// Determine whether this text already exists at this position.
|
||||
// If so, mark it for inclusion in the next render pass.
|
||||
|
||||
for (var i = 0, position; position = positions[i]; i++) {
|
||||
if (position.x == x && position.y == y) {
|
||||
position.active = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// If the text doesn't exist at this position, create a new entry
|
||||
|
||||
position = {
|
||||
active: true,
|
||||
lines: [],
|
||||
x: x,
|
||||
y: y
|
||||
};
|
||||
|
||||
positions.push(position);
|
||||
|
||||
// Fill in the x & y positions of each line, adjusting them
|
||||
// individually for horizontal alignment.
|
||||
|
||||
for (var i = 0, line; line = lines[i]; i++) {
|
||||
if (halign == "center") {
|
||||
position.lines.push([Math.round(x - line.width / 2), y]);
|
||||
} else if (halign == "right") {
|
||||
position.lines.push([Math.round(x - line.width), y]);
|
||||
} else {
|
||||
position.lines.push([Math.round(x), y]);
|
||||
}
|
||||
y += line.height;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: "canvas",
|
||||
version: "1.0"
|
||||
});
|
||||
|
||||
})(jQuery);
|
||||
@ -1,28 +0,0 @@
|
||||
/* Flot plugin for drawing all elements of a plot on the canvas.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
Flot normally produces certain elements, like axis labels and the legend, using
|
||||
HTML elements. This permits greater interactivity and customization, and often
|
||||
looks better, due to cross-browser canvas text inconsistencies and limitations.
|
||||
|
||||
It can also be desirable to render the plot entirely in canvas, particularly
|
||||
if the goal is to save it as an image, or if Flot is being used in a context
|
||||
where the HTML DOM does not exist, as is the case within Node.js. This plugin
|
||||
switches out Flot's standard drawing operations for canvas-only replacements.
|
||||
|
||||
Currently the plugin supports only axis labels, but it will eventually allow
|
||||
every element of the plot to be rendered directly to canvas.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
{
|
||||
canvas: boolean
|
||||
}
|
||||
|
||||
The "canvas" option controls whether full canvas drawing is enabled, making it
|
||||
possible to toggle on and off. This is useful when a plot uses HTML text in the
|
||||
browser, but needs to redraw with canvas text when exporting as an image.
|
||||
|
||||
*/(function(e){function o(t,o){var u=o.Canvas;n==null&&(r=u.prototype.getTextInfo,i=u.prototype.addText,n=u.prototype.render),u.prototype.render=function(){if(!t.getOptions().canvas)return n.call(this);var e=this.context,r=this._textCache;e.save(),e.textBaseline="middle";for(var i in r)if(s.call(r,i)){var o=r[i];for(var u in o)if(s.call(o,u)){var a=o[u],f=!0;for(var l in a)if(s.call(a,l)){var c=a[l],h=c.positions,p=c.lines;f&&(e.fillStyle=c.font.color,e.font=c.font.definition,f=!1);for(var d=0,v;v=h[d];d++)if(v.active)for(var m=0,g;g=v.lines[m];m++)e.fillText(p[m].text,g[0],g[1]);else h.splice(d--,1);h.length==0&&delete a[l]}}}e.restore()},u.prototype.getTextInfo=function(n,i,s,o,u){if(!t.getOptions().canvas)return r.call(this,n,i,s,o,u);var a,f,l,c;i=""+i,typeof s=="object"?a=s.style+" "+s.variant+" "+s.weight+" "+s.size+"px "+s.family:a=s,f=this._textCache[n],f==null&&(f=this._textCache[n]={}),l=f[a],l==null&&(l=f[a]={}),c=l[i];if(c==null){var h=this.context;if(typeof s!="object"){var p=e("<div> </div>").css("position","absolute").addClass(typeof s=="string"?s:null).appendTo(this.getTextLayer(n));s={lineHeight:p.height(),style:p.css("font-style"),variant:p.css("font-variant"),weight:p.css("font-weight"),family:p.css("font-family"),color:p.css("color")},s.size=p.css("line-height",1).height(),p.remove()}a=s.style+" "+s.variant+" "+s.weight+" "+s.size+"px "+s.family,c=l[i]={width:0,height:0,positions:[],lines:[],font:{definition:a,color:s.color}},h.save(),h.font=a;var d=(i+"").replace(/<br ?\/?>|\r\n|\r/g,"\n").split("\n");for(var v=0;v<d.length;++v){var m=d[v],g=h.measureText(m);c.width=Math.max(g.width,c.width),c.height+=s.lineHeight,c.lines.push({text:m,width:g.width,height:s.lineHeight})}h.restore()}return c},u.prototype.addText=function(e,n,r,s,o,u,a,f,l){if(!t.getOptions().canvas)return i.call(this,e,n,r,s,o,u,a,f,l);var c=this.getTextInfo(e,s,o,u,a),h=c.positions,p=c.lines;r+=c.height/p.length/2,l=="middle"?r=Math.round(r-c.height/2):l=="bottom"?r=Math.round(r-c.height):r=Math.round(r),!(window.opera&&window.opera.version().split(".")[0]<12)||(r-=2);for(var d=0,v;v=h[d];d++)if(v.x==n&&v.y==r){v.active=!0;return}v={active:!0,lines:[],x:n,y:r},h.push(v);for(var d=0,m;m=p[d];d++)f=="center"?v.lines.push([Math.round(n-m.width/2),r]):f=="right"?v.lines.push([Math.round(n-m.width),r]):v.lines.push([Math.round(n),r]),r+=m.height}}var t={canvas:!0},n,r,i,s=Object.prototype.hasOwnProperty;e.plot.plugins.push({init:o,options:t,name:"canvas",version:"1.0"})})(jQuery);
|
||||
@ -1,190 +0,0 @@
|
||||
/* Flot plugin for plotting textual data or categories.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
Consider a dataset like [["February", 34], ["March", 20], ...]. This plugin
|
||||
allows you to plot such a dataset directly.
|
||||
|
||||
To enable it, you must specify mode: "categories" on the axis with the textual
|
||||
labels, e.g.
|
||||
|
||||
$.plot("#placeholder", data, { xaxis: { mode: "categories" } });
|
||||
|
||||
By default, the labels are ordered as they are met in the data series. If you
|
||||
need a different ordering, you can specify "categories" on the axis options
|
||||
and list the categories there:
|
||||
|
||||
xaxis: {
|
||||
mode: "categories",
|
||||
categories: ["February", "March", "April"]
|
||||
}
|
||||
|
||||
If you need to customize the distances between the categories, you can specify
|
||||
"categories" as an object mapping labels to values
|
||||
|
||||
xaxis: {
|
||||
mode: "categories",
|
||||
categories: { "February": 1, "March": 3, "April": 4 }
|
||||
}
|
||||
|
||||
If you don't specify all categories, the remaining categories will be numbered
|
||||
from the max value plus 1 (with a spacing of 1 between each).
|
||||
|
||||
Internally, the plugin works by transforming the input data through an auto-
|
||||
generated mapping where the first category becomes 0, the second 1, etc.
|
||||
Hence, a point like ["February", 34] becomes [0, 34] internally in Flot (this
|
||||
is visible in hover and click events that return numbers rather than the
|
||||
category labels). The plugin also overrides the tick generator to spit out the
|
||||
categories as ticks instead of the values.
|
||||
|
||||
If you need to map a value back to its label, the mapping is always accessible
|
||||
as "categories" on the axis object, e.g. plot.getAxes().xaxis.categories.
|
||||
|
||||
*/
|
||||
|
||||
(function ($) {
|
||||
var options = {
|
||||
xaxis: {
|
||||
categories: null
|
||||
},
|
||||
yaxis: {
|
||||
categories: null
|
||||
}
|
||||
};
|
||||
|
||||
function processRawData(plot, series, data, datapoints) {
|
||||
// if categories are enabled, we need to disable
|
||||
// auto-transformation to numbers so the strings are intact
|
||||
// for later processing
|
||||
|
||||
var xCategories = series.xaxis.options.mode == "categories",
|
||||
yCategories = series.yaxis.options.mode == "categories";
|
||||
|
||||
if (!(xCategories || yCategories))
|
||||
return;
|
||||
|
||||
var format = datapoints.format;
|
||||
|
||||
if (!format) {
|
||||
// FIXME: auto-detection should really not be defined here
|
||||
var s = series;
|
||||
format = [];
|
||||
format.push({ x: true, number: true, required: true });
|
||||
format.push({ y: true, number: true, required: true });
|
||||
|
||||
if (s.bars.show || (s.lines.show && s.lines.fill)) {
|
||||
var autoscale = !!((s.bars.show && s.bars.zero) || (s.lines.show && s.lines.zero));
|
||||
format.push({ y: true, number: true, required: false, defaultValue: 0, autoscale: autoscale });
|
||||
if (s.bars.horizontal) {
|
||||
delete format[format.length - 1].y;
|
||||
format[format.length - 1].x = true;
|
||||
}
|
||||
}
|
||||
|
||||
datapoints.format = format;
|
||||
}
|
||||
|
||||
for (var m = 0; m < format.length; ++m) {
|
||||
if (format[m].x && xCategories)
|
||||
format[m].number = false;
|
||||
|
||||
if (format[m].y && yCategories)
|
||||
format[m].number = false;
|
||||
}
|
||||
}
|
||||
|
||||
function getNextIndex(categories) {
|
||||
var index = -1;
|
||||
|
||||
for (var v in categories)
|
||||
if (categories[v] > index)
|
||||
index = categories[v];
|
||||
|
||||
return index + 1;
|
||||
}
|
||||
|
||||
function categoriesTickGenerator(axis) {
|
||||
var res = [];
|
||||
for (var label in axis.categories) {
|
||||
var v = axis.categories[label];
|
||||
if (v >= axis.min && v <= axis.max)
|
||||
res.push([v, label]);
|
||||
}
|
||||
|
||||
res.sort(function (a, b) { return a[0] - b[0]; });
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
function setupCategoriesForAxis(series, axis, datapoints) {
|
||||
if (series[axis].options.mode != "categories")
|
||||
return;
|
||||
|
||||
if (!series[axis].categories) {
|
||||
// parse options
|
||||
var c = {}, o = series[axis].options.categories || {};
|
||||
if ($.isArray(o)) {
|
||||
for (var i = 0; i < o.length; ++i)
|
||||
c[o[i]] = i;
|
||||
}
|
||||
else {
|
||||
for (var v in o)
|
||||
c[v] = o[v];
|
||||
}
|
||||
|
||||
series[axis].categories = c;
|
||||
}
|
||||
|
||||
// fix ticks
|
||||
if (!series[axis].options.ticks)
|
||||
series[axis].options.ticks = categoriesTickGenerator;
|
||||
|
||||
transformPointsOnAxis(datapoints, axis, series[axis].categories);
|
||||
}
|
||||
|
||||
function transformPointsOnAxis(datapoints, axis, categories) {
|
||||
// go through the points, transforming them
|
||||
var points = datapoints.points,
|
||||
ps = datapoints.pointsize,
|
||||
format = datapoints.format,
|
||||
formatColumn = axis.charAt(0),
|
||||
index = getNextIndex(categories);
|
||||
|
||||
for (var i = 0; i < points.length; i += ps) {
|
||||
if (points[i] == null)
|
||||
continue;
|
||||
|
||||
for (var m = 0; m < ps; ++m) {
|
||||
var val = points[i + m];
|
||||
|
||||
if (val == null || !format[m][formatColumn])
|
||||
continue;
|
||||
|
||||
if (!(val in categories)) {
|
||||
categories[val] = index;
|
||||
++index;
|
||||
}
|
||||
|
||||
points[i + m] = categories[val];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function processDatapoints(plot, series, datapoints) {
|
||||
setupCategoriesForAxis(series, "xaxis", datapoints);
|
||||
setupCategoriesForAxis(series, "yaxis", datapoints);
|
||||
}
|
||||
|
||||
function init(plot) {
|
||||
plot.hooks.processRawData.push(processRawData);
|
||||
plot.hooks.processDatapoints.push(processDatapoints);
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'categories',
|
||||
version: '1.0'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,44 +0,0 @@
|
||||
/* Flot plugin for plotting textual data or categories.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
Consider a dataset like [["February", 34], ["March", 20], ...]. This plugin
|
||||
allows you to plot such a dataset directly.
|
||||
|
||||
To enable it, you must specify mode: "categories" on the axis with the textual
|
||||
labels, e.g.
|
||||
|
||||
$.plot("#placeholder", data, { xaxis: { mode: "categories" } });
|
||||
|
||||
By default, the labels are ordered as they are met in the data series. If you
|
||||
need a different ordering, you can specify "categories" on the axis options
|
||||
and list the categories there:
|
||||
|
||||
xaxis: {
|
||||
mode: "categories",
|
||||
categories: ["February", "March", "April"]
|
||||
}
|
||||
|
||||
If you need to customize the distances between the categories, you can specify
|
||||
"categories" as an object mapping labels to values
|
||||
|
||||
xaxis: {
|
||||
mode: "categories",
|
||||
categories: { "February": 1, "March": 3, "April": 4 }
|
||||
}
|
||||
|
||||
If you don't specify all categories, the remaining categories will be numbered
|
||||
from the max value plus 1 (with a spacing of 1 between each).
|
||||
|
||||
Internally, the plugin works by transforming the input data through an auto-
|
||||
generated mapping where the first category becomes 0, the second 1, etc.
|
||||
Hence, a point like ["February", 34] becomes [0, 34] internally in Flot (this
|
||||
is visible in hover and click events that return numbers rather than the
|
||||
category labels). The plugin also overrides the tick generator to spit out the
|
||||
categories as ticks instead of the values.
|
||||
|
||||
If you need to map a value back to its label, the mapping is always accessible
|
||||
as "categories" on the axis object, e.g. plot.getAxes().xaxis.categories.
|
||||
|
||||
*/(function(e){function n(e,t,n,r){var i=t.xaxis.options.mode=="categories",s=t.yaxis.options.mode=="categories";if(!i&&!s)return;var o=r.format;if(!o){var u=t;o=[],o.push({x:!0,number:!0,required:!0}),o.push({y:!0,number:!0,required:!0});if(u.bars.show||u.lines.show&&u.lines.fill){var a=!!(u.bars.show&&u.bars.zero||u.lines.show&&u.lines.zero);o.push({y:!0,number:!0,required:!1,defaultValue:0,autoscale:a}),u.bars.horizontal&&(delete o[o.length-1].y,o[o.length-1].x=!0)}r.format=o}for(var f=0;f<o.length;++f)o[f].x&&i&&(o[f].number=!1),o[f].y&&s&&(o[f].number=!1)}function r(e){var t=-1;for(var n in e)e[n]>t&&(t=e[n]);return t+1}function i(e){var t=[];for(var n in e.categories){var r=e.categories[n];r>=e.min&&r<=e.max&&t.push([r,n])}return t.sort(function(e,t){return e[0]-t[0]}),t}function s(t,n,r){if(t[n].options.mode!="categories")return;if(!t[n].categories){var s={},u=t[n].options.categories||{};if(e.isArray(u))for(var a=0;a<u.length;++a)s[u[a]]=a;else for(var f in u)s[f]=u[f];t[n].categories=s}t[n].options.ticks||(t[n].options.ticks=i),o(r,n,t[n].categories)}function o(e,t,n){var i=e.points,s=e.pointsize,o=e.format,u=t.charAt(0),a=r(n);for(var f=0;f<i.length;f+=s){if(i[f]==null)continue;for(var l=0;l<s;++l){var c=i[f+l];if(c==null||!o[l][u])continue;c in n||(n[c]=a,++a),i[f+l]=n[c]}}}function u(e,t,n){s(t,"xaxis",n),s(t,"yaxis",n)}function a(e){e.hooks.processRawData.push(n),e.hooks.processDatapoints.push(u)}var t={xaxis:{categories:null},yaxis:{categories:null}};e.plot.plugins.push({init:a,options:t,name:"categories",version:"1.0"})})(jQuery);
|
||||
@ -1,176 +0,0 @@
|
||||
/* Flot plugin for showing crosshairs when the mouse hovers over the plot.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
crosshair: {
|
||||
mode: null or "x" or "y" or "xy"
|
||||
color: color
|
||||
lineWidth: number
|
||||
}
|
||||
|
||||
Set the mode to one of "x", "y" or "xy". The "x" mode enables a vertical
|
||||
crosshair that lets you trace the values on the x axis, "y" enables a
|
||||
horizontal crosshair and "xy" enables them both. "color" is the color of the
|
||||
crosshair (default is "rgba(170, 0, 0, 0.80)"), "lineWidth" is the width of
|
||||
the drawn lines (default is 1).
|
||||
|
||||
The plugin also adds four public methods:
|
||||
|
||||
- setCrosshair( pos )
|
||||
|
||||
Set the position of the crosshair. Note that this is cleared if the user
|
||||
moves the mouse. "pos" is in coordinates of the plot and should be on the
|
||||
form { x: xpos, y: ypos } (you can use x2/x3/... if you're using multiple
|
||||
axes), which is coincidentally the same format as what you get from a
|
||||
"plothover" event. If "pos" is null, the crosshair is cleared.
|
||||
|
||||
- clearCrosshair()
|
||||
|
||||
Clear the crosshair.
|
||||
|
||||
- lockCrosshair(pos)
|
||||
|
||||
Cause the crosshair to lock to the current location, no longer updating if
|
||||
the user moves the mouse. Optionally supply a position (passed on to
|
||||
setCrosshair()) to move it to.
|
||||
|
||||
Example usage:
|
||||
|
||||
var myFlot = $.plot( $("#graph"), ..., { crosshair: { mode: "x" } } };
|
||||
$("#graph").bind( "plothover", function ( evt, position, item ) {
|
||||
if ( item ) {
|
||||
// Lock the crosshair to the data point being hovered
|
||||
myFlot.lockCrosshair({
|
||||
x: item.datapoint[ 0 ],
|
||||
y: item.datapoint[ 1 ]
|
||||
});
|
||||
} else {
|
||||
// Return normal crosshair operation
|
||||
myFlot.unlockCrosshair();
|
||||
}
|
||||
});
|
||||
|
||||
- unlockCrosshair()
|
||||
|
||||
Free the crosshair to move again after locking it.
|
||||
*/
|
||||
|
||||
(function ($) {
|
||||
var options = {
|
||||
crosshair: {
|
||||
mode: null, // one of null, "x", "y" or "xy",
|
||||
color: "rgba(170, 0, 0, 0.80)",
|
||||
lineWidth: 1
|
||||
}
|
||||
};
|
||||
|
||||
function init(plot) {
|
||||
// position of crosshair in pixels
|
||||
var crosshair = { x: -1, y: -1, locked: false };
|
||||
|
||||
plot.setCrosshair = function setCrosshair(pos) {
|
||||
if (!pos)
|
||||
crosshair.x = -1;
|
||||
else {
|
||||
var o = plot.p2c(pos);
|
||||
crosshair.x = Math.max(0, Math.min(o.left, plot.width()));
|
||||
crosshair.y = Math.max(0, Math.min(o.top, plot.height()));
|
||||
}
|
||||
|
||||
plot.triggerRedrawOverlay();
|
||||
};
|
||||
|
||||
plot.clearCrosshair = plot.setCrosshair; // passes null for pos
|
||||
|
||||
plot.lockCrosshair = function lockCrosshair(pos) {
|
||||
if (pos)
|
||||
plot.setCrosshair(pos);
|
||||
crosshair.locked = true;
|
||||
};
|
||||
|
||||
plot.unlockCrosshair = function unlockCrosshair() {
|
||||
crosshair.locked = false;
|
||||
};
|
||||
|
||||
function onMouseOut(e) {
|
||||
if (crosshair.locked)
|
||||
return;
|
||||
|
||||
if (crosshair.x != -1) {
|
||||
crosshair.x = -1;
|
||||
plot.triggerRedrawOverlay();
|
||||
}
|
||||
}
|
||||
|
||||
function onMouseMove(e) {
|
||||
if (crosshair.locked)
|
||||
return;
|
||||
|
||||
if (plot.getSelection && plot.getSelection()) {
|
||||
crosshair.x = -1; // hide the crosshair while selecting
|
||||
return;
|
||||
}
|
||||
|
||||
var offset = plot.offset();
|
||||
crosshair.x = Math.max(0, Math.min(e.pageX - offset.left, plot.width()));
|
||||
crosshair.y = Math.max(0, Math.min(e.pageY - offset.top, plot.height()));
|
||||
plot.triggerRedrawOverlay();
|
||||
}
|
||||
|
||||
plot.hooks.bindEvents.push(function (plot, eventHolder) {
|
||||
if (!plot.getOptions().crosshair.mode)
|
||||
return;
|
||||
|
||||
eventHolder.mouseout(onMouseOut);
|
||||
eventHolder.mousemove(onMouseMove);
|
||||
});
|
||||
|
||||
plot.hooks.drawOverlay.push(function (plot, ctx) {
|
||||
var c = plot.getOptions().crosshair;
|
||||
if (!c.mode)
|
||||
return;
|
||||
|
||||
var plotOffset = plot.getPlotOffset();
|
||||
|
||||
ctx.save();
|
||||
ctx.translate(plotOffset.left, plotOffset.top);
|
||||
|
||||
if (crosshair.x != -1) {
|
||||
var adj = plot.getOptions().crosshair.lineWidth % 2 === 0 ? 0 : 0.5;
|
||||
|
||||
ctx.strokeStyle = c.color;
|
||||
ctx.lineWidth = c.lineWidth;
|
||||
ctx.lineJoin = "round";
|
||||
|
||||
ctx.beginPath();
|
||||
if (c.mode.indexOf("x") != -1) {
|
||||
var drawX = Math.round(crosshair.x) + adj;
|
||||
ctx.moveTo(drawX, 0);
|
||||
ctx.lineTo(drawX, plot.height());
|
||||
}
|
||||
if (c.mode.indexOf("y") != -1) {
|
||||
var drawY = Math.round(crosshair.y) + adj;
|
||||
ctx.moveTo(0, drawY);
|
||||
ctx.lineTo(plot.width(), drawY);
|
||||
}
|
||||
ctx.stroke();
|
||||
}
|
||||
ctx.restore();
|
||||
});
|
||||
|
||||
plot.hooks.shutdown.push(function (plot, eventHolder) {
|
||||
eventHolder.unbind("mouseout", onMouseOut);
|
||||
eventHolder.unbind("mousemove", onMouseMove);
|
||||
});
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'crosshair',
|
||||
version: '1.0'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,59 +0,0 @@
|
||||
/* Flot plugin for showing crosshairs when the mouse hovers over the plot.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
crosshair: {
|
||||
mode: null or "x" or "y" or "xy"
|
||||
color: color
|
||||
lineWidth: number
|
||||
}
|
||||
|
||||
Set the mode to one of "x", "y" or "xy". The "x" mode enables a vertical
|
||||
crosshair that lets you trace the values on the x axis, "y" enables a
|
||||
horizontal crosshair and "xy" enables them both. "color" is the color of the
|
||||
crosshair (default is "rgba(170, 0, 0, 0.80)"), "lineWidth" is the width of
|
||||
the drawn lines (default is 1).
|
||||
|
||||
The plugin also adds four public methods:
|
||||
|
||||
- setCrosshair( pos )
|
||||
|
||||
Set the position of the crosshair. Note that this is cleared if the user
|
||||
moves the mouse. "pos" is in coordinates of the plot and should be on the
|
||||
form { x: xpos, y: ypos } (you can use x2/x3/... if you're using multiple
|
||||
axes), which is coincidentally the same format as what you get from a
|
||||
"plothover" event. If "pos" is null, the crosshair is cleared.
|
||||
|
||||
- clearCrosshair()
|
||||
|
||||
Clear the crosshair.
|
||||
|
||||
- lockCrosshair(pos)
|
||||
|
||||
Cause the crosshair to lock to the current location, no longer updating if
|
||||
the user moves the mouse. Optionally supply a position (passed on to
|
||||
setCrosshair()) to move it to.
|
||||
|
||||
Example usage:
|
||||
|
||||
var myFlot = $.plot( $("#graph"), ..., { crosshair: { mode: "x" } } };
|
||||
$("#graph").bind( "plothover", function ( evt, position, item ) {
|
||||
if ( item ) {
|
||||
// Lock the crosshair to the data point being hovered
|
||||
myFlot.lockCrosshair({
|
||||
x: item.datapoint[ 0 ],
|
||||
y: item.datapoint[ 1 ]
|
||||
});
|
||||
} else {
|
||||
// Return normal crosshair operation
|
||||
myFlot.unlockCrosshair();
|
||||
}
|
||||
});
|
||||
|
||||
- unlockCrosshair()
|
||||
|
||||
Free the crosshair to move again after locking it.
|
||||
*/(function(e){function n(e){function n(n){if(t.locked)return;t.x!=-1&&(t.x=-1,e.triggerRedrawOverlay())}function r(n){if(t.locked)return;if(e.getSelection&&e.getSelection()){t.x=-1;return}var r=e.offset();t.x=Math.max(0,Math.min(n.pageX-r.left,e.width())),t.y=Math.max(0,Math.min(n.pageY-r.top,e.height())),e.triggerRedrawOverlay()}var t={x:-1,y:-1,locked:!1};e.setCrosshair=function(r){if(!r)t.x=-1;else{var i=e.p2c(r);t.x=Math.max(0,Math.min(i.left,e.width())),t.y=Math.max(0,Math.min(i.top,e.height()))}e.triggerRedrawOverlay()},e.clearCrosshair=e.setCrosshair,e.lockCrosshair=function(r){r&&e.setCrosshair(r),t.locked=!0},e.unlockCrosshair=function(){t.locked=!1},e.hooks.bindEvents.push(function(e,t){if(!e.getOptions().crosshair.mode)return;t.mouseout(n),t.mousemove(r)}),e.hooks.drawOverlay.push(function(e,n){var r=e.getOptions().crosshair;if(!r.mode)return;var i=e.getPlotOffset();n.save(),n.translate(i.left,i.top);if(t.x!=-1){var s=e.getOptions().crosshair.lineWidth%2===0?0:.5;n.strokeStyle=r.color,n.lineWidth=r.lineWidth,n.lineJoin="round",n.beginPath();if(r.mode.indexOf("x")!=-1){var o=Math.round(t.x)+s;n.moveTo(o,0),n.lineTo(o,e.height())}if(r.mode.indexOf("y")!=-1){var u=Math.round(t.y)+s;n.moveTo(0,u),n.lineTo(e.width(),u)}n.stroke()}n.restore()}),e.hooks.shutdown.push(function(e,t){t.unbind("mouseout",n),t.unbind("mousemove",r)})}var t={crosshair:{mode:null,color:"rgba(170, 0, 0, 0.80)",lineWidth:1}};e.plot.plugins.push({init:n,options:t,name:"crosshair",version:"1.0"})})(jQuery);
|
||||
@ -1,353 +0,0 @@
|
||||
/* Flot plugin for plotting error bars.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
Error bars are used to show standard deviation and other statistical
|
||||
properties in a plot.
|
||||
|
||||
* Created by Rui Pereira - rui (dot) pereira (at) gmail (dot) com
|
||||
|
||||
This plugin allows you to plot error-bars over points. Set "errorbars" inside
|
||||
the points series to the axis name over which there will be error values in
|
||||
your data array (*even* if you do not intend to plot them later, by setting
|
||||
"show: null" on xerr/yerr).
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
series: {
|
||||
points: {
|
||||
errorbars: "x" or "y" or "xy",
|
||||
xerr: {
|
||||
show: null/false or true,
|
||||
asymmetric: null/false or true,
|
||||
upperCap: null or "-" or function,
|
||||
lowerCap: null or "-" or function,
|
||||
color: null or color,
|
||||
radius: null or number
|
||||
},
|
||||
yerr: { same options as xerr }
|
||||
}
|
||||
}
|
||||
|
||||
Each data point array is expected to be of the type:
|
||||
|
||||
"x" [ x, y, xerr ]
|
||||
"y" [ x, y, yerr ]
|
||||
"xy" [ x, y, xerr, yerr ]
|
||||
|
||||
Where xerr becomes xerr_lower,xerr_upper for the asymmetric error case, and
|
||||
equivalently for yerr. Eg., a datapoint for the "xy" case with symmetric
|
||||
error-bars on X and asymmetric on Y would be:
|
||||
|
||||
[ x, y, xerr, yerr_lower, yerr_upper ]
|
||||
|
||||
By default no end caps are drawn. Setting upperCap and/or lowerCap to "-" will
|
||||
draw a small cap perpendicular to the error bar. They can also be set to a
|
||||
user-defined drawing function, with (ctx, x, y, radius) as parameters, as eg.
|
||||
|
||||
function drawSemiCircle( ctx, x, y, radius ) {
|
||||
ctx.beginPath();
|
||||
ctx.arc( x, y, radius, 0, Math.PI, false );
|
||||
ctx.moveTo( x - radius, y );
|
||||
ctx.lineTo( x + radius, y );
|
||||
ctx.stroke();
|
||||
}
|
||||
|
||||
Color and radius both default to the same ones of the points series if not
|
||||
set. The independent radius parameter on xerr/yerr is useful for the case when
|
||||
we may want to add error-bars to a line, without showing the interconnecting
|
||||
points (with radius: 0), and still showing end caps on the error-bars.
|
||||
shadowSize and lineWidth are derived as well from the points series.
|
||||
|
||||
*/
|
||||
|
||||
(function ($) {
|
||||
var options = {
|
||||
series: {
|
||||
points: {
|
||||
errorbars: null, //should be 'x', 'y' or 'xy'
|
||||
xerr: { err: 'x', show: null, asymmetric: null, upperCap: null, lowerCap: null, color: null, radius: null},
|
||||
yerr: { err: 'y', show: null, asymmetric: null, upperCap: null, lowerCap: null, color: null, radius: null}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
function processRawData(plot, series, data, datapoints){
|
||||
if (!series.points.errorbars)
|
||||
return;
|
||||
|
||||
// x,y values
|
||||
var format = [
|
||||
{ x: true, number: true, required: true },
|
||||
{ y: true, number: true, required: true }
|
||||
];
|
||||
|
||||
var errors = series.points.errorbars;
|
||||
// error bars - first X then Y
|
||||
if (errors == 'x' || errors == 'xy') {
|
||||
// lower / upper error
|
||||
if (series.points.xerr.asymmetric) {
|
||||
format.push({ x: true, number: true, required: true });
|
||||
format.push({ x: true, number: true, required: true });
|
||||
} else
|
||||
format.push({ x: true, number: true, required: true });
|
||||
}
|
||||
if (errors == 'y' || errors == 'xy') {
|
||||
// lower / upper error
|
||||
if (series.points.yerr.asymmetric) {
|
||||
format.push({ y: true, number: true, required: true });
|
||||
format.push({ y: true, number: true, required: true });
|
||||
} else
|
||||
format.push({ y: true, number: true, required: true });
|
||||
}
|
||||
datapoints.format = format;
|
||||
}
|
||||
|
||||
function parseErrors(series, i){
|
||||
|
||||
var points = series.datapoints.points;
|
||||
|
||||
// read errors from points array
|
||||
var exl = null,
|
||||
exu = null,
|
||||
eyl = null,
|
||||
eyu = null;
|
||||
var xerr = series.points.xerr,
|
||||
yerr = series.points.yerr;
|
||||
|
||||
var eb = series.points.errorbars;
|
||||
// error bars - first X
|
||||
if (eb == 'x' || eb == 'xy') {
|
||||
if (xerr.asymmetric) {
|
||||
exl = points[i + 2];
|
||||
exu = points[i + 3];
|
||||
if (eb == 'xy')
|
||||
if (yerr.asymmetric){
|
||||
eyl = points[i + 4];
|
||||
eyu = points[i + 5];
|
||||
} else eyl = points[i + 4];
|
||||
} else {
|
||||
exl = points[i + 2];
|
||||
if (eb == 'xy')
|
||||
if (yerr.asymmetric) {
|
||||
eyl = points[i + 3];
|
||||
eyu = points[i + 4];
|
||||
} else eyl = points[i + 3];
|
||||
}
|
||||
// only Y
|
||||
} else if (eb == 'y')
|
||||
if (yerr.asymmetric) {
|
||||
eyl = points[i + 2];
|
||||
eyu = points[i + 3];
|
||||
} else eyl = points[i + 2];
|
||||
|
||||
// symmetric errors?
|
||||
if (exu == null) exu = exl;
|
||||
if (eyu == null) eyu = eyl;
|
||||
|
||||
var errRanges = [exl, exu, eyl, eyu];
|
||||
// nullify if not showing
|
||||
if (!xerr.show){
|
||||
errRanges[0] = null;
|
||||
errRanges[1] = null;
|
||||
}
|
||||
if (!yerr.show){
|
||||
errRanges[2] = null;
|
||||
errRanges[3] = null;
|
||||
}
|
||||
return errRanges;
|
||||
}
|
||||
|
||||
function drawSeriesErrors(plot, ctx, s){
|
||||
|
||||
var points = s.datapoints.points,
|
||||
ps = s.datapoints.pointsize,
|
||||
ax = [s.xaxis, s.yaxis],
|
||||
radius = s.points.radius,
|
||||
err = [s.points.xerr, s.points.yerr];
|
||||
|
||||
//sanity check, in case some inverted axis hack is applied to flot
|
||||
var invertX = false;
|
||||
if (ax[0].p2c(ax[0].max) < ax[0].p2c(ax[0].min)) {
|
||||
invertX = true;
|
||||
var tmp = err[0].lowerCap;
|
||||
err[0].lowerCap = err[0].upperCap;
|
||||
err[0].upperCap = tmp;
|
||||
}
|
||||
|
||||
var invertY = false;
|
||||
if (ax[1].p2c(ax[1].min) < ax[1].p2c(ax[1].max)) {
|
||||
invertY = true;
|
||||
var tmp = err[1].lowerCap;
|
||||
err[1].lowerCap = err[1].upperCap;
|
||||
err[1].upperCap = tmp;
|
||||
}
|
||||
|
||||
for (var i = 0; i < s.datapoints.points.length; i += ps) {
|
||||
|
||||
//parse
|
||||
var errRanges = parseErrors(s, i);
|
||||
|
||||
//cycle xerr & yerr
|
||||
for (var e = 0; e < err.length; e++){
|
||||
|
||||
var minmax = [ax[e].min, ax[e].max];
|
||||
|
||||
//draw this error?
|
||||
if (errRanges[e * err.length]){
|
||||
|
||||
//data coordinates
|
||||
var x = points[i],
|
||||
y = points[i + 1];
|
||||
|
||||
//errorbar ranges
|
||||
var upper = [x, y][e] + errRanges[e * err.length + 1],
|
||||
lower = [x, y][e] - errRanges[e * err.length];
|
||||
|
||||
//points outside of the canvas
|
||||
if (err[e].err == 'x')
|
||||
if (y > ax[1].max || y < ax[1].min || upper < ax[0].min || lower > ax[0].max)
|
||||
continue;
|
||||
if (err[e].err == 'y')
|
||||
if (x > ax[0].max || x < ax[0].min || upper < ax[1].min || lower > ax[1].max)
|
||||
continue;
|
||||
|
||||
// prevent errorbars getting out of the canvas
|
||||
var drawUpper = true,
|
||||
drawLower = true;
|
||||
|
||||
if (upper > minmax[1]) {
|
||||
drawUpper = false;
|
||||
upper = minmax[1];
|
||||
}
|
||||
if (lower < minmax[0]) {
|
||||
drawLower = false;
|
||||
lower = minmax[0];
|
||||
}
|
||||
|
||||
//sanity check, in case some inverted axis hack is applied to flot
|
||||
if ((err[e].err == 'x' && invertX) || (err[e].err == 'y' && invertY)) {
|
||||
//swap coordinates
|
||||
var tmp = lower;
|
||||
lower = upper;
|
||||
upper = tmp;
|
||||
tmp = drawLower;
|
||||
drawLower = drawUpper;
|
||||
drawUpper = tmp;
|
||||
tmp = minmax[0];
|
||||
minmax[0] = minmax[1];
|
||||
minmax[1] = tmp;
|
||||
}
|
||||
|
||||
// convert to pixels
|
||||
x = ax[0].p2c(x),
|
||||
y = ax[1].p2c(y),
|
||||
upper = ax[e].p2c(upper);
|
||||
lower = ax[e].p2c(lower);
|
||||
minmax[0] = ax[e].p2c(minmax[0]);
|
||||
minmax[1] = ax[e].p2c(minmax[1]);
|
||||
|
||||
//same style as points by default
|
||||
var lw = err[e].lineWidth ? err[e].lineWidth : s.points.lineWidth,
|
||||
sw = s.points.shadowSize != null ? s.points.shadowSize : s.shadowSize;
|
||||
|
||||
//shadow as for points
|
||||
if (lw > 0 && sw > 0) {
|
||||
var w = sw / 2;
|
||||
ctx.lineWidth = w;
|
||||
ctx.strokeStyle = "rgba(0,0,0,0.1)";
|
||||
drawError(ctx, err[e], x, y, upper, lower, drawUpper, drawLower, radius, w + w/2, minmax);
|
||||
|
||||
ctx.strokeStyle = "rgba(0,0,0,0.2)";
|
||||
drawError(ctx, err[e], x, y, upper, lower, drawUpper, drawLower, radius, w/2, minmax);
|
||||
}
|
||||
|
||||
ctx.strokeStyle = err[e].color? err[e].color: s.color;
|
||||
ctx.lineWidth = lw;
|
||||
//draw it
|
||||
drawError(ctx, err[e], x, y, upper, lower, drawUpper, drawLower, radius, 0, minmax);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function drawError(ctx,err,x,y,upper,lower,drawUpper,drawLower,radius,offset,minmax){
|
||||
|
||||
//shadow offset
|
||||
y += offset;
|
||||
upper += offset;
|
||||
lower += offset;
|
||||
|
||||
// error bar - avoid plotting over circles
|
||||
if (err.err == 'x'){
|
||||
if (upper > x + radius) drawPath(ctx, [[upper,y],[Math.max(x + radius,minmax[0]),y]]);
|
||||
else drawUpper = false;
|
||||
if (lower < x - radius) drawPath(ctx, [[Math.min(x - radius,minmax[1]),y],[lower,y]] );
|
||||
else drawLower = false;
|
||||
}
|
||||
else {
|
||||
if (upper < y - radius) drawPath(ctx, [[x,upper],[x,Math.min(y - radius,minmax[0])]] );
|
||||
else drawUpper = false;
|
||||
if (lower > y + radius) drawPath(ctx, [[x,Math.max(y + radius,minmax[1])],[x,lower]] );
|
||||
else drawLower = false;
|
||||
}
|
||||
|
||||
//internal radius value in errorbar, allows to plot radius 0 points and still keep proper sized caps
|
||||
//this is a way to get errorbars on lines without visible connecting dots
|
||||
radius = err.radius != null? err.radius: radius;
|
||||
|
||||
// upper cap
|
||||
if (drawUpper) {
|
||||
if (err.upperCap == '-'){
|
||||
if (err.err=='x') drawPath(ctx, [[upper,y - radius],[upper,y + radius]] );
|
||||
else drawPath(ctx, [[x - radius,upper],[x + radius,upper]] );
|
||||
} else if ($.isFunction(err.upperCap)){
|
||||
if (err.err=='x') err.upperCap(ctx, upper, y, radius);
|
||||
else err.upperCap(ctx, x, upper, radius);
|
||||
}
|
||||
}
|
||||
// lower cap
|
||||
if (drawLower) {
|
||||
if (err.lowerCap == '-'){
|
||||
if (err.err=='x') drawPath(ctx, [[lower,y - radius],[lower,y + radius]] );
|
||||
else drawPath(ctx, [[x - radius,lower],[x + radius,lower]] );
|
||||
} else if ($.isFunction(err.lowerCap)){
|
||||
if (err.err=='x') err.lowerCap(ctx, lower, y, radius);
|
||||
else err.lowerCap(ctx, x, lower, radius);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function drawPath(ctx, pts){
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(pts[0][0], pts[0][1]);
|
||||
for (var p=1; p < pts.length; p++)
|
||||
ctx.lineTo(pts[p][0], pts[p][1]);
|
||||
ctx.stroke();
|
||||
}
|
||||
|
||||
function draw(plot, ctx){
|
||||
var plotOffset = plot.getPlotOffset();
|
||||
|
||||
ctx.save();
|
||||
ctx.translate(plotOffset.left, plotOffset.top);
|
||||
$.each(plot.getData(), function (i, s) {
|
||||
if (s.points.errorbars && (s.points.xerr.show || s.points.yerr.show))
|
||||
drawSeriesErrors(plot, ctx, s);
|
||||
});
|
||||
ctx.restore();
|
||||
}
|
||||
|
||||
function init(plot) {
|
||||
plot.hooks.processRawData.push(processRawData);
|
||||
plot.hooks.draw.push(draw);
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'errorbars',
|
||||
version: '1.0'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,63 +0,0 @@
|
||||
/* Flot plugin for plotting error bars.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
Error bars are used to show standard deviation and other statistical
|
||||
properties in a plot.
|
||||
|
||||
* Created by Rui Pereira - rui (dot) pereira (at) gmail (dot) com
|
||||
|
||||
This plugin allows you to plot error-bars over points. Set "errorbars" inside
|
||||
the points series to the axis name over which there will be error values in
|
||||
your data array (*even* if you do not intend to plot them later, by setting
|
||||
"show: null" on xerr/yerr).
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
series: {
|
||||
points: {
|
||||
errorbars: "x" or "y" or "xy",
|
||||
xerr: {
|
||||
show: null/false or true,
|
||||
asymmetric: null/false or true,
|
||||
upperCap: null or "-" or function,
|
||||
lowerCap: null or "-" or function,
|
||||
color: null or color,
|
||||
radius: null or number
|
||||
},
|
||||
yerr: { same options as xerr }
|
||||
}
|
||||
}
|
||||
|
||||
Each data point array is expected to be of the type:
|
||||
|
||||
"x" [ x, y, xerr ]
|
||||
"y" [ x, y, yerr ]
|
||||
"xy" [ x, y, xerr, yerr ]
|
||||
|
||||
Where xerr becomes xerr_lower,xerr_upper for the asymmetric error case, and
|
||||
equivalently for yerr. Eg., a datapoint for the "xy" case with symmetric
|
||||
error-bars on X and asymmetric on Y would be:
|
||||
|
||||
[ x, y, xerr, yerr_lower, yerr_upper ]
|
||||
|
||||
By default no end caps are drawn. Setting upperCap and/or lowerCap to "-" will
|
||||
draw a small cap perpendicular to the error bar. They can also be set to a
|
||||
user-defined drawing function, with (ctx, x, y, radius) as parameters, as eg.
|
||||
|
||||
function drawSemiCircle( ctx, x, y, radius ) {
|
||||
ctx.beginPath();
|
||||
ctx.arc( x, y, radius, 0, Math.PI, false );
|
||||
ctx.moveTo( x - radius, y );
|
||||
ctx.lineTo( x + radius, y );
|
||||
ctx.stroke();
|
||||
}
|
||||
|
||||
Color and radius both default to the same ones of the points series if not
|
||||
set. The independent radius parameter on xerr/yerr is useful for the case when
|
||||
we may want to add error-bars to a line, without showing the interconnecting
|
||||
points (with radius: 0), and still showing end caps on the error-bars.
|
||||
shadowSize and lineWidth are derived as well from the points series.
|
||||
|
||||
*/(function(e){function n(e,t,n,r){if(!t.points.errorbars)return;var i=[{x:!0,number:!0,required:!0},{y:!0,number:!0,required:!0}],s=t.points.errorbars;if(s=="x"||s=="xy")t.points.xerr.asymmetric?(i.push({x:!0,number:!0,required:!0}),i.push({x:!0,number:!0,required:!0})):i.push({x:!0,number:!0,required:!0});if(s=="y"||s=="xy")t.points.yerr.asymmetric?(i.push({y:!0,number:!0,required:!0}),i.push({y:!0,number:!0,required:!0})):i.push({y:!0,number:!0,required:!0});r.format=i}function r(e,t){var n=e.datapoints.points,r=null,i=null,s=null,o=null,u=e.points.xerr,a=e.points.yerr,f=e.points.errorbars;f=="x"||f=="xy"?u.asymmetric?(r=n[t+2],i=n[t+3],f=="xy"&&(a.asymmetric?(s=n[t+4],o=n[t+5]):s=n[t+4])):(r=n[t+2],f=="xy"&&(a.asymmetric?(s=n[t+3],o=n[t+4]):s=n[t+3])):f=="y"&&(a.asymmetric?(s=n[t+2],o=n[t+3]):s=n[t+2]),i==null&&(i=r),o==null&&(o=s);var l=[r,i,s,o];return u.show||(l[0]=null,l[1]=null),a.show||(l[2]=null,l[3]=null),l}function i(e,t,n){var i=n.datapoints.points,o=n.datapoints.pointsize,u=[n.xaxis,n.yaxis],a=n.points.radius,f=[n.points.xerr,n.points.yerr],l=!1;if(u[0].p2c(u[0].max)<u[0].p2c(u[0].min)){l=!0;var c=f[0].lowerCap;f[0].lowerCap=f[0].upperCap,f[0].upperCap=c}var h=!1;if(u[1].p2c(u[1].min)<u[1].p2c(u[1].max)){h=!0;var c=f[1].lowerCap;f[1].lowerCap=f[1].upperCap,f[1].upperCap=c}for(var p=0;p<n.datapoints.points.length;p+=o){var d=r(n,p);for(var v=0;v<f.length;v++){var m=[u[v].min,u[v].max];if(d[v*f.length]){var g=i[p],y=i[p+1],b=[g,y][v]+d[v*f.length+1],w=[g,y][v]-d[v*f.length];if(f[v].err=="x")if(y>u[1].max||y<u[1].min||b<u[0].min||w>u[0].max)continue;if(f[v].err=="y")if(g>u[0].max||g<u[0].min||b<u[1].min||w>u[1].max)continue;var E=!0,S=!0;b>m[1]&&(E=!1,b=m[1]),w<m[0]&&(S=!1,w=m[0]);if(f[v].err=="x"&&l||f[v].err=="y"&&h){var c=w;w=b,b=c,c=S,S=E,E=c,c=m[0],m[0]=m[1],m[1]=c}g=u[0].p2c(g),y=u[1].p2c(y),b=u[v].p2c(b),w=u[v].p2c(w),m[0]=u[v].p2c(m[0]),m[1]=u[v].p2c(m[1]);var x=f[v].lineWidth?f[v].lineWidth:n.points.lineWidth,T=n.points.shadowSize!=null?n.points.shadowSize:n.shadowSize;if(x>0&&T>0){var N=T/2;t.lineWidth=N,t.strokeStyle="rgba(0,0,0,0.1)",s(t,f[v],g,y,b,w,E,S,a,N+N/2,m),t.strokeStyle="rgba(0,0,0,0.2)",s(t,f[v],g,y,b,w,E,S,a,N/2,m)}t.strokeStyle=f[v].color?f[v].color:n.color,t.lineWidth=x,s(t,f[v],g,y,b,w,E,S,a,0,m)}}}}function s(t,n,r,i,s,u,a,f,l,c,h){i+=c,s+=c,u+=c,n.err=="x"?(s>r+l?o(t,[[s,i],[Math.max(r+l,h[0]),i]]):a=!1,u<r-l?o(t,[[Math.min(r-l,h[1]),i],[u,i]]):f=!1):(s<i-l?o(t,[[r,s],[r,Math.min(i-l,h[0])]]):a=!1,u>i+l?o(t,[[r,Math.max(i+l,h[1])],[r,u]]):f=!1),l=n.radius!=null?n.radius:l,a&&(n.upperCap=="-"?n.err=="x"?o(t,[[s,i-l],[s,i+l]]):o(t,[[r-l,s],[r+l,s]]):e.isFunction(n.upperCap)&&(n.err=="x"?n.upperCap(t,s,i,l):n.upperCap(t,r,s,l))),f&&(n.lowerCap=="-"?n.err=="x"?o(t,[[u,i-l],[u,i+l]]):o(t,[[r-l,u],[r+l,u]]):e.isFunction(n.lowerCap)&&(n.err=="x"?n.lowerCap(t,u,i,l):n.lowerCap(t,r,u,l)))}function o(e,t){e.beginPath(),e.moveTo(t[0][0],t[0][1]);for(var n=1;n<t.length;n++)e.lineTo(t[n][0],t[n][1]);e.stroke()}function u(t,n){var r=t.getPlotOffset();n.save(),n.translate(r.left,r.top),e.each(t.getData(),function(e,r){r.points.errorbars&&(r.points.xerr.show||r.points.yerr.show)&&i(t,n,r)}),n.restore()}function a(e){e.hooks.processRawData.push(n),e.hooks.draw.push(u)}var t={series:{points:{errorbars:null,xerr:{err:"x",show:null,asymmetric:null,upperCap:null,lowerCap:null,color:null,radius:null},yerr:{err:"y",show:null,asymmetric:null,upperCap:null,lowerCap:null,color:null,radius:null}}}};e.plot.plugins.push({init:a,options:t,name:"errorbars",version:"1.0"})})(jQuery);
|
||||
@ -1,226 +0,0 @@
|
||||
/* Flot plugin for computing bottoms for filled line and bar charts.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The case: you've got two series that you want to fill the area between. In Flot
|
||||
terms, you need to use one as the fill bottom of the other. You can specify the
|
||||
bottom of each data point as the third coordinate manually, or you can use this
|
||||
plugin to compute it for you.
|
||||
|
||||
In order to name the other series, you need to give it an id, like this:
|
||||
|
||||
var dataset = [
|
||||
{ data: [ ... ], id: "foo" } , // use default bottom
|
||||
{ data: [ ... ], fillBetween: "foo" }, // use first dataset as bottom
|
||||
];
|
||||
|
||||
$.plot($("#placeholder"), dataset, { lines: { show: true, fill: true }});
|
||||
|
||||
As a convenience, if the id given is a number that doesn't appear as an id in
|
||||
the series, it is interpreted as the index in the array instead (so fillBetween:
|
||||
0 can also mean the first series).
|
||||
|
||||
Internally, the plugin modifies the datapoints in each series. For line series,
|
||||
extra data points might be inserted through interpolation. Note that at points
|
||||
where the bottom line is not defined (due to a null point or start/end of line),
|
||||
the current line will show a gap too. The algorithm comes from the
|
||||
jquery.flot.stack.js plugin, possibly some code could be shared.
|
||||
|
||||
*/
|
||||
|
||||
(function ( $ ) {
|
||||
|
||||
var options = {
|
||||
series: {
|
||||
fillBetween: null // or number
|
||||
}
|
||||
};
|
||||
|
||||
function init( plot ) {
|
||||
|
||||
function findBottomSeries( s, allseries ) {
|
||||
|
||||
var i;
|
||||
|
||||
for ( i = 0; i < allseries.length; ++i ) {
|
||||
if ( allseries[ i ].id === s.fillBetween ) {
|
||||
return allseries[ i ];
|
||||
}
|
||||
}
|
||||
|
||||
if ( typeof s.fillBetween === "number" ) {
|
||||
if ( s.fillBetween < 0 || s.fillBetween >= allseries.length ) {
|
||||
return null;
|
||||
}
|
||||
return allseries[ s.fillBetween ];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
function computeFillBottoms( plot, s, datapoints ) {
|
||||
|
||||
if ( s.fillBetween == null ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var other = findBottomSeries( s, plot.getData() );
|
||||
|
||||
if ( !other ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var ps = datapoints.pointsize,
|
||||
points = datapoints.points,
|
||||
otherps = other.datapoints.pointsize,
|
||||
otherpoints = other.datapoints.points,
|
||||
newpoints = [],
|
||||
px, py, intery, qx, qy, bottom,
|
||||
withlines = s.lines.show,
|
||||
withbottom = ps > 2 && datapoints.format[2].y,
|
||||
withsteps = withlines && s.lines.steps,
|
||||
fromgap = true,
|
||||
i = 0,
|
||||
j = 0,
|
||||
l, m;
|
||||
|
||||
while ( true ) {
|
||||
|
||||
if ( i >= points.length ) {
|
||||
break;
|
||||
}
|
||||
|
||||
l = newpoints.length;
|
||||
|
||||
if ( points[ i ] == null ) {
|
||||
|
||||
// copy gaps
|
||||
|
||||
for ( m = 0; m < ps; ++m ) {
|
||||
newpoints.push( points[ i + m ] );
|
||||
}
|
||||
|
||||
i += ps;
|
||||
|
||||
} else if ( j >= otherpoints.length ) {
|
||||
|
||||
// for lines, we can't use the rest of the points
|
||||
|
||||
if ( !withlines ) {
|
||||
for ( m = 0; m < ps; ++m ) {
|
||||
newpoints.push( points[ i + m ] );
|
||||
}
|
||||
}
|
||||
|
||||
i += ps;
|
||||
|
||||
} else if ( otherpoints[ j ] == null ) {
|
||||
|
||||
// oops, got a gap
|
||||
|
||||
for ( m = 0; m < ps; ++m ) {
|
||||
newpoints.push( null );
|
||||
}
|
||||
|
||||
fromgap = true;
|
||||
j += otherps;
|
||||
|
||||
} else {
|
||||
|
||||
// cases where we actually got two points
|
||||
|
||||
px = points[ i ];
|
||||
py = points[ i + 1 ];
|
||||
qx = otherpoints[ j ];
|
||||
qy = otherpoints[ j + 1 ];
|
||||
bottom = 0;
|
||||
|
||||
if ( px === qx ) {
|
||||
|
||||
for ( m = 0; m < ps; ++m ) {
|
||||
newpoints.push( points[ i + m ] );
|
||||
}
|
||||
|
||||
//newpoints[ l + 1 ] += qy;
|
||||
bottom = qy;
|
||||
|
||||
i += ps;
|
||||
j += otherps;
|
||||
|
||||
} else if ( px > qx ) {
|
||||
|
||||
// we got past point below, might need to
|
||||
// insert interpolated extra point
|
||||
|
||||
if ( withlines && i > 0 && points[ i - ps ] != null ) {
|
||||
intery = py + ( points[ i - ps + 1 ] - py ) * ( qx - px ) / ( points[ i - ps ] - px );
|
||||
newpoints.push( qx );
|
||||
newpoints.push( intery );
|
||||
for ( m = 2; m < ps; ++m ) {
|
||||
newpoints.push( points[ i + m ] );
|
||||
}
|
||||
bottom = qy;
|
||||
}
|
||||
|
||||
j += otherps;
|
||||
|
||||
} else { // px < qx
|
||||
|
||||
// if we come from a gap, we just skip this point
|
||||
|
||||
if ( fromgap && withlines ) {
|
||||
i += ps;
|
||||
continue;
|
||||
}
|
||||
|
||||
for ( m = 0; m < ps; ++m ) {
|
||||
newpoints.push( points[ i + m ] );
|
||||
}
|
||||
|
||||
// we might be able to interpolate a point below,
|
||||
// this can give us a better y
|
||||
|
||||
if ( withlines && j > 0 && otherpoints[ j - otherps ] != null ) {
|
||||
bottom = qy + ( otherpoints[ j - otherps + 1 ] - qy ) * ( px - qx ) / ( otherpoints[ j - otherps ] - qx );
|
||||
}
|
||||
|
||||
//newpoints[l + 1] += bottom;
|
||||
|
||||
i += ps;
|
||||
}
|
||||
|
||||
fromgap = false;
|
||||
|
||||
if ( l !== newpoints.length && withbottom ) {
|
||||
newpoints[ l + 2 ] = bottom;
|
||||
}
|
||||
}
|
||||
|
||||
// maintain the line steps invariant
|
||||
|
||||
if ( withsteps && l !== newpoints.length && l > 0 &&
|
||||
newpoints[ l ] !== null &&
|
||||
newpoints[ l ] !== newpoints[ l - ps ] &&
|
||||
newpoints[ l + 1 ] !== newpoints[ l - ps + 1 ] ) {
|
||||
for (m = 0; m < ps; ++m) {
|
||||
newpoints[ l + ps + m ] = newpoints[ l + m ];
|
||||
}
|
||||
newpoints[ l + 1 ] = newpoints[ l - ps + 1 ];
|
||||
}
|
||||
}
|
||||
|
||||
datapoints.points = newpoints;
|
||||
}
|
||||
|
||||
plot.hooks.processDatapoints.push( computeFillBottoms );
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: "fillbetween",
|
||||
version: "1.0"
|
||||
});
|
||||
|
||||
})(jQuery);
|
||||
@ -1,30 +0,0 @@
|
||||
/* Flot plugin for computing bottoms for filled line and bar charts.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The case: you've got two series that you want to fill the area between. In Flot
|
||||
terms, you need to use one as the fill bottom of the other. You can specify the
|
||||
bottom of each data point as the third coordinate manually, or you can use this
|
||||
plugin to compute it for you.
|
||||
|
||||
In order to name the other series, you need to give it an id, like this:
|
||||
|
||||
var dataset = [
|
||||
{ data: [ ... ], id: "foo" } , // use default bottom
|
||||
{ data: [ ... ], fillBetween: "foo" }, // use first dataset as bottom
|
||||
];
|
||||
|
||||
$.plot($("#placeholder"), dataset, { lines: { show: true, fill: true }});
|
||||
|
||||
As a convenience, if the id given is a number that doesn't appear as an id in
|
||||
the series, it is interpreted as the index in the array instead (so fillBetween:
|
||||
0 can also mean the first series).
|
||||
|
||||
Internally, the plugin modifies the datapoints in each series. For line series,
|
||||
extra data points might be inserted through interpolation. Note that at points
|
||||
where the bottom line is not defined (due to a null point or start/end of line),
|
||||
the current line will show a gap too. The algorithm comes from the
|
||||
jquery.flot.stack.js plugin, possibly some code could be shared.
|
||||
|
||||
*/(function(e){function n(e){function t(e,t){var n;for(n=0;n<t.length;++n)if(t[n].id===e.fillBetween)return t[n];return typeof e.fillBetween=="number"?e.fillBetween<0||e.fillBetween>=t.length?null:t[e.fillBetween]:null}function n(e,n,r){if(n.fillBetween==null)return;var i=t(n,e.getData());if(!i)return;var s=r.pointsize,o=r.points,u=i.datapoints.pointsize,a=i.datapoints.points,f=[],l,c,h,p,d,v,m=n.lines.show,g=s>2&&r.format[2].y,y=m&&n.lines.steps,b=!0,w=0,E=0,S,x;for(;;){if(w>=o.length)break;S=f.length;if(o[w]==null){for(x=0;x<s;++x)f.push(o[w+x]);w+=s}else if(E>=a.length){if(!m)for(x=0;x<s;++x)f.push(o[w+x]);w+=s}else if(a[E]==null){for(x=0;x<s;++x)f.push(null);b=!0,E+=u}else{l=o[w],c=o[w+1],p=a[E],d=a[E+1],v=0;if(l===p){for(x=0;x<s;++x)f.push(o[w+x]);v=d,w+=s,E+=u}else if(l>p){if(m&&w>0&&o[w-s]!=null){h=c+(o[w-s+1]-c)*(p-l)/(o[w-s]-l),f.push(p),f.push(h);for(x=2;x<s;++x)f.push(o[w+x]);v=d}E+=u}else{if(b&&m){w+=s;continue}for(x=0;x<s;++x)f.push(o[w+x]);m&&E>0&&a[E-u]!=null&&(v=d+(a[E-u+1]-d)*(l-p)/(a[E-u]-p)),w+=s}b=!1,S!==f.length&&g&&(f[S+2]=v)}if(y&&S!==f.length&&S>0&&f[S]!==null&&f[S]!==f[S-s]&&f[S+1]!==f[S-s+1]){for(x=0;x<s;++x)f[S+s+x]=f[S+x];f[S+1]=f[S-s+1]}}r.points=f}e.hooks.processDatapoints.push(n)}var t={series:{fillBetween:null}};e.plot.plugins.push({init:n,options:t,name:"fillbetween",version:"1.0"})})(jQuery);
|
||||
@ -1,241 +0,0 @@
|
||||
/* Flot plugin for plotting images.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The data syntax is [ [ image, x1, y1, x2, y2 ], ... ] where (x1, y1) and
|
||||
(x2, y2) are where you intend the two opposite corners of the image to end up
|
||||
in the plot. Image must be a fully loaded Javascript image (you can make one
|
||||
with new Image()). If the image is not complete, it's skipped when plotting.
|
||||
|
||||
There are two helpers included for retrieving images. The easiest work the way
|
||||
that you put in URLs instead of images in the data, like this:
|
||||
|
||||
[ "myimage.png", 0, 0, 10, 10 ]
|
||||
|
||||
Then call $.plot.image.loadData( data, options, callback ) where data and
|
||||
options are the same as you pass in to $.plot. This loads the images, replaces
|
||||
the URLs in the data with the corresponding images and calls "callback" when
|
||||
all images are loaded (or failed loading). In the callback, you can then call
|
||||
$.plot with the data set. See the included example.
|
||||
|
||||
A more low-level helper, $.plot.image.load(urls, callback) is also included.
|
||||
Given a list of URLs, it calls callback with an object mapping from URL to
|
||||
Image object when all images are loaded or have failed loading.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
series: {
|
||||
images: {
|
||||
show: boolean
|
||||
anchor: "corner" or "center"
|
||||
alpha: [ 0, 1 ]
|
||||
}
|
||||
}
|
||||
|
||||
They can be specified for a specific series:
|
||||
|
||||
$.plot( $("#placeholder"), [{
|
||||
data: [ ... ],
|
||||
images: { ... }
|
||||
])
|
||||
|
||||
Note that because the data format is different from usual data points, you
|
||||
can't use images with anything else in a specific data series.
|
||||
|
||||
Setting "anchor" to "center" causes the pixels in the image to be anchored at
|
||||
the corner pixel centers inside of at the pixel corners, effectively letting
|
||||
half a pixel stick out to each side in the plot.
|
||||
|
||||
A possible future direction could be support for tiling for large images (like
|
||||
Google Maps).
|
||||
|
||||
*/
|
||||
|
||||
(function ($) {
|
||||
var options = {
|
||||
series: {
|
||||
images: {
|
||||
show: false,
|
||||
alpha: 1,
|
||||
anchor: "corner" // or "center"
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
$.plot.image = {};
|
||||
|
||||
$.plot.image.loadDataImages = function (series, options, callback) {
|
||||
var urls = [], points = [];
|
||||
|
||||
var defaultShow = options.series.images.show;
|
||||
|
||||
$.each(series, function (i, s) {
|
||||
if (!(defaultShow || s.images.show))
|
||||
return;
|
||||
|
||||
if (s.data)
|
||||
s = s.data;
|
||||
|
||||
$.each(s, function (i, p) {
|
||||
if (typeof p[0] == "string") {
|
||||
urls.push(p[0]);
|
||||
points.push(p);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
$.plot.image.load(urls, function (loadedImages) {
|
||||
$.each(points, function (i, p) {
|
||||
var url = p[0];
|
||||
if (loadedImages[url])
|
||||
p[0] = loadedImages[url];
|
||||
});
|
||||
|
||||
callback();
|
||||
});
|
||||
}
|
||||
|
||||
$.plot.image.load = function (urls, callback) {
|
||||
var missing = urls.length, loaded = {};
|
||||
if (missing == 0)
|
||||
callback({});
|
||||
|
||||
$.each(urls, function (i, url) {
|
||||
var handler = function () {
|
||||
--missing;
|
||||
|
||||
loaded[url] = this;
|
||||
|
||||
if (missing == 0)
|
||||
callback(loaded);
|
||||
};
|
||||
|
||||
$('<img />').load(handler).error(handler).attr('src', url);
|
||||
});
|
||||
};
|
||||
|
||||
function drawSeries(plot, ctx, series) {
|
||||
var plotOffset = plot.getPlotOffset();
|
||||
|
||||
if (!series.images || !series.images.show)
|
||||
return;
|
||||
|
||||
var points = series.datapoints.points,
|
||||
ps = series.datapoints.pointsize;
|
||||
|
||||
for (var i = 0; i < points.length; i += ps) {
|
||||
var img = points[i],
|
||||
x1 = points[i + 1], y1 = points[i + 2],
|
||||
x2 = points[i + 3], y2 = points[i + 4],
|
||||
xaxis = series.xaxis, yaxis = series.yaxis,
|
||||
tmp;
|
||||
|
||||
// actually we should check img.complete, but it
|
||||
// appears to be a somewhat unreliable indicator in
|
||||
// IE6 (false even after load event)
|
||||
if (!img || img.width <= 0 || img.height <= 0)
|
||||
continue;
|
||||
|
||||
if (x1 > x2) {
|
||||
tmp = x2;
|
||||
x2 = x1;
|
||||
x1 = tmp;
|
||||
}
|
||||
if (y1 > y2) {
|
||||
tmp = y2;
|
||||
y2 = y1;
|
||||
y1 = tmp;
|
||||
}
|
||||
|
||||
// if the anchor is at the center of the pixel, expand the
|
||||
// image by 1/2 pixel in each direction
|
||||
if (series.images.anchor == "center") {
|
||||
tmp = 0.5 * (x2-x1) / (img.width - 1);
|
||||
x1 -= tmp;
|
||||
x2 += tmp;
|
||||
tmp = 0.5 * (y2-y1) / (img.height - 1);
|
||||
y1 -= tmp;
|
||||
y2 += tmp;
|
||||
}
|
||||
|
||||
// clip
|
||||
if (x1 == x2 || y1 == y2 ||
|
||||
x1 >= xaxis.max || x2 <= xaxis.min ||
|
||||
y1 >= yaxis.max || y2 <= yaxis.min)
|
||||
continue;
|
||||
|
||||
var sx1 = 0, sy1 = 0, sx2 = img.width, sy2 = img.height;
|
||||
if (x1 < xaxis.min) {
|
||||
sx1 += (sx2 - sx1) * (xaxis.min - x1) / (x2 - x1);
|
||||
x1 = xaxis.min;
|
||||
}
|
||||
|
||||
if (x2 > xaxis.max) {
|
||||
sx2 += (sx2 - sx1) * (xaxis.max - x2) / (x2 - x1);
|
||||
x2 = xaxis.max;
|
||||
}
|
||||
|
||||
if (y1 < yaxis.min) {
|
||||
sy2 += (sy1 - sy2) * (yaxis.min - y1) / (y2 - y1);
|
||||
y1 = yaxis.min;
|
||||
}
|
||||
|
||||
if (y2 > yaxis.max) {
|
||||
sy1 += (sy1 - sy2) * (yaxis.max - y2) / (y2 - y1);
|
||||
y2 = yaxis.max;
|
||||
}
|
||||
|
||||
x1 = xaxis.p2c(x1);
|
||||
x2 = xaxis.p2c(x2);
|
||||
y1 = yaxis.p2c(y1);
|
||||
y2 = yaxis.p2c(y2);
|
||||
|
||||
// the transformation may have swapped us
|
||||
if (x1 > x2) {
|
||||
tmp = x2;
|
||||
x2 = x1;
|
||||
x1 = tmp;
|
||||
}
|
||||
if (y1 > y2) {
|
||||
tmp = y2;
|
||||
y2 = y1;
|
||||
y1 = tmp;
|
||||
}
|
||||
|
||||
tmp = ctx.globalAlpha;
|
||||
ctx.globalAlpha *= series.images.alpha;
|
||||
ctx.drawImage(img,
|
||||
sx1, sy1, sx2 - sx1, sy2 - sy1,
|
||||
x1 + plotOffset.left, y1 + plotOffset.top,
|
||||
x2 - x1, y2 - y1);
|
||||
ctx.globalAlpha = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
function processRawData(plot, series, data, datapoints) {
|
||||
if (!series.images.show)
|
||||
return;
|
||||
|
||||
// format is Image, x1, y1, x2, y2 (opposite corners)
|
||||
datapoints.format = [
|
||||
{ required: true },
|
||||
{ x: true, number: true, required: true },
|
||||
{ y: true, number: true, required: true },
|
||||
{ x: true, number: true, required: true },
|
||||
{ y: true, number: true, required: true }
|
||||
];
|
||||
}
|
||||
|
||||
function init(plot) {
|
||||
plot.hooks.processRawData.push(processRawData);
|
||||
plot.hooks.drawSeries.push(drawSeries);
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'image',
|
||||
version: '1.1'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,53 +0,0 @@
|
||||
/* Flot plugin for plotting images.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The data syntax is [ [ image, x1, y1, x2, y2 ], ... ] where (x1, y1) and
|
||||
(x2, y2) are where you intend the two opposite corners of the image to end up
|
||||
in the plot. Image must be a fully loaded Javascript image (you can make one
|
||||
with new Image()). If the image is not complete, it's skipped when plotting.
|
||||
|
||||
There are two helpers included for retrieving images. The easiest work the way
|
||||
that you put in URLs instead of images in the data, like this:
|
||||
|
||||
[ "myimage.png", 0, 0, 10, 10 ]
|
||||
|
||||
Then call $.plot.image.loadData( data, options, callback ) where data and
|
||||
options are the same as you pass in to $.plot. This loads the images, replaces
|
||||
the URLs in the data with the corresponding images and calls "callback" when
|
||||
all images are loaded (or failed loading). In the callback, you can then call
|
||||
$.plot with the data set. See the included example.
|
||||
|
||||
A more low-level helper, $.plot.image.load(urls, callback) is also included.
|
||||
Given a list of URLs, it calls callback with an object mapping from URL to
|
||||
Image object when all images are loaded or have failed loading.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
series: {
|
||||
images: {
|
||||
show: boolean
|
||||
anchor: "corner" or "center"
|
||||
alpha: [ 0, 1 ]
|
||||
}
|
||||
}
|
||||
|
||||
They can be specified for a specific series:
|
||||
|
||||
$.plot( $("#placeholder"), [{
|
||||
data: [ ... ],
|
||||
images: { ... }
|
||||
])
|
||||
|
||||
Note that because the data format is different from usual data points, you
|
||||
can't use images with anything else in a specific data series.
|
||||
|
||||
Setting "anchor" to "center" causes the pixels in the image to be anchored at
|
||||
the corner pixel centers inside of at the pixel corners, effectively letting
|
||||
half a pixel stick out to each side in the plot.
|
||||
|
||||
A possible future direction could be support for tiling for large images (like
|
||||
Google Maps).
|
||||
|
||||
*/(function(e){function n(e,t,n){var r=e.getPlotOffset();if(!n.images||!n.images.show)return;var i=n.datapoints.points,s=n.datapoints.pointsize;for(var o=0;o<i.length;o+=s){var u=i[o],a=i[o+1],f=i[o+2],l=i[o+3],c=i[o+4],h=n.xaxis,p=n.yaxis,d;if(!u||u.width<=0||u.height<=0)continue;a>l&&(d=l,l=a,a=d),f>c&&(d=c,c=f,f=d),n.images.anchor=="center"&&(d=.5*(l-a)/(u.width-1),a-=d,l+=d,d=.5*(c-f)/(u.height-1),f-=d,c+=d);if(a==l||f==c||a>=h.max||l<=h.min||f>=p.max||c<=p.min)continue;var v=0,m=0,g=u.width,y=u.height;a<h.min&&(v+=(g-v)*(h.min-a)/(l-a),a=h.min),l>h.max&&(g+=(g-v)*(h.max-l)/(l-a),l=h.max),f<p.min&&(y+=(m-y)*(p.min-f)/(c-f),f=p.min),c>p.max&&(m+=(m-y)*(p.max-c)/(c-f),c=p.max),a=h.p2c(a),l=h.p2c(l),f=p.p2c(f),c=p.p2c(c),a>l&&(d=l,l=a,a=d),f>c&&(d=c,c=f,f=d),d=t.globalAlpha,t.globalAlpha*=n.images.alpha,t.drawImage(u,v,m,g-v,y-m,a+r.left,f+r.top,l-a,c-f),t.globalAlpha=d}}function r(e,t,n,r){if(!t.images.show)return;r.format=[{required:!0},{x:!0,number:!0,required:!0},{y:!0,number:!0,required:!0},{x:!0,number:!0,required:!0},{y:!0,number:!0,required:!0}]}function i(e){e.hooks.processRawData.push(r),e.hooks.drawSeries.push(n)}var t={series:{images:{show:!1,alpha:1,anchor:"corner"}}};e.plot.image={},e.plot.image.loadDataImages=function(t,n,r){var i=[],s=[],o=n.series.images.show;e.each(t,function(t,n){if(!o&&!n.images.show)return;n.data&&(n=n.data),e.each(n,function(e,t){typeof t[0]=="string"&&(i.push(t[0]),s.push(t))})}),e.plot.image.load(i,function(t){e.each(s,function(e,n){var r=n[0];t[r]&&(n[0]=t[r])}),r()})},e.plot.image.load=function(t,n){var r=t.length,i={};r==0&&n({}),e.each(t,function(t,s){var o=function(){--r,i[s]=this,r==0&&n(i)};e("<img />").load(o).error(o).attr("src",s)})},e.plot.plugins.push({init:i,options:t,name:"image",version:"1.1"})})(jQuery);
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
@ -1,346 +0,0 @@
|
||||
/* Flot plugin for adding the ability to pan and zoom the plot.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The default behaviour is double click and scrollwheel up/down to zoom in, drag
|
||||
to pan. The plugin defines plot.zoom({ center }), plot.zoomOut() and
|
||||
plot.pan( offset ) so you easily can add custom controls. It also fires
|
||||
"plotpan" and "plotzoom" events, useful for synchronizing plots.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
zoom: {
|
||||
interactive: false
|
||||
trigger: "dblclick" // or "click" for single click
|
||||
amount: 1.5 // 2 = 200% (zoom in), 0.5 = 50% (zoom out)
|
||||
}
|
||||
|
||||
pan: {
|
||||
interactive: false
|
||||
cursor: "move" // CSS mouse cursor value used when dragging, e.g. "pointer"
|
||||
frameRate: 20
|
||||
}
|
||||
|
||||
xaxis, yaxis, x2axis, y2axis: {
|
||||
zoomRange: null // or [ number, number ] (min range, max range) or false
|
||||
panRange: null // or [ number, number ] (min, max) or false
|
||||
}
|
||||
|
||||
"interactive" enables the built-in drag/click behaviour. If you enable
|
||||
interactive for pan, then you'll have a basic plot that supports moving
|
||||
around; the same for zoom.
|
||||
|
||||
"amount" specifies the default amount to zoom in (so 1.5 = 150%) relative to
|
||||
the current viewport.
|
||||
|
||||
"cursor" is a standard CSS mouse cursor string used for visual feedback to the
|
||||
user when dragging.
|
||||
|
||||
"frameRate" specifies the maximum number of times per second the plot will
|
||||
update itself while the user is panning around on it (set to null to disable
|
||||
intermediate pans, the plot will then not update until the mouse button is
|
||||
released).
|
||||
|
||||
"zoomRange" is the interval in which zooming can happen, e.g. with zoomRange:
|
||||
[1, 100] the zoom will never scale the axis so that the difference between min
|
||||
and max is smaller than 1 or larger than 100. You can set either end to null
|
||||
to ignore, e.g. [1, null]. If you set zoomRange to false, zooming on that axis
|
||||
will be disabled.
|
||||
|
||||
"panRange" confines the panning to stay within a range, e.g. with panRange:
|
||||
[-10, 20] panning stops at -10 in one end and at 20 in the other. Either can
|
||||
be null, e.g. [-10, null]. If you set panRange to false, panning on that axis
|
||||
will be disabled.
|
||||
|
||||
Example API usage:
|
||||
|
||||
plot = $.plot(...);
|
||||
|
||||
// zoom default amount in on the pixel ( 10, 20 )
|
||||
plot.zoom({ center: { left: 10, top: 20 } });
|
||||
|
||||
// zoom out again
|
||||
plot.zoomOut({ center: { left: 10, top: 20 } });
|
||||
|
||||
// zoom 200% in on the pixel (10, 20)
|
||||
plot.zoom({ amount: 2, center: { left: 10, top: 20 } });
|
||||
|
||||
// pan 100 pixels to the left and 20 down
|
||||
plot.pan({ left: -100, top: 20 })
|
||||
|
||||
Here, "center" specifies where the center of the zooming should happen. Note
|
||||
that this is defined in pixel space, not the space of the data points (you can
|
||||
use the p2c helpers on the axes in Flot to help you convert between these).
|
||||
|
||||
"amount" is the amount to zoom the viewport relative to the current range, so
|
||||
1 is 100% (i.e. no change), 1.5 is 150% (zoom in), 0.7 is 70% (zoom out). You
|
||||
can set the default in the options.
|
||||
|
||||
*/
|
||||
|
||||
// First two dependencies, jquery.event.drag.js and
|
||||
// jquery.mousewheel.js, we put them inline here to save people the
|
||||
// effort of downloading them.
|
||||
|
||||
/*
|
||||
jquery.event.drag.js ~ v1.5 ~ Copyright (c) 2008, Three Dub Media (http://threedubmedia.com)
|
||||
Licensed under the MIT License ~ http://threedubmedia.googlecode.com/files/MIT-LICENSE.txt
|
||||
*/
|
||||
(function(a){function e(h){var k,j=this,l=h.data||{};if(l.elem)j=h.dragTarget=l.elem,h.dragProxy=d.proxy||j,h.cursorOffsetX=l.pageX-l.left,h.cursorOffsetY=l.pageY-l.top,h.offsetX=h.pageX-h.cursorOffsetX,h.offsetY=h.pageY-h.cursorOffsetY;else if(d.dragging||l.which>0&&h.which!=l.which||a(h.target).is(l.not))return;switch(h.type){case"mousedown":return a.extend(l,a(j).offset(),{elem:j,target:h.target,pageX:h.pageX,pageY:h.pageY}),b.add(document,"mousemove mouseup",e,l),i(j,!1),d.dragging=null,!1;case!d.dragging&&"mousemove":if(g(h.pageX-l.pageX)+g(h.pageY-l.pageY)<l.distance)break;h.target=l.target,k=f(h,"dragstart",j),k!==!1&&(d.dragging=j,d.proxy=h.dragProxy=a(k||j)[0]);case"mousemove":if(d.dragging){if(k=f(h,"drag",j),c.drop&&(c.drop.allowed=k!==!1,c.drop.handler(h)),k!==!1)break;h.type="mouseup"}case"mouseup":b.remove(document,"mousemove mouseup",e),d.dragging&&(c.drop&&c.drop.handler(h),f(h,"dragend",j)),i(j,!0),d.dragging=d.proxy=l.elem=!1}return!0}function f(b,c,d){b.type=c;var e=a.event.dispatch.call(d,b);return e===!1?!1:e||b.result}function g(a){return Math.pow(a,2)}function h(){return d.dragging===!1}function i(a,b){a&&(a.unselectable=b?"off":"on",a.onselectstart=function(){return b},a.style&&(a.style.MozUserSelect=b?"":"none"))}a.fn.drag=function(a,b,c){return b&&this.bind("dragstart",a),c&&this.bind("dragend",c),a?this.bind("drag",b?b:a):this.trigger("drag")};var b=a.event,c=b.special,d=c.drag={not:":input",distance:0,which:1,dragging:!1,setup:function(c){c=a.extend({distance:d.distance,which:d.which,not:d.not},c||{}),c.distance=g(c.distance),b.add(this,"mousedown",e,c),this.attachEvent&&this.attachEvent("ondragstart",h)},teardown:function(){b.remove(this,"mousedown",e),this===d.dragging&&(d.dragging=d.proxy=!1),i(this,!0),this.detachEvent&&this.detachEvent("ondragstart",h)}};c.dragstart=c.dragend={setup:function(){},teardown:function(){}}})(jQuery);
|
||||
|
||||
/* jquery.mousewheel.min.js
|
||||
* Copyright (c) 2011 Brandon Aaron (http://brandonaaron.net)
|
||||
* Licensed under the MIT License (LICENSE.txt).
|
||||
* Thanks to: http://adomas.org/javascript-mouse-wheel/ for some pointers.
|
||||
* Thanks to: Mathias Bank(http://www.mathias-bank.de) for a scope bug fix.
|
||||
* Thanks to: Seamus Leahy for adding deltaX and deltaY
|
||||
*
|
||||
* Version: 3.0.6
|
||||
*
|
||||
* Requires: 1.2.2+
|
||||
*/
|
||||
(function(d){function e(a){var b=a||window.event,c=[].slice.call(arguments,1),f=0,e=0,g=0,a=d.event.fix(b);a.type="mousewheel";b.wheelDelta&&(f=b.wheelDelta/120);b.detail&&(f=-b.detail/3);g=f;void 0!==b.axis&&b.axis===b.HORIZONTAL_AXIS&&(g=0,e=-1*f);void 0!==b.wheelDeltaY&&(g=b.wheelDeltaY/120);void 0!==b.wheelDeltaX&&(e=-1*b.wheelDeltaX/120);c.unshift(a,f,e,g);return(d.event.dispatch||d.event.handle).apply(this,c)}var c=["DOMMouseScroll","mousewheel"];if(d.event.fixHooks)for(var h=c.length;h;)d.event.fixHooks[c[--h]]=d.event.mouseHooks;d.event.special.mousewheel={setup:function(){if(this.addEventListener)for(var a=c.length;a;)this.addEventListener(c[--a],e,!1);else this.onmousewheel=e},teardown:function(){if(this.removeEventListener)for(var a=c.length;a;)this.removeEventListener(c[--a],e,!1);else this.onmousewheel=null}};d.fn.extend({mousewheel:function(a){return a?this.bind("mousewheel",a):this.trigger("mousewheel")},unmousewheel:function(a){return this.unbind("mousewheel",a)}})})(jQuery);
|
||||
|
||||
|
||||
|
||||
|
||||
(function ($) {
|
||||
var options = {
|
||||
xaxis: {
|
||||
zoomRange: null, // or [number, number] (min range, max range)
|
||||
panRange: null // or [number, number] (min, max)
|
||||
},
|
||||
zoom: {
|
||||
interactive: false,
|
||||
trigger: "dblclick", // or "click" for single click
|
||||
amount: 1.5 // how much to zoom relative to current position, 2 = 200% (zoom in), 0.5 = 50% (zoom out)
|
||||
},
|
||||
pan: {
|
||||
interactive: false,
|
||||
cursor: "move",
|
||||
frameRate: 20
|
||||
}
|
||||
};
|
||||
|
||||
function init(plot) {
|
||||
function onZoomClick(e, zoomOut) {
|
||||
var c = plot.offset();
|
||||
c.left = e.pageX - c.left;
|
||||
c.top = e.pageY - c.top;
|
||||
if (zoomOut)
|
||||
plot.zoomOut({ center: c });
|
||||
else
|
||||
plot.zoom({ center: c });
|
||||
}
|
||||
|
||||
function onMouseWheel(e, delta) {
|
||||
e.preventDefault();
|
||||
onZoomClick(e, delta < 0);
|
||||
return false;
|
||||
}
|
||||
|
||||
var prevCursor = 'default', prevPageX = 0, prevPageY = 0,
|
||||
panTimeout = null;
|
||||
|
||||
function onDragStart(e) {
|
||||
if (e.which != 1) // only accept left-click
|
||||
return false;
|
||||
var c = plot.getPlaceholder().css('cursor');
|
||||
if (c)
|
||||
prevCursor = c;
|
||||
plot.getPlaceholder().css('cursor', plot.getOptions().pan.cursor);
|
||||
prevPageX = e.pageX;
|
||||
prevPageY = e.pageY;
|
||||
}
|
||||
|
||||
function onDrag(e) {
|
||||
var frameRate = plot.getOptions().pan.frameRate;
|
||||
if (panTimeout || !frameRate)
|
||||
return;
|
||||
|
||||
panTimeout = setTimeout(function () {
|
||||
plot.pan({ left: prevPageX - e.pageX,
|
||||
top: prevPageY - e.pageY });
|
||||
prevPageX = e.pageX;
|
||||
prevPageY = e.pageY;
|
||||
|
||||
panTimeout = null;
|
||||
}, 1 / frameRate * 1000);
|
||||
}
|
||||
|
||||
function onDragEnd(e) {
|
||||
if (panTimeout) {
|
||||
clearTimeout(panTimeout);
|
||||
panTimeout = null;
|
||||
}
|
||||
|
||||
plot.getPlaceholder().css('cursor', prevCursor);
|
||||
plot.pan({ left: prevPageX - e.pageX,
|
||||
top: prevPageY - e.pageY });
|
||||
}
|
||||
|
||||
function bindEvents(plot, eventHolder) {
|
||||
var o = plot.getOptions();
|
||||
if (o.zoom.interactive) {
|
||||
eventHolder[o.zoom.trigger](onZoomClick);
|
||||
eventHolder.mousewheel(onMouseWheel);
|
||||
}
|
||||
|
||||
if (o.pan.interactive) {
|
||||
eventHolder.bind("dragstart", { distance: 10 }, onDragStart);
|
||||
eventHolder.bind("drag", onDrag);
|
||||
eventHolder.bind("dragend", onDragEnd);
|
||||
}
|
||||
}
|
||||
|
||||
plot.zoomOut = function (args) {
|
||||
if (!args)
|
||||
args = {};
|
||||
|
||||
if (!args.amount)
|
||||
args.amount = plot.getOptions().zoom.amount;
|
||||
|
||||
args.amount = 1 / args.amount;
|
||||
plot.zoom(args);
|
||||
};
|
||||
|
||||
plot.zoom = function (args) {
|
||||
if (!args)
|
||||
args = {};
|
||||
|
||||
var c = args.center,
|
||||
amount = args.amount || plot.getOptions().zoom.amount,
|
||||
w = plot.width(), h = plot.height();
|
||||
|
||||
if (!c)
|
||||
c = { left: w / 2, top: h / 2 };
|
||||
|
||||
var xf = c.left / w,
|
||||
yf = c.top / h,
|
||||
minmax = {
|
||||
x: {
|
||||
min: c.left - xf * w / amount,
|
||||
max: c.left + (1 - xf) * w / amount
|
||||
},
|
||||
y: {
|
||||
min: c.top - yf * h / amount,
|
||||
max: c.top + (1 - yf) * h / amount
|
||||
}
|
||||
};
|
||||
|
||||
$.each(plot.getAxes(), function(_, axis) {
|
||||
var opts = axis.options,
|
||||
min = minmax[axis.direction].min,
|
||||
max = minmax[axis.direction].max,
|
||||
zr = opts.zoomRange,
|
||||
pr = opts.panRange;
|
||||
|
||||
if (zr === false) // no zooming on this axis
|
||||
return;
|
||||
|
||||
min = axis.c2p(min);
|
||||
max = axis.c2p(max);
|
||||
if (min > max) {
|
||||
// make sure min < max
|
||||
var tmp = min;
|
||||
min = max;
|
||||
max = tmp;
|
||||
}
|
||||
|
||||
//Check that we are in panRange
|
||||
if (pr) {
|
||||
if (pr[0] != null && min < pr[0]) {
|
||||
min = pr[0];
|
||||
}
|
||||
if (pr[1] != null && max > pr[1]) {
|
||||
max = pr[1];
|
||||
}
|
||||
}
|
||||
|
||||
var range = max - min;
|
||||
if (zr &&
|
||||
((zr[0] != null && range < zr[0]) ||
|
||||
(zr[1] != null && range > zr[1])))
|
||||
return;
|
||||
|
||||
opts.min = min;
|
||||
opts.max = max;
|
||||
});
|
||||
|
||||
plot.setupGrid();
|
||||
plot.draw();
|
||||
|
||||
if (!args.preventEvent)
|
||||
plot.getPlaceholder().trigger("plotzoom", [ plot, args ]);
|
||||
};
|
||||
|
||||
plot.pan = function (args) {
|
||||
var delta = {
|
||||
x: +args.left,
|
||||
y: +args.top
|
||||
};
|
||||
|
||||
if (isNaN(delta.x))
|
||||
delta.x = 0;
|
||||
if (isNaN(delta.y))
|
||||
delta.y = 0;
|
||||
|
||||
$.each(plot.getAxes(), function (_, axis) {
|
||||
var opts = axis.options,
|
||||
min, max, d = delta[axis.direction];
|
||||
|
||||
min = axis.c2p(axis.p2c(axis.min) + d),
|
||||
max = axis.c2p(axis.p2c(axis.max) + d);
|
||||
|
||||
var pr = opts.panRange;
|
||||
if (pr === false) // no panning on this axis
|
||||
return;
|
||||
|
||||
if (pr) {
|
||||
// check whether we hit the wall
|
||||
if (pr[0] != null && pr[0] > min) {
|
||||
d = pr[0] - min;
|
||||
min += d;
|
||||
max += d;
|
||||
}
|
||||
|
||||
if (pr[1] != null && pr[1] < max) {
|
||||
d = pr[1] - max;
|
||||
min += d;
|
||||
max += d;
|
||||
}
|
||||
}
|
||||
|
||||
opts.min = min;
|
||||
opts.max = max;
|
||||
});
|
||||
|
||||
plot.setupGrid();
|
||||
plot.draw();
|
||||
|
||||
if (!args.preventEvent)
|
||||
plot.getPlaceholder().trigger("plotpan", [ plot, args ]);
|
||||
};
|
||||
|
||||
function shutdown(plot, eventHolder) {
|
||||
eventHolder.unbind(plot.getOptions().zoom.trigger, onZoomClick);
|
||||
eventHolder.unbind("mousewheel", onMouseWheel);
|
||||
eventHolder.unbind("dragstart", onDragStart);
|
||||
eventHolder.unbind("drag", onDrag);
|
||||
eventHolder.unbind("dragend", onDragEnd);
|
||||
if (panTimeout)
|
||||
clearTimeout(panTimeout);
|
||||
}
|
||||
|
||||
plot.hooks.bindEvents.push(bindEvents);
|
||||
plot.hooks.shutdown.push(shutdown);
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'navigate',
|
||||
version: '1.3'
|
||||
});
|
||||
})(jQuery);
|
||||
File diff suppressed because one or more lines are too long
@ -1,817 +0,0 @@
|
||||
/* Flot plugin for rendering pie charts.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin assumes that each series has a single data value, and that each
|
||||
value is a positive integer or zero. Negative numbers don't make sense for a
|
||||
pie chart, and have unpredictable results. The values do NOT need to be
|
||||
passed in as percentages; the plugin will calculate the total and per-slice
|
||||
percentages internally.
|
||||
|
||||
* Created by Brian Medendorp
|
||||
|
||||
* Updated with contributions from btburnett3, Anthony Aragues and Xavi Ivars
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
series: {
|
||||
pie: {
|
||||
show: true/false
|
||||
radius: 0-1 for percentage of fullsize, or a specified pixel length, or 'auto'
|
||||
innerRadius: 0-1 for percentage of fullsize or a specified pixel length, for creating a donut effect
|
||||
startAngle: 0-2 factor of PI used for starting angle (in radians) i.e 3/2 starts at the top, 0 and 2 have the same result
|
||||
tilt: 0-1 for percentage to tilt the pie, where 1 is no tilt, and 0 is completely flat (nothing will show)
|
||||
offset: {
|
||||
top: integer value to move the pie up or down
|
||||
left: integer value to move the pie left or right, or 'auto'
|
||||
},
|
||||
stroke: {
|
||||
color: any hexidecimal color value (other formats may or may not work, so best to stick with something like '#FFF')
|
||||
width: integer pixel width of the stroke
|
||||
},
|
||||
label: {
|
||||
show: true/false, or 'auto'
|
||||
formatter: a user-defined function that modifies the text/style of the label text
|
||||
radius: 0-1 for percentage of fullsize, or a specified pixel length
|
||||
background: {
|
||||
color: any hexidecimal color value (other formats may or may not work, so best to stick with something like '#000')
|
||||
opacity: 0-1
|
||||
},
|
||||
threshold: 0-1 for the percentage value at which to hide labels (if they're too small)
|
||||
},
|
||||
combine: {
|
||||
threshold: 0-1 for the percentage value at which to combine slices (if they're too small)
|
||||
color: any hexidecimal color value (other formats may or may not work, so best to stick with something like '#CCC'), if null, the plugin will automatically use the color of the first slice to be combined
|
||||
label: any text value of what the combined slice should be labeled
|
||||
}
|
||||
highlight: {
|
||||
opacity: 0-1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
More detail and specific examples can be found in the included HTML file.
|
||||
|
||||
*/
|
||||
|
||||
(function($) {
|
||||
|
||||
// Maximum redraw attempts when fitting labels within the plot
|
||||
|
||||
var REDRAW_ATTEMPTS = 10;
|
||||
|
||||
// Factor by which to shrink the pie when fitting labels within the plot
|
||||
|
||||
var REDRAW_SHRINK = 0.95;
|
||||
|
||||
function init(plot) {
|
||||
|
||||
var canvas = null,
|
||||
target = null,
|
||||
maxRadius = null,
|
||||
centerLeft = null,
|
||||
centerTop = null,
|
||||
processed = false,
|
||||
ctx = null;
|
||||
|
||||
// interactive variables
|
||||
|
||||
var highlights = [];
|
||||
|
||||
// add hook to determine if pie plugin in enabled, and then perform necessary operations
|
||||
|
||||
plot.hooks.processOptions.push(function(plot, options) {
|
||||
if (options.series.pie.show) {
|
||||
|
||||
options.grid.show = false;
|
||||
|
||||
// set labels.show
|
||||
|
||||
if (options.series.pie.label.show == "auto") {
|
||||
if (options.legend.show) {
|
||||
options.series.pie.label.show = false;
|
||||
} else {
|
||||
options.series.pie.label.show = true;
|
||||
}
|
||||
}
|
||||
|
||||
// set radius
|
||||
|
||||
if (options.series.pie.radius == "auto") {
|
||||
if (options.series.pie.label.show) {
|
||||
options.series.pie.radius = 3/4;
|
||||
} else {
|
||||
options.series.pie.radius = 1;
|
||||
}
|
||||
}
|
||||
|
||||
// ensure sane tilt
|
||||
|
||||
if (options.series.pie.tilt > 1) {
|
||||
options.series.pie.tilt = 1;
|
||||
} else if (options.series.pie.tilt < 0) {
|
||||
options.series.pie.tilt = 0;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
plot.hooks.bindEvents.push(function(plot, eventHolder) {
|
||||
var options = plot.getOptions();
|
||||
if (options.series.pie.show) {
|
||||
if (options.grid.hoverable) {
|
||||
eventHolder.unbind("mousemove").mousemove(onMouseMove);
|
||||
}
|
||||
if (options.grid.clickable) {
|
||||
eventHolder.unbind("click").click(onClick);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
plot.hooks.processDatapoints.push(function(plot, series, data, datapoints) {
|
||||
var options = plot.getOptions();
|
||||
if (options.series.pie.show) {
|
||||
processDatapoints(plot, series, data, datapoints);
|
||||
}
|
||||
});
|
||||
|
||||
plot.hooks.drawOverlay.push(function(plot, octx) {
|
||||
var options = plot.getOptions();
|
||||
if (options.series.pie.show) {
|
||||
drawOverlay(plot, octx);
|
||||
}
|
||||
});
|
||||
|
||||
plot.hooks.draw.push(function(plot, newCtx) {
|
||||
var options = plot.getOptions();
|
||||
if (options.series.pie.show) {
|
||||
draw(plot, newCtx);
|
||||
}
|
||||
});
|
||||
|
||||
function processDatapoints(plot, series, datapoints) {
|
||||
if (!processed) {
|
||||
processed = true;
|
||||
canvas = plot.getCanvas();
|
||||
target = $(canvas).parent();
|
||||
options = plot.getOptions();
|
||||
plot.setData(combine(plot.getData()));
|
||||
}
|
||||
}
|
||||
|
||||
function combine(data) {
|
||||
|
||||
var total = 0,
|
||||
combined = 0,
|
||||
numCombined = 0,
|
||||
color = options.series.pie.combine.color,
|
||||
newdata = [];
|
||||
|
||||
// Fix up the raw data from Flot, ensuring the data is numeric
|
||||
|
||||
for (var i = 0; i < data.length; ++i) {
|
||||
|
||||
var value = data[i].data;
|
||||
|
||||
// If the data is an array, we'll assume that it's a standard
|
||||
// Flot x-y pair, and are concerned only with the second value.
|
||||
|
||||
// Note how we use the original array, rather than creating a
|
||||
// new one; this is more efficient and preserves any extra data
|
||||
// that the user may have stored in higher indexes.
|
||||
|
||||
if ($.isArray(value) && value.length == 1) {
|
||||
value = value[0];
|
||||
}
|
||||
|
||||
if ($.isArray(value)) {
|
||||
// Equivalent to $.isNumeric() but compatible with jQuery < 1.7
|
||||
if (!isNaN(parseFloat(value[1])) && isFinite(value[1])) {
|
||||
value[1] = +value[1];
|
||||
} else {
|
||||
value[1] = 0;
|
||||
}
|
||||
} else if (!isNaN(parseFloat(value)) && isFinite(value)) {
|
||||
value = [1, +value];
|
||||
} else {
|
||||
value = [1, 0];
|
||||
}
|
||||
|
||||
data[i].data = [value];
|
||||
}
|
||||
|
||||
// Sum up all the slices, so we can calculate percentages for each
|
||||
|
||||
for (var i = 0; i < data.length; ++i) {
|
||||
total += data[i].data[0][1];
|
||||
}
|
||||
|
||||
// Count the number of slices with percentages below the combine
|
||||
// threshold; if it turns out to be just one, we won't combine.
|
||||
|
||||
for (var i = 0; i < data.length; ++i) {
|
||||
var value = data[i].data[0][1];
|
||||
if (value / total <= options.series.pie.combine.threshold) {
|
||||
combined += value;
|
||||
numCombined++;
|
||||
if (!color) {
|
||||
color = data[i].color;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (var i = 0; i < data.length; ++i) {
|
||||
var value = data[i].data[0][1];
|
||||
if (numCombined < 2 || value / total > options.series.pie.combine.threshold) {
|
||||
newdata.push({
|
||||
data: [[1, value]],
|
||||
color: data[i].color,
|
||||
label: data[i].label,
|
||||
angle: value * Math.PI * 2 / total,
|
||||
percent: value / (total / 100)
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (numCombined > 1) {
|
||||
newdata.push({
|
||||
data: [[1, combined]],
|
||||
color: color,
|
||||
label: options.series.pie.combine.label,
|
||||
angle: combined * Math.PI * 2 / total,
|
||||
percent: combined / (total / 100)
|
||||
});
|
||||
}
|
||||
|
||||
return newdata;
|
||||
}
|
||||
|
||||
function draw(plot, newCtx) {
|
||||
|
||||
if (!target) {
|
||||
return; // if no series were passed
|
||||
}
|
||||
|
||||
var canvasWidth = plot.getPlaceholder().width(),
|
||||
canvasHeight = plot.getPlaceholder().height(),
|
||||
legendWidth = target.children().filter(".legend").children().width() || 0;
|
||||
|
||||
ctx = newCtx;
|
||||
|
||||
// WARNING: HACK! REWRITE THIS CODE AS SOON AS POSSIBLE!
|
||||
|
||||
// When combining smaller slices into an 'other' slice, we need to
|
||||
// add a new series. Since Flot gives plugins no way to modify the
|
||||
// list of series, the pie plugin uses a hack where the first call
|
||||
// to processDatapoints results in a call to setData with the new
|
||||
// list of series, then subsequent processDatapoints do nothing.
|
||||
|
||||
// The plugin-global 'processed' flag is used to control this hack;
|
||||
// it starts out false, and is set to true after the first call to
|
||||
// processDatapoints.
|
||||
|
||||
// Unfortunately this turns future setData calls into no-ops; they
|
||||
// call processDatapoints, the flag is true, and nothing happens.
|
||||
|
||||
// To fix this we'll set the flag back to false here in draw, when
|
||||
// all series have been processed, so the next sequence of calls to
|
||||
// processDatapoints once again starts out with a slice-combine.
|
||||
// This is really a hack; in 0.9 we need to give plugins a proper
|
||||
// way to modify series before any processing begins.
|
||||
|
||||
processed = false;
|
||||
|
||||
// calculate maximum radius and center point
|
||||
|
||||
maxRadius = Math.min(canvasWidth, canvasHeight / options.series.pie.tilt) / 2;
|
||||
centerTop = canvasHeight / 2 + options.series.pie.offset.top;
|
||||
centerLeft = canvasWidth / 2;
|
||||
|
||||
if (options.series.pie.offset.left == "auto") {
|
||||
if (options.legend.position.match("w")) {
|
||||
centerLeft += legendWidth / 2;
|
||||
} else {
|
||||
centerLeft -= legendWidth / 2;
|
||||
}
|
||||
} else {
|
||||
centerLeft += options.series.pie.offset.left;
|
||||
}
|
||||
|
||||
if (centerLeft < maxRadius) {
|
||||
centerLeft = maxRadius;
|
||||
} else if (centerLeft > canvasWidth - maxRadius) {
|
||||
centerLeft = canvasWidth - maxRadius;
|
||||
}
|
||||
|
||||
var slices = plot.getData(),
|
||||
attempts = 0;
|
||||
|
||||
// Keep shrinking the pie's radius until drawPie returns true,
|
||||
// indicating that all the labels fit, or we try too many times.
|
||||
|
||||
do {
|
||||
if (attempts > 0) {
|
||||
maxRadius *= REDRAW_SHRINK;
|
||||
}
|
||||
attempts += 1;
|
||||
clear();
|
||||
if (options.series.pie.tilt <= 0.8) {
|
||||
drawShadow();
|
||||
}
|
||||
} while (!drawPie() && attempts < REDRAW_ATTEMPTS)
|
||||
|
||||
if (attempts >= REDRAW_ATTEMPTS) {
|
||||
clear();
|
||||
target.prepend("<div class='error'>Could not draw pie with labels contained inside canvas</div>");
|
||||
}
|
||||
|
||||
if (plot.setSeries && plot.insertLegend) {
|
||||
plot.setSeries(slices);
|
||||
plot.insertLegend();
|
||||
}
|
||||
|
||||
// we're actually done at this point, just defining internal functions at this point
|
||||
|
||||
function clear() {
|
||||
ctx.clearRect(0, 0, canvasWidth, canvasHeight);
|
||||
target.children().filter(".pieLabel, .pieLabelBackground").remove();
|
||||
}
|
||||
|
||||
function drawShadow() {
|
||||
|
||||
var shadowLeft = options.series.pie.shadow.left;
|
||||
var shadowTop = options.series.pie.shadow.top;
|
||||
var edge = 10;
|
||||
var alpha = options.series.pie.shadow.alpha;
|
||||
var radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius;
|
||||
|
||||
if (radius >= canvasWidth / 2 - shadowLeft || radius * options.series.pie.tilt >= canvasHeight / 2 - shadowTop || radius <= edge) {
|
||||
return; // shadow would be outside canvas, so don't draw it
|
||||
}
|
||||
|
||||
ctx.save();
|
||||
ctx.translate(shadowLeft,shadowTop);
|
||||
ctx.globalAlpha = alpha;
|
||||
ctx.fillStyle = "#000";
|
||||
|
||||
// center and rotate to starting position
|
||||
|
||||
ctx.translate(centerLeft,centerTop);
|
||||
ctx.scale(1, options.series.pie.tilt);
|
||||
|
||||
//radius -= edge;
|
||||
|
||||
for (var i = 1; i <= edge; i++) {
|
||||
ctx.beginPath();
|
||||
ctx.arc(0, 0, radius, 0, Math.PI * 2, false);
|
||||
ctx.fill();
|
||||
radius -= i;
|
||||
}
|
||||
|
||||
ctx.restore();
|
||||
}
|
||||
|
||||
function drawPie() {
|
||||
|
||||
var startAngle = Math.PI * options.series.pie.startAngle;
|
||||
var radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius;
|
||||
|
||||
// center and rotate to starting position
|
||||
|
||||
ctx.save();
|
||||
ctx.translate(centerLeft,centerTop);
|
||||
ctx.scale(1, options.series.pie.tilt);
|
||||
//ctx.rotate(startAngle); // start at top; -- This doesn't work properly in Opera
|
||||
|
||||
// draw slices
|
||||
|
||||
ctx.save();
|
||||
var currentAngle = startAngle;
|
||||
for (var i = 0; i < slices.length; ++i) {
|
||||
slices[i].startAngle = currentAngle;
|
||||
drawSlice(slices[i].angle, slices[i].color, true);
|
||||
}
|
||||
ctx.restore();
|
||||
|
||||
// draw slice outlines
|
||||
|
||||
if (options.series.pie.stroke.width > 0) {
|
||||
ctx.save();
|
||||
ctx.lineWidth = options.series.pie.stroke.width;
|
||||
currentAngle = startAngle;
|
||||
for (var i = 0; i < slices.length; ++i) {
|
||||
drawSlice(slices[i].angle, options.series.pie.stroke.color, false);
|
||||
}
|
||||
ctx.restore();
|
||||
}
|
||||
|
||||
// draw donut hole
|
||||
|
||||
drawDonutHole(ctx);
|
||||
|
||||
ctx.restore();
|
||||
|
||||
// Draw the labels, returning true if they fit within the plot
|
||||
|
||||
if (options.series.pie.label.show) {
|
||||
return drawLabels();
|
||||
} else return true;
|
||||
|
||||
function drawSlice(angle, color, fill) {
|
||||
|
||||
if (angle <= 0 || isNaN(angle)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (fill) {
|
||||
ctx.fillStyle = color;
|
||||
} else {
|
||||
ctx.strokeStyle = color;
|
||||
ctx.lineJoin = "round";
|
||||
}
|
||||
|
||||
ctx.beginPath();
|
||||
if (Math.abs(angle - Math.PI * 2) > 0.000000001) {
|
||||
ctx.moveTo(0, 0); // Center of the pie
|
||||
}
|
||||
|
||||
//ctx.arc(0, 0, radius, 0, angle, false); // This doesn't work properly in Opera
|
||||
ctx.arc(0, 0, radius,currentAngle, currentAngle + angle / 2, false);
|
||||
ctx.arc(0, 0, radius,currentAngle + angle / 2, currentAngle + angle, false);
|
||||
ctx.closePath();
|
||||
//ctx.rotate(angle); // This doesn't work properly in Opera
|
||||
currentAngle += angle;
|
||||
|
||||
if (fill) {
|
||||
ctx.fill();
|
||||
} else {
|
||||
ctx.stroke();
|
||||
}
|
||||
}
|
||||
|
||||
function drawLabels() {
|
||||
|
||||
var currentAngle = startAngle;
|
||||
var radius = options.series.pie.label.radius > 1 ? options.series.pie.label.radius : maxRadius * options.series.pie.label.radius;
|
||||
|
||||
for (var i = 0; i < slices.length; ++i) {
|
||||
if (slices[i].percent >= options.series.pie.label.threshold * 100) {
|
||||
if (!drawLabel(slices[i], currentAngle, i)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
currentAngle += slices[i].angle;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
function drawLabel(slice, startAngle, index) {
|
||||
|
||||
if (slice.data[0][1] == 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// format label text
|
||||
|
||||
var lf = options.legend.labelFormatter, text, plf = options.series.pie.label.formatter;
|
||||
|
||||
if (lf) {
|
||||
text = lf(slice.label, slice);
|
||||
} else {
|
||||
text = slice.label;
|
||||
}
|
||||
|
||||
if (plf) {
|
||||
text = plf(text, slice);
|
||||
}
|
||||
|
||||
var halfAngle = ((startAngle + slice.angle) + startAngle) / 2;
|
||||
var x = centerLeft + Math.round(Math.cos(halfAngle) * radius);
|
||||
var y = centerTop + Math.round(Math.sin(halfAngle) * radius) * options.series.pie.tilt;
|
||||
|
||||
var html = "<span class='pieLabel' id='pieLabel" + index + "' style='position:absolute;top:" + y + "px;left:" + x + "px;'>" + text + "</span>";
|
||||
target.append(html);
|
||||
|
||||
var label = target.children("#pieLabel" + index);
|
||||
var labelTop = (y - label.height() / 2);
|
||||
var labelLeft = (x - label.width() / 2);
|
||||
|
||||
label.css("top", labelTop);
|
||||
label.css("left", labelLeft);
|
||||
|
||||
// check to make sure that the label is not outside the canvas
|
||||
|
||||
if (0 - labelTop > 0 || 0 - labelLeft > 0 || canvasHeight - (labelTop + label.height()) < 0 || canvasWidth - (labelLeft + label.width()) < 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (options.series.pie.label.background.opacity != 0) {
|
||||
|
||||
// put in the transparent background separately to avoid blended labels and label boxes
|
||||
|
||||
var c = options.series.pie.label.background.color;
|
||||
|
||||
if (c == null) {
|
||||
c = slice.color;
|
||||
}
|
||||
|
||||
var pos = "top:" + labelTop + "px;left:" + labelLeft + "px;";
|
||||
$("<div class='pieLabelBackground' style='position:absolute;width:" + label.width() + "px;height:" + label.height() + "px;" + pos + "background-color:" + c + ";'></div>")
|
||||
.css("opacity", options.series.pie.label.background.opacity)
|
||||
.insertBefore(label);
|
||||
}
|
||||
|
||||
return true;
|
||||
} // end individual label function
|
||||
} // end drawLabels function
|
||||
} // end drawPie function
|
||||
} // end draw function
|
||||
|
||||
// Placed here because it needs to be accessed from multiple locations
|
||||
|
||||
function drawDonutHole(layer) {
|
||||
if (options.series.pie.innerRadius > 0) {
|
||||
|
||||
// subtract the center
|
||||
|
||||
layer.save();
|
||||
var innerRadius = options.series.pie.innerRadius > 1 ? options.series.pie.innerRadius : maxRadius * options.series.pie.innerRadius;
|
||||
layer.globalCompositeOperation = "destination-out"; // this does not work with excanvas, but it will fall back to using the stroke color
|
||||
layer.beginPath();
|
||||
layer.fillStyle = options.series.pie.stroke.color;
|
||||
layer.arc(0, 0, innerRadius, 0, Math.PI * 2, false);
|
||||
layer.fill();
|
||||
layer.closePath();
|
||||
layer.restore();
|
||||
|
||||
// add inner stroke
|
||||
|
||||
layer.save();
|
||||
layer.beginPath();
|
||||
layer.strokeStyle = options.series.pie.stroke.color;
|
||||
layer.arc(0, 0, innerRadius, 0, Math.PI * 2, false);
|
||||
layer.stroke();
|
||||
layer.closePath();
|
||||
layer.restore();
|
||||
|
||||
// TODO: add extra shadow inside hole (with a mask) if the pie is tilted.
|
||||
}
|
||||
}
|
||||
|
||||
//-- Additional Interactive related functions --
|
||||
|
||||
function isPointInPoly(poly, pt) {
|
||||
for(var c = false, i = -1, l = poly.length, j = l - 1; ++i < l; j = i)
|
||||
((poly[i][1] <= pt[1] && pt[1] < poly[j][1]) || (poly[j][1] <= pt[1] && pt[1]< poly[i][1]))
|
||||
&& (pt[0] < (poly[j][0] - poly[i][0]) * (pt[1] - poly[i][1]) / (poly[j][1] - poly[i][1]) + poly[i][0])
|
||||
&& (c = !c);
|
||||
return c;
|
||||
}
|
||||
|
||||
function findNearbySlice(mouseX, mouseY) {
|
||||
|
||||
var slices = plot.getData(),
|
||||
options = plot.getOptions(),
|
||||
radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius,
|
||||
x, y;
|
||||
|
||||
for (var i = 0; i < slices.length; ++i) {
|
||||
|
||||
var s = slices[i];
|
||||
|
||||
if (s.pie.show) {
|
||||
|
||||
ctx.save();
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(0, 0); // Center of the pie
|
||||
//ctx.scale(1, options.series.pie.tilt); // this actually seems to break everything when here.
|
||||
ctx.arc(0, 0, radius, s.startAngle, s.startAngle + s.angle / 2, false);
|
||||
ctx.arc(0, 0, radius, s.startAngle + s.angle / 2, s.startAngle + s.angle, false);
|
||||
ctx.closePath();
|
||||
x = mouseX - centerLeft;
|
||||
y = mouseY - centerTop;
|
||||
|
||||
if (ctx.isPointInPath) {
|
||||
if (ctx.isPointInPath(mouseX - centerLeft, mouseY - centerTop)) {
|
||||
ctx.restore();
|
||||
return {
|
||||
datapoint: [s.percent, s.data],
|
||||
dataIndex: 0,
|
||||
series: s,
|
||||
seriesIndex: i
|
||||
};
|
||||
}
|
||||
} else {
|
||||
|
||||
// excanvas for IE doesn;t support isPointInPath, this is a workaround.
|
||||
|
||||
var p1X = radius * Math.cos(s.startAngle),
|
||||
p1Y = radius * Math.sin(s.startAngle),
|
||||
p2X = radius * Math.cos(s.startAngle + s.angle / 4),
|
||||
p2Y = radius * Math.sin(s.startAngle + s.angle / 4),
|
||||
p3X = radius * Math.cos(s.startAngle + s.angle / 2),
|
||||
p3Y = radius * Math.sin(s.startAngle + s.angle / 2),
|
||||
p4X = radius * Math.cos(s.startAngle + s.angle / 1.5),
|
||||
p4Y = radius * Math.sin(s.startAngle + s.angle / 1.5),
|
||||
p5X = radius * Math.cos(s.startAngle + s.angle),
|
||||
p5Y = radius * Math.sin(s.startAngle + s.angle),
|
||||
arrPoly = [[0, 0], [p1X, p1Y], [p2X, p2Y], [p3X, p3Y], [p4X, p4Y], [p5X, p5Y]],
|
||||
arrPoint = [x, y];
|
||||
|
||||
// TODO: perhaps do some mathmatical trickery here with the Y-coordinate to compensate for pie tilt?
|
||||
|
||||
if (isPointInPoly(arrPoly, arrPoint)) {
|
||||
ctx.restore();
|
||||
return {
|
||||
datapoint: [s.percent, s.data],
|
||||
dataIndex: 0,
|
||||
series: s,
|
||||
seriesIndex: i
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
ctx.restore();
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
function onMouseMove(e) {
|
||||
triggerClickHoverEvent("plothover", e);
|
||||
}
|
||||
|
||||
function onClick(e) {
|
||||
triggerClickHoverEvent("plotclick", e);
|
||||
}
|
||||
|
||||
// trigger click or hover event (they send the same parameters so we share their code)
|
||||
|
||||
function triggerClickHoverEvent(eventname, e) {
|
||||
|
||||
var offset = plot.offset();
|
||||
var canvasX = parseInt(e.pageX - offset.left);
|
||||
var canvasY = parseInt(e.pageY - offset.top);
|
||||
var item = findNearbySlice(canvasX, canvasY);
|
||||
|
||||
if (options.grid.autoHighlight) {
|
||||
|
||||
// clear auto-highlights
|
||||
|
||||
for (var i = 0; i < highlights.length; ++i) {
|
||||
var h = highlights[i];
|
||||
if (h.auto == eventname && !(item && h.series == item.series)) {
|
||||
unhighlight(h.series);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// highlight the slice
|
||||
|
||||
if (item) {
|
||||
highlight(item.series, eventname);
|
||||
}
|
||||
|
||||
// trigger any hover bind events
|
||||
|
||||
var pos = { pageX: e.pageX, pageY: e.pageY };
|
||||
target.trigger(eventname, [pos, item]);
|
||||
}
|
||||
|
||||
function highlight(s, auto) {
|
||||
//if (typeof s == "number") {
|
||||
// s = series[s];
|
||||
//}
|
||||
|
||||
var i = indexOfHighlight(s);
|
||||
|
||||
if (i == -1) {
|
||||
highlights.push({ series: s, auto: auto });
|
||||
plot.triggerRedrawOverlay();
|
||||
} else if (!auto) {
|
||||
highlights[i].auto = false;
|
||||
}
|
||||
}
|
||||
|
||||
function unhighlight(s) {
|
||||
if (s == null) {
|
||||
highlights = [];
|
||||
plot.triggerRedrawOverlay();
|
||||
}
|
||||
|
||||
//if (typeof s == "number") {
|
||||
// s = series[s];
|
||||
//}
|
||||
|
||||
var i = indexOfHighlight(s);
|
||||
|
||||
if (i != -1) {
|
||||
highlights.splice(i, 1);
|
||||
plot.triggerRedrawOverlay();
|
||||
}
|
||||
}
|
||||
|
||||
function indexOfHighlight(s) {
|
||||
for (var i = 0; i < highlights.length; ++i) {
|
||||
var h = highlights[i];
|
||||
if (h.series == s)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
function drawOverlay(plot, octx) {
|
||||
|
||||
var options = plot.getOptions();
|
||||
|
||||
var radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius;
|
||||
|
||||
octx.save();
|
||||
octx.translate(centerLeft, centerTop);
|
||||
octx.scale(1, options.series.pie.tilt);
|
||||
|
||||
for (var i = 0; i < highlights.length; ++i) {
|
||||
drawHighlight(highlights[i].series);
|
||||
}
|
||||
|
||||
drawDonutHole(octx);
|
||||
|
||||
octx.restore();
|
||||
|
||||
function drawHighlight(series) {
|
||||
|
||||
if (series.angle <= 0 || isNaN(series.angle)) {
|
||||
return;
|
||||
}
|
||||
|
||||
//octx.fillStyle = parseColor(options.series.pie.highlight.color).scale(null, null, null, options.series.pie.highlight.opacity).toString();
|
||||
octx.fillStyle = "rgba(255, 255, 255, " + options.series.pie.highlight.opacity + ")"; // this is temporary until we have access to parseColor
|
||||
octx.beginPath();
|
||||
if (Math.abs(series.angle - Math.PI * 2) > 0.000000001) {
|
||||
octx.moveTo(0, 0); // Center of the pie
|
||||
}
|
||||
octx.arc(0, 0, radius, series.startAngle, series.startAngle + series.angle / 2, false);
|
||||
octx.arc(0, 0, radius, series.startAngle + series.angle / 2, series.startAngle + series.angle, false);
|
||||
octx.closePath();
|
||||
octx.fill();
|
||||
}
|
||||
}
|
||||
} // end init (plugin body)
|
||||
|
||||
// define pie specific options and their default values
|
||||
|
||||
var options = {
|
||||
series: {
|
||||
pie: {
|
||||
show: false,
|
||||
radius: "auto", // actual radius of the visible pie (based on full calculated radius if <=1, or hard pixel value)
|
||||
innerRadius: 0, /* for donut */
|
||||
startAngle: 3/2,
|
||||
tilt: 1,
|
||||
shadow: {
|
||||
left: 5, // shadow left offset
|
||||
top: 15, // shadow top offset
|
||||
alpha: 0.02 // shadow alpha
|
||||
},
|
||||
offset: {
|
||||
top: 0,
|
||||
left: "auto"
|
||||
},
|
||||
stroke: {
|
||||
color: "#fff",
|
||||
width: 1
|
||||
},
|
||||
label: {
|
||||
show: "auto",
|
||||
formatter: function(label, slice) {
|
||||
return "<div style='font-size:x-small;text-align:center;padding:2px;color:" + slice.color + ";'>" + label + "<br/>" + Math.round(slice.percent) + "%</div>";
|
||||
}, // formatter function
|
||||
radius: 1, // radius at which to place the labels (based on full calculated radius if <=1, or hard pixel value)
|
||||
background: {
|
||||
color: null,
|
||||
opacity: 0
|
||||
},
|
||||
threshold: 0 // percentage at which to hide the label (i.e. the slice is too narrow)
|
||||
},
|
||||
combine: {
|
||||
threshold: -1, // percentage at which to combine little slices into one larger slice
|
||||
color: null, // color to give the new slice (auto-generated if null)
|
||||
label: "Other" // label to give the new slice
|
||||
},
|
||||
highlight: {
|
||||
//color: "#fff", // will add this functionality once parseColor is available
|
||||
opacity: 0.5
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: "pie",
|
||||
version: "1.1"
|
||||
});
|
||||
|
||||
})(jQuery);
|
||||
File diff suppressed because one or more lines are too long
@ -1,60 +0,0 @@
|
||||
/* Flot plugin for automatically redrawing plots as the placeholder resizes.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
It works by listening for changes on the placeholder div (through the jQuery
|
||||
resize event plugin) - if the size changes, it will redraw the plot.
|
||||
|
||||
There are no options. If you need to disable the plugin for some plots, you
|
||||
can just fix the size of their placeholders.
|
||||
|
||||
*/
|
||||
|
||||
/* Inline dependency:
|
||||
* jQuery resize event - v1.1 - 3/14/2010
|
||||
* http://benalman.com/projects/jquery-resize-plugin/
|
||||
*
|
||||
* Copyright (c) 2010 "Cowboy" Ben Alman
|
||||
* Dual licensed under the MIT and GPL licenses.
|
||||
* http://benalman.com/about/license/
|
||||
*/
|
||||
|
||||
(function($,h,c){var a=$([]),e=$.resize=$.extend($.resize,{}),i,k="setTimeout",j="resize",d=j+"-special-event",b="delay",f="throttleWindow";e[b]=250;e[f]=true;$.event.special[j]={setup:function(){if(!e[f]&&this[k]){return false}var l=$(this);a=a.add(l);$.data(this,d,{w:l.width(),h:l.height()});if(a.length===1){g()}},teardown:function(){if(!e[f]&&this[k]){return false}var l=$(this);a=a.not(l);l.removeData(d);if(!a.length){clearTimeout(i)}},add:function(l){if(!e[f]&&this[k]){return false}var n;function m(s,o,p){var q=$(this),r=$.data(this,d);r.w=o!==c?o:q.width();r.h=p!==c?p:q.height();n.apply(this,arguments)}if($.isFunction(l)){n=l;return m}else{n=l.handler;l.handler=m}}};function g(){i=h[k](function(){a.each(function(){var n=$(this),m=n.width(),l=n.height(),o=$.data(this,d);if(m!==o.w||l!==o.h){n.trigger(j,[o.w=m,o.h=l])}});g()},e[b])}})(jQuery,this);
|
||||
|
||||
(function ($) {
|
||||
var options = { }; // no options
|
||||
|
||||
function init(plot) {
|
||||
function onResize() {
|
||||
var placeholder = plot.getPlaceholder();
|
||||
|
||||
// somebody might have hidden us and we can't plot
|
||||
// when we don't have the dimensions
|
||||
if (placeholder.width() == 0 || placeholder.height() == 0)
|
||||
return;
|
||||
|
||||
plot.resize();
|
||||
plot.setupGrid();
|
||||
plot.draw();
|
||||
}
|
||||
|
||||
function bindEvents(plot, eventHolder) {
|
||||
plot.getPlaceholder().resize(onResize);
|
||||
}
|
||||
|
||||
function shutdown(plot, eventHolder) {
|
||||
plot.getPlaceholder().unbind("resize", onResize);
|
||||
}
|
||||
|
||||
plot.hooks.bindEvents.push(bindEvents);
|
||||
plot.hooks.shutdown.push(shutdown);
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'resize',
|
||||
version: '1.0'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,19 +0,0 @@
|
||||
/* Flot plugin for automatically redrawing plots as the placeholder resizes.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
It works by listening for changes on the placeholder div (through the jQuery
|
||||
resize event plugin) - if the size changes, it will redraw the plot.
|
||||
|
||||
There are no options. If you need to disable the plugin for some plots, you
|
||||
can just fix the size of their placeholders.
|
||||
|
||||
*//* Inline dependency:
|
||||
* jQuery resize event - v1.1 - 3/14/2010
|
||||
* http://benalman.com/projects/jquery-resize-plugin/
|
||||
*
|
||||
* Copyright (c) 2010 "Cowboy" Ben Alman
|
||||
* Dual licensed under the MIT and GPL licenses.
|
||||
* http://benalman.com/about/license/
|
||||
*/(function(e,t,n){function c(){s=t[o](function(){r.each(function(){var t=e(this),n=t.width(),r=t.height(),i=e.data(this,a);(n!==i.w||r!==i.h)&&t.trigger(u,[i.w=n,i.h=r])}),c()},i[f])}var r=e([]),i=e.resize=e.extend(e.resize,{}),s,o="setTimeout",u="resize",a=u+"-special-event",f="delay",l="throttleWindow";i[f]=250,i[l]=!0,e.event.special[u]={setup:function(){if(!i[l]&&this[o])return!1;var t=e(this);r=r.add(t),e.data(this,a,{w:t.width(),h:t.height()}),r.length===1&&c()},teardown:function(){if(!i[l]&&this[o])return!1;var t=e(this);r=r.not(t),t.removeData(a),r.length||clearTimeout(s)},add:function(t){function s(t,i,s){var o=e(this),u=e.data(this,a);u.w=i!==n?i:o.width(),u.h=s!==n?s:o.height(),r.apply(this,arguments)}if(!i[l]&&this[o])return!1;var r;if(e.isFunction(t))return r=t,s;r=t.handler,t.handler=s}}})(jQuery,this),function(e){function n(e){function t(){var t=e.getPlaceholder();if(t.width()==0||t.height()==0)return;e.resize(),e.setupGrid(),e.draw()}function n(e,n){e.getPlaceholder().resize(t)}function r(e,n){e.getPlaceholder().unbind("resize",t)}e.hooks.bindEvents.push(n),e.hooks.shutdown.push(r)}var t={};e.plot.plugins.push({init:n,options:t,name:"resize",version:"1.0"})}(jQuery);
|
||||
@ -1,360 +0,0 @@
|
||||
/* Flot plugin for selecting regions of a plot.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
selection: {
|
||||
mode: null or "x" or "y" or "xy",
|
||||
color: color,
|
||||
shape: "round" or "miter" or "bevel",
|
||||
minSize: number of pixels
|
||||
}
|
||||
|
||||
Selection support is enabled by setting the mode to one of "x", "y" or "xy".
|
||||
In "x" mode, the user will only be able to specify the x range, similarly for
|
||||
"y" mode. For "xy", the selection becomes a rectangle where both ranges can be
|
||||
specified. "color" is color of the selection (if you need to change the color
|
||||
later on, you can get to it with plot.getOptions().selection.color). "shape"
|
||||
is the shape of the corners of the selection.
|
||||
|
||||
"minSize" is the minimum size a selection can be in pixels. This value can
|
||||
be customized to determine the smallest size a selection can be and still
|
||||
have the selection rectangle be displayed. When customizing this value, the
|
||||
fact that it refers to pixels, not axis units must be taken into account.
|
||||
Thus, for example, if there is a bar graph in time mode with BarWidth set to 1
|
||||
minute, setting "minSize" to 1 will not make the minimum selection size 1
|
||||
minute, but rather 1 pixel. Note also that setting "minSize" to 0 will prevent
|
||||
"plotunselected" events from being fired when the user clicks the mouse without
|
||||
dragging.
|
||||
|
||||
When selection support is enabled, a "plotselected" event will be emitted on
|
||||
the DOM element you passed into the plot function. The event handler gets a
|
||||
parameter with the ranges selected on the axes, like this:
|
||||
|
||||
placeholder.bind( "plotselected", function( event, ranges ) {
|
||||
alert("You selected " + ranges.xaxis.from + " to " + ranges.xaxis.to)
|
||||
// similar for yaxis - with multiple axes, the extra ones are in
|
||||
// x2axis, x3axis, ...
|
||||
});
|
||||
|
||||
The "plotselected" event is only fired when the user has finished making the
|
||||
selection. A "plotselecting" event is fired during the process with the same
|
||||
parameters as the "plotselected" event, in case you want to know what's
|
||||
happening while it's happening,
|
||||
|
||||
A "plotunselected" event with no arguments is emitted when the user clicks the
|
||||
mouse to remove the selection. As stated above, setting "minSize" to 0 will
|
||||
destroy this behavior.
|
||||
|
||||
The plugin allso adds the following methods to the plot object:
|
||||
|
||||
- setSelection( ranges, preventEvent )
|
||||
|
||||
Set the selection rectangle. The passed in ranges is on the same form as
|
||||
returned in the "plotselected" event. If the selection mode is "x", you
|
||||
should put in either an xaxis range, if the mode is "y" you need to put in
|
||||
an yaxis range and both xaxis and yaxis if the selection mode is "xy", like
|
||||
this:
|
||||
|
||||
setSelection({ xaxis: { from: 0, to: 10 }, yaxis: { from: 40, to: 60 } });
|
||||
|
||||
setSelection will trigger the "plotselected" event when called. If you don't
|
||||
want that to happen, e.g. if you're inside a "plotselected" handler, pass
|
||||
true as the second parameter. If you are using multiple axes, you can
|
||||
specify the ranges on any of those, e.g. as x2axis/x3axis/... instead of
|
||||
xaxis, the plugin picks the first one it sees.
|
||||
|
||||
- clearSelection( preventEvent )
|
||||
|
||||
Clear the selection rectangle. Pass in true to avoid getting a
|
||||
"plotunselected" event.
|
||||
|
||||
- getSelection()
|
||||
|
||||
Returns the current selection in the same format as the "plotselected"
|
||||
event. If there's currently no selection, the function returns null.
|
||||
|
||||
*/
|
||||
|
||||
(function ($) {
|
||||
function init(plot) {
|
||||
var selection = {
|
||||
first: { x: -1, y: -1}, second: { x: -1, y: -1},
|
||||
show: false,
|
||||
active: false
|
||||
};
|
||||
|
||||
// FIXME: The drag handling implemented here should be
|
||||
// abstracted out, there's some similar code from a library in
|
||||
// the navigation plugin, this should be massaged a bit to fit
|
||||
// the Flot cases here better and reused. Doing this would
|
||||
// make this plugin much slimmer.
|
||||
var savedhandlers = {};
|
||||
|
||||
var mouseUpHandler = null;
|
||||
|
||||
function onMouseMove(e) {
|
||||
if (selection.active) {
|
||||
updateSelection(e);
|
||||
|
||||
plot.getPlaceholder().trigger("plotselecting", [ getSelection() ]);
|
||||
}
|
||||
}
|
||||
|
||||
function onMouseDown(e) {
|
||||
if (e.which != 1) // only accept left-click
|
||||
return;
|
||||
|
||||
// cancel out any text selections
|
||||
document.body.focus();
|
||||
|
||||
// prevent text selection and drag in old-school browsers
|
||||
if (document.onselectstart !== undefined && savedhandlers.onselectstart == null) {
|
||||
savedhandlers.onselectstart = document.onselectstart;
|
||||
document.onselectstart = function () { return false; };
|
||||
}
|
||||
if (document.ondrag !== undefined && savedhandlers.ondrag == null) {
|
||||
savedhandlers.ondrag = document.ondrag;
|
||||
document.ondrag = function () { return false; };
|
||||
}
|
||||
|
||||
setSelectionPos(selection.first, e);
|
||||
|
||||
selection.active = true;
|
||||
|
||||
// this is a bit silly, but we have to use a closure to be
|
||||
// able to whack the same handler again
|
||||
mouseUpHandler = function (e) { onMouseUp(e); };
|
||||
|
||||
$(document).one("mouseup", mouseUpHandler);
|
||||
}
|
||||
|
||||
function onMouseUp(e) {
|
||||
mouseUpHandler = null;
|
||||
|
||||
// revert drag stuff for old-school browsers
|
||||
if (document.onselectstart !== undefined)
|
||||
document.onselectstart = savedhandlers.onselectstart;
|
||||
if (document.ondrag !== undefined)
|
||||
document.ondrag = savedhandlers.ondrag;
|
||||
|
||||
// no more dragging
|
||||
selection.active = false;
|
||||
updateSelection(e);
|
||||
|
||||
if (selectionIsSane())
|
||||
triggerSelectedEvent();
|
||||
else {
|
||||
// this counts as a clear
|
||||
plot.getPlaceholder().trigger("plotunselected", [ ]);
|
||||
plot.getPlaceholder().trigger("plotselecting", [ null ]);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function getSelection() {
|
||||
if (!selectionIsSane())
|
||||
return null;
|
||||
|
||||
if (!selection.show) return null;
|
||||
|
||||
var r = {}, c1 = selection.first, c2 = selection.second;
|
||||
$.each(plot.getAxes(), function (name, axis) {
|
||||
if (axis.used) {
|
||||
var p1 = axis.c2p(c1[axis.direction]), p2 = axis.c2p(c2[axis.direction]);
|
||||
r[name] = { from: Math.min(p1, p2), to: Math.max(p1, p2) };
|
||||
}
|
||||
});
|
||||
return r;
|
||||
}
|
||||
|
||||
function triggerSelectedEvent() {
|
||||
var r = getSelection();
|
||||
|
||||
plot.getPlaceholder().trigger("plotselected", [ r ]);
|
||||
|
||||
// backwards-compat stuff, to be removed in future
|
||||
if (r.xaxis && r.yaxis)
|
||||
plot.getPlaceholder().trigger("selected", [ { x1: r.xaxis.from, y1: r.yaxis.from, x2: r.xaxis.to, y2: r.yaxis.to } ]);
|
||||
}
|
||||
|
||||
function clamp(min, value, max) {
|
||||
return value < min ? min: (value > max ? max: value);
|
||||
}
|
||||
|
||||
function setSelectionPos(pos, e) {
|
||||
var o = plot.getOptions();
|
||||
var offset = plot.getPlaceholder().offset();
|
||||
var plotOffset = plot.getPlotOffset();
|
||||
pos.x = clamp(0, e.pageX - offset.left - plotOffset.left, plot.width());
|
||||
pos.y = clamp(0, e.pageY - offset.top - plotOffset.top, plot.height());
|
||||
|
||||
if (o.selection.mode == "y")
|
||||
pos.x = pos == selection.first ? 0 : plot.width();
|
||||
|
||||
if (o.selection.mode == "x")
|
||||
pos.y = pos == selection.first ? 0 : plot.height();
|
||||
}
|
||||
|
||||
function updateSelection(pos) {
|
||||
if (pos.pageX == null)
|
||||
return;
|
||||
|
||||
setSelectionPos(selection.second, pos);
|
||||
if (selectionIsSane()) {
|
||||
selection.show = true;
|
||||
plot.triggerRedrawOverlay();
|
||||
}
|
||||
else
|
||||
clearSelection(true);
|
||||
}
|
||||
|
||||
function clearSelection(preventEvent) {
|
||||
if (selection.show) {
|
||||
selection.show = false;
|
||||
plot.triggerRedrawOverlay();
|
||||
if (!preventEvent)
|
||||
plot.getPlaceholder().trigger("plotunselected", [ ]);
|
||||
}
|
||||
}
|
||||
|
||||
// function taken from markings support in Flot
|
||||
function extractRange(ranges, coord) {
|
||||
var axis, from, to, key, axes = plot.getAxes();
|
||||
|
||||
for (var k in axes) {
|
||||
axis = axes[k];
|
||||
if (axis.direction == coord) {
|
||||
key = coord + axis.n + "axis";
|
||||
if (!ranges[key] && axis.n == 1)
|
||||
key = coord + "axis"; // support x1axis as xaxis
|
||||
if (ranges[key]) {
|
||||
from = ranges[key].from;
|
||||
to = ranges[key].to;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// backwards-compat stuff - to be removed in future
|
||||
if (!ranges[key]) {
|
||||
axis = coord == "x" ? plot.getXAxes()[0] : plot.getYAxes()[0];
|
||||
from = ranges[coord + "1"];
|
||||
to = ranges[coord + "2"];
|
||||
}
|
||||
|
||||
// auto-reverse as an added bonus
|
||||
if (from != null && to != null && from > to) {
|
||||
var tmp = from;
|
||||
from = to;
|
||||
to = tmp;
|
||||
}
|
||||
|
||||
return { from: from, to: to, axis: axis };
|
||||
}
|
||||
|
||||
function setSelection(ranges, preventEvent) {
|
||||
var axis, range, o = plot.getOptions();
|
||||
|
||||
if (o.selection.mode == "y") {
|
||||
selection.first.x = 0;
|
||||
selection.second.x = plot.width();
|
||||
}
|
||||
else {
|
||||
range = extractRange(ranges, "x");
|
||||
|
||||
selection.first.x = range.axis.p2c(range.from);
|
||||
selection.second.x = range.axis.p2c(range.to);
|
||||
}
|
||||
|
||||
if (o.selection.mode == "x") {
|
||||
selection.first.y = 0;
|
||||
selection.second.y = plot.height();
|
||||
}
|
||||
else {
|
||||
range = extractRange(ranges, "y");
|
||||
|
||||
selection.first.y = range.axis.p2c(range.from);
|
||||
selection.second.y = range.axis.p2c(range.to);
|
||||
}
|
||||
|
||||
selection.show = true;
|
||||
plot.triggerRedrawOverlay();
|
||||
if (!preventEvent && selectionIsSane())
|
||||
triggerSelectedEvent();
|
||||
}
|
||||
|
||||
function selectionIsSane() {
|
||||
var minSize = plot.getOptions().selection.minSize;
|
||||
return Math.abs(selection.second.x - selection.first.x) >= minSize &&
|
||||
Math.abs(selection.second.y - selection.first.y) >= minSize;
|
||||
}
|
||||
|
||||
plot.clearSelection = clearSelection;
|
||||
plot.setSelection = setSelection;
|
||||
plot.getSelection = getSelection;
|
||||
|
||||
plot.hooks.bindEvents.push(function(plot, eventHolder) {
|
||||
var o = plot.getOptions();
|
||||
if (o.selection.mode != null) {
|
||||
eventHolder.mousemove(onMouseMove);
|
||||
eventHolder.mousedown(onMouseDown);
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
plot.hooks.drawOverlay.push(function (plot, ctx) {
|
||||
// draw selection
|
||||
if (selection.show && selectionIsSane()) {
|
||||
var plotOffset = plot.getPlotOffset();
|
||||
var o = plot.getOptions();
|
||||
|
||||
ctx.save();
|
||||
ctx.translate(plotOffset.left, plotOffset.top);
|
||||
|
||||
var c = $.color.parse(o.selection.color);
|
||||
|
||||
ctx.strokeStyle = c.scale('a', 0.8).toString();
|
||||
ctx.lineWidth = 1;
|
||||
ctx.lineJoin = o.selection.shape;
|
||||
ctx.fillStyle = c.scale('a', 0.4).toString();
|
||||
|
||||
var x = Math.min(selection.first.x, selection.second.x) + 0.5,
|
||||
y = Math.min(selection.first.y, selection.second.y) + 0.5,
|
||||
w = Math.abs(selection.second.x - selection.first.x) - 1,
|
||||
h = Math.abs(selection.second.y - selection.first.y) - 1;
|
||||
|
||||
ctx.fillRect(x, y, w, h);
|
||||
ctx.strokeRect(x, y, w, h);
|
||||
|
||||
ctx.restore();
|
||||
}
|
||||
});
|
||||
|
||||
plot.hooks.shutdown.push(function (plot, eventHolder) {
|
||||
eventHolder.unbind("mousemove", onMouseMove);
|
||||
eventHolder.unbind("mousedown", onMouseDown);
|
||||
|
||||
if (mouseUpHandler)
|
||||
$(document).unbind("mouseup", mouseUpHandler);
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: {
|
||||
selection: {
|
||||
mode: null, // one of null, "x", "y" or "xy"
|
||||
color: "#e8cfac",
|
||||
shape: "round", // one of "round", "miter", or "bevel"
|
||||
minSize: 5 // minimum number of pixels
|
||||
}
|
||||
},
|
||||
name: 'selection',
|
||||
version: '1.1'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,79 +0,0 @@
|
||||
/* Flot plugin for selecting regions of a plot.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
selection: {
|
||||
mode: null or "x" or "y" or "xy",
|
||||
color: color,
|
||||
shape: "round" or "miter" or "bevel",
|
||||
minSize: number of pixels
|
||||
}
|
||||
|
||||
Selection support is enabled by setting the mode to one of "x", "y" or "xy".
|
||||
In "x" mode, the user will only be able to specify the x range, similarly for
|
||||
"y" mode. For "xy", the selection becomes a rectangle where both ranges can be
|
||||
specified. "color" is color of the selection (if you need to change the color
|
||||
later on, you can get to it with plot.getOptions().selection.color). "shape"
|
||||
is the shape of the corners of the selection.
|
||||
|
||||
"minSize" is the minimum size a selection can be in pixels. This value can
|
||||
be customized to determine the smallest size a selection can be and still
|
||||
have the selection rectangle be displayed. When customizing this value, the
|
||||
fact that it refers to pixels, not axis units must be taken into account.
|
||||
Thus, for example, if there is a bar graph in time mode with BarWidth set to 1
|
||||
minute, setting "minSize" to 1 will not make the minimum selection size 1
|
||||
minute, but rather 1 pixel. Note also that setting "minSize" to 0 will prevent
|
||||
"plotunselected" events from being fired when the user clicks the mouse without
|
||||
dragging.
|
||||
|
||||
When selection support is enabled, a "plotselected" event will be emitted on
|
||||
the DOM element you passed into the plot function. The event handler gets a
|
||||
parameter with the ranges selected on the axes, like this:
|
||||
|
||||
placeholder.bind( "plotselected", function( event, ranges ) {
|
||||
alert("You selected " + ranges.xaxis.from + " to " + ranges.xaxis.to)
|
||||
// similar for yaxis - with multiple axes, the extra ones are in
|
||||
// x2axis, x3axis, ...
|
||||
});
|
||||
|
||||
The "plotselected" event is only fired when the user has finished making the
|
||||
selection. A "plotselecting" event is fired during the process with the same
|
||||
parameters as the "plotselected" event, in case you want to know what's
|
||||
happening while it's happening,
|
||||
|
||||
A "plotunselected" event with no arguments is emitted when the user clicks the
|
||||
mouse to remove the selection. As stated above, setting "minSize" to 0 will
|
||||
destroy this behavior.
|
||||
|
||||
The plugin allso adds the following methods to the plot object:
|
||||
|
||||
- setSelection( ranges, preventEvent )
|
||||
|
||||
Set the selection rectangle. The passed in ranges is on the same form as
|
||||
returned in the "plotselected" event. If the selection mode is "x", you
|
||||
should put in either an xaxis range, if the mode is "y" you need to put in
|
||||
an yaxis range and both xaxis and yaxis if the selection mode is "xy", like
|
||||
this:
|
||||
|
||||
setSelection({ xaxis: { from: 0, to: 10 }, yaxis: { from: 40, to: 60 } });
|
||||
|
||||
setSelection will trigger the "plotselected" event when called. If you don't
|
||||
want that to happen, e.g. if you're inside a "plotselected" handler, pass
|
||||
true as the second parameter. If you are using multiple axes, you can
|
||||
specify the ranges on any of those, e.g. as x2axis/x3axis/... instead of
|
||||
xaxis, the plugin picks the first one it sees.
|
||||
|
||||
- clearSelection( preventEvent )
|
||||
|
||||
Clear the selection rectangle. Pass in true to avoid getting a
|
||||
"plotunselected" event.
|
||||
|
||||
- getSelection()
|
||||
|
||||
Returns the current selection in the same format as the "plotselected"
|
||||
event. If there's currently no selection, the function returns null.
|
||||
|
||||
*/(function(e){function t(t){function s(e){n.active&&(h(e),t.getPlaceholder().trigger("plotselecting",[a()]))}function o(t){if(t.which!=1)return;document.body.focus(),document.onselectstart!==undefined&&r.onselectstart==null&&(r.onselectstart=document.onselectstart,document.onselectstart=function(){return!1}),document.ondrag!==undefined&&r.ondrag==null&&(r.ondrag=document.ondrag,document.ondrag=function(){return!1}),c(n.first,t),n.active=!0,i=function(e){u(e)},e(document).one("mouseup",i)}function u(e){return i=null,document.onselectstart!==undefined&&(document.onselectstart=r.onselectstart),document.ondrag!==undefined&&(document.ondrag=r.ondrag),n.active=!1,h(e),m()?f():(t.getPlaceholder().trigger("plotunselected",[]),t.getPlaceholder().trigger("plotselecting",[null])),!1}function a(){if(!m())return null;if(!n.show)return null;var r={},i=n.first,s=n.second;return e.each(t.getAxes(),function(e,t){if(t.used){var n=t.c2p(i[t.direction]),o=t.c2p(s[t.direction]);r[e]={from:Math.min(n,o),to:Math.max(n,o)}}}),r}function f(){var e=a();t.getPlaceholder().trigger("plotselected",[e]),e.xaxis&&e.yaxis&&t.getPlaceholder().trigger("selected",[{x1:e.xaxis.from,y1:e.yaxis.from,x2:e.xaxis.to,y2:e.yaxis.to}])}function l(e,t,n){return t<e?e:t>n?n:t}function c(e,r){var i=t.getOptions(),s=t.getPlaceholder().offset(),o=t.getPlotOffset();e.x=l(0,r.pageX-s.left-o.left,t.width()),e.y=l(0,r.pageY-s.top-o.top,t.height()),i.selection.mode=="y"&&(e.x=e==n.first?0:t.width()),i.selection.mode=="x"&&(e.y=e==n.first?0:t.height())}function h(e){if(e.pageX==null)return;c(n.second,e),m()?(n.show=!0,t.triggerRedrawOverlay()):p(!0)}function p(e){n.show&&(n.show=!1,t.triggerRedrawOverlay(),e||t.getPlaceholder().trigger("plotunselected",[]))}function d(e,n){var r,i,s,o,u=t.getAxes();for(var a in u){r=u[a];if(r.direction==n){o=n+r.n+"axis",!e[o]&&r.n==1&&(o=n+"axis");if(e[o]){i=e[o].from,s=e[o].to;break}}}e[o]||(r=n=="x"?t.getXAxes()[0]:t.getYAxes()[0],i=e[n+"1"],s=e[n+"2"]);if(i!=null&&s!=null&&i>s){var f=i;i=s,s=f}return{from:i,to:s,axis:r}}function v(e,r){var i,s,o=t.getOptions();o.selection.mode=="y"?(n.first.x=0,n.second.x=t.width()):(s=d(e,"x"),n.first.x=s.axis.p2c(s.from),n.second.x=s.axis.p2c(s.to)),o.selection.mode=="x"?(n.first.y=0,n.second.y=t.height()):(s=d(e,"y"),n.first.y=s.axis.p2c(s.from),n.second.y=s.axis.p2c(s.to)),n.show=!0,t.triggerRedrawOverlay(),!r&&m()&&f()}function m(){var e=t.getOptions().selection.minSize;return Math.abs(n.second.x-n.first.x)>=e&&Math.abs(n.second.y-n.first.y)>=e}var n={first:{x:-1,y:-1},second:{x:-1,y:-1},show:!1,active:!1},r={},i=null;t.clearSelection=p,t.setSelection=v,t.getSelection=a,t.hooks.bindEvents.push(function(e,t){var n=e.getOptions();n.selection.mode!=null&&(t.mousemove(s),t.mousedown(o))}),t.hooks.drawOverlay.push(function(t,r){if(n.show&&m()){var i=t.getPlotOffset(),s=t.getOptions();r.save(),r.translate(i.left,i.top);var o=e.color.parse(s.selection.color);r.strokeStyle=o.scale("a",.8).toString(),r.lineWidth=1,r.lineJoin=s.selection.shape,r.fillStyle=o.scale("a",.4).toString();var u=Math.min(n.first.x,n.second.x)+.5,a=Math.min(n.first.y,n.second.y)+.5,f=Math.abs(n.second.x-n.first.x)-1,l=Math.abs(n.second.y-n.first.y)-1;r.fillRect(u,a,f,l),r.strokeRect(u,a,f,l),r.restore()}}),t.hooks.shutdown.push(function(t,n){n.unbind("mousemove",s),n.unbind("mousedown",o),i&&e(document).unbind("mouseup",i)})}e.plot.plugins.push({init:t,options:{selection:{mode:null,color:"#e8cfac",shape:"round",minSize:5}},name:"selection",version:"1.1"})})(jQuery);
|
||||
@ -1,188 +0,0 @@
|
||||
/* Flot plugin for stacking data sets rather than overlyaing them.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin assumes the data is sorted on x (or y if stacking horizontally).
|
||||
For line charts, it is assumed that if a line has an undefined gap (from a
|
||||
null point), then the line above it should have the same gap - insert zeros
|
||||
instead of "null" if you want another behaviour. This also holds for the start
|
||||
and end of the chart. Note that stacking a mix of positive and negative values
|
||||
in most instances doesn't make sense (so it looks weird).
|
||||
|
||||
Two or more series are stacked when their "stack" attribute is set to the same
|
||||
key (which can be any number or string or just "true"). To specify the default
|
||||
stack, you can set the stack option like this:
|
||||
|
||||
series: {
|
||||
stack: null/false, true, or a key (number/string)
|
||||
}
|
||||
|
||||
You can also specify it for a single series, like this:
|
||||
|
||||
$.plot( $("#placeholder"), [{
|
||||
data: [ ... ],
|
||||
stack: true
|
||||
}])
|
||||
|
||||
The stacking order is determined by the order of the data series in the array
|
||||
(later series end up on top of the previous).
|
||||
|
||||
Internally, the plugin modifies the datapoints in each series, adding an
|
||||
offset to the y value. For line series, extra data points are inserted through
|
||||
interpolation. If there's a second y value, it's also adjusted (e.g for bar
|
||||
charts or filled areas).
|
||||
|
||||
*/
|
||||
|
||||
(function ($) {
|
||||
var options = {
|
||||
series: { stack: null } // or number/string
|
||||
};
|
||||
|
||||
function init(plot) {
|
||||
function findMatchingSeries(s, allseries) {
|
||||
var res = null;
|
||||
for (var i = 0; i < allseries.length; ++i) {
|
||||
if (s == allseries[i])
|
||||
break;
|
||||
|
||||
if (allseries[i].stack == s.stack)
|
||||
res = allseries[i];
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
function stackData(plot, s, datapoints) {
|
||||
if (s.stack == null || s.stack === false)
|
||||
return;
|
||||
|
||||
var other = findMatchingSeries(s, plot.getData());
|
||||
if (!other)
|
||||
return;
|
||||
|
||||
var ps = datapoints.pointsize,
|
||||
points = datapoints.points,
|
||||
otherps = other.datapoints.pointsize,
|
||||
otherpoints = other.datapoints.points,
|
||||
newpoints = [],
|
||||
px, py, intery, qx, qy, bottom,
|
||||
withlines = s.lines.show,
|
||||
horizontal = s.bars.horizontal,
|
||||
withbottom = ps > 2 && (horizontal ? datapoints.format[2].x : datapoints.format[2].y),
|
||||
withsteps = withlines && s.lines.steps,
|
||||
fromgap = true,
|
||||
keyOffset = horizontal ? 1 : 0,
|
||||
accumulateOffset = horizontal ? 0 : 1,
|
||||
i = 0, j = 0, l, m;
|
||||
|
||||
while (true) {
|
||||
if (i >= points.length)
|
||||
break;
|
||||
|
||||
l = newpoints.length;
|
||||
|
||||
if (points[i] == null) {
|
||||
// copy gaps
|
||||
for (m = 0; m < ps; ++m)
|
||||
newpoints.push(points[i + m]);
|
||||
i += ps;
|
||||
}
|
||||
else if (j >= otherpoints.length) {
|
||||
// for lines, we can't use the rest of the points
|
||||
if (!withlines) {
|
||||
for (m = 0; m < ps; ++m)
|
||||
newpoints.push(points[i + m]);
|
||||
}
|
||||
i += ps;
|
||||
}
|
||||
else if (otherpoints[j] == null) {
|
||||
// oops, got a gap
|
||||
for (m = 0; m < ps; ++m)
|
||||
newpoints.push(null);
|
||||
fromgap = true;
|
||||
j += otherps;
|
||||
}
|
||||
else {
|
||||
// cases where we actually got two points
|
||||
px = points[i + keyOffset];
|
||||
py = points[i + accumulateOffset];
|
||||
qx = otherpoints[j + keyOffset];
|
||||
qy = otherpoints[j + accumulateOffset];
|
||||
bottom = 0;
|
||||
|
||||
if (px == qx) {
|
||||
for (m = 0; m < ps; ++m)
|
||||
newpoints.push(points[i + m]);
|
||||
|
||||
newpoints[l + accumulateOffset] += qy;
|
||||
bottom = qy;
|
||||
|
||||
i += ps;
|
||||
j += otherps;
|
||||
}
|
||||
else if (px > qx) {
|
||||
// we got past point below, might need to
|
||||
// insert interpolated extra point
|
||||
if (withlines && i > 0 && points[i - ps] != null) {
|
||||
intery = py + (points[i - ps + accumulateOffset] - py) * (qx - px) / (points[i - ps + keyOffset] - px);
|
||||
newpoints.push(qx);
|
||||
newpoints.push(intery + qy);
|
||||
for (m = 2; m < ps; ++m)
|
||||
newpoints.push(points[i + m]);
|
||||
bottom = qy;
|
||||
}
|
||||
|
||||
j += otherps;
|
||||
}
|
||||
else { // px < qx
|
||||
if (fromgap && withlines) {
|
||||
// if we come from a gap, we just skip this point
|
||||
i += ps;
|
||||
continue;
|
||||
}
|
||||
|
||||
for (m = 0; m < ps; ++m)
|
||||
newpoints.push(points[i + m]);
|
||||
|
||||
// we might be able to interpolate a point below,
|
||||
// this can give us a better y
|
||||
if (withlines && j > 0 && otherpoints[j - otherps] != null)
|
||||
bottom = qy + (otherpoints[j - otherps + accumulateOffset] - qy) * (px - qx) / (otherpoints[j - otherps + keyOffset] - qx);
|
||||
|
||||
newpoints[l + accumulateOffset] += bottom;
|
||||
|
||||
i += ps;
|
||||
}
|
||||
|
||||
fromgap = false;
|
||||
|
||||
if (l != newpoints.length && withbottom)
|
||||
newpoints[l + 2] += bottom;
|
||||
}
|
||||
|
||||
// maintain the line steps invariant
|
||||
if (withsteps && l != newpoints.length && l > 0
|
||||
&& newpoints[l] != null
|
||||
&& newpoints[l] != newpoints[l - ps]
|
||||
&& newpoints[l + 1] != newpoints[l - ps + 1]) {
|
||||
for (m = 0; m < ps; ++m)
|
||||
newpoints[l + ps + m] = newpoints[l + m];
|
||||
newpoints[l + 1] = newpoints[l - ps + 1];
|
||||
}
|
||||
}
|
||||
|
||||
datapoints.points = newpoints;
|
||||
}
|
||||
|
||||
plot.hooks.processDatapoints.push(stackData);
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'stack',
|
||||
version: '1.2'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,36 +0,0 @@
|
||||
/* Flot plugin for stacking data sets rather than overlyaing them.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin assumes the data is sorted on x (or y if stacking horizontally).
|
||||
For line charts, it is assumed that if a line has an undefined gap (from a
|
||||
null point), then the line above it should have the same gap - insert zeros
|
||||
instead of "null" if you want another behaviour. This also holds for the start
|
||||
and end of the chart. Note that stacking a mix of positive and negative values
|
||||
in most instances doesn't make sense (so it looks weird).
|
||||
|
||||
Two or more series are stacked when their "stack" attribute is set to the same
|
||||
key (which can be any number or string or just "true"). To specify the default
|
||||
stack, you can set the stack option like this:
|
||||
|
||||
series: {
|
||||
stack: null/false, true, or a key (number/string)
|
||||
}
|
||||
|
||||
You can also specify it for a single series, like this:
|
||||
|
||||
$.plot( $("#placeholder"), [{
|
||||
data: [ ... ],
|
||||
stack: true
|
||||
}])
|
||||
|
||||
The stacking order is determined by the order of the data series in the array
|
||||
(later series end up on top of the previous).
|
||||
|
||||
Internally, the plugin modifies the datapoints in each series, adding an
|
||||
offset to the y value. For line series, extra data points are inserted through
|
||||
interpolation. If there's a second y value, it's also adjusted (e.g for bar
|
||||
charts or filled areas).
|
||||
|
||||
*/(function(e){function n(e){function t(e,t){var n=null;for(var r=0;r<t.length;++r){if(e==t[r])break;t[r].stack==e.stack&&(n=t[r])}return n}function n(e,n,r){if(n.stack==null||n.stack===!1)return;var i=t(n,e.getData());if(!i)return;var s=r.pointsize,o=r.points,u=i.datapoints.pointsize,a=i.datapoints.points,f=[],l,c,h,p,d,v,m=n.lines.show,g=n.bars.horizontal,y=s>2&&(g?r.format[2].x:r.format[2].y),b=m&&n.lines.steps,w=!0,E=g?1:0,S=g?0:1,x=0,T=0,N,C;for(;;){if(x>=o.length)break;N=f.length;if(o[x]==null){for(C=0;C<s;++C)f.push(o[x+C]);x+=s}else if(T>=a.length){if(!m)for(C=0;C<s;++C)f.push(o[x+C]);x+=s}else if(a[T]==null){for(C=0;C<s;++C)f.push(null);w=!0,T+=u}else{l=o[x+E],c=o[x+S],p=a[T+E],d=a[T+S],v=0;if(l==p){for(C=0;C<s;++C)f.push(o[x+C]);f[N+S]+=d,v=d,x+=s,T+=u}else if(l>p){if(m&&x>0&&o[x-s]!=null){h=c+(o[x-s+S]-c)*(p-l)/(o[x-s+E]-l),f.push(p),f.push(h+d);for(C=2;C<s;++C)f.push(o[x+C]);v=d}T+=u}else{if(w&&m){x+=s;continue}for(C=0;C<s;++C)f.push(o[x+C]);m&&T>0&&a[T-u]!=null&&(v=d+(a[T-u+S]-d)*(l-p)/(a[T-u+E]-p)),f[N+S]+=v,x+=s}w=!1,N!=f.length&&y&&(f[N+2]+=v)}if(b&&N!=f.length&&N>0&&f[N]!=null&&f[N]!=f[N-s]&&f[N+1]!=f[N-s+1]){for(C=0;C<s;++C)f[N+s+C]=f[N+C];f[N+1]=f[N-s+1]}}r.points=f}e.hooks.processDatapoints.push(n)}var t={series:{stack:null}};e.plot.plugins.push({init:n,options:t,name:"stack",version:"1.2"})})(jQuery);
|
||||
@ -1,71 +0,0 @@
|
||||
/* Flot plugin that adds some extra symbols for plotting points.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The symbols are accessed as strings through the standard symbol options:
|
||||
|
||||
series: {
|
||||
points: {
|
||||
symbol: "square" // or "diamond", "triangle", "cross"
|
||||
}
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
(function ($) {
|
||||
function processRawData(plot, series, datapoints) {
|
||||
// we normalize the area of each symbol so it is approximately the
|
||||
// same as a circle of the given radius
|
||||
|
||||
var handlers = {
|
||||
square: function (ctx, x, y, radius, shadow) {
|
||||
// pi * r^2 = (2s)^2 => s = r * sqrt(pi)/2
|
||||
var size = radius * Math.sqrt(Math.PI) / 2;
|
||||
ctx.rect(x - size, y - size, size + size, size + size);
|
||||
},
|
||||
diamond: function (ctx, x, y, radius, shadow) {
|
||||
// pi * r^2 = 2s^2 => s = r * sqrt(pi/2)
|
||||
var size = radius * Math.sqrt(Math.PI / 2);
|
||||
ctx.moveTo(x - size, y);
|
||||
ctx.lineTo(x, y - size);
|
||||
ctx.lineTo(x + size, y);
|
||||
ctx.lineTo(x, y + size);
|
||||
ctx.lineTo(x - size, y);
|
||||
},
|
||||
triangle: function (ctx, x, y, radius, shadow) {
|
||||
// pi * r^2 = 1/2 * s^2 * sin (pi / 3) => s = r * sqrt(2 * pi / sin(pi / 3))
|
||||
var size = radius * Math.sqrt(2 * Math.PI / Math.sin(Math.PI / 3));
|
||||
var height = size * Math.sin(Math.PI / 3);
|
||||
ctx.moveTo(x - size/2, y + height/2);
|
||||
ctx.lineTo(x + size/2, y + height/2);
|
||||
if (!shadow) {
|
||||
ctx.lineTo(x, y - height/2);
|
||||
ctx.lineTo(x - size/2, y + height/2);
|
||||
}
|
||||
},
|
||||
cross: function (ctx, x, y, radius, shadow) {
|
||||
// pi * r^2 = (2s)^2 => s = r * sqrt(pi)/2
|
||||
var size = radius * Math.sqrt(Math.PI) / 2;
|
||||
ctx.moveTo(x - size, y - size);
|
||||
ctx.lineTo(x + size, y + size);
|
||||
ctx.moveTo(x - size, y + size);
|
||||
ctx.lineTo(x + size, y - size);
|
||||
}
|
||||
};
|
||||
|
||||
var s = series.points.symbol;
|
||||
if (handlers[s])
|
||||
series.points.symbol = handlers[s];
|
||||
}
|
||||
|
||||
function init(plot) {
|
||||
plot.hooks.processDatapoints.push(processRawData);
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
name: 'symbols',
|
||||
version: '1.0'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,14 +0,0 @@
|
||||
/* Flot plugin that adds some extra symbols for plotting points.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The symbols are accessed as strings through the standard symbol options:
|
||||
|
||||
series: {
|
||||
points: {
|
||||
symbol: "square" // or "diamond", "triangle", "cross"
|
||||
}
|
||||
}
|
||||
|
||||
*/(function(e){function t(e,t,n){var r={square:function(e,t,n,r,i){var s=r*Math.sqrt(Math.PI)/2;e.rect(t-s,n-s,s+s,s+s)},diamond:function(e,t,n,r,i){var s=r*Math.sqrt(Math.PI/2);e.moveTo(t-s,n),e.lineTo(t,n-s),e.lineTo(t+s,n),e.lineTo(t,n+s),e.lineTo(t-s,n)},triangle:function(e,t,n,r,i){var s=r*Math.sqrt(2*Math.PI/Math.sin(Math.PI/3)),o=s*Math.sin(Math.PI/3);e.moveTo(t-s/2,n+o/2),e.lineTo(t+s/2,n+o/2),i||(e.lineTo(t,n-o/2),e.lineTo(t-s/2,n+o/2))},cross:function(e,t,n,r,i){var s=r*Math.sqrt(Math.PI)/2;e.moveTo(t-s,n-s),e.lineTo(t+s,n+s),e.moveTo(t-s,n+s),e.lineTo(t+s,n-s)}},i=t.points.symbol;r[i]&&(t.points.symbol=r[i])}function n(e){e.hooks.processDatapoints.push(t)}e.plot.plugins.push({init:n,name:"symbols",version:"1.0"})})(jQuery);
|
||||
@ -1,142 +0,0 @@
|
||||
/* Flot plugin for thresholding data.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
series: {
|
||||
threshold: {
|
||||
below: number
|
||||
color: colorspec
|
||||
}
|
||||
}
|
||||
|
||||
It can also be applied to a single series, like this:
|
||||
|
||||
$.plot( $("#placeholder"), [{
|
||||
data: [ ... ],
|
||||
threshold: { ... }
|
||||
}])
|
||||
|
||||
An array can be passed for multiple thresholding, like this:
|
||||
|
||||
threshold: [{
|
||||
below: number1
|
||||
color: color1
|
||||
},{
|
||||
below: number2
|
||||
color: color2
|
||||
}]
|
||||
|
||||
These multiple threshold objects can be passed in any order since they are
|
||||
sorted by the processing function.
|
||||
|
||||
The data points below "below" are drawn with the specified color. This makes
|
||||
it easy to mark points below 0, e.g. for budget data.
|
||||
|
||||
Internally, the plugin works by splitting the data into two series, above and
|
||||
below the threshold. The extra series below the threshold will have its label
|
||||
cleared and the special "originSeries" attribute set to the original series.
|
||||
You may need to check for this in hover events.
|
||||
|
||||
*/
|
||||
|
||||
(function ($) {
|
||||
var options = {
|
||||
series: { threshold: null } // or { below: number, color: color spec}
|
||||
};
|
||||
|
||||
function init(plot) {
|
||||
function thresholdData(plot, s, datapoints, below, color) {
|
||||
var ps = datapoints.pointsize, i, x, y, p, prevp,
|
||||
thresholded = $.extend({}, s); // note: shallow copy
|
||||
|
||||
thresholded.datapoints = { points: [], pointsize: ps, format: datapoints.format };
|
||||
thresholded.label = null;
|
||||
thresholded.color = color;
|
||||
thresholded.threshold = null;
|
||||
thresholded.originSeries = s;
|
||||
thresholded.data = [];
|
||||
|
||||
var origpoints = datapoints.points,
|
||||
addCrossingPoints = s.lines.show;
|
||||
|
||||
var threspoints = [];
|
||||
var newpoints = [];
|
||||
var m;
|
||||
|
||||
for (i = 0; i < origpoints.length; i += ps) {
|
||||
x = origpoints[i];
|
||||
y = origpoints[i + 1];
|
||||
|
||||
prevp = p;
|
||||
if (y < below)
|
||||
p = threspoints;
|
||||
else
|
||||
p = newpoints;
|
||||
|
||||
if (addCrossingPoints && prevp != p && x != null
|
||||
&& i > 0 && origpoints[i - ps] != null) {
|
||||
var interx = x + (below - y) * (x - origpoints[i - ps]) / (y - origpoints[i - ps + 1]);
|
||||
prevp.push(interx);
|
||||
prevp.push(below);
|
||||
for (m = 2; m < ps; ++m)
|
||||
prevp.push(origpoints[i + m]);
|
||||
|
||||
p.push(null); // start new segment
|
||||
p.push(null);
|
||||
for (m = 2; m < ps; ++m)
|
||||
p.push(origpoints[i + m]);
|
||||
p.push(interx);
|
||||
p.push(below);
|
||||
for (m = 2; m < ps; ++m)
|
||||
p.push(origpoints[i + m]);
|
||||
}
|
||||
|
||||
p.push(x);
|
||||
p.push(y);
|
||||
for (m = 2; m < ps; ++m)
|
||||
p.push(origpoints[i + m]);
|
||||
}
|
||||
|
||||
datapoints.points = newpoints;
|
||||
thresholded.datapoints.points = threspoints;
|
||||
|
||||
if (thresholded.datapoints.points.length > 0) {
|
||||
var origIndex = $.inArray(s, plot.getData());
|
||||
// Insert newly-generated series right after original one (to prevent it from becoming top-most)
|
||||
plot.getData().splice(origIndex + 1, 0, thresholded);
|
||||
}
|
||||
|
||||
// FIXME: there are probably some edge cases left in bars
|
||||
}
|
||||
|
||||
function processThresholds(plot, s, datapoints) {
|
||||
if (!s.threshold)
|
||||
return;
|
||||
|
||||
if (s.threshold instanceof Array) {
|
||||
s.threshold.sort(function(a, b) {
|
||||
return a.below - b.below;
|
||||
});
|
||||
|
||||
$(s.threshold).each(function(i, th) {
|
||||
thresholdData(plot, s, datapoints, th.below, th.color);
|
||||
});
|
||||
}
|
||||
else {
|
||||
thresholdData(plot, s, datapoints, s.threshold.below, s.threshold.color);
|
||||
}
|
||||
}
|
||||
|
||||
plot.hooks.processDatapoints.push(processThresholds);
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'threshold',
|
||||
version: '1.2'
|
||||
});
|
||||
})(jQuery);
|
||||
@ -1,43 +0,0 @@
|
||||
/* Flot plugin for thresholding data.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
The plugin supports these options:
|
||||
|
||||
series: {
|
||||
threshold: {
|
||||
below: number
|
||||
color: colorspec
|
||||
}
|
||||
}
|
||||
|
||||
It can also be applied to a single series, like this:
|
||||
|
||||
$.plot( $("#placeholder"), [{
|
||||
data: [ ... ],
|
||||
threshold: { ... }
|
||||
}])
|
||||
|
||||
An array can be passed for multiple thresholding, like this:
|
||||
|
||||
threshold: [{
|
||||
below: number1
|
||||
color: color1
|
||||
},{
|
||||
below: number2
|
||||
color: color2
|
||||
}]
|
||||
|
||||
These multiple threshold objects can be passed in any order since they are
|
||||
sorted by the processing function.
|
||||
|
||||
The data points below "below" are drawn with the specified color. This makes
|
||||
it easy to mark points below 0, e.g. for budget data.
|
||||
|
||||
Internally, the plugin works by splitting the data into two series, above and
|
||||
below the threshold. The extra series below the threshold will have its label
|
||||
cleared and the special "originSeries" attribute set to the original series.
|
||||
You may need to check for this in hover events.
|
||||
|
||||
*/(function(e){function n(t){function n(t,n,r,i,s){var o=r.pointsize,u,a,f,l,c,h=e.extend({},n);h.datapoints={points:[],pointsize:o,format:r.format},h.label=null,h.color=s,h.threshold=null,h.originSeries=n,h.data=[];var p=r.points,d=n.lines.show,v=[],m=[],g;for(u=0;u<p.length;u+=o){a=p[u],f=p[u+1],c=l,f<i?l=v:l=m;if(d&&c!=l&&a!=null&&u>0&&p[u-o]!=null){var y=a+(i-f)*(a-p[u-o])/(f-p[u-o+1]);c.push(y),c.push(i);for(g=2;g<o;++g)c.push(p[u+g]);l.push(null),l.push(null);for(g=2;g<o;++g)l.push(p[u+g]);l.push(y),l.push(i);for(g=2;g<o;++g)l.push(p[u+g])}l.push(a),l.push(f);for(g=2;g<o;++g)l.push(p[u+g])}r.points=m,h.datapoints.points=v;if(h.datapoints.points.length>0){var b=e.inArray(n,t.getData());t.getData().splice(b+1,0,h)}}function r(t,r,i){if(!r.threshold)return;r.threshold instanceof Array?(r.threshold.sort(function(e,t){return e.below-t.below}),e(r.threshold).each(function(e,o){n(t,r,i,o.below,o.color)})):n(t,r,i,r.threshold.below,r.threshold.color)}t.hooks.processDatapoints.push(r)}var t={series:{threshold:null}};e.plot.plugins.push({init:n,options:t,name:"threshold",version:"1.2"})})(jQuery);
|
||||
@ -1,431 +0,0 @@
|
||||
/* Pretty handling of time axes.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
Set axis.mode to "time" to enable. See the section "Time series data" in
|
||||
API.txt for details.
|
||||
|
||||
*/
|
||||
|
||||
(function($) {
|
||||
|
||||
var options = {
|
||||
xaxis: {
|
||||
timezone: null, // "browser" for local to the client or timezone for timezone-js
|
||||
timeformat: null, // format string to use
|
||||
twelveHourClock: false, // 12 or 24 time in time mode
|
||||
monthNames: null // list of names of months
|
||||
}
|
||||
};
|
||||
|
||||
// round to nearby lower multiple of base
|
||||
|
||||
function floorInBase(n, base) {
|
||||
return base * Math.floor(n / base);
|
||||
}
|
||||
|
||||
// Returns a string with the date d formatted according to fmt.
|
||||
// A subset of the Open Group's strftime format is supported.
|
||||
|
||||
function formatDate(d, fmt, monthNames, dayNames) {
|
||||
|
||||
if (typeof d.strftime == "function") {
|
||||
return d.strftime(fmt);
|
||||
}
|
||||
|
||||
var leftPad = function(n, pad) {
|
||||
n = "" + n;
|
||||
pad = "" + (pad == null ? "0" : pad);
|
||||
return n.length == 1 ? pad + n : n;
|
||||
};
|
||||
|
||||
var r = [];
|
||||
var escape = false;
|
||||
var hours = d.getHours();
|
||||
var isAM = hours < 12;
|
||||
|
||||
if (monthNames == null) {
|
||||
monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
|
||||
}
|
||||
|
||||
if (dayNames == null) {
|
||||
dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
|
||||
}
|
||||
|
||||
var hours12;
|
||||
|
||||
if (hours > 12) {
|
||||
hours12 = hours - 12;
|
||||
} else if (hours == 0) {
|
||||
hours12 = 12;
|
||||
} else {
|
||||
hours12 = hours;
|
||||
}
|
||||
|
||||
for (var i = 0; i < fmt.length; ++i) {
|
||||
|
||||
var c = fmt.charAt(i);
|
||||
|
||||
if (escape) {
|
||||
switch (c) {
|
||||
case 'a': c = "" + dayNames[d.getDay()]; break;
|
||||
case 'b': c = "" + monthNames[d.getMonth()]; break;
|
||||
case 'd': c = leftPad(d.getDate()); break;
|
||||
case 'e': c = leftPad(d.getDate(), " "); break;
|
||||
case 'h': // For back-compat with 0.7; remove in 1.0
|
||||
case 'H': c = leftPad(hours); break;
|
||||
case 'I': c = leftPad(hours12); break;
|
||||
case 'l': c = leftPad(hours12, " "); break;
|
||||
case 'm': c = leftPad(d.getMonth() + 1); break;
|
||||
case 'M': c = leftPad(d.getMinutes()); break;
|
||||
// quarters not in Open Group's strftime specification
|
||||
case 'q':
|
||||
c = "" + (Math.floor(d.getMonth() / 3) + 1); break;
|
||||
case 'S': c = leftPad(d.getSeconds()); break;
|
||||
case 'y': c = leftPad(d.getFullYear() % 100); break;
|
||||
case 'Y': c = "" + d.getFullYear(); break;
|
||||
case 'p': c = (isAM) ? ("" + "am") : ("" + "pm"); break;
|
||||
case 'P': c = (isAM) ? ("" + "AM") : ("" + "PM"); break;
|
||||
case 'w': c = "" + d.getDay(); break;
|
||||
}
|
||||
r.push(c);
|
||||
escape = false;
|
||||
} else {
|
||||
if (c == "%") {
|
||||
escape = true;
|
||||
} else {
|
||||
r.push(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return r.join("");
|
||||
}
|
||||
|
||||
// To have a consistent view of time-based data independent of which time
|
||||
// zone the client happens to be in we need a date-like object independent
|
||||
// of time zones. This is done through a wrapper that only calls the UTC
|
||||
// versions of the accessor methods.
|
||||
|
||||
function makeUtcWrapper(d) {
|
||||
|
||||
function addProxyMethod(sourceObj, sourceMethod, targetObj, targetMethod) {
|
||||
sourceObj[sourceMethod] = function() {
|
||||
return targetObj[targetMethod].apply(targetObj, arguments);
|
||||
};
|
||||
};
|
||||
|
||||
var utc = {
|
||||
date: d
|
||||
};
|
||||
|
||||
// support strftime, if found
|
||||
|
||||
if (d.strftime != undefined) {
|
||||
addProxyMethod(utc, "strftime", d, "strftime");
|
||||
}
|
||||
|
||||
addProxyMethod(utc, "getTime", d, "getTime");
|
||||
addProxyMethod(utc, "setTime", d, "setTime");
|
||||
|
||||
var props = ["Date", "Day", "FullYear", "Hours", "Milliseconds", "Minutes", "Month", "Seconds"];
|
||||
|
||||
for (var p = 0; p < props.length; p++) {
|
||||
addProxyMethod(utc, "get" + props[p], d, "getUTC" + props[p]);
|
||||
addProxyMethod(utc, "set" + props[p], d, "setUTC" + props[p]);
|
||||
}
|
||||
|
||||
return utc;
|
||||
};
|
||||
|
||||
// select time zone strategy. This returns a date-like object tied to the
|
||||
// desired timezone
|
||||
|
||||
function dateGenerator(ts, opts) {
|
||||
if (opts.timezone == "browser") {
|
||||
return new Date(ts);
|
||||
} else if (!opts.timezone || opts.timezone == "utc") {
|
||||
return makeUtcWrapper(new Date(ts));
|
||||
} else if (typeof timezoneJS != "undefined" && typeof timezoneJS.Date != "undefined") {
|
||||
var d = new timezoneJS.Date();
|
||||
// timezone-js is fickle, so be sure to set the time zone before
|
||||
// setting the time.
|
||||
d.setTimezone(opts.timezone);
|
||||
d.setTime(ts);
|
||||
return d;
|
||||
} else {
|
||||
return makeUtcWrapper(new Date(ts));
|
||||
}
|
||||
}
|
||||
|
||||
// map of app. size of time units in milliseconds
|
||||
|
||||
var timeUnitSize = {
|
||||
"second": 1000,
|
||||
"minute": 60 * 1000,
|
||||
"hour": 60 * 60 * 1000,
|
||||
"day": 24 * 60 * 60 * 1000,
|
||||
"month": 30 * 24 * 60 * 60 * 1000,
|
||||
"quarter": 3 * 30 * 24 * 60 * 60 * 1000,
|
||||
"year": 365.2425 * 24 * 60 * 60 * 1000
|
||||
};
|
||||
|
||||
// the allowed tick sizes, after 1 year we use
|
||||
// an integer algorithm
|
||||
|
||||
var baseSpec = [
|
||||
[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"]
|
||||
];
|
||||
|
||||
// we don't know which variant(s) we'll need yet, but generating both is
|
||||
// cheap
|
||||
|
||||
var specMonths = baseSpec.concat([[3, "month"], [6, "month"],
|
||||
[1, "year"]]);
|
||||
var specQuarters = baseSpec.concat([[1, "quarter"], [2, "quarter"],
|
||||
[1, "year"]]);
|
||||
|
||||
function init(plot) {
|
||||
plot.hooks.processOptions.push(function (plot, options) {
|
||||
$.each(plot.getAxes(), function(axisName, axis) {
|
||||
|
||||
var opts = axis.options;
|
||||
|
||||
if (opts.mode == "time") {
|
||||
axis.tickGenerator = function(axis) {
|
||||
|
||||
var ticks = [];
|
||||
var d = dateGenerator(axis.min, opts);
|
||||
var minSize = 0;
|
||||
|
||||
// make quarter use a possibility if quarters are
|
||||
// mentioned in either of these options
|
||||
|
||||
var spec = (opts.tickSize && opts.tickSize[1] ===
|
||||
"quarter") ||
|
||||
(opts.minTickSize && opts.minTickSize[1] ===
|
||||
"quarter") ? specQuarters : specMonths;
|
||||
|
||||
if (opts.minTickSize != null) {
|
||||
if (typeof opts.tickSize == "number") {
|
||||
minSize = opts.tickSize;
|
||||
} else {
|
||||
minSize = opts.minTickSize[0] * timeUnitSize[opts.minTickSize[1]];
|
||||
}
|
||||
}
|
||||
|
||||
for (var i = 0; i < spec.length - 1; ++i) {
|
||||
if (axis.delta < (spec[i][0] * timeUnitSize[spec[i][1]]
|
||||
+ spec[i + 1][0] * timeUnitSize[spec[i + 1][1]]) / 2
|
||||
&& spec[i][0] * timeUnitSize[spec[i][1]] >= minSize) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
var size = spec[i][0];
|
||||
var unit = spec[i][1];
|
||||
|
||||
// special-case the possibility of several years
|
||||
|
||||
if (unit == "year") {
|
||||
|
||||
// if given a minTickSize in years, just use it,
|
||||
// ensuring that it's an integer
|
||||
|
||||
if (opts.minTickSize != null && opts.minTickSize[1] == "year") {
|
||||
size = Math.floor(opts.minTickSize[0]);
|
||||
} else {
|
||||
|
||||
var magn = Math.pow(10, Math.floor(Math.log(axis.delta / timeUnitSize.year) / Math.LN10));
|
||||
var norm = (axis.delta / timeUnitSize.year) / magn;
|
||||
|
||||
if (norm < 1.5) {
|
||||
size = 1;
|
||||
} else if (norm < 3) {
|
||||
size = 2;
|
||||
} else if (norm < 7.5) {
|
||||
size = 5;
|
||||
} else {
|
||||
size = 10;
|
||||
}
|
||||
|
||||
size *= magn;
|
||||
}
|
||||
|
||||
// minimum size for years is 1
|
||||
|
||||
if (size < 1) {
|
||||
size = 1;
|
||||
}
|
||||
}
|
||||
|
||||
axis.tickSize = opts.tickSize || [size, unit];
|
||||
var tickSize = axis.tickSize[0];
|
||||
unit = axis.tickSize[1];
|
||||
|
||||
var step = tickSize * timeUnitSize[unit];
|
||||
|
||||
if (unit == "second") {
|
||||
d.setSeconds(floorInBase(d.getSeconds(), tickSize));
|
||||
} else if (unit == "minute") {
|
||||
d.setMinutes(floorInBase(d.getMinutes(), tickSize));
|
||||
} else if (unit == "hour") {
|
||||
d.setHours(floorInBase(d.getHours(), tickSize));
|
||||
} else if (unit == "month") {
|
||||
d.setMonth(floorInBase(d.getMonth(), tickSize));
|
||||
} else if (unit == "quarter") {
|
||||
d.setMonth(3 * floorInBase(d.getMonth() / 3,
|
||||
tickSize));
|
||||
} else if (unit == "year") {
|
||||
d.setFullYear(floorInBase(d.getFullYear(), tickSize));
|
||||
}
|
||||
|
||||
// reset smaller components
|
||||
|
||||
d.setMilliseconds(0);
|
||||
|
||||
if (step >= timeUnitSize.minute) {
|
||||
d.setSeconds(0);
|
||||
}
|
||||
if (step >= timeUnitSize.hour) {
|
||||
d.setMinutes(0);
|
||||
}
|
||||
if (step >= timeUnitSize.day) {
|
||||
d.setHours(0);
|
||||
}
|
||||
if (step >= timeUnitSize.day * 4) {
|
||||
d.setDate(1);
|
||||
}
|
||||
if (step >= timeUnitSize.month * 2) {
|
||||
d.setMonth(floorInBase(d.getMonth(), 3));
|
||||
}
|
||||
if (step >= timeUnitSize.quarter * 2) {
|
||||
d.setMonth(floorInBase(d.getMonth(), 6));
|
||||
}
|
||||
if (step >= timeUnitSize.year) {
|
||||
d.setMonth(0);
|
||||
}
|
||||
|
||||
var carry = 0;
|
||||
var v = Number.NaN;
|
||||
var prev;
|
||||
|
||||
do {
|
||||
|
||||
prev = v;
|
||||
v = d.getTime();
|
||||
ticks.push(v);
|
||||
|
||||
if (unit == "month" || unit == "quarter") {
|
||||
if (tickSize < 1) {
|
||||
|
||||
// a bit complicated - we'll divide the
|
||||
// month/quarter up but we need to take
|
||||
// care of fractions so we don't end up in
|
||||
// the middle of a day
|
||||
|
||||
d.setDate(1);
|
||||
var start = d.getTime();
|
||||
d.setMonth(d.getMonth() +
|
||||
(unit == "quarter" ? 3 : 1));
|
||||
var end = d.getTime();
|
||||
d.setTime(v + carry * timeUnitSize.hour + (end - start) * tickSize);
|
||||
carry = d.getHours();
|
||||
d.setHours(0);
|
||||
} else {
|
||||
d.setMonth(d.getMonth() +
|
||||
tickSize * (unit == "quarter" ? 3 : 1));
|
||||
}
|
||||
} else if (unit == "year") {
|
||||
d.setFullYear(d.getFullYear() + tickSize);
|
||||
} else {
|
||||
d.setTime(v + step);
|
||||
}
|
||||
} while (v < axis.max && v != prev);
|
||||
|
||||
return ticks;
|
||||
};
|
||||
|
||||
axis.tickFormatter = function (v, axis) {
|
||||
|
||||
var d = dateGenerator(v, axis.options);
|
||||
|
||||
// first check global format
|
||||
|
||||
if (opts.timeformat != null) {
|
||||
return formatDate(d, opts.timeformat, opts.monthNames, opts.dayNames);
|
||||
}
|
||||
|
||||
// possibly use quarters if quarters are mentioned in
|
||||
// any of these places
|
||||
|
||||
var useQuarters = (axis.options.tickSize &&
|
||||
axis.options.tickSize[1] == "quarter") ||
|
||||
(axis.options.minTickSize &&
|
||||
axis.options.minTickSize[1] == "quarter");
|
||||
|
||||
var t = axis.tickSize[0] * timeUnitSize[axis.tickSize[1]];
|
||||
var span = axis.max - axis.min;
|
||||
var suffix = (opts.twelveHourClock) ? " %p" : "";
|
||||
var hourCode = (opts.twelveHourClock) ? "%I" : "%H";
|
||||
var fmt;
|
||||
|
||||
if (t < timeUnitSize.minute) {
|
||||
fmt = hourCode + ":%M:%S" + suffix;
|
||||
} else if (t < timeUnitSize.day) {
|
||||
if (span < 2 * timeUnitSize.day) {
|
||||
fmt = hourCode + ":%M" + suffix;
|
||||
} else {
|
||||
fmt = "%b %d " + hourCode + ":%M" + suffix;
|
||||
}
|
||||
} else if (t < timeUnitSize.month) {
|
||||
fmt = "%b %d";
|
||||
} else if ((useQuarters && t < timeUnitSize.quarter) ||
|
||||
(!useQuarters && t < timeUnitSize.year)) {
|
||||
if (span < timeUnitSize.year) {
|
||||
fmt = "%b";
|
||||
} else {
|
||||
fmt = "%b %Y";
|
||||
}
|
||||
} else if (useQuarters && t < timeUnitSize.year) {
|
||||
if (span < timeUnitSize.year) {
|
||||
fmt = "Q%q";
|
||||
} else {
|
||||
fmt = "Q%q %Y";
|
||||
}
|
||||
} else {
|
||||
fmt = "%Y";
|
||||
}
|
||||
|
||||
var rt = formatDate(d, fmt, opts.monthNames, opts.dayNames);
|
||||
|
||||
return rt;
|
||||
};
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
$.plot.plugins.push({
|
||||
init: init,
|
||||
options: options,
|
||||
name: 'time',
|
||||
version: '1.0'
|
||||
});
|
||||
|
||||
// Time-axis support used to be in Flot core, which exposed the
|
||||
// formatDate function on the plot object. Various plugins depend
|
||||
// on the function, so we need to re-expose it here.
|
||||
|
||||
$.plot.formatDate = formatDate;
|
||||
|
||||
})(jQuery);
|
||||
@ -1,9 +0,0 @@
|
||||
/* Pretty handling of time axes.
|
||||
|
||||
Copyright (c) 2007-2013 IOLA and Ole Laursen.
|
||||
Licensed under the MIT license.
|
||||
|
||||
Set axis.mode to "time" to enable. See the section "Time series data" in
|
||||
API.txt for details.
|
||||
|
||||
*/(function(e){function n(e,t){return t*Math.floor(e/t)}function r(e,t,n,r){if(typeof e.strftime=="function")return e.strftime(t);var i=function(e,t){return e=""+e,t=""+(t==null?"0":t),e.length==1?t+e:e},s=[],o=!1,u=e.getHours(),a=u<12;n==null&&(n=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]),r==null&&(r=["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]);var f;u>12?f=u-12:u==0?f=12:f=u;for(var l=0;l<t.length;++l){var c=t.charAt(l);if(o){switch(c){case"a":c=""+r[e.getDay()];break;case"b":c=""+n[e.getMonth()];break;case"d":c=i(e.getDate());break;case"e":c=i(e.getDate()," ");break;case"h":case"H":c=i(u);break;case"I":c=i(f);break;case"l":c=i(f," ");break;case"m":c=i(e.getMonth()+1);break;case"M":c=i(e.getMinutes());break;case"q":c=""+(Math.floor(e.getMonth()/3)+1);break;case"S":c=i(e.getSeconds());break;case"y":c=i(e.getFullYear()%100);break;case"Y":c=""+e.getFullYear();break;case"p":c=a?"am":"pm";break;case"P":c=a?"AM":"PM";break;case"w":c=""+e.getDay()}s.push(c),o=!1}else c=="%"?o=!0:s.push(c)}return s.join("")}function i(e){function t(e,t,n,r){e[t]=function(){return n[r].apply(n,arguments)}}var n={date:e};e.strftime!=undefined&&t(n,"strftime",e,"strftime"),t(n,"getTime",e,"getTime"),t(n,"setTime",e,"setTime");var r=["Date","Day","FullYear","Hours","Milliseconds","Minutes","Month","Seconds"];for(var i=0;i<r.length;i++)t(n,"get"+r[i],e,"getUTC"+r[i]),t(n,"set"+r[i],e,"setUTC"+r[i]);return n}function s(e,t){if(t.timezone=="browser")return new Date(e);if(!t.timezone||t.timezone=="utc")return i(new Date(e));if(typeof timezoneJS!="undefined"&&typeof timezoneJS.Date!="undefined"){var n=new timezoneJS.Date;return n.setTimezone(t.timezone),n.setTime(e),n}return i(new Date(e))}function l(t){t.hooks.processOptions.push(function(t,i){e.each(t.getAxes(),function(e,t){var i=t.options;i.mode=="time"&&(t.tickGenerator=function(e){var t=[],r=s(e.min,i),u=0,l=i.tickSize&&i.tickSize[1]==="quarter"||i.minTickSize&&i.minTickSize[1]==="quarter"?f:a;i.minTickSize!=null&&(typeof i.tickSize=="number"?u=i.tickSize:u=i.minTickSize[0]*o[i.minTickSize[1]]);for(var c=0;c<l.length-1;++c)if(e.delta<(l[c][0]*o[l[c][1]]+l[c+1][0]*o[l[c+1][1]])/2&&l[c][0]*o[l[c][1]]>=u)break;var h=l[c][0],p=l[c][1];if(p=="year"){if(i.minTickSize!=null&&i.minTickSize[1]=="year")h=Math.floor(i.minTickSize[0]);else{var d=Math.pow(10,Math.floor(Math.log(e.delta/o.year)/Math.LN10)),v=e.delta/o.year/d;v<1.5?h=1:v<3?h=2:v<7.5?h=5:h=10,h*=d}h<1&&(h=1)}e.tickSize=i.tickSize||[h,p];var m=e.tickSize[0];p=e.tickSize[1];var g=m*o[p];p=="second"?r.setSeconds(n(r.getSeconds(),m)):p=="minute"?r.setMinutes(n(r.getMinutes(),m)):p=="hour"?r.setHours(n(r.getHours(),m)):p=="month"?r.setMonth(n(r.getMonth(),m)):p=="quarter"?r.setMonth(3*n(r.getMonth()/3,m)):p=="year"&&r.setFullYear(n(r.getFullYear(),m)),r.setMilliseconds(0),g>=o.minute&&r.setSeconds(0),g>=o.hour&&r.setMinutes(0),g>=o.day&&r.setHours(0),g>=o.day*4&&r.setDate(1),g>=o.month*2&&r.setMonth(n(r.getMonth(),3)),g>=o.quarter*2&&r.setMonth(n(r.getMonth(),6)),g>=o.year&&r.setMonth(0);var y=0,b=Number.NaN,w;do{w=b,b=r.getTime(),t.push(b);if(p=="month"||p=="quarter")if(m<1){r.setDate(1);var E=r.getTime();r.setMonth(r.getMonth()+(p=="quarter"?3:1));var S=r.getTime();r.setTime(b+y*o.hour+(S-E)*m),y=r.getHours(),r.setHours(0)}else r.setMonth(r.getMonth()+m*(p=="quarter"?3:1));else p=="year"?r.setFullYear(r.getFullYear()+m):r.setTime(b+g)}while(b<e.max&&b!=w);return t},t.tickFormatter=function(e,t){var n=s(e,t.options);if(i.timeformat!=null)return r(n,i.timeformat,i.monthNames,i.dayNames);var u=t.options.tickSize&&t.options.tickSize[1]=="quarter"||t.options.minTickSize&&t.options.minTickSize[1]=="quarter",a=t.tickSize[0]*o[t.tickSize[1]],f=t.max-t.min,l=i.twelveHourClock?" %p":"",c=i.twelveHourClock?"%I":"%H",h;a<o.minute?h=c+":%M:%S"+l:a<o.day?f<2*o.day?h=c+":%M"+l:h="%b %d "+c+":%M"+l:a<o.month?h="%b %d":u&&a<o.quarter||!u&&a<o.year?f<o.year?h="%b":h="%b %Y":u&&a<o.year?f<o.year?h="Q%q":h="Q%q %Y":h="%Y";var p=r(n,h,i.monthNames,i.dayNames);return p})})})}var t={xaxis:{timezone:null,timeformat:null,twelveHourClock:!1,monthNames:null}},o={second:1e3,minute:6e4,hour:36e5,day:864e5,month:2592e6,quarter:7776e6,year:525949.2*60*1e3},u=[[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"],[.25,"month"],[.5,"month"],[1,"month"],[2,"month"]],a=u.concat([[3,"month"],[6,"month"],[1,"year"]]),f=u.concat([[1,"quarter"],[2,"quarter"],[1,"year"]]);e.plot.plugins.push({init:l,options:t,name:"time",version:"1.0"}),e.plot.formatDate=r})(jQuery);
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
@ -1,234 +0,0 @@
|
||||
|
||||
/*
|
||||
* BinaryFile over XMLHttpRequest
|
||||
* Part of the javascriptRRD package
|
||||
* Copyright (c) 2009 Frank Wuerthwein, fkw@ucsd.edu
|
||||
* MIT License [http://www.opensource.org/licenses/mit-license.php]
|
||||
*
|
||||
* Original repository: http://javascriptrrd.sourceforge.net/
|
||||
*
|
||||
* Based on:
|
||||
* Binary Ajax 0.1.5
|
||||
* Copyright (c) 2008 Jacob Seidelin, cupboy@gmail.com, http://blog.nihilogic.dk/
|
||||
* MIT License [http://www.opensource.org/licenses/mit-license.php]
|
||||
*/
|
||||
|
||||
// ============================================================
|
||||
// Exception class
|
||||
function InvalidBinaryFile(msg) {
|
||||
this.message=msg;
|
||||
this.name="Invalid BinaryFile";
|
||||
}
|
||||
|
||||
// pretty print
|
||||
InvalidBinaryFile.prototype.toString = function() {
|
||||
return this.name + ': "' + this.message + '"';
|
||||
}
|
||||
|
||||
// =====================================================================
|
||||
// BinaryFile class
|
||||
// Allows access to element inside a binary stream
|
||||
function BinaryFile(strData, iDataOffset, iDataLength) {
|
||||
var data = strData;
|
||||
var dataOffset = iDataOffset || 0;
|
||||
var dataLength = 0;
|
||||
// added
|
||||
var doubleMantExpHi=Math.pow(2,-28);
|
||||
var doubleMantExpLo=Math.pow(2,-52);
|
||||
var doubleMantExpFast=Math.pow(2,-20);
|
||||
|
||||
this.getRawData = function() {
|
||||
return data;
|
||||
}
|
||||
|
||||
if (typeof strData == "string") {
|
||||
dataLength = iDataLength || data.length;
|
||||
|
||||
this.getByteAt = function(iOffset) {
|
||||
return data.charCodeAt(iOffset + dataOffset) & 0xFF;
|
||||
}
|
||||
} else if (typeof strData == "unknown") {
|
||||
dataLength = iDataLength || IEBinary_getLength(data);
|
||||
|
||||
this.getByteAt = function(iOffset) {
|
||||
return IEBinary_getByteAt(data, iOffset + dataOffset);
|
||||
}
|
||||
} else {
|
||||
throw new InvalidBinaryFile("Unsupported type " + (typeof strData));
|
||||
}
|
||||
|
||||
this.getLength = function() {
|
||||
return dataLength;
|
||||
}
|
||||
|
||||
this.getSByteAt = function(iOffset) {
|
||||
var iByte = this.getByteAt(iOffset);
|
||||
if (iByte > 127)
|
||||
return iByte - 256;
|
||||
else
|
||||
return iByte;
|
||||
}
|
||||
|
||||
this.getShortAt = function(iOffset) {
|
||||
var iShort = (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset)
|
||||
if (iShort < 0) iShort += 65536;
|
||||
return iShort;
|
||||
}
|
||||
this.getSShortAt = function(iOffset) {
|
||||
var iUShort = this.getShortAt(iOffset);
|
||||
if (iUShort > 32767)
|
||||
return iUShort - 65536;
|
||||
else
|
||||
return iUShort;
|
||||
}
|
||||
this.getLongAt = function(iOffset) {
|
||||
var iByte1 = this.getByteAt(iOffset),
|
||||
iByte2 = this.getByteAt(iOffset + 1),
|
||||
iByte3 = this.getByteAt(iOffset + 2),
|
||||
iByte4 = this.getByteAt(iOffset + 3);
|
||||
|
||||
var iLong = (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1;
|
||||
if (iLong < 0) iLong += 4294967296;
|
||||
return iLong;
|
||||
}
|
||||
this.getSLongAt = function(iOffset) {
|
||||
var iULong = this.getLongAt(iOffset);
|
||||
if (iULong > 2147483647)
|
||||
return iULong - 4294967296;
|
||||
else
|
||||
return iULong;
|
||||
}
|
||||
this.getStringAt = function(iOffset, iLength) {
|
||||
var aStr = [];
|
||||
for (var i=iOffset,j=0;i<iOffset+iLength;i++,j++) {
|
||||
aStr[j] = String.fromCharCode(this.getByteAt(i));
|
||||
}
|
||||
return aStr.join("");
|
||||
}
|
||||
|
||||
// Added
|
||||
this.getCStringAt = function(iOffset, iMaxLength) {
|
||||
var aStr = [];
|
||||
for (var i=iOffset,j=0;(i<iOffset+iMaxLength) && (this.getByteAt(i)>0);i++,j++) {
|
||||
aStr[j] = String.fromCharCode(this.getByteAt(i));
|
||||
}
|
||||
return aStr.join("");
|
||||
}
|
||||
|
||||
// Added
|
||||
this.getDoubleAt = function(iOffset) {
|
||||
var iByte1 = this.getByteAt(iOffset),
|
||||
iByte2 = this.getByteAt(iOffset + 1),
|
||||
iByte3 = this.getByteAt(iOffset + 2),
|
||||
iByte4 = this.getByteAt(iOffset + 3),
|
||||
iByte5 = this.getByteAt(iOffset + 4),
|
||||
iByte6 = this.getByteAt(iOffset + 5),
|
||||
iByte7 = this.getByteAt(iOffset + 6),
|
||||
iByte8 = this.getByteAt(iOffset + 7);
|
||||
var iSign=iByte8 >> 7;
|
||||
var iExpRaw=((iByte8 & 0x7F)<< 4) + (iByte7 >> 4);
|
||||
var iMantHi=((((((iByte7 & 0x0F) << 8) + iByte6) << 8) + iByte5) << 8) + iByte4;
|
||||
var iMantLo=((((iByte3) << 8) + iByte2) << 8) + iByte1;
|
||||
|
||||
if (iExpRaw==0) return 0.0;
|
||||
if (iExpRaw==0x7ff) return undefined;
|
||||
|
||||
var iExp=(iExpRaw & 0x7FF)-1023;
|
||||
|
||||
var dDouble = ((iSign==1)?-1:1)*Math.pow(2,iExp)*(1.0 + iMantLo*doubleMantExpLo + iMantHi*doubleMantExpHi);
|
||||
return dDouble;
|
||||
}
|
||||
// added
|
||||
// Extracts only 4 bytes out of 8, loosing in precision (20 bit mantissa)
|
||||
this.getFastDoubleAt = function(iOffset) {
|
||||
var iByte5 = this.getByteAt(iOffset + 4),
|
||||
iByte6 = this.getByteAt(iOffset + 5),
|
||||
iByte7 = this.getByteAt(iOffset + 6),
|
||||
iByte8 = this.getByteAt(iOffset + 7);
|
||||
var iSign=iByte8 >> 7;
|
||||
var iExpRaw=((iByte8 & 0x7F)<< 4) + (iByte7 >> 4);
|
||||
var iMant=((((iByte7 & 0x0F) << 8) + iByte6) << 8) + iByte5;
|
||||
|
||||
if (iExpRaw==0) return 0.0;
|
||||
if (iExpRaw==0x7ff) return undefined;
|
||||
|
||||
var iExp=(iExpRaw & 0x7FF)-1023;
|
||||
|
||||
var dDouble = ((iSign==1)?-1:1)*Math.pow(2,iExp)*(1.0 + iMant*doubleMantExpFast);
|
||||
return dDouble;
|
||||
}
|
||||
|
||||
this.getCharAt = function(iOffset) {
|
||||
return String.fromCharCode(this.getByteAt(iOffset));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
document.write(
|
||||
"<script type='text/vbscript'>\r\n"
|
||||
+ "Function IEBinary_getByteAt(strBinary, iOffset)\r\n"
|
||||
+ " IEBinary_getByteAt = AscB(MidB(strBinary,iOffset+1,1))\r\n"
|
||||
+ "End Function\r\n"
|
||||
+ "Function IEBinary_getLength(strBinary)\r\n"
|
||||
+ " IEBinary_getLength = LenB(strBinary)\r\n"
|
||||
+ "End Function\r\n"
|
||||
+ "</script>\r\n"
|
||||
);
|
||||
|
||||
|
||||
|
||||
// ===============================================================
|
||||
// Load a binary file from the specified URL
|
||||
// Will return an object of type BinaryFile
|
||||
function FetchBinaryURL(url) {
|
||||
var request = new XMLHttpRequest();
|
||||
request.open("GET", url,false);
|
||||
try {
|
||||
request.overrideMimeType('text/plain; charset=x-user-defined');
|
||||
} catch (err) {
|
||||
// ignore any error, just to make both FF and IE work
|
||||
}
|
||||
request.send(null);
|
||||
|
||||
var response=request.responseBody;
|
||||
if (response==undefined){ // responseBody is non standard, but the only way to make it work in IE
|
||||
response=request.responseText;
|
||||
}
|
||||
var bf=new BinaryFile(response);
|
||||
return bf;
|
||||
}
|
||||
|
||||
|
||||
// ===============================================================
|
||||
// Asyncronously load a binary file from the specified URL
|
||||
//
|
||||
// callback must be a function with one or two arguments:
|
||||
// - bf = an object of type BinaryFile
|
||||
// - optional argument object (used only if callback_arg not undefined)
|
||||
function FetchBinaryURLAsync(url, callback, callback_arg) {
|
||||
var callback_wrapper = function() {
|
||||
if(this.readyState == 4) {
|
||||
var response=this.responseBody;
|
||||
if (response==undefined){ // responseBody is non standard, but the only way to make it work in IE
|
||||
response=this.responseText;
|
||||
}
|
||||
var bf=new BinaryFile(response);
|
||||
if (callback_arg!=null) {
|
||||
callback(bf,callback_arg);
|
||||
} else {
|
||||
callback(bf);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var request = new XMLHttpRequest();
|
||||
request.onreadystatechange = callback_wrapper;
|
||||
request.open("GET", url,true);
|
||||
try {
|
||||
request.overrideMimeType('text/plain; charset=x-user-defined');
|
||||
} catch (err) {
|
||||
// ignore any error, just to make both FF and IE work
|
||||
}
|
||||
request.send(null);
|
||||
return request
|
||||
}
|
||||
@ -1,408 +0,0 @@
|
||||
/*
|
||||
* Client library for access to RRD archive files
|
||||
* Part of the javascriptRRD package
|
||||
* Copyright (c) 2009-2010 Frank Wuerthwein, fkw@ucsd.edu
|
||||
* Igor Sfiligoi, isfiligoi@ucsd.edu
|
||||
*
|
||||
* Original repository: http://javascriptrrd.sourceforge.net/
|
||||
*
|
||||
* MIT License [http://www.opensource.org/licenses/mit-license.php]
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
*
|
||||
* RRDTool has been developed and is maintained by
|
||||
* Tobias Oether [http://oss.oetiker.ch/rrdtool/]
|
||||
*
|
||||
* This software can be used to read files produced by the RRDTool
|
||||
* but has been developed independently.
|
||||
*
|
||||
* Limitations:
|
||||
*
|
||||
* This version of the module assumes RRD files created on linux
|
||||
* with intel architecture and supports both 32 and 64 bit CPUs.
|
||||
* All integers in RRD files are suppoes to fit in 32bit values.
|
||||
*
|
||||
* Only versions 3 and 4 of the RRD archive are supported.
|
||||
*
|
||||
* Only AVERAGE,MAXIMUM,MINIMUM and LAST consolidation functions are
|
||||
* supported. For all others, the behaviour is at the moment undefined.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Dependencies:
|
||||
*
|
||||
* The data provided to this module require an object of a class
|
||||
* that implements the following methods:
|
||||
* getByteAt(idx) - Return a 8 bit unsigned integer at offset idx
|
||||
* getLongAt(idx) - Return a 32 bit unsigned integer at offset idx
|
||||
* getDoubleAt(idx) - Return a double float at offset idx
|
||||
* getFastDoubleAt(idx) - Similar to getDoubleAt but with less precision
|
||||
* getCStringAt(idx,maxsize) - Return a string of at most maxsize characters
|
||||
* that was 0-terminated in the source
|
||||
*
|
||||
* The BinaryFile from binaryXHR.js implements this interface.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
// ============================================================
|
||||
// Exception class
|
||||
function InvalidRRD(msg) {
|
||||
this.message=msg;
|
||||
this.name="Invalid RRD";
|
||||
}
|
||||
|
||||
// pretty print
|
||||
InvalidRRD.prototype.toString = function() {
|
||||
return this.name + ': "' + this.message + '"';
|
||||
}
|
||||
|
||||
|
||||
// ============================================================
|
||||
// RRD DS Info class
|
||||
function RRDDS(rrd_data,rrd_data_idx,my_idx) {
|
||||
this.rrd_data=rrd_data;
|
||||
this.rrd_data_idx=rrd_data_idx;
|
||||
this.my_idx=my_idx;
|
||||
}
|
||||
|
||||
RRDDS.prototype.getIdx = function() {
|
||||
return this.my_idx;
|
||||
}
|
||||
RRDDS.prototype.getName = function() {
|
||||
return this.rrd_data.getCStringAt(this.rrd_data_idx,20);
|
||||
}
|
||||
RRDDS.prototype.getType = function() {
|
||||
return this.rrd_data.getCStringAt(this.rrd_data_idx+20,20);
|
||||
}
|
||||
RRDDS.prototype.getMin = function() {
|
||||
return this.rrd_data.getDoubleAt(this.rrd_data_idx+48);
|
||||
}
|
||||
RRDDS.prototype.getMax = function() {
|
||||
return this.rrd_data.getDoubleAt(this.rrd_data_idx+56);
|
||||
}
|
||||
|
||||
|
||||
// ============================================================
|
||||
// RRD RRA Info class
|
||||
function RRDRRAInfo(rrd_data,rra_def_idx,
|
||||
rrd_align,row_cnt,pdp_step,my_idx) {
|
||||
this.rrd_data=rrd_data;
|
||||
this.rra_def_idx=rra_def_idx;
|
||||
this.rrd_align=rrd_align;
|
||||
this.row_cnt=row_cnt;
|
||||
this.pdp_step=pdp_step;
|
||||
this.my_idx=my_idx;
|
||||
}
|
||||
|
||||
RRDRRAInfo.prototype.getIdx = function() {
|
||||
return this.my_idx;
|
||||
}
|
||||
|
||||
// Get number of rows
|
||||
RRDRRAInfo.prototype.getNrRows = function() {
|
||||
return this.row_cnt;
|
||||
}
|
||||
|
||||
// Get number of slots used for consolidation
|
||||
// Mostly for internal use
|
||||
RRDRRAInfo.prototype.getPdpPerRow = function() {
|
||||
if (this.rrd_align==32)
|
||||
return this.rrd_data.getLongAt(this.rra_def_idx+24,20);
|
||||
else
|
||||
return this.rrd_data.getLongAt(this.rra_def_idx+32,20);
|
||||
}
|
||||
|
||||
// Get RRA step (expressed in seconds)
|
||||
RRDRRAInfo.prototype.getStep = function() {
|
||||
return this.pdp_step*this.getPdpPerRow();
|
||||
}
|
||||
|
||||
// Get consolidation function name
|
||||
RRDRRAInfo.prototype.getCFName = function() {
|
||||
return this.rrd_data.getCStringAt(this.rra_def_idx,20);
|
||||
}
|
||||
|
||||
|
||||
// ============================================================
|
||||
// RRD RRA handling class
|
||||
function RRDRRA(rrd_data,rra_ptr_idx,
|
||||
rra_info,
|
||||
header_size,prev_row_cnts,ds_cnt) {
|
||||
this.rrd_data=rrd_data;
|
||||
this.rra_info=rra_info;
|
||||
this.row_cnt=rra_info.row_cnt;
|
||||
this.ds_cnt=ds_cnt;
|
||||
|
||||
var row_size=ds_cnt*8;
|
||||
|
||||
this.base_rrd_db_idx=header_size+prev_row_cnts*row_size;
|
||||
|
||||
// get imediately, since it will be needed often
|
||||
this.cur_row=rrd_data.getLongAt(rra_ptr_idx);
|
||||
|
||||
// calculate idx relative to base_rrd_db_idx
|
||||
// mostly used internally
|
||||
this.calc_idx = function(row_idx,ds_idx) {
|
||||
if ((row_idx>=0) && (row_idx<this.row_cnt)) {
|
||||
if ((ds_idx>=0) && (ds_idx<ds_cnt)){
|
||||
// it is round robin, starting from cur_row+1
|
||||
var real_row_idx=row_idx+this.cur_row+1;
|
||||
if (real_row_idx>=this.row_cnt) real_row_idx-=this.row_cnt;
|
||||
return row_size*real_row_idx+ds_idx*8;
|
||||
} else {
|
||||
throw RangeError("DS idx ("+ row_idx +") out of range [0-" + ds_cnt +").");
|
||||
}
|
||||
} else {
|
||||
throw RangeError("Row idx ("+ row_idx +") out of range [0-" + this.row_cnt +").");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RRDRRA.prototype.getIdx = function() {
|
||||
return this.rra_info.getIdx();
|
||||
}
|
||||
|
||||
// Get number of rows/columns
|
||||
RRDRRA.prototype.getNrRows = function() {
|
||||
return this.row_cnt;
|
||||
}
|
||||
RRDRRA.prototype.getNrDSs = function() {
|
||||
return this.ds_cnt;
|
||||
}
|
||||
|
||||
// Get RRA step (expressed in seconds)
|
||||
RRDRRA.prototype.getStep = function() {
|
||||
return this.rra_info.getStep();
|
||||
}
|
||||
|
||||
// Get consolidation function name
|
||||
RRDRRA.prototype.getCFName = function() {
|
||||
return this.rra_info.getCFName();
|
||||
}
|
||||
|
||||
RRDRRA.prototype.getEl = function(row_idx,ds_idx) {
|
||||
return this.rrd_data.getDoubleAt(this.base_rrd_db_idx+this.calc_idx(row_idx,ds_idx));
|
||||
}
|
||||
|
||||
// Low precision version of getEl
|
||||
// Uses getFastDoubleAt
|
||||
RRDRRA.prototype.getElFast = function(row_idx,ds_idx) {
|
||||
return this.rrd_data.getFastDoubleAt(this.base_rrd_db_idx+this.calc_idx(row_idx,ds_idx));
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// RRD Header handling class
|
||||
function RRDHeader(rrd_data) {
|
||||
this.rrd_data=rrd_data;
|
||||
this.validate_rrd();
|
||||
this.load_header();
|
||||
this.calc_idxs();
|
||||
}
|
||||
|
||||
// Internal, used for initialization
|
||||
RRDHeader.prototype.validate_rrd = function() {
|
||||
if (this.rrd_data.getCStringAt(0,4)!=="RRD") throw new InvalidRRD("Wrong magic id.");
|
||||
|
||||
this.rrd_version=this.rrd_data.getCStringAt(4,5);
|
||||
if ((this.rrd_version!=="0003")&&(this.rrd_version!=="0004")) {
|
||||
throw new InvalidRRD("Unsupported RRD version "+this.rrd_version+".");
|
||||
}
|
||||
|
||||
if (this.rrd_data.getDoubleAt(12)==8.642135e+130) {
|
||||
this.rrd_align=32;
|
||||
} else if (this.rrd_data.getDoubleAt(16)==8.642135e+130) {
|
||||
this.rrd_align=64;
|
||||
} else {
|
||||
throw new InvalidRRD("Unsupported platform.");
|
||||
}
|
||||
}
|
||||
|
||||
// Internal, used for initialization
|
||||
RRDHeader.prototype.load_header = function() {
|
||||
if (this.rrd_align==32) {
|
||||
this.ds_cnt=this.rrd_data.getLongAt(20,false);
|
||||
this.rra_cnt=this.rrd_data.getLongAt(24,false);
|
||||
this.pdp_step=this.rrd_data.getLongAt(28,false);
|
||||
// 8*10 unused values follow
|
||||
this.top_header_size=112;
|
||||
} else {
|
||||
//get only the low 32 bits, the high 32 should always be 0
|
||||
this.ds_cnt=this.rrd_data.getLongAt(24,false);
|
||||
this.rra_cnt=this.rrd_data.getLongAt(32,false);
|
||||
this.pdp_step=this.rrd_data.getLongAt(40,false);
|
||||
// 8*10 unused values follow
|
||||
this.top_header_size=128;
|
||||
}
|
||||
}
|
||||
|
||||
// Internal, used for initialization
|
||||
RRDHeader.prototype.calc_idxs = function() {
|
||||
this.ds_def_idx=this.top_header_size;
|
||||
// char ds_nam[20], char dst[20], unival par[10]
|
||||
this.ds_el_size=120;
|
||||
|
||||
this.rra_def_idx=this.ds_def_idx+this.ds_el_size*this.ds_cnt;
|
||||
// char cf_nam[20], uint row_cnt, uint pdp_cnt, unival par[10]
|
||||
this.row_cnt_idx;
|
||||
if (this.rrd_align==32) {
|
||||
this.rra_def_el_size=108;
|
||||
this.row_cnt_idx=20;
|
||||
} else {
|
||||
this.rra_def_el_size=120;
|
||||
this.row_cnt_idx=24;
|
||||
}
|
||||
|
||||
this.live_head_idx=this.rra_def_idx+this.rra_def_el_size*this.rra_cnt;
|
||||
// time_t last_up, int last_up_usec
|
||||
if (this.rrd_align==32) {
|
||||
this.live_head_size=8;
|
||||
} else {
|
||||
this.live_head_size=16;
|
||||
}
|
||||
|
||||
this.pdp_prep_idx=this.live_head_idx+this.live_head_size;
|
||||
// char last_ds[30], unival scratch[10]
|
||||
this.pdp_prep_el_size=112;
|
||||
|
||||
this.cdp_prep_idx=this.pdp_prep_idx+this.pdp_prep_el_size*this.ds_cnt;
|
||||
// unival scratch[10]
|
||||
this.cdp_prep_el_size=80;
|
||||
|
||||
this.rra_ptr_idx=this.cdp_prep_idx+this.cdp_prep_el_size*this.ds_cnt*this.rra_cnt;
|
||||
// uint cur_row
|
||||
if (this.rrd_align==32) {
|
||||
this.rra_ptr_el_size=4;
|
||||
} else {
|
||||
this.rra_ptr_el_size=8;
|
||||
}
|
||||
|
||||
this.header_size=this.rra_ptr_idx+this.rra_ptr_el_size*this.rra_cnt;
|
||||
}
|
||||
|
||||
// Optional initialization
|
||||
// Read and calculate row counts
|
||||
RRDHeader.prototype.load_row_cnts = function() {
|
||||
this.rra_def_row_cnts=[];
|
||||
this.rra_def_row_cnt_sums=[]; // how many rows before me
|
||||
for (var i=0; i<this.rra_cnt; i++) {
|
||||
this.rra_def_row_cnts[i]=this.rrd_data.getLongAt(this.rra_def_idx+i*this.rra_def_el_size+this.row_cnt_idx,false);
|
||||
if (i==0) {
|
||||
this.rra_def_row_cnt_sums[i]=0;
|
||||
} else {
|
||||
this.rra_def_row_cnt_sums[i]=this.rra_def_row_cnt_sums[i-1]+this.rra_def_row_cnts[i-1];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------
|
||||
// Start of user functions
|
||||
|
||||
RRDHeader.prototype.getMinStep = function() {
|
||||
return this.pdp_step;
|
||||
}
|
||||
RRDHeader.prototype.getLastUpdate = function() {
|
||||
return this.rrd_data.getLongAt(this.live_head_idx,false);
|
||||
}
|
||||
|
||||
RRDHeader.prototype.getNrDSs = function() {
|
||||
return this.ds_cnt;
|
||||
}
|
||||
RRDHeader.prototype.getDSNames = function() {
|
||||
var ds_names=[]
|
||||
for (var idx=0; idx<this.ds_cnt; idx++) {
|
||||
var ds=this.getDSbyIdx(idx);
|
||||
var ds_name=ds.getName()
|
||||
ds_names.push(ds_name);
|
||||
}
|
||||
return ds_names;
|
||||
}
|
||||
RRDHeader.prototype.getDSbyIdx = function(idx) {
|
||||
if ((idx>=0) && (idx<this.ds_cnt)) {
|
||||
return new RRDDS(this.rrd_data,this.ds_def_idx+this.ds_el_size*idx,idx);
|
||||
} else {
|
||||
throw RangeError("DS idx ("+ idx +") out of range [0-" + this.ds_cnt +").");
|
||||
}
|
||||
}
|
||||
RRDHeader.prototype.getDSbyName = function(name) {
|
||||
for (var idx=0; idx<this.ds_cnt; idx++) {
|
||||
var ds=this.getDSbyIdx(idx);
|
||||
var ds_name=ds.getName()
|
||||
if (ds_name==name)
|
||||
return ds;
|
||||
}
|
||||
throw RangeError("DS name "+ name +" unknown.");
|
||||
}
|
||||
|
||||
RRDHeader.prototype.getNrRRAs = function() {
|
||||
return this.rra_cnt;
|
||||
}
|
||||
RRDHeader.prototype.getRRAInfo = function(idx) {
|
||||
if ((idx>=0) && (idx<this.rra_cnt)) {
|
||||
return new RRDRRAInfo(this.rrd_data,
|
||||
this.rra_def_idx+idx*this.rra_def_el_size,
|
||||
this.rrd_align,this.rra_def_row_cnts[idx],this.pdp_step,
|
||||
idx);
|
||||
} else {
|
||||
throw RangeError("RRA idx ("+ idx +") out of range [0-" + this.rra_cnt +").");
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
// RRDFile class
|
||||
// Given a BinaryFile, gives access to the RRD archive fields
|
||||
//
|
||||
// Arguments:
|
||||
// bf must be an object compatible with the BinaryFile interface
|
||||
function RRDFile(bf) {
|
||||
var rrd_data=bf
|
||||
|
||||
this.rrd_header=new RRDHeader(rrd_data);
|
||||
this.rrd_header.load_row_cnts();
|
||||
|
||||
// ===================================
|
||||
// Start of user functions
|
||||
|
||||
this.getMinStep = function() {
|
||||
return this.rrd_header.getMinStep();
|
||||
}
|
||||
this.getLastUpdate = function() {
|
||||
return this.rrd_header.getLastUpdate();
|
||||
}
|
||||
|
||||
this.getNrDSs = function() {
|
||||
return this.rrd_header.getNrDSs();
|
||||
}
|
||||
this.getDSNames = function() {
|
||||
return this.rrd_header.getDSNames();
|
||||
}
|
||||
this.getDS = function(id) {
|
||||
if (typeof id == "number") {
|
||||
return this.rrd_header.getDSbyIdx(id);
|
||||
} else {
|
||||
return this.rrd_header.getDSbyName(id);
|
||||
}
|
||||
}
|
||||
|
||||
this.getNrRRAs = function() {
|
||||
return this.rrd_header.getNrRRAs();
|
||||
}
|
||||
|
||||
this.getRRAInfo = function(idx) {
|
||||
return this.rrd_header.getRRAInfo(idx);
|
||||
}
|
||||
|
||||
this.getRRA = function(idx) {
|
||||
rra_info=this.rrd_header.getRRAInfo(idx);
|
||||
return new RRDRRA(rrd_data,
|
||||
this.rrd_header.rra_ptr_idx+idx*this.rrd_header.rra_ptr_el_size,
|
||||
rra_info,
|
||||
this.rrd_header.header_size,
|
||||
this.rrd_header.rra_def_row_cnt_sums[idx],
|
||||
this.rrd_header.ds_cnt);
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,242 +0,0 @@
|
||||
/*
|
||||
* Filter classes for rrdFile
|
||||
* They implement the same interface, but changing the content
|
||||
*
|
||||
* Part of the javascriptRRD package
|
||||
* Copyright (c) 2009 Frank Wuerthwein, fkw@ucsd.edu
|
||||
*
|
||||
* Original repository: http://javascriptrrd.sourceforge.net/
|
||||
*
|
||||
* MIT License [http://www.opensource.org/licenses/mit-license.php]
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* All filter classes must implement the following interface:
|
||||
* getMinStep()
|
||||
* getLastUpdate()
|
||||
* getNrRRAs()
|
||||
* getRRAInfo(rra_idx)
|
||||
* getFilterRRA(rra_idx)
|
||||
* getName()
|
||||
*
|
||||
* Where getFilterRRA returns an object implementing the following interface:
|
||||
* getIdx()
|
||||
* getNrRows()
|
||||
* getStep()
|
||||
* getCFName()
|
||||
* getEl(row_idx)
|
||||
* getElFast(row_idx)
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
// ================================================================
|
||||
// Filter out a subset of DSs (identified either by idx or by name)
|
||||
|
||||
function RRDRRAFilterDS(rrd_rra,ds_list) {
|
||||
this.rrd_rra=rrd_rra;
|
||||
this.ds_list=ds_list;
|
||||
}
|
||||
RRDRRAFilterDS.prototype.getIdx = function() {return this.rrd_rra.getIdx();}
|
||||
RRDRRAFilterDS.prototype.getNrRows = function() {return this.rrd_rra.getNrRows();}
|
||||
RRDRRAFilterDS.prototype.getNrDSs = function() {return this.ds_list.length;}
|
||||
RRDRRAFilterDS.prototype.getStep = function() {return this.rrd_rra.getStep();}
|
||||
RRDRRAFilterDS.prototype.getCFName = function() {return this.rrd_rra.getCFName();}
|
||||
RRDRRAFilterDS.prototype.getEl = function(row_idx,ds_idx) {
|
||||
if ((ds_idx>=0) && (ds_idx<this.ds_list.length)) {
|
||||
var real_ds_idx=this.ds_list[ds_idx].real_ds_idx;
|
||||
return this.rrd_rra.getEl(row_idx,real_ds_idx);
|
||||
} else {
|
||||
throw RangeError("DS idx ("+ ds_idx +") out of range [0-" + this.ds_list.length +").");
|
||||
}
|
||||
}
|
||||
RRDRRAFilterDS.prototype.getElFast = function(row_idx,ds_idx) {
|
||||
if ((ds_idx>=0) && (ds_idx<this.ds_list.length)) {
|
||||
var real_ds_idx=this.ds_list[ds_idx].real_ds_idx;
|
||||
return this.rrd_rra.getElFast(row_idx,real_ds_idx);
|
||||
} else {
|
||||
throw RangeError("DS idx ("+ ds_idx +") out of range [0-" + this.ds_list.length +").");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// --------------------------------------------------
|
||||
function RRDFilterDS(rrd_file,ds_id_list) {
|
||||
this.rrd_file=rrd_file;
|
||||
this.ds_list=[];
|
||||
for (var i=0; i<ds_id_list.length; i++) {
|
||||
var org_ds=rrd_file.getDS(ds_id_list[i]);
|
||||
// must create a new copy, as the index has changed
|
||||
var new_ds=new RRDDS(org_ds.rrd_data,org_ds.rrd_data_idx,i);
|
||||
// then extend it to include the real RRD index
|
||||
new_ds.real_ds_idx=org_ds.my_idx;
|
||||
|
||||
this.ds_list.push(new_ds);
|
||||
}
|
||||
}
|
||||
RRDFilterDS.prototype.getMinSteps = function() {return this.rrd_file.getMinSteps();}
|
||||
RRDFilterDS.prototype.getLastUpdate = function() {return this.rrd_file.getLastUpdate();}
|
||||
|
||||
RRDFilterDS.prototype.getNrDSs = function() {return this.ds_list.length;}
|
||||
RRDFilterDS.prototype.getDSNames = function() {
|
||||
var ds_names=[];
|
||||
for (var i=0; i<this.ds_list.length; i++) {
|
||||
ds_names.push(ds_list[i].getName());
|
||||
}
|
||||
return ds_names;
|
||||
}
|
||||
RRDFilterDS.prototype.getDS = function(id) {
|
||||
if (typeof id == "number") {
|
||||
return this.getDSbyIdx(id);
|
||||
} else {
|
||||
return this.getDSbyName(id);
|
||||
}
|
||||
}
|
||||
|
||||
// INTERNAL: Do not call directly
|
||||
RRDFilterDS.prototype.getDSbyIdx = function(idx) {
|
||||
if ((idx>=0) && (idx<this.ds_list.length)) {
|
||||
return this.ds_list[idx];
|
||||
} else {
|
||||
throw RangeError("DS idx ("+ idx +") out of range [0-" + this.ds_list.length +").");
|
||||
}
|
||||
}
|
||||
|
||||
// INTERNAL: Do not call directly
|
||||
RRDFilterDS.prototype.getDSbyName = function(name) {
|
||||
for (var idx=0; idx<this.ds_list.length; idx++) {
|
||||
var ds=this.ds_list[idx];
|
||||
var ds_name=ds.getName()
|
||||
if (ds_name==name)
|
||||
return ds;
|
||||
}
|
||||
throw RangeError("DS name "+ name +" unknown.");
|
||||
}
|
||||
|
||||
RRDFilterDS.prototype.getNrRRAs = function() {return this.rrd_file.getNrRRAs();}
|
||||
RRDFilterDS.prototype.getRRAInfo = function(idx) {return this.rrd_file.getRRAInfo(idx);}
|
||||
RRDFilterDS.prototype.getRRA = function(idx) {return new RRDRRAFilterDS(this.rrd_file.getRRA(idx),this.ds_list);}
|
||||
|
||||
// ================================================================
|
||||
// Filter out by using a user provided filter object
|
||||
// The object must implement the following interface
|
||||
// getName() - Symbolic name give to this function
|
||||
// getDSName() - list of DSs used in computing the result (names or indexes)
|
||||
// computeResult(val_list) - val_list contains the values of the requested DSs (in the same order)
|
||||
|
||||
// Example class that implements the interface:
|
||||
// function sumDS(ds1,ds2) {
|
||||
// this.getName = function() {return ds1+"+"+ds2;}
|
||||
// this.getDSNames = function() {return [ds1,ds2];}
|
||||
// this.computeResult = function(val_list) {return val_list[0]+val_list[1];}
|
||||
// }
|
||||
|
||||
function RRDDSFilterOp(rrd_file,op_obj,my_idx) {
|
||||
this.rrd_file=rrd_file;
|
||||
this.op_obj=op_obj;
|
||||
this.my_idx=my_idx;
|
||||
var ds_names=op_obj.getDSNames();
|
||||
var ds_idx_list=[];
|
||||
for (var i=0; i<ds_names.length; i++) {
|
||||
ds_idx_list.push(rrd_file.getDS(ds_names[i]).getIdx());
|
||||
}
|
||||
this.ds_idx_list=ds_idx_list;
|
||||
}
|
||||
RRDDSFilterOp.prototype.getIdx = function() {return this.my_idx;}
|
||||
RRDDSFilterOp.prototype.getName = function() {return this.op_obj.getName();}
|
||||
|
||||
RRDDSFilterOp.prototype.getType = function() {return "function";}
|
||||
RRDDSFilterOp.prototype.getMin = function() {return undefined;}
|
||||
RRDDSFilterOp.prototype.getMax = function() {return undefined;}
|
||||
|
||||
// These are new to RRDDSFilterOp
|
||||
RRDDSFilterOp.prototype.getRealDSList = function() { return this.ds_idx_list;}
|
||||
RRDDSFilterOp.prototype.computeResult = function(val_list) {return this.op_obj.computeResult(val_list);}
|
||||
|
||||
// --------------------------------------------------
|
||||
function RRDRRAFilterOp(rrd_rra,ds_list) {
|
||||
this.rrd_rra=rrd_rra;
|
||||
this.ds_list=ds_list;
|
||||
}
|
||||
RRDRRAFilterOp.prototype.getIdx = function() {return this.rrd_rra.getIdx();}
|
||||
RRDRRAFilterOp.prototype.getNrRows = function() {return this.rrd_rra.getNrRows();}
|
||||
RRDRRAFilterOp.prototype.getNrDSs = function() {return this.ds_list.length;}
|
||||
RRDRRAFilterOp.prototype.getStep = function() {return this.rrd_rra.getStep();}
|
||||
RRDRRAFilterOp.prototype.getCFName = function() {return this.rrd_rra.getCFName();}
|
||||
RRDRRAFilterOp.prototype.getEl = function(row_idx,ds_idx) {
|
||||
if ((ds_idx>=0) && (ds_idx<this.ds_list.length)) {
|
||||
var ds_idx_list=this.ds_list[ds_idx].getRealDSList();
|
||||
var val_list=[];
|
||||
for (var i=0; i<ds_idx_list.length; i++) {
|
||||
val_list.push(this.rrd_rra.getEl(row_idx,ds_idx_list[i]));
|
||||
}
|
||||
return this.ds_list[ds_idx].computeResult(val_list);
|
||||
} else {
|
||||
throw RangeError("DS idx ("+ ds_idx +") out of range [0-" + this.ds_list.length +").");
|
||||
}
|
||||
}
|
||||
RRDRRAFilterOp.prototype.getElFast = function(row_idx,ds_idx) {
|
||||
if ((ds_idx>=0) && (ds_idx<this.ds_list.length)) {
|
||||
var ds_idx_list=this.ds_list[ds_idx].getRealDSList();
|
||||
var val_list=[];
|
||||
for (var i=0; i<ds_idx_list.length; i++) {
|
||||
val_list.push(this.rrd_rra.getEl(row_idx,ds_idx_list[i]));
|
||||
}
|
||||
return this.ds_list[ds_idx].computeResult(val_list);
|
||||
} else {
|
||||
throw RangeError("DS idx ("+ ds_idx +") out of range [0-" + this.ds_list.length +").");
|
||||
}
|
||||
}
|
||||
|
||||
// --------------------------------------------------
|
||||
function RRDFilterOp(rrd_file,op_obj_list) {
|
||||
this.rrd_file=rrd_file;
|
||||
this.ds_list=[];
|
||||
for (var i=0; i<op_obj_list.length; i++) {
|
||||
this.ds_list.push(new RRDDSFilterOp(rrd_file,op_obj_list[i],i));
|
||||
}
|
||||
}
|
||||
RRDFilterOp.prototype.getMinSteps = function() {return this.rrd_file.getMinSteps();}
|
||||
RRDFilterOp.prototype.getLastUpdate = function() {return this.rrd_file.getLastUpdate();}
|
||||
|
||||
RRDFilterOp.prototype.getNrDSs = function() {return this.ds_list.length;}
|
||||
RRDFilterOp.prototype.getDSNames = function() {
|
||||
var ds_names=[];
|
||||
for (var i=0; i<this.ds_list.length; i++) {
|
||||
ds_names.push(ds_list[i].getName());
|
||||
}
|
||||
return ds_names;
|
||||
}
|
||||
RRDFilterOp.prototype.getDS = function(id) {
|
||||
if (typeof id == "number") {
|
||||
return this.getDSbyIdx(id);
|
||||
} else {
|
||||
return this.getDSbyName(id);
|
||||
}
|
||||
}
|
||||
|
||||
// INTERNAL: Do not call directly
|
||||
RRDFilterOp.prototype.getDSbyIdx = function(idx) {
|
||||
if ((idx>=0) && (idx<this.ds_list.length)) {
|
||||
return this.ds_list[idx];
|
||||
} else {
|
||||
throw RangeError("DS idx ("+ idx +") out of range [0-" + this.ds_list.length +").");
|
||||
}
|
||||
}
|
||||
|
||||
// INTERNAL: Do not call directly
|
||||
RRDFilterOp.prototype.getDSbyName = function(name) {
|
||||
for (var idx=0; idx<this.ds_list.length; idx++) {
|
||||
var ds=this.ds_list[idx];
|
||||
var ds_name=ds.getName()
|
||||
if (ds_name==name)
|
||||
return ds;
|
||||
}
|
||||
throw RangeError("DS name "+ name +" unknown.");
|
||||
}
|
||||
|
||||
RRDFilterOp.prototype.getNrRRAs = function() {return this.rrd_file.getNrRRAs();}
|
||||
RRDFilterOp.prototype.getRRAInfo = function(idx) {return this.rrd_file.getRRAInfo(idx);}
|
||||
RRDFilterOp.prototype.getRRA = function(idx) {return new RRDRRAFilterOp(this.rrd_file.getRRA(idx),this.ds_list);}
|
||||
|
||||
@ -1,328 +0,0 @@
|
||||
/*
|
||||
* RRD graphing libraries, based on Flot
|
||||
* Part of the javascriptRRD package
|
||||
* Copyright (c) 2010 Frank Wuerthwein, fkw@ucsd.edu
|
||||
* Igor Sfiligoi, isfiligoi@ucsd.edu
|
||||
*
|
||||
* Original repository: http://javascriptrrd.sourceforge.net/
|
||||
*
|
||||
* MIT License [http://www.opensource.org/licenses/mit-license.php]
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
*
|
||||
* Flot is a javascript plotting library developed and maintained by
|
||||
* Ole Laursen [http://code.google.com/p/flot/]
|
||||
*
|
||||
*/
|
||||
|
||||
function suffixFormatter(val, axis) {
|
||||
var tickDec = 2;
|
||||
if (val > 1000000000)
|
||||
return (val / 1000000000).toFixed(tickDec) + "G";
|
||||
else if (val > 1000000)
|
||||
return (val / 1000000).toFixed(tickDec) + "M";
|
||||
else if (val > 1000)
|
||||
return (val / 1000).toFixed(tickDec) + "k";
|
||||
else
|
||||
return val.toFixed(tickDec);
|
||||
}
|
||||
|
||||
function rrdFlot(html_id, rrd_file, graph_options, ds_graph_options, si_suffix, tz_offset) {
|
||||
if(si_suffix==null)
|
||||
this.si_suffix = false;
|
||||
else
|
||||
this.si_suffix = si_suffix;
|
||||
|
||||
// tz_offset: offset of timezone in seconds
|
||||
if(tz_offset==null)
|
||||
this.tz_offset = 0;
|
||||
else
|
||||
this.tz_offset = tz_offset;
|
||||
|
||||
this.html_id=html_id;
|
||||
this.rrd_file=rrd_file;
|
||||
this.graph_options=graph_options;
|
||||
if (ds_graph_options==null) {
|
||||
this.ds_graph_options=new Object();
|
||||
} else {
|
||||
this.ds_graph_options=ds_graph_options;
|
||||
}
|
||||
this.selection_range=new rrdFlotSelection();
|
||||
|
||||
this.createHTML();
|
||||
this.populateRes();
|
||||
this.populateDScb();
|
||||
this.drawFlotGraph();
|
||||
}
|
||||
|
||||
|
||||
rrdFlot.prototype.createHTML = function() {
|
||||
var rf_this=this; // use obj inside other functions
|
||||
|
||||
var base_el=document.getElementById(this.html_id);
|
||||
|
||||
this.res_id=this.html_id+"_res";
|
||||
this.ds_cb_id=this.html_id+"_ds_cb";
|
||||
this.graph_id=this.html_id+"_graph";
|
||||
this.scale_id=this.html_id+"_scale";
|
||||
this.legend_sel_id=this.html_id+"_legend_sel";
|
||||
|
||||
while (base_el.lastChild!=null) base_el.removeChild(base_el.lastChild);
|
||||
var external_table=document.createElement("Table");
|
||||
|
||||
var rowHeader=external_table.insertRow(-1);
|
||||
var cellRes=rowHeader.insertCell(-1);
|
||||
var forRes=document.createElement("Select");
|
||||
forRes.id=this.res_id;
|
||||
forRes.onChange= this.callback_res_changed;
|
||||
forRes.onchange= function () {rf_this.callback_res_changed();};
|
||||
cellRes.appendChild(forRes);
|
||||
|
||||
var cellScaleReset=rowHeader.insertCell(-1);
|
||||
cellScaleReset.vAlign="center";
|
||||
cellScaleReset.appendChild(document.createTextNode(" "));
|
||||
var elScaleReset=document.createElement("input");
|
||||
elScaleReset.type = "button";
|
||||
elScaleReset.value = "Reset Zoom";
|
||||
elScaleReset.setAttribute("class", "btn btn-tertiary btn-medium");
|
||||
elScaleReset.onclick = function () {rf_this.callback_scale_reset();}
|
||||
cellScaleReset.appendChild(elScaleReset);
|
||||
|
||||
var rowGraph=external_table.insertRow(-1);
|
||||
var cellGraph=rowGraph.insertCell(-1);
|
||||
cellGraph.colSpan=3;
|
||||
var elGraph=document.createElement("Div");
|
||||
elGraph.style.width="670px";
|
||||
elGraph.style.height="200px";
|
||||
elGraph.id=this.graph_id;
|
||||
cellGraph.appendChild(elGraph);
|
||||
|
||||
var cellDScb=rowGraph.insertCell(-1);
|
||||
cellDScb.vAlign="top";
|
||||
var formDScb=document.createElement("Form");
|
||||
formDScb.id=this.ds_cb_id;
|
||||
formDScb.onchange= function () {rf_this.callback_ds_cb_changed();};
|
||||
cellDScb.appendChild(formDScb);
|
||||
|
||||
var rowScale=external_table.insertRow(-1);
|
||||
var cellScale=rowScale.insertCell(-1);
|
||||
cellScale.colSpan=2;
|
||||
var elScale=document.createElement("Div");
|
||||
elScale.style.width="670px";
|
||||
elScale.style.height="80px";
|
||||
elScale.id=this.scale_id;
|
||||
cellScale.appendChild(elScale);
|
||||
|
||||
base_el.appendChild(external_table);
|
||||
};
|
||||
|
||||
rrdFlot.prototype.populateRes = function() {
|
||||
var form_el=document.getElementById(this.res_id);
|
||||
|
||||
while (form_el.lastChild!=null) form_el.removeChild(form_el.lastChild);
|
||||
|
||||
var nrRRAs=this.rrd_file.getNrRRAs();
|
||||
for (var i=0; i<nrRRAs; i++) {
|
||||
var rra=this.rrd_file.getRRAInfo(i);
|
||||
if(rra.getCFName() != "AVERAGE")
|
||||
continue;
|
||||
var step=rra.getStep();
|
||||
var rows=rra.getNrRows();
|
||||
var period=step*rows;
|
||||
var rra_label=rfs_format_time(period) + " - " + rfs_format_time(step) + " steps";
|
||||
form_el.appendChild(new Option(rra_label,i));
|
||||
}
|
||||
};
|
||||
|
||||
rrdFlot.prototype.populateDScb = function() {
|
||||
var form_el=document.getElementById(this.ds_cb_id);
|
||||
|
||||
while (form_el.lastChild!=null) form_el.removeChild(form_el.lastChild);
|
||||
|
||||
var nrDSs=this.rrd_file.getNrDSs();
|
||||
for (var i=0; i<nrDSs; i++) {
|
||||
var ds=this.rrd_file.getDS(i);
|
||||
var name=ds.getName();
|
||||
var title=name;
|
||||
var checked=1;
|
||||
if (this.ds_graph_options[name]!=null) {
|
||||
var dgo=this.ds_graph_options[name];
|
||||
if (dgo['title']!=null) {
|
||||
title=dgo['title'];
|
||||
} else if (dgo['label']!=null) {
|
||||
title=dgo['label'];
|
||||
}
|
||||
if (dgo['checked']!=null) {
|
||||
checked=dgo['checked'];
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// ======================================
|
||||
//
|
||||
rrdFlot.prototype.drawFlotGraph = function() {
|
||||
var oSelect=document.getElementById(this.res_id);
|
||||
var rra_idx=Number(oSelect.options[oSelect.selectedIndex].value);
|
||||
|
||||
var ds_positive_stack_list=[];
|
||||
var ds_negative_stack_list=[];
|
||||
var ds_single_list=[];
|
||||
var ds_colors={};
|
||||
|
||||
var nrDSs=this.rrd_file.getNrDSs();
|
||||
for (var i=0; i<nrDSs; i++) {
|
||||
var ds_name=this.rrd_file.getDS(i).getName();
|
||||
var ds_stack_type='none';
|
||||
if (this.ds_graph_options[ds_name]!=null) {
|
||||
var dgo=this.ds_graph_options[ds_name];
|
||||
if (dgo['stack']!=null) {
|
||||
var ds_stack_type=dgo['stack'];
|
||||
}
|
||||
}
|
||||
if (ds_stack_type=='positive') {
|
||||
ds_positive_stack_list.push(ds_name);
|
||||
} else if (ds_stack_type=='negative') {
|
||||
ds_negative_stack_list.push(ds_name);
|
||||
} else {
|
||||
ds_single_list.push(ds_name);
|
||||
}
|
||||
ds_colors[ds_name]=i;
|
||||
}
|
||||
|
||||
var flot_obj=rrdRRAStackFlotObj(this.rrd_file,rra_idx,
|
||||
ds_positive_stack_list,ds_negative_stack_list,ds_single_list,
|
||||
this.tz_offset);
|
||||
|
||||
for (var i=0; i<flot_obj.data.length; i++) {
|
||||
var name=flot_obj.data[i].label;
|
||||
var color=ds_colors[name];
|
||||
if (this.ds_graph_options[name]!=null) {
|
||||
var dgo=this.ds_graph_options[name];
|
||||
if (dgo['color']!=null) {
|
||||
color=dgo['color'];
|
||||
}
|
||||
if (dgo['label']!=null) {
|
||||
flot_obj.data[i].label=dgo['label'];
|
||||
} else if (dgo['title']!=null) {
|
||||
flot_obj.data[i].label=dgo['title'];
|
||||
}
|
||||
if (dgo['lines']!=null) {
|
||||
flot_obj.data[i].lines=dgo['lines'];
|
||||
}
|
||||
if (dgo['yaxis']!=null) {
|
||||
flot_obj.data[i].yaxis=dgo['yaxis'];
|
||||
}
|
||||
}
|
||||
flot_obj.data[i].color=color;
|
||||
}
|
||||
|
||||
this.bindFlotGraph(flot_obj);
|
||||
};
|
||||
|
||||
rrdFlot.prototype.bindFlotGraph = function(flot_obj) {
|
||||
var rf_this=this;
|
||||
|
||||
var graph_jq_id="#"+this.graph_id;
|
||||
var scale_jq_id="#"+this.scale_id;
|
||||
fmt_cb = this.si_suffix ? suffixFormatter : null;
|
||||
|
||||
var graph_options = {
|
||||
legend: {show:false, position:"nw",noColumns:5, backgroundOpacity: 0.5 },
|
||||
lines: {show:true},
|
||||
xaxis: { mode: "time" },
|
||||
yaxis: { autoscaleMargin: 0.20, tickFormatter: fmt_cb },
|
||||
selection: { mode: "x" },
|
||||
};
|
||||
|
||||
graph_options.legend.show=true;
|
||||
|
||||
if (this.selection_range.isSet()) {
|
||||
var selection_range=this.selection_range.getFlotRanges();
|
||||
graph_options.xaxis.min=selection_range.xaxis.from;
|
||||
graph_options.xaxis.max=selection_range.xaxis.to;
|
||||
} else {
|
||||
graph_options.xaxis.min=flot_obj.min;
|
||||
graph_options.xaxis.max=flot_obj.max;
|
||||
}
|
||||
|
||||
if (this.graph_options!=null) {
|
||||
if (this.graph_options.legend!=null) {
|
||||
if (this.graph_options.legend.position!=null) {
|
||||
graph_options.legend.position=this.graph_options.legend.position;
|
||||
}
|
||||
if (this.graph_options.legend.noColumns!=null) {
|
||||
graph_options.legend.noColumns=this.graph_options.legend.noColumns;
|
||||
}
|
||||
}
|
||||
if (this.graph_options.yaxis!=null) {
|
||||
if (this.graph_options.yaxis.autoscaleMargin!=null) {
|
||||
graph_options.yaxis.autoscaleMargin=this.graph_options.yaxis.autoscaleMargin;
|
||||
}
|
||||
}
|
||||
if (this.graph_options.lines!=null) {
|
||||
graph_options.lines=this.graph_options.lines;
|
||||
}
|
||||
}
|
||||
|
||||
var scale_options = {
|
||||
legend: {show:false},
|
||||
lines: {show:true},
|
||||
xaxis: { mode: "time", min:flot_obj.min, max:flot_obj.max },
|
||||
yaxis: { tickFormatter: fmt_cb },
|
||||
selection: { mode: "x" },
|
||||
};
|
||||
|
||||
var flot_data=flot_obj.data;
|
||||
|
||||
var graph_data=this.selection_range.trim_flot_data(flot_data);
|
||||
var scale_data=flot_data;
|
||||
|
||||
this.graph = $.plot($(graph_jq_id), graph_data, graph_options);
|
||||
this.scale = $.plot($(scale_jq_id), scale_data, scale_options);
|
||||
|
||||
if (this.selection_range.isSet()) {
|
||||
this.scale.setSelection(this.selection_range.getFlotRanges(),true);
|
||||
}
|
||||
|
||||
$(graph_jq_id).unbind("plotselected");
|
||||
$(graph_jq_id).bind("plotselected", function (event, ranges) {
|
||||
rf_this.selection_range.setFromFlotRanges(ranges);
|
||||
graph_options.xaxis.min=ranges.xaxis.from;
|
||||
graph_options.xaxis.max=ranges.xaxis.to;
|
||||
rf_this.graph = $.plot($(graph_jq_id), rf_this.selection_range.trim_flot_data(flot_data), graph_options);
|
||||
|
||||
rf_this.scale.setSelection(ranges, true);
|
||||
});
|
||||
|
||||
$(scale_jq_id).unbind("plotselected");
|
||||
$(scale_jq_id).bind("plotselected", function (event, ranges) {
|
||||
rf_this.graph.setSelection(ranges);
|
||||
});
|
||||
|
||||
$(scale_jq_id).bind("plotunselected", function() {
|
||||
rf_this.selection_range.reset();
|
||||
graph_options.xaxis.min=flot_obj.min;
|
||||
graph_options.xaxis.max=flot_obj.max;
|
||||
rf_this.graph = $.plot($(graph_jq_id), rf_this.selection_range.trim_flot_data(flot_data), graph_options);
|
||||
});
|
||||
};
|
||||
|
||||
rrdFlot.prototype.callback_res_changed = function() {
|
||||
this.drawFlotGraph();
|
||||
};
|
||||
|
||||
rrdFlot.prototype.callback_ds_cb_changed = function() {
|
||||
this.drawFlotGraph();
|
||||
};
|
||||
|
||||
rrdFlot.prototype.callback_scale_reset = function() {
|
||||
this.scale.clearSelection();
|
||||
};
|
||||
|
||||
rrdFlot.prototype.callback_legend_changed = function() {
|
||||
this.drawFlotGraph();
|
||||
};
|
||||
|
||||
@ -1,487 +0,0 @@
|
||||
/*
|
||||
* RRD graphing libraries, based on Flot
|
||||
* Part of the javascriptRRD package
|
||||
* Copyright (c) 2010 Frank Wuerthwein, fkw@ucsd.edu
|
||||
* Igor Sfiligoi, isfiligoi@ucsd.edu
|
||||
*
|
||||
* Original repository: http://javascriptrrd.sourceforge.net/
|
||||
*
|
||||
* MIT License [http://www.opensource.org/licenses/mit-license.php]
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
*
|
||||
* Flot is a javascript plotting library developed and maintained by
|
||||
* Ole Laursen [http://code.google.com/p/flot/]
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* The rrd_files is a list of
|
||||
* [rrd_id,rrd_file] pairs
|
||||
* All rrd_files must have the same step, the same DSes and the same number of RRAs.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* The ds_list is a list of
|
||||
* [ds_id, ds_title] pairs
|
||||
* If not defined, the list will be created from the RRDs
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Local dependencies:
|
||||
* rrdFlotSupport.py
|
||||
*
|
||||
* External dependencies:
|
||||
* [Flot]/jquery.py
|
||||
* [Flot]/jquery.flot.js
|
||||
* [Flot]/jquery.flot.selection.js
|
||||
*/
|
||||
|
||||
/* graph_options defaults (see Flot docs for details)
|
||||
* {
|
||||
* legend: { position:"nw",noColumns:3},
|
||||
* lines: { show:true },
|
||||
* yaxis: { autoscaleMargin: 0.20}
|
||||
* }
|
||||
*
|
||||
* rrd_graph_options is a dictionary of rrd_id,
|
||||
* with each element being a graph_option
|
||||
* The defaults for each element are
|
||||
* {
|
||||
* title: label or rrd_name // this is what is displayed in the checkboxes
|
||||
* checked: true // boolean
|
||||
* label: title or rrd_name // this is what is displayed in the legend
|
||||
* color: rrd_index // see Flot docs for details
|
||||
* lines: { show:true, fill: true, fillColor:color } // see Flot docs for details
|
||||
* }
|
||||
*/
|
||||
|
||||
function rrdFlotMatrix(html_id, rrd_files, ds_list, graph_options, rrd_graph_options) {
|
||||
this.html_id=html_id;
|
||||
this.rrd_files=rrd_files;
|
||||
if (ds_list==null) {
|
||||
this.ds_list=[];
|
||||
var rrd_file=this.rrd_files[0][1]; // get the first one... they are all the same
|
||||
var nrDSs=rrd_file.getNrDSs();
|
||||
for (var i=0; i<nrDSs; i++) {
|
||||
var ds=this.rrd_files[0][1].getDS(i);
|
||||
var name=ds.getName();
|
||||
this.ds_list.push([name,name]);
|
||||
}
|
||||
} else {
|
||||
this.ds_list=ds_list;
|
||||
}
|
||||
this.graph_options=graph_options;
|
||||
if (rrd_graph_options==null) {
|
||||
this.rrd_graph_options=new Object(); // empty object, just not to be null
|
||||
} else {
|
||||
this.rrd_graph_options=rrd_graph_options;
|
||||
}
|
||||
this.selection_range=new rrdFlotSelection();
|
||||
|
||||
this.createHTML();
|
||||
this.populateDS();
|
||||
this.populateRes();
|
||||
this.populateRRDcb();
|
||||
this.drawFlotGraph()
|
||||
}
|
||||
|
||||
|
||||
// ===============================================
|
||||
// Create the HTML tags needed to host the graphs
|
||||
rrdFlotMatrix.prototype.createHTML = function() {
|
||||
var rf_this=this; // use obj inside other functions
|
||||
|
||||
var base_el=document.getElementById(this.html_id);
|
||||
|
||||
this.ds_id=this.html_id+"_ds";
|
||||
this.res_id=this.html_id+"_res";
|
||||
this.rrd_cb_id=this.html_id+"_rrd_cb";
|
||||
this.graph_id=this.html_id+"_graph";
|
||||
this.scale_id=this.html_id+"_scale";
|
||||
this.legend_sel_id=this.html_id+"_legend_sel";
|
||||
|
||||
// First clean up anything in the element
|
||||
while (base_el.lastChild!=null) base_el.removeChild(base_el.lastChild);
|
||||
|
||||
// Now create the layout
|
||||
var external_table=document.createElement("Table");
|
||||
|
||||
// DS rows: select DS
|
||||
var rowDS=external_table.insertRow(-1);
|
||||
var cellDS=rowDS.insertCell(-1);
|
||||
cellDS.colSpan=4
|
||||
cellDS.appendChild(document.createTextNode("Element:"));
|
||||
var forDS=document.createElement("Select");
|
||||
forDS.id=this.ds_id;
|
||||
forDS.onchange= function () {rf_this.callback_ds_changed();};
|
||||
cellDS.appendChild(forDS);
|
||||
|
||||
// Header row: resulution select and DS selection title
|
||||
var rowHeader=external_table.insertRow(-1);
|
||||
var cellRes=rowHeader.insertCell(-1);
|
||||
cellRes.colSpan=3;
|
||||
cellRes.appendChild(document.createTextNode("Resolution:"));
|
||||
var forRes=document.createElement("Select");
|
||||
forRes.id=this.res_id;
|
||||
forRes.onchange= function () {rf_this.callback_res_changed();};
|
||||
cellRes.appendChild(forRes);
|
||||
|
||||
var cellRRDTitle=rowHeader.insertCell(-1);
|
||||
cellRRDTitle.appendChild(document.createTextNode("Select RRDs to plot:"));
|
||||
|
||||
// Graph row: main graph and DS selection block
|
||||
var rowGraph=external_table.insertRow(-1);
|
||||
var cellGraph=rowGraph.insertCell(-1);
|
||||
cellGraph.colSpan=3;
|
||||
var elGraph=document.createElement("Div");
|
||||
elGraph.style.width="500px";
|
||||
elGraph.style.height="300px";
|
||||
elGraph.id=this.graph_id;
|
||||
cellGraph.appendChild(elGraph);
|
||||
|
||||
var cellRRDcb=rowGraph.insertCell(-1);
|
||||
cellRRDcb.vAlign="top";
|
||||
var formRRDcb=document.createElement("Form");
|
||||
formRRDcb.id=this.rrd_cb_id;
|
||||
formRRDcb.onchange= function () {rf_this.callback_rrd_cb_changed();};
|
||||
cellRRDcb.appendChild(formRRDcb);
|
||||
|
||||
// Scale row: scaled down selection graph
|
||||
var rowScale=external_table.insertRow(-1);
|
||||
|
||||
var cellScaleLegend=rowScale.insertCell(-1);
|
||||
cellScaleLegend.vAlign="top";
|
||||
cellScaleLegend.appendChild(document.createTextNode("Legend:"));
|
||||
cellScaleLegend.appendChild(document.createElement('br'));
|
||||
var forScaleLegend=document.createElement("Select");
|
||||
forScaleLegend.id=this.legend_sel_id;
|
||||
forScaleLegend.appendChild(new Option("Top","nw"));
|
||||
forScaleLegend.appendChild(new Option("Bottom","sw"));
|
||||
forScaleLegend.appendChild(new Option("TopRight","ne"));
|
||||
forScaleLegend.appendChild(new Option("BottomRight","se"));
|
||||
forScaleLegend.appendChild(new Option("None","None"));
|
||||
forScaleLegend.onchange= function () {rf_this.callback_legend_changed();};
|
||||
cellScaleLegend.appendChild(forScaleLegend);
|
||||
|
||||
var cellScale=rowScale.insertCell(-1);
|
||||
cellScale.align="right";
|
||||
var elScale=document.createElement("Div");
|
||||
elScale.style.width="250px";
|
||||
elScale.style.height="110px";
|
||||
elScale.id=this.scale_id;
|
||||
cellScale.appendChild(elScale);
|
||||
|
||||
var cellScaleReset=rowScale.insertCell(-1);
|
||||
cellScaleReset.vAlign="top";
|
||||
cellScaleReset.appendChild(document.createTextNode(" "));
|
||||
cellScaleReset.appendChild(document.createElement('br'));
|
||||
var elScaleReset=document.createElement("input");
|
||||
elScaleReset.type = "button";
|
||||
elScaleReset.value = "Reset selection";
|
||||
elScaleReset.onclick = function () {rf_this.callback_scale_reset();}
|
||||
cellScaleReset.appendChild(elScaleReset);
|
||||
|
||||
|
||||
base_el.appendChild(external_table);
|
||||
};
|
||||
|
||||
// ======================================
|
||||
// Populate DSs, RRA and RRD info
|
||||
rrdFlotMatrix.prototype.populateDS = function() {
|
||||
var form_el=document.getElementById(this.ds_id);
|
||||
|
||||
// First clean up anything in the element
|
||||
while (form_el.lastChild!=null) form_el.removeChild(form_el.lastChild);
|
||||
|
||||
for (i in this.ds_list) {
|
||||
var ds=this.ds_list[i];
|
||||
form_el.appendChild(new Option(ds[1],ds[0]));
|
||||
}
|
||||
};
|
||||
|
||||
rrdFlotMatrix.prototype.populateRes = function() {
|
||||
var form_el=document.getElementById(this.res_id);
|
||||
|
||||
// First clean up anything in the element
|
||||
while (form_el.lastChild!=null) form_el.removeChild(form_el.lastChild);
|
||||
|
||||
var rrd_file=this.rrd_files[0][1]; // get the first one... they are all the same
|
||||
// now populate with RRA info
|
||||
var nrRRAs=rrd_file.getNrRRAs();
|
||||
for (var i=0; i<nrRRAs; i++) {
|
||||
var rra=rrd_file.getRRAInfo(i);
|
||||
var step=rra.getStep();
|
||||
var rows=rra.getNrRows();
|
||||
var period=step*rows;
|
||||
var rra_label=rfs_format_time(step)+" ("+rfs_format_time(period)+" total)";
|
||||
form_el.appendChild(new Option(rra_label,i));
|
||||
}
|
||||
};
|
||||
|
||||
rrdFlotMatrix.prototype.populateRRDcb = function() {
|
||||
var form_el=document.getElementById(this.rrd_cb_id);
|
||||
|
||||
// First clean up anything in the element
|
||||
while (form_el.lastChild!=null) form_el.removeChild(form_el.lastChild);
|
||||
|
||||
var table_el=document.createElement("Table");
|
||||
var row_el=table_el.insertRow(-1);
|
||||
row_el.vAlign="top";
|
||||
var cell_el=null; // will define later
|
||||
|
||||
// now populate with RRD info
|
||||
var nrRRDs=this.rrd_files.length;
|
||||
for (var i=0; i<nrRRDs; i++) {
|
||||
if ((i%15)==0) { // one column every 15 elements
|
||||
cell_el=row_el.insertCell(-1);
|
||||
}
|
||||
|
||||
var rrd_el=this.rrd_files[i];
|
||||
var rrd_file=rrd_el[1];
|
||||
var name=rrd_el[0];
|
||||
var title=name;
|
||||
var checked=true; // all checked by default
|
||||
if (this.rrd_graph_options[name]!=null) {
|
||||
var rgo=this.rrd_graph_options[name];
|
||||
if (rgo['title']!=null) {
|
||||
// if the user provided the title, use it
|
||||
title=rgo['title'];
|
||||
} else if (rgo['label']!=null) {
|
||||
// use label as a second choice
|
||||
title=rgo['label'];
|
||||
} // else leave the ds name
|
||||
if (rgo['checked']!=null) {
|
||||
// if the user provided the title, use it
|
||||
checked=rgo['checked'];
|
||||
}
|
||||
}
|
||||
|
||||
var cb_el = document.createElement("input");
|
||||
cb_el.type = "checkbox";
|
||||
cb_el.name = "rrd";
|
||||
cb_el.value = i;
|
||||
cb_el.checked = cb_el.defaultChecked = checked;
|
||||
cell_el.appendChild(cb_el);
|
||||
cell_el.appendChild(document.createTextNode(title));
|
||||
cell_el.appendChild(document.createElement('br'));
|
||||
}
|
||||
form_el.appendChild(table_el);
|
||||
};
|
||||
|
||||
// ======================================
|
||||
//
|
||||
rrdFlotMatrix.prototype.drawFlotGraph = function() {
|
||||
// DS
|
||||
var oSelect=document.getElementById(this.ds_id);
|
||||
var ds_id=oSelect.options[oSelect.selectedIndex].value;
|
||||
|
||||
// Res contains the RRA idx
|
||||
oSelect=document.getElementById(this.res_id);
|
||||
var rra_idx=Number(oSelect.options[oSelect.selectedIndex].value);
|
||||
|
||||
// Extract ds info ... to be finished
|
||||
var ds_positive_stack=null;
|
||||
|
||||
var std_colors=["#00ff00","#00ffff","#0000ff","#ff00ff",
|
||||
"#808080","#ff0000","#ffff00","#e66266",
|
||||
"#33cccc","#fff8a9","#ccffff","#a57e81",
|
||||
"#7bea81","#8d4dff","#ffcc99","#000000"];
|
||||
|
||||
// now get the list of selected RRDs
|
||||
var rrd_list=[];
|
||||
var rrd_colors=[];
|
||||
var oCB=document.getElementById(this.rrd_cb_id);
|
||||
var nrRRDs=oCB.rrd.length;
|
||||
if (oCB.rrd.length>0) {
|
||||
for (var i=0; i<oCB.rrd.length; i++) {
|
||||
if (oCB.rrd[i].checked==true) {
|
||||
//var rrd_idx=Number(oCB.rrd[i].value);
|
||||
rrd_list.push(this.rrd_files[i]);
|
||||
color=std_colors[i%std_colors.length];
|
||||
if ((i/std_colors.length)>=1) {
|
||||
// wraparound, change them a little
|
||||
idiv=Math.floor(i/std_colors.length);
|
||||
c1=parseInt(color[1]+color[2],16);
|
||||
c2=parseInt(color[3]+color[4],16);
|
||||
c3=parseInt(color[5]+color[6],16);
|
||||
m1=Math.floor((c1-128)/Math.sqrt(idiv+1))+128;
|
||||
m2=Math.floor((c2-128)/Math.sqrt(idiv+1))+128;
|
||||
m3=Math.floor((c3-128)/Math.sqrt(idiv+1))+128;
|
||||
if (m1>15) s1=(m1).toString(16); else s1="0"+(m1).toString(16);
|
||||
if (m2>15) s2=(m2).toString(16); else s2="0"+(m2).toString(16);
|
||||
if (m3>15) s3=(m3).toString(16); else s3="0"+(m3).toString(16);
|
||||
color="#"+s1+s2+s3;
|
||||
}
|
||||
rrd_colors.push(color);
|
||||
}
|
||||
}
|
||||
} else { // single element is not treated as an array
|
||||
if (oCB.rrd.checked==true) {
|
||||
// no sense trying to stack a single element
|
||||
rrd_list.push(this.rrd_files[0]);
|
||||
rrd_colors.push(std_colors[0]);
|
||||
}
|
||||
}
|
||||
|
||||
// then extract RRA data about those DSs... to be finished
|
||||
var flot_obj=rrdRRAMultiStackFlotObj(rrd_list,rra_idx,ds_id);
|
||||
|
||||
// fix the colors, based on the position in the RRD
|
||||
for (var i=0; i<flot_obj.data.length; i++) {
|
||||
var name=flot_obj.data[i].label; // at this point, label is the rrd_name
|
||||
var color=rrd_colors[flot_obj.data.length-i-1]; // stack inverts colors
|
||||
var lines=null;
|
||||
if (this.rrd_graph_options[name]!=null) {
|
||||
var dgo=this.rrd_graph_options[name];
|
||||
if (dgo['color']!=null) {
|
||||
color=dgo['color'];
|
||||
}
|
||||
if (dgo['label']!=null) {
|
||||
// if the user provided the label, use it
|
||||
flot_obj.data[i].label=dgo['label'];
|
||||
} else if (dgo['title']!=null) {
|
||||
// use title as a second choice
|
||||
flot_obj.data[i].label=dgo['title'];
|
||||
} // else use the rrd name
|
||||
if (dgo['lines']!=null) {
|
||||
// if the user provided the label, use it
|
||||
flot_obj.data[i].lines=dgo['lines'];
|
||||
}
|
||||
}
|
||||
if (lines==null) {
|
||||
flot_obj.data[i].lines= { show:true, fill: true, fillColor:color };
|
||||
}
|
||||
flot_obj.data[i].color=color;
|
||||
}
|
||||
|
||||
// finally do the real plotting
|
||||
this.bindFlotGraph(flot_obj);
|
||||
};
|
||||
|
||||
// ======================================
|
||||
// Bind the graphs to the HTML tags
|
||||
rrdFlotMatrix.prototype.bindFlotGraph = function(flot_obj) {
|
||||
var rf_this=this; // use obj inside other functions
|
||||
|
||||
// Legend
|
||||
var oSelect=document.getElementById(this.legend_sel_id);
|
||||
var legend_id=oSelect.options[oSelect.selectedIndex].value;
|
||||
|
||||
var graph_jq_id="#"+this.graph_id;
|
||||
var scale_jq_id="#"+this.scale_id;
|
||||
|
||||
var graph_options = {
|
||||
legend: {show:false, position:"nw",noColumns:3},
|
||||
lines: {show:true},
|
||||
xaxis: { mode: "time" },
|
||||
yaxis: { autoscaleMargin: 0.20},
|
||||
selection: { mode: "x" },
|
||||
};
|
||||
|
||||
|
||||
if (legend_id=="None") {
|
||||
// do nothing
|
||||
} else {
|
||||
graph_options.legend.show=true;
|
||||
graph_options.legend.position=legend_id;
|
||||
}
|
||||
|
||||
if (this.selection_range.isSet()) {
|
||||
var selection_range=this.selection_range.getFlotRanges();
|
||||
graph_options.xaxis.min=selection_range.xaxis.from;
|
||||
graph_options.xaxis.max=selection_range.xaxis.to;
|
||||
} else {
|
||||
graph_options.xaxis.min=flot_obj.min;
|
||||
graph_options.xaxis.max=flot_obj.max;
|
||||
}
|
||||
|
||||
if (this.graph_options!=null) {
|
||||
if (this.graph_options.legend!=null) {
|
||||
if (this.graph_options.legend.position!=null) {
|
||||
graph_options.legend.position=this.graph_options.legend.position;
|
||||
}
|
||||
if (this.graph_options.legend.noColumns!=null) {
|
||||
graph_options.legend.noColumns=this.graph_options.legend.noColumns;
|
||||
}
|
||||
}
|
||||
if (this.graph_options.yaxis!=null) {
|
||||
if (this.graph_options.yaxis.autoscaleMargin!=null) {
|
||||
graph_options.yaxis.autoscaleMargin=this.graph_options.yaxis.autoscaleMargin;
|
||||
}
|
||||
}
|
||||
if (this.graph_options.lines!=null) {
|
||||
graph_options.lines=this.graph_options.lines;
|
||||
}
|
||||
}
|
||||
|
||||
var scale_options = {
|
||||
legend: {show:false},
|
||||
lines: {show:true},
|
||||
xaxis: { mode: "time", min:flot_obj.min, max:flot_obj.max },
|
||||
selection: { mode: "x" },
|
||||
};
|
||||
|
||||
var flot_data=flot_obj.data;
|
||||
|
||||
var graph_data=this.selection_range.trim_flot_data(flot_data);
|
||||
var scale_data=flot_data;
|
||||
|
||||
this.graph = $.plot($(graph_jq_id), graph_data, graph_options);
|
||||
this.scale = $.plot($(scale_jq_id), scale_data, scale_options);
|
||||
|
||||
if (this.selection_range.isSet()) {
|
||||
this.scale.setSelection(this.selection_range.getFlotRanges(),true); //don't fire event, no need
|
||||
}
|
||||
|
||||
// now connect the two
|
||||
$(graph_jq_id).bind("plotselected", function (event, ranges) {
|
||||
// do the zooming
|
||||
rf_this.selection_range.setFromFlotRanges(ranges);
|
||||
graph_options.xaxis.min=ranges.xaxis.from;
|
||||
graph_options.xaxis.max=ranges.xaxis.to;
|
||||
rf_this.graph = $.plot($(graph_jq_id), rf_this.selection_range.trim_flot_data(flot_data), graph_options);
|
||||
|
||||
// don't fire event on the scale to prevent eternal loop
|
||||
rf_this.scale.setSelection(ranges, true);
|
||||
});
|
||||
|
||||
$(scale_jq_id).bind("plotselected", function (event, ranges) {
|
||||
rf_this.graph.setSelection(ranges);
|
||||
});
|
||||
|
||||
// only the scale has a selection
|
||||
// so when that is cleared, redraw also the graph
|
||||
$(scale_jq_id).bind("plotunselected", function() {
|
||||
rf_this.selection_range.reset();
|
||||
graph_options.xaxis.min=flot_obj.min;
|
||||
graph_options.xaxis.max=flot_obj.max;
|
||||
rf_this.graph = $.plot($(graph_jq_id), rf_this.selection_range.trim_flot_data(flot_data), graph_options);
|
||||
});
|
||||
};
|
||||
|
||||
// callback functions that are called when one of the selections changes
|
||||
rrdFlotMatrix.prototype.callback_res_changed = function() {
|
||||
this.drawFlotGraph();
|
||||
};
|
||||
|
||||
rrdFlotMatrix.prototype.callback_ds_changed = function() {
|
||||
this.drawFlotGraph();
|
||||
};
|
||||
|
||||
rrdFlotMatrix.prototype.callback_rrd_cb_changed = function() {
|
||||
this.drawFlotGraph();
|
||||
};
|
||||
|
||||
rrdFlotMatrix.prototype.callback_scale_reset = function() {
|
||||
this.scale.clearSelection();
|
||||
};
|
||||
|
||||
rrdFlotMatrix.prototype.callback_legend_changed = function() {
|
||||
this.drawFlotGraph();
|
||||
};
|
||||
|
||||
@ -1,399 +0,0 @@
|
||||
/*
|
||||
* Support library aimed at providing commonly used functions and classes
|
||||
* that may be used while plotting RRD files with Flot
|
||||
*
|
||||
* Part of the javascriptRRD package
|
||||
* Copyright (c) 2009 Frank Wuerthwein, fkw@ucsd.edu
|
||||
*
|
||||
* Original repository: http://javascriptrrd.sourceforge.net/
|
||||
*
|
||||
* MIT License [http://www.opensource.org/licenses/mit-license.php]
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
*
|
||||
* Flot is a javascript plotting library developed and maintained by
|
||||
* Ole Laursen [http://code.google.com/p/flot/]
|
||||
*
|
||||
*/
|
||||
|
||||
// Return a Flot-like data structure
|
||||
// Since Flot does not properly handle empty elements, min and max are returned, too
|
||||
function rrdDS2FlotSeries(rrd_file,ds_id,rra_idx,want_rounding) {
|
||||
var ds=rrd_file.getDS(ds_id);
|
||||
var ds_name=ds.getName();
|
||||
var ds_idx=ds.getIdx();
|
||||
var rra=rrd_file.getRRA(rra_idx);
|
||||
var rra_rows=rra.getNrRows();
|
||||
var last_update=rrd_file.getLastUpdate();
|
||||
var step=rra.getStep();
|
||||
|
||||
if (want_rounding!=false) {
|
||||
// round last_update to step
|
||||
// so that all elements are sync
|
||||
last_update-=(last_update%step);
|
||||
}
|
||||
|
||||
var first_el=last_update-(rra_rows-1)*step;
|
||||
var timestamp=first_el;
|
||||
var flot_series=[];
|
||||
for (var i=0;i<rra_rows;i++) {
|
||||
var el=rra.getEl(i,ds_idx);
|
||||
if (el!=undefined) {
|
||||
flot_series.push([timestamp*1000.0,el]);
|
||||
}
|
||||
timestamp+=step;
|
||||
} // end for
|
||||
|
||||
return {label: ds_name, data: flot_series, min: first_el*1000.0, max:last_update*1000.0};
|
||||
}
|
||||
|
||||
// return an object with an array containing Flot elements, one per DS
|
||||
// min and max are also returned
|
||||
function rrdRRA2FlotObj(rrd_file,rra_idx,ds_list,want_ds_labels,want_rounding) {
|
||||
var rra=rrd_file.getRRA(rra_idx);
|
||||
var rra_rows=rra.getNrRows();
|
||||
var last_update=rrd_file.getLastUpdate();
|
||||
var step=rra.getStep();
|
||||
if (want_rounding!=false) {
|
||||
// round last_update to step
|
||||
// so that all elements are sync
|
||||
last_update-=(last_update%step);
|
||||
}
|
||||
|
||||
var first_el=last_update-(rra_rows-1)*step;
|
||||
|
||||
var out_el={data:[], min:first_el*1000.0, max:last_update*1000.0};
|
||||
|
||||
for (ds_list_idx in ds_list) {
|
||||
var ds_id=ds_list[ds_list_idx];
|
||||
var ds=rrd_file.getDS(ds_id);
|
||||
var ds_name=ds.getName();
|
||||
var ds_idx=ds.getIdx();
|
||||
|
||||
var timestamp=first_el;
|
||||
var flot_series=[];
|
||||
for (var i=0;i<rra_rows;i++) {
|
||||
var el=rra.getEl(i,ds_idx);
|
||||
if (el!=undefined) {
|
||||
flot_series.push([timestamp*1000.0,el]);
|
||||
}
|
||||
timestamp+=step;
|
||||
} // end for
|
||||
|
||||
var flot_el={data:flot_series};
|
||||
if (want_ds_labels!=false) {
|
||||
var ds_name=ds.getName();
|
||||
flot_el.label= ds_name;
|
||||
}
|
||||
out_el.data.push(flot_el);
|
||||
} //end for ds_list_idx
|
||||
return out_el;
|
||||
}
|
||||
|
||||
// return an object with an array containing Flot elements
|
||||
// have a positive and a negative stack of DSes, plus DSes with no stacking
|
||||
// min and max are also returned
|
||||
// If one_undefined_enough==true, a whole stack is invalidated if a single element
|
||||
// of the stack is invalid
|
||||
function rrdRRAStackFlotObj(rrd_file,rra_idx,
|
||||
ds_positive_stack_list,ds_negative_stack_list,ds_single_list,
|
||||
tz_offset,
|
||||
want_ds_labels,want_rounding,one_undefined_enough) {
|
||||
|
||||
var rra=rrd_file.getRRA(rra_idx);
|
||||
var rra_rows=rra.getNrRows();
|
||||
var last_update=rrd_file.getLastUpdate();
|
||||
var step=rra.getStep();
|
||||
if (want_rounding!=false) {
|
||||
// round last_update to step
|
||||
// so that all elements are sync
|
||||
last_update-=(last_update%step);
|
||||
}
|
||||
if (one_undefined_enough!=true) { // make sure it is a boolean
|
||||
one_undefined_enough=false;
|
||||
}
|
||||
|
||||
var first_el=last_update-(rra_rows-1)*step;
|
||||
var out_el={data:[], min:(first_el+tz_offset)*1000.0, max:(last_update+tz_offset)*1000.0};
|
||||
|
||||
// first the stacks stack
|
||||
var stack_els=[ds_positive_stack_list,ds_negative_stack_list];
|
||||
for (stack_list_id in stack_els) {
|
||||
var stack_list=stack_els[stack_list_id];
|
||||
var tmp_flot_els=[];
|
||||
var tmp_ds_ids=[];
|
||||
var tmp_nr_ids=stack_list.length;
|
||||
for (ds_list_idx in stack_list) {
|
||||
var ds_id=stack_list[ds_list_idx];
|
||||
var ds=rrd_file.getDS(ds_id);
|
||||
var ds_name=ds.getName();
|
||||
var ds_idx=ds.getIdx();
|
||||
tmp_ds_ids.push(ds_idx); // getting this is expensive, call only once
|
||||
|
||||
// initialize
|
||||
var flot_el={data:[]}
|
||||
if (want_ds_labels!=false) {
|
||||
var ds_name=ds.getName();
|
||||
flot_el.label= ds_name;
|
||||
}
|
||||
tmp_flot_els.push(flot_el);
|
||||
}
|
||||
|
||||
var timestamp=first_el;
|
||||
for (var row=0;row<rra_rows;row++) {
|
||||
var ds_vals=[];
|
||||
var all_undef=true;
|
||||
var all_def=true;
|
||||
for (var id=0; id<tmp_nr_ids; id++) {
|
||||
var ds_idx=tmp_ds_ids[id];
|
||||
var el=rra.getEl(row,ds_idx);
|
||||
if (el!=undefined) {
|
||||
all_undef=false;
|
||||
ds_vals.push(el);
|
||||
} else {
|
||||
all_def=false;
|
||||
ds_vals.push(0);
|
||||
}
|
||||
} // end for id
|
||||
if (!all_undef) { // if all undefined, skip
|
||||
if (all_def || (!one_undefined_enough)) {
|
||||
// this is a valid column, do the math
|
||||
for (var id=1; id<tmp_nr_ids; id++) {
|
||||
ds_vals[id]+=ds_vals[id-1]; // both positive and negative stack use a +, negative stack assumes negative values
|
||||
}
|
||||
// fill the flot data
|
||||
for (var id=0; id<tmp_nr_ids; id++) {
|
||||
tmp_flot_els[id].data.push([(timestamp+tz_offset)*1000.0,ds_vals[id]]);
|
||||
}
|
||||
}
|
||||
} // end if
|
||||
|
||||
timestamp+=step;
|
||||
} // end for row
|
||||
|
||||
// put flot data in output object
|
||||
// reverse order so higher numbers are behind
|
||||
for (var id=0; id<tmp_nr_ids; id++) {
|
||||
out_el.data.push(tmp_flot_els[tmp_nr_ids-id-1]);
|
||||
}
|
||||
} //end for stack_list_id
|
||||
|
||||
for (ds_list_idx in ds_single_list) {
|
||||
var ds_id=ds_single_list[ds_list_idx];
|
||||
var ds=rrd_file.getDS(ds_id);
|
||||
var ds_name=ds.getName();
|
||||
var ds_idx=ds.getIdx();
|
||||
|
||||
var timestamp=first_el;
|
||||
var flot_series=[];
|
||||
for (var i=0;i<rra_rows;i++) {
|
||||
var el=rra.getEl(i,ds_idx);
|
||||
if (el!=undefined) {
|
||||
flot_series.push([(timestamp+tz_offset)*1000.0,el]);
|
||||
}
|
||||
timestamp+=step;
|
||||
} // end for
|
||||
|
||||
var flot_el={data:flot_series};
|
||||
if (want_ds_labels!=false) {
|
||||
var ds_name=ds.getName();
|
||||
flot_el.label= ds_name;
|
||||
}
|
||||
out_el.data.push(flot_el);
|
||||
} //end for ds_list_idx
|
||||
|
||||
return out_el;
|
||||
}
|
||||
|
||||
// return an object with an array containing Flot elements, one per RRD
|
||||
// min and max are also returned
|
||||
function rrdRRAMultiStackFlotObj(rrd_files, // a list of [rrd_id,rrd_file] pairs, all rrds must have the same step
|
||||
rra_idx,ds_id,
|
||||
want_rrd_labels,want_rounding,
|
||||
one_undefined_enough) { // If true, a whole stack is invalidated if a single element of the stack is invalid
|
||||
|
||||
var reference_rra=rrd_files[0][1].getRRA(rra_idx); // get the first one, all should be the same
|
||||
var rows=reference_rra.getNrRows();
|
||||
var step=reference_rra.getStep();
|
||||
var ds_idx=rrd_files[0][1].getDS(ds_id).getIdx(); // this can be expensive, do once (all the same)
|
||||
|
||||
// rrds can be slightly shifted, calculate range
|
||||
var max_ts=null;
|
||||
var min_ts=null;
|
||||
|
||||
// initialize list of rrd data elements
|
||||
var tmp_flot_els=[];
|
||||
var tmp_rras=[];
|
||||
var tmp_last_updates=[];
|
||||
var tmp_nr_ids=rrd_files.length;
|
||||
for (var id=0; id<tmp_nr_ids; id++) {
|
||||
var rrd_file=rrd_files[id][1];
|
||||
var rrd_rra=rrd_file.getRRA(rra_idx);
|
||||
|
||||
var rrd_last_update=rrd_file.getLastUpdate();
|
||||
if (want_rounding!=false) {
|
||||
// round last_update to step
|
||||
// so that all elements are sync
|
||||
rrd_last_update-=(rrd_last_update%step);
|
||||
}
|
||||
tmp_last_updates.push(rrd_last_update);
|
||||
|
||||
var rrd_min_ts=rrd_last_update-(rows-1)*step;
|
||||
if ((max_ts==null) || (rrd_last_update>max_ts)) {
|
||||
max_ts=rrd_last_update;
|
||||
}
|
||||
if ((min_ts==null) || (rrd_min_ts<min_ts)) {
|
||||
min_ts=rrd_min_ts;
|
||||
}
|
||||
|
||||
tmp_rras.push(rrd_rra);
|
||||
|
||||
// initialize
|
||||
var flot_el={data:[]}
|
||||
if (want_rrd_labels!=false) {
|
||||
var rrd_name=rrd_files[id][0];
|
||||
flot_el.label= rrd_name;
|
||||
}
|
||||
tmp_flot_els.push(flot_el);
|
||||
}
|
||||
|
||||
var out_el={data:[], min:min_ts*1000.0, max:max_ts*1000.0};
|
||||
|
||||
for (var ts=min_ts;ts<=max_ts;ts+=step) {
|
||||
var rrd_vals=[];
|
||||
var all_undef=true;
|
||||
var all_def=true;
|
||||
for (var id=0; id<tmp_nr_ids; id++) {
|
||||
var rrd_rra=tmp_rras[id];
|
||||
var rrd_last_update=tmp_last_updates[id];
|
||||
var row_delta=Math.round((rrd_last_update-ts)/step);
|
||||
var el=undefined; // if out of range
|
||||
if ((row_delta>=0) && (row_delta<rows)) {
|
||||
el=rrd_rra.getEl(rows-row_delta-1,ds_idx);
|
||||
}
|
||||
if (el!=undefined) {
|
||||
all_undef=false;
|
||||
rrd_vals.push(el);
|
||||
} else {
|
||||
all_def=false;
|
||||
rrd_vals.push(0);
|
||||
}
|
||||
} // end for id
|
||||
if (!all_undef) { // if all undefined, skip
|
||||
if (all_def || (!one_undefined_enough)) {
|
||||
// this is a valid column, do the math
|
||||
for (var id=1; id<tmp_nr_ids; id++) {
|
||||
rrd_vals[id]+=rrd_vals[id-1];
|
||||
}
|
||||
// fill the flot data
|
||||
for (var id=0; id<tmp_nr_ids; id++) {
|
||||
tmp_flot_els[id].data.push([ts*1000.0,rrd_vals[id]]);
|
||||
}
|
||||
}
|
||||
} // end if
|
||||
} // end for ts
|
||||
|
||||
// put flot data in output object
|
||||
// reverse order so higher numbers are behind
|
||||
for (var id=0; id<tmp_nr_ids; id++) {
|
||||
out_el.data.push(tmp_flot_els[tmp_nr_ids-id-1]);
|
||||
}
|
||||
|
||||
return out_el;
|
||||
}
|
||||
|
||||
// ======================================
|
||||
// Helper class for handling selections
|
||||
// =======================================================
|
||||
function rrdFlotSelection() {
|
||||
this.selection_min=null;
|
||||
this.selection_max=null;
|
||||
};
|
||||
|
||||
// reset to a state where ther is no selection
|
||||
rrdFlotSelection.prototype.reset = function() {
|
||||
this.selection_min=null;
|
||||
this.selection_max=null;
|
||||
};
|
||||
|
||||
// given the selection ranges, set internal variable accordingly
|
||||
rrdFlotSelection.prototype.setFromFlotRanges = function(ranges) {
|
||||
this.selection_min=ranges.xaxis.from;
|
||||
this.selection_max=ranges.xaxis.to;
|
||||
};
|
||||
|
||||
// Return a Flot ranges structure that can be promptly used in setSelection
|
||||
rrdFlotSelection.prototype.getFlotRanges = function() {
|
||||
return { xaxis: {from: this.selection_min, to: this.selection_max}};
|
||||
};
|
||||
|
||||
// return true is a selection is in use
|
||||
rrdFlotSelection.prototype.isSet = function() {
|
||||
return this.selection_min!=null;
|
||||
};
|
||||
|
||||
// Given an array of flot lines, limit to the selection
|
||||
rrdFlotSelection.prototype.trim_flot_data = function(flot_data) {
|
||||
var out_data=[];
|
||||
for (var i=0; i<flot_data.length; i++) {
|
||||
var data_el=flot_data[i];
|
||||
out_data.push({label : data_el.label, data:this.trim_data(data_el.data), color:data_el.color, lines:data_el.lines, yaxis:data_el.yaxis});
|
||||
}
|
||||
return out_data;
|
||||
};
|
||||
|
||||
// Limit to selection the flot series data element
|
||||
rrdFlotSelection.prototype.trim_data = function(data_list) {
|
||||
if (this.selection_min==null) return data_list; // no selection => no filtering
|
||||
|
||||
var out_data=[];
|
||||
for (var i=0; i<data_list.length; i++) {
|
||||
if (data_list[i]==null) continue; // protect
|
||||
var nr=data_list[i][0];
|
||||
if ((nr>=this.selection_min) && (nr<=this.selection_max)) {
|
||||
out_data.push(data_list[i]);
|
||||
}
|
||||
}
|
||||
return out_data;
|
||||
};
|
||||
|
||||
// ======================================
|
||||
// Miscelabeous helper functions
|
||||
// ======================================
|
||||
|
||||
function rfs_format_time(s) {
|
||||
if (s<120) {
|
||||
return s+"s";
|
||||
} else {
|
||||
var s60=s%60;
|
||||
var m=(s-s60)/60;
|
||||
if ((m<10) && (s60>9)) {
|
||||
return m+":"+s60+"min";
|
||||
} if (m<120) {
|
||||
return m+"min";
|
||||
} else {
|
||||
var m60=m%60;
|
||||
var h=(m-m60)/60;
|
||||
if ((h<12) && (m60>9)) {
|
||||
return h+":"+m60+"h";
|
||||
} if (h<48) {
|
||||
return h+"h";
|
||||
} else {
|
||||
var h24=h%24;
|
||||
var d=(h-h24)/24;
|
||||
if ((d<7) && (h24>0)) {
|
||||
return d+" days "+h24+"h";
|
||||
} if (d<60) {
|
||||
return d+" days";
|
||||
} else {
|
||||
var d30=d%30;
|
||||
var mt=(d-d30)/30;
|
||||
return mt+" months";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@ -1,173 +0,0 @@
|
||||
/*
|
||||
* Combine multiple rrdFiles into one object
|
||||
* It implements the same interface, but changing the content
|
||||
*
|
||||
* Part of the javascriptRRD package
|
||||
* Copyright (c) 2010 Igor Sfiligoi, isfiligoi@ucsd.edu
|
||||
*
|
||||
* Original repository: http://javascriptrrd.sourceforge.net/
|
||||
*
|
||||
* MIT License [http://www.opensource.org/licenses/mit-license.php]
|
||||
*
|
||||
*/
|
||||
|
||||
// ============================================================
|
||||
// RRD RRA handling class
|
||||
function RRDRRASum(rra_list,offset_list,treat_undefined_as_zero) {
|
||||
this.rra_list=rra_list;
|
||||
this.offset_list=offset_list;
|
||||
this.treat_undefined_as_zero=treat_undefined_as_zero;
|
||||
this.row_cnt= this.rra_list[0].getNrRows();
|
||||
}
|
||||
|
||||
RRDRRASum.prototype.getIdx = function() {
|
||||
return this.rra_list[0].getIdx();
|
||||
}
|
||||
|
||||
// Get number of rows/columns
|
||||
RRDRRASum.prototype.getNrRows = function() {
|
||||
return this.row_cnt;
|
||||
}
|
||||
RRDRRASum.prototype.getNrDSs = function() {
|
||||
return this.rra_list[0].getNrDSs();
|
||||
}
|
||||
|
||||
// Get RRA step (expressed in seconds)
|
||||
RRDRRASum.prototype.getStep = function() {
|
||||
return this.rra_list[0].getStep();
|
||||
}
|
||||
|
||||
// Get consolidation function name
|
||||
RRDRRASum.prototype.getCFName = function() {
|
||||
return this.rra_list[0].getCFName();
|
||||
}
|
||||
|
||||
RRDRRASum.prototype.getEl = function(row_idx,ds_idx) {
|
||||
var outSum=0.0;
|
||||
for (var i in this.rra_list) {
|
||||
var offset=this.offset_list[i];
|
||||
if ((row_idx+offset)<this.row_cnt) {
|
||||
var rra=this.rra_list[i];
|
||||
val=rra.getEl(row_idx+offset,ds_idx);
|
||||
} else {
|
||||
/* out of row range -> undefined*/
|
||||
val=undefined;
|
||||
}
|
||||
/* treat all undefines as 0 for now */
|
||||
if (val==undefined) {
|
||||
if (this.treat_undefined_as_zero) {
|
||||
val=0;
|
||||
} else {
|
||||
/* if even one element is undefined, the whole sum is undefined */
|
||||
outSum=undefined;
|
||||
break;
|
||||
}
|
||||
}
|
||||
outSum+=val;
|
||||
}
|
||||
return outSum;
|
||||
}
|
||||
|
||||
// Low precision version of getEl
|
||||
// Uses getFastDoubleAt
|
||||
RRDRRASum.prototype.getElFast = function(row_idx,ds_idx) {
|
||||
var outSum=0.0;
|
||||
for (var i in this.rra_list) {
|
||||
var offset=this.offset_list[i];
|
||||
if ((row_id+offset)<this.row_cnt) {
|
||||
var rra=this.rra_list[i];
|
||||
val=rra.getElFast(row_idx+offset,ds_idx);
|
||||
} else {
|
||||
/* out of row range -> undefined*/
|
||||
val=undefined;
|
||||
}
|
||||
/* treat all undefines as 0 for now */
|
||||
if (val==undefined) {
|
||||
if (this.treat_undefined_as_zero) {
|
||||
val=0;
|
||||
} else {
|
||||
/* if even one element is undefined, the whole sum is undefined */
|
||||
outSum=undefined;
|
||||
break;
|
||||
}
|
||||
}
|
||||
outSum+=val;
|
||||
}
|
||||
return outSum;
|
||||
}
|
||||
|
||||
/*** INTERNAL ** sort by lastupdate, descending ***/
|
||||
|
||||
function rrdFileSort(f1, f2) {
|
||||
return f2.getLastUpdate()-f1.getLastUpdate();
|
||||
}
|
||||
|
||||
/*
|
||||
* Sum several RRDfiles together
|
||||
* They must all have the same DSes and the same RRAs
|
||||
*/
|
||||
|
||||
function RRDFileSum(file_list,treat_undefined_as_zero) {
|
||||
if (treat_undefined_as_zero==undefined) {
|
||||
this.treat_undefined_as_zero=true;
|
||||
} else {
|
||||
this.treat_undefined_as_zero=treat_undefined_as_zero;
|
||||
}
|
||||
this.file_list=file_list;
|
||||
this.file_list.sort();
|
||||
|
||||
// ===================================
|
||||
// Start of user functions
|
||||
|
||||
this.getMinStep = function() {
|
||||
return this.file_list[0].getMinStep();
|
||||
}
|
||||
this.getLastUpdate = function() {
|
||||
return this.file_list[0].getLastUpdate();
|
||||
}
|
||||
|
||||
this.getNrDSs = function() {
|
||||
return this.file_list[0].getNrDSs();
|
||||
}
|
||||
|
||||
this.getDSNames = function() {
|
||||
return this.file_list[0].getDSNames();
|
||||
}
|
||||
|
||||
this.getDS = function(id) {
|
||||
return this.file_list[0].getDS(id);
|
||||
}
|
||||
|
||||
this.getNrRRAs = function() {
|
||||
return this.file_list[0].getNrRRAs();
|
||||
}
|
||||
|
||||
this.getRRAInfo = function(idx) {
|
||||
return this.file_list[0].getRRAInfo(idx);
|
||||
}
|
||||
|
||||
this.getRRA = function(idx) {
|
||||
var rra_info=this.getRRAInfo(idx);
|
||||
var rra_step=rra_info.getStep();
|
||||
var realLastUpdate=undefined;
|
||||
|
||||
var rra_list=new Array();
|
||||
var offset_list=new Array();
|
||||
for (var i in this.file_list) {
|
||||
file=file_list[i];
|
||||
fileLastUpdate=file.getLastUpdate();
|
||||
if (realLastUpdate!=undefined) {
|
||||
fileSkrew=Math.floor((realLastUpdate-fileLastUpdate)/rra_step);
|
||||
} else {
|
||||
fileSkrew=0;
|
||||
firstLastUpdate=fileLastUpdate;
|
||||
}
|
||||
offset_list.push(fileSkrew);
|
||||
fileRRA=file.getRRA(idx);
|
||||
rra_list.push(fileRRA);
|
||||
}
|
||||
|
||||
return new RRDRRASum(rra_list,offset_list,this.treat_undefined_as_zero);
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,106 +0,0 @@
|
||||
[% site_config.title = c.loc('System Statistics') -%]
|
||||
|
||||
<!--[if lte IE 9]><script language="javascript" type="text/javascript" src="/js/jsrrd/flot/excanvas.min.js"></script><![endif]-->
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/jsrrd/binaryXHR.js"></script>
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/jsrrd/rrdFile.js"></script>
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/jsrrd/rrdMultiFile.js"></script>
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/jsrrd/rrdFlotSupport.js"></script>
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/jsrrd/rrdFlot.js"></script>
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/flot/jquery.flot.js"></script>
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/flot/jquery.flot.selection.js"></script>
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/flot/jquery.flot.pie.js"></script>
|
||||
<script type="text/javascript" src="/js/libs/jsrrd/flot/jquery.flot.time.js"></script>
|
||||
<script type="text/javascript" >
|
||||
$(document).ready(function() {
|
||||
$('#host').change(function() {
|
||||
$('#folder').load('/statistics/subdirs/' + $(this).attr('value'));
|
||||
});
|
||||
});
|
||||
</script>
|
||||
|
||||
[% UNLESS framed -%]
|
||||
<div class="row">
|
||||
<span>
|
||||
<a class="btn btn-primary btn-large" href="[% c.uri_for('/back') %]"><i class="icon-arrow-left"></i> [% c.loc('Back') %]</a>
|
||||
</span>
|
||||
</div>
|
||||
[% back_created = 1 -%]
|
||||
[% END -%]
|
||||
|
||||
<div class="ngcp-separator"></div>
|
||||
|
||||
<div class="row-fluid">
|
||||
[% form.render %]
|
||||
</div>
|
||||
|
||||
<div class="ngcp-separator"></div>
|
||||
|
||||
<div class="ngcp-statistics">
|
||||
|
||||
<p>[% c.loc('Click&Drag on the graphs to zoom individual ranges.') | html %]</p>
|
||||
|
||||
<div class="row-fluid">
|
||||
[% even = 0 %]
|
||||
[% FOREACH item IN plotdata %]
|
||||
<h3>[% item.title %]</h3>
|
||||
<div id="plot_[% item.name | replace('[^a-zA-Z0-9_]+', '_') %]" class="ngcp-plot"><div style="margin: 20px;"><img src="/img/loader.gif" alt="loading" style="margin-right: 10px;"/>[% c.loc('loading...') %]</div></div>
|
||||
[% END %]
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script type="text/javascript">
|
||||
|
||||
function update_fname(rrd_data_arr, args) {
|
||||
var graph_opts = {};
|
||||
var ds_graph_opts = {};
|
||||
var tz_offset = [% tz_offset %];
|
||||
|
||||
if (rrd_data_arr.length == 1)
|
||||
var f = new rrdFlot(args['plot_id'],rrd_data_arr[0],graph_opts,ds_graph_opts,args['si_suffix'],tz_offset);
|
||||
else {
|
||||
var t = new RRDFileSum(rrd_data_arr, false);
|
||||
var f = new rrdFlot(args['plot_id'],t,graph_opts,ds_graph_opts,args['si_suffix'],tz_offset);
|
||||
}
|
||||
}
|
||||
|
||||
function update_fname_handler(bf, args) {
|
||||
var rrd_data=undefined;
|
||||
var fname = args['name'];
|
||||
var output = args['output'];
|
||||
try {
|
||||
var rrd_data=new RRDFile(bf);
|
||||
} catch(err) {
|
||||
alert("File "+fname+" is not a valid RRD archive!");
|
||||
}
|
||||
if (rrd_data!=undefined) {
|
||||
output.push(rrd_data);
|
||||
if (output.length >= args['rrd_count']) {
|
||||
update_fname(output, args);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function fname_update(fname, plot_id, si_suffix) {
|
||||
var o = new Array();
|
||||
for (var i = 0; i < fname.length; i++) {
|
||||
try {
|
||||
FetchBinaryURLAsync(fname[i], update_fname_handler, {plot_id: plot_id,
|
||||
si_suffix: si_suffix, rrd_count: fname.length, name: fname[i],
|
||||
output: o});
|
||||
} catch (err) {
|
||||
alert("Failed loading "+fname[i]+"\n"+err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[% FOREACH item IN plotdata %]
|
||||
fname_update([
|
||||
[% FOREACH url IN item.url %]
|
||||
"[% url %]",
|
||||
[% END %]
|
||||
], "plot_[% item.name | replace('[^a-zA-Z0-9_]+', '_') %]", [% item.si ? "true" : "false" %]);
|
||||
[% END %]
|
||||
|
||||
</script>
|
||||
|
||||
[% # vim: set tabstop=4 syntax=html expandtab: -%]
|
||||
Loading…
Reference in new issue