|
|
@@ -0,0 +1,1104 @@
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ * Smoothie Charts - http:
|
|
|
+ * (c) 2010-2013, Joe Walnes
|
|
|
+ * 2013-2018, Drew Noakes
|
|
|
+ *
|
|
|
+ * v1.0: Main charting library, by Joe Walnes
|
|
|
+ * v1.1: Auto scaling of axis, by Neil Dunn
|
|
|
+ * v1.2: fps (frames per second) option, by Mathias Petterson
|
|
|
+ * v1.3: Fix for divide by zero, by Paul Nikitochkin
|
|
|
+ * v1.4: Set minimum, top-scale padding, remove timeseries, add optional timer to reset bounds, by Kelley Reynolds
|
|
|
+ * v1.5: Set default frames per second to 50... smoother.
|
|
|
+ * .start(), .stop() methods for conserving CPU, by Dmitry Vyal
|
|
|
+ * options.interpolation = 'bezier' or 'line', by Dmitry Vyal
|
|
|
+ * options.maxValue to fix scale, by Dmitry Vyal
|
|
|
+ * v1.6: minValue/maxValue will always get converted to floats, by Przemek Matylla
|
|
|
+ * v1.7: options.grid.fillStyle may be a transparent color, by Dmitry A. Shashkin
|
|
|
+ * Smooth rescaling, by Kostas Michalopoulos
|
|
|
+ * v1.8: Set max length to customize number of live points in the dataset with options.maxDataSetLength, by Krishna Narni
|
|
|
+ * v1.9: Display timestamps along the bottom, by Nick and Stev-io
|
|
|
+ * (https:
|
|
|
+ * Refactored by Krishna Narni, to support timestamp formatting function
|
|
|
+ * v1.10: Switch to requestAnimationFrame, removed the now obsoleted options.fps, by Gergely Imreh
|
|
|
+ * v1.11: options.grid.sharpLines option added, by @drewnoakes
|
|
|
+ * Addressed warning seen in Firefox when seriesOption.fillStyle undefined, by @drewnoakes
|
|
|
+ * v1.12: Support for horizontalLines added, by @drewnoakes
|
|
|
+ * Support for yRangeFunction callback added, by @drewnoakes
|
|
|
+ * v1.13: Fixed typo (#32), by @alnikitich
|
|
|
+ * v1.14: Timer cleared when last TimeSeries removed (#23), by @davidgaleano
|
|
|
+ * Fixed diagonal line on chart at start/end of data stream, by @drewnoakes
|
|
|
+ * v1.15: Support for npm package (#18), by @dominictarr
|
|
|
+ * Fixed broken removeTimeSeries function (#24) by @davidgaleano
|
|
|
+ * Minor performance and tidying, by @drewnoakes
|
|
|
+ * v1.16: Bug fix introduced in v1.14 relating to timer creation/clearance (#23), by @drewnoakes
|
|
|
+ * TimeSeries.append now deals with out-of-order timestamps, and can merge duplicates, by @zacwitte (#12)
|
|
|
+ * Documentation and some local variable renaming for clarity, by @drewnoakes
|
|
|
+ * v1.17: Allow control over font size (#10), by @drewnoakes
|
|
|
+ * Timestamp text won't overlap, by @drewnoakes
|
|
|
+ * v1.18: Allow control of max/min label precision, by @drewnoakes
|
|
|
+ * Added 'borderVisible' chart option, by @drewnoakes
|
|
|
+ * Allow drawing series with fill but no stroke (line), by @drewnoakes
|
|
|
+ * v1.19: Avoid unnecessary repaints, and fixed flicker in old browsers having multiple charts in document (#40), by @asbai
|
|
|
+ * v1.20: Add SmoothieChart.getTimeSeriesOptions and SmoothieChart.bringToFront functions, by @drewnoakes
|
|
|
+ * v1.21: Add 'step' interpolation mode, by @drewnoakes
|
|
|
+ * v1.22: Add support for different pixel ratios. Also add optional y limit formatters, by @copacetic
|
|
|
+ * v1.23: Fix bug introduced in v1.22 (#44), by @drewnoakes
|
|
|
+ * v1.24: Fix bug introduced in v1.23, re-adding parseFloat to y-axis formatter defaults, by @siggy_sf
|
|
|
+ * v1.25: Fix bug seen when adding a data point to TimeSeries which is older than the current data, by @Nking92
|
|
|
+ * Draw time labels on top of series, by @comolosabia
|
|
|
+ * Add TimeSeries.clear function, by @drewnoakes
|
|
|
+ * v1.26: Add support for resizing on high device pixel ratio screens, by @copacetic
|
|
|
+ * v1.27: Fix bug introduced in v1.26 for non whole number devicePixelRatio values, by @zmbush
|
|
|
+ * v1.28: Add 'minValueScale' option, by @megawac
|
|
|
+ * Fix 'labelPos' for different size of 'minValueString' 'maxValueString', by @henryn
|
|
|
+ * v1.29: Support responsive sizing, by @drewnoakes
|
|
|
+ * v1.29.1: Include types in package, and make property optional, by @TrentHouliston
|
|
|
+ * v1.30: Fix inverted logic in devicePixelRatio support, by @scanlime
|
|
|
+ * v1.31: Support tooltips, by @Sly1024 and @drewnoakes
|
|
|
+ * v1.32: Support frame rate limit, by @dpuyosa
|
|
|
+ * v1.33: Use Date static method instead of instance, by @nnnoel
|
|
|
+ * Fix bug with tooltips when multiple charts on a page, by @jpmbiz70
|
|
|
+ * v1.34: Add disabled option to TimeSeries, by @TechGuard (#91)
|
|
|
+ * Add nonRealtimeData option, by @annazhelt (#92, #93)
|
|
|
+ * Add showIntermediateLabels option, by @annazhelt (#94)
|
|
|
+ * Add displayDataFromPercentile option, by @annazhelt (#95)
|
|
|
+ * Fix bug when hiding tooltip element, by @ralphwetzel (#96)
|
|
|
+ * Support intermediate y-axis labels, by @beikeland (#99)
|
|
|
+ * v1.35: Fix issue with responsive mode at high DPI, by @drewnoakes (#101)
|
|
|
+ * v1.36: Add tooltipLabel to ITimeSeriesPresentationOptions.
|
|
|
+ * If tooltipLabel is present, tooltipLabel displays inside tooltip
|
|
|
+ * next to value, by @jackdesert (#102)
|
|
|
+ * Fix bug rendering issue in series fill when using scroll backwards, by @olssonfredrik
|
|
|
+ * Add title option, by @mesca
|
|
|
+ */
|
|
|
+
|
|
|
+;(function(exports) {
|
|
|
+
|
|
|
+
|
|
|
+ Date.now = Date.now || function() { return new Date().getTime(); };
|
|
|
+
|
|
|
+ var Util = {
|
|
|
+ extend: function() {
|
|
|
+ arguments[0] = arguments[0] || {};
|
|
|
+ for (var i = 1; i < arguments.length; i++)
|
|
|
+ {
|
|
|
+ for (var key in arguments[i])
|
|
|
+ {
|
|
|
+ if (arguments[i].hasOwnProperty(key))
|
|
|
+ {
|
|
|
+ if (typeof(arguments[i][key]) === 'object') {
|
|
|
+ if (arguments[i][key] instanceof Array) {
|
|
|
+ arguments[0][key] = arguments[i][key];
|
|
|
+ } else {
|
|
|
+ arguments[0][key] = Util.extend(arguments[0][key], arguments[i][key]);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ arguments[0][key] = arguments[i][key];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return arguments[0];
|
|
|
+ },
|
|
|
+ binarySearch: function(data, value) {
|
|
|
+ var low = 0,
|
|
|
+ high = data.length;
|
|
|
+ while (low < high) {
|
|
|
+ var mid = (low + high) >> 1;
|
|
|
+ if (value < data[mid][0])
|
|
|
+ high = mid;
|
|
|
+ else
|
|
|
+ low = mid + 1;
|
|
|
+ }
|
|
|
+ return low;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Initialises a new <code>TimeSeries</code> with optional data options.
|
|
|
+ *
|
|
|
+ * Options are of the form (defaults shown):
|
|
|
+ *
|
|
|
+ * <pre>
|
|
|
+ * {
|
|
|
+ * resetBounds: true,
|
|
|
+ * resetBoundsInterval: 3000
|
|
|
+ * }
|
|
|
+ * </pre>
|
|
|
+ *
|
|
|
+ * Presentation options for TimeSeries are specified as an argument to <code>SmoothieChart.addTimeSeries</code>.
|
|
|
+ *
|
|
|
+ * @constructor
|
|
|
+ */
|
|
|
+ function TimeSeries(options) {
|
|
|
+ this.options = Util.extend({}, TimeSeries.defaultOptions, options);
|
|
|
+ this.disabled = false;
|
|
|
+ this.clear();
|
|
|
+ }
|
|
|
+
|
|
|
+ TimeSeries.defaultOptions = {
|
|
|
+ resetBoundsInterval: 3000,
|
|
|
+ resetBounds: true
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Clears all data and state from this TimeSeries object.
|
|
|
+ */
|
|
|
+ TimeSeries.prototype.clear = function() {
|
|
|
+ this.data = [];
|
|
|
+ this.maxValue = Number.NaN;
|
|
|
+ this.minValue = Number.NaN;
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Recalculate the min/max values for this <code>TimeSeries</code> object.
|
|
|
+ *
|
|
|
+ * This causes the graph to scale itself in the y-axis.
|
|
|
+ */
|
|
|
+ TimeSeries.prototype.resetBounds = function() {
|
|
|
+ if (this.data.length) {
|
|
|
+
|
|
|
+ this.maxValue = this.data[0][1];
|
|
|
+ this.minValue = this.data[0][1];
|
|
|
+ for (var i = 1; i < this.data.length; i++) {
|
|
|
+ var value = this.data[i][1];
|
|
|
+ if (value > this.maxValue) {
|
|
|
+ this.maxValue = value;
|
|
|
+ }
|
|
|
+ if (value < this.minValue) {
|
|
|
+ this.minValue = value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+
|
|
|
+ this.maxValue = Number.NaN;
|
|
|
+ this.minValue = Number.NaN;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Adds a new data point to the <code>TimeSeries</code>, preserving chronological order.
|
|
|
+ *
|
|
|
+ * @param timestamp the position, in time, of this data point
|
|
|
+ * @param value the value of this data point
|
|
|
+ * @param sumRepeatedTimeStampValues if <code>timestamp</code> has an exact match in the series, this flag controls
|
|
|
+ * whether it is replaced, or the values summed (defaults to false.)
|
|
|
+ */
|
|
|
+ TimeSeries.prototype.append = function(timestamp, value, sumRepeatedTimeStampValues) {
|
|
|
+
|
|
|
+ var i = this.data.length - 1;
|
|
|
+ while (i >= 0 && this.data[i][0] > timestamp) {
|
|
|
+ i--;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (i === -1) {
|
|
|
+
|
|
|
+ this.data.splice(0, 0, [timestamp, value]);
|
|
|
+ } else if (this.data.length > 0 && this.data[i][0] === timestamp) {
|
|
|
+
|
|
|
+ if (sumRepeatedTimeStampValues) {
|
|
|
+
|
|
|
+ this.data[i][1] += value;
|
|
|
+ value = this.data[i][1];
|
|
|
+ } else {
|
|
|
+
|
|
|
+ this.data[i][1] = value;
|
|
|
+ }
|
|
|
+ } else if (i < this.data.length - 1) {
|
|
|
+
|
|
|
+ this.data.splice(i + 1, 0, [timestamp, value]);
|
|
|
+ } else {
|
|
|
+
|
|
|
+ this.data.push([timestamp, value]);
|
|
|
+ }
|
|
|
+
|
|
|
+ this.maxValue = isNaN(this.maxValue) ? value : Math.max(this.maxValue, value);
|
|
|
+ this.minValue = isNaN(this.minValue) ? value : Math.min(this.minValue, value);
|
|
|
+ };
|
|
|
+
|
|
|
+ TimeSeries.prototype.dropOldData = function(oldestValidTime, maxDataSetLength) {
|
|
|
+
|
|
|
+
|
|
|
+ var removeCount = 0;
|
|
|
+ while (this.data.length - removeCount >= maxDataSetLength && this.data[removeCount + 1][0] < oldestValidTime) {
|
|
|
+ removeCount++;
|
|
|
+ }
|
|
|
+ if (removeCount !== 0) {
|
|
|
+ this.data.splice(0, removeCount);
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Initialises a new <code>SmoothieChart</code>.
|
|
|
+ *
|
|
|
+ * Options are optional, and should be of the form below. Just specify the values you
|
|
|
+ * need and the rest will be given sensible defaults as shown:
|
|
|
+ *
|
|
|
+ * <pre>
|
|
|
+ * {
|
|
|
+ * minValue: undefined,
|
|
|
+ * maxValue: undefined,
|
|
|
+ * maxValueScale: 1,
|
|
|
+ * minValueScale: 1,
|
|
|
+ * yRangeFunction: undefined,
|
|
|
+ * scaleSmoothing: 0.125,
|
|
|
+ * millisPerPixel: 20,
|
|
|
+ * enableDpiScaling: true,
|
|
|
+ * yMinFormatter: function(min, precision) {
|
|
|
+ * return parseFloat(min).toFixed(precision);
|
|
|
+ * },
|
|
|
+ * yMaxFormatter: function(max, precision) {
|
|
|
+ * return parseFloat(max).toFixed(precision);
|
|
|
+ * },
|
|
|
+ * yIntermediateFormatter: function(intermediate, precision) {
|
|
|
+ * return parseFloat(intermediate).toFixed(precision);
|
|
|
+ * },
|
|
|
+ * maxDataSetLength: 2,
|
|
|
+ * interpolation: 'bezier'
|
|
|
+ * timestampFormatter: null,
|
|
|
+ *
|
|
|
+ * scrollBackwards: false,
|
|
|
+ * horizontalLines: [],
|
|
|
+ * grid:
|
|
|
+ * {
|
|
|
+ * fillStyle: '#000000',
|
|
|
+ * lineWidth: 1,
|
|
|
+ * strokeStyle: '#777777',
|
|
|
+ * millisPerLine: 1000,
|
|
|
+ * sharpLines: false,
|
|
|
+ * verticalSections: 2,
|
|
|
+ * borderVisible: true
|
|
|
+ * },
|
|
|
+ * labels
|
|
|
+ * {
|
|
|
+ * disabled: false,
|
|
|
+ * fillStyle: '#ffffff',
|
|
|
+ * fontSize: 15,
|
|
|
+ * fontFamily: 'sans-serif',
|
|
|
+ * precision: 2,
|
|
|
+ * showIntermediateLabels: false,
|
|
|
+ * intermediateLabelSameAxis: true,
|
|
|
+ * },
|
|
|
+ * title
|
|
|
+ * {
|
|
|
+ * text: '',
|
|
|
+ * fillStyle: '#ffffff',
|
|
|
+ * fontSize: 15,
|
|
|
+ * fontFamily: 'sans-serif',
|
|
|
+ * verticalAlign: 'middle'
|
|
|
+ * },
|
|
|
+ * tooltip: false
|
|
|
+ * tooltipLine: {
|
|
|
+ * lineWidth: 1,
|
|
|
+ * strokeStyle: '#BBBBBB'
|
|
|
+ * },
|
|
|
+ * tooltipFormatter: SmoothieChart.tooltipFormatter,
|
|
|
+ * nonRealtimeData: false,
|
|
|
+ * displayDataFromPercentile: 1,
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * responsive: false,
|
|
|
+ * limitFPS: 0
|
|
|
+ * }
|
|
|
+ * </pre>
|
|
|
+ *
|
|
|
+ * @constructor
|
|
|
+ */
|
|
|
+ function SmoothieChart(options) {
|
|
|
+ this.options = Util.extend({}, SmoothieChart.defaultChartOptions, options);
|
|
|
+ this.seriesSet = [];
|
|
|
+ this.currentValueRange = 1;
|
|
|
+ this.currentVisMinValue = 0;
|
|
|
+ this.lastRenderTimeMillis = 0;
|
|
|
+ this.lastChartTimestamp = 0;
|
|
|
+
|
|
|
+ this.mousemove = this.mousemove.bind(this);
|
|
|
+ this.mouseout = this.mouseout.bind(this);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ SmoothieChart.tooltipFormatter = function (timestamp, data) {
|
|
|
+ var timestampFormatter = this.options.timestampFormatter || SmoothieChart.timeFormatter,
|
|
|
+ lines = [timestampFormatter(new Date(timestamp))],
|
|
|
+ label;
|
|
|
+
|
|
|
+ for (var i = 0; i < data.length; ++i) {
|
|
|
+ label = data[i].series.options.tooltipLabel || ''
|
|
|
+ if (label !== ''){
|
|
|
+ label = label + ' ';
|
|
|
+ }
|
|
|
+ lines.push('<span style="color:' + data[i].series.options.strokeStyle + '">' +
|
|
|
+ label +
|
|
|
+ this.options.yMaxFormatter(data[i].value, this.options.labels.precision) + '</span>');
|
|
|
+ }
|
|
|
+
|
|
|
+ return lines.join('<br>');
|
|
|
+ };
|
|
|
+
|
|
|
+ SmoothieChart.defaultChartOptions = {
|
|
|
+ millisPerPixel: 20,
|
|
|
+ enableDpiScaling: true,
|
|
|
+ yMinFormatter: function(min, precision) {
|
|
|
+ return parseFloat(min).toFixed(precision);
|
|
|
+ },
|
|
|
+ yMaxFormatter: function(max, precision) {
|
|
|
+ return parseFloat(max).toFixed(precision);
|
|
|
+ },
|
|
|
+ yIntermediateFormatter: function(intermediate, precision) {
|
|
|
+ return parseFloat(intermediate).toFixed(precision);
|
|
|
+ },
|
|
|
+ maxValueScale: 1,
|
|
|
+ minValueScale: 1,
|
|
|
+ interpolation: 'bezier',
|
|
|
+ scaleSmoothing: 0.125,
|
|
|
+ maxDataSetLength: 2,
|
|
|
+ scrollBackwards: false,
|
|
|
+ displayDataFromPercentile: 1,
|
|
|
+ grid: {
|
|
|
+ fillStyle: '#000000',
|
|
|
+ strokeStyle: '#777777',
|
|
|
+ lineWidth: 1,
|
|
|
+ sharpLines: false,
|
|
|
+ millisPerLine: 1000,
|
|
|
+ verticalSections: 2,
|
|
|
+ borderVisible: true
|
|
|
+ },
|
|
|
+ labels: {
|
|
|
+ fillStyle: '#ffffff',
|
|
|
+ disabled: false,
|
|
|
+ fontSize: 10,
|
|
|
+ fontFamily: 'monospace',
|
|
|
+ precision: 2,
|
|
|
+ showIntermediateLabels: false,
|
|
|
+ intermediateLabelSameAxis: true,
|
|
|
+ },
|
|
|
+ title: {
|
|
|
+ text: '',
|
|
|
+ fillStyle: '#ffffff',
|
|
|
+ fontSize: 15,
|
|
|
+ fontFamily: 'monospace',
|
|
|
+ verticalAlign: 'middle'
|
|
|
+ },
|
|
|
+ horizontalLines: [],
|
|
|
+ tooltip: false,
|
|
|
+ tooltipLine: {
|
|
|
+ lineWidth: 1,
|
|
|
+ strokeStyle: '#BBBBBB'
|
|
|
+ },
|
|
|
+ tooltipFormatter: SmoothieChart.tooltipFormatter,
|
|
|
+ nonRealtimeData: false,
|
|
|
+ responsive: false,
|
|
|
+ limitFPS: 0
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ SmoothieChart.AnimateCompatibility = (function() {
|
|
|
+ var requestAnimationFrame = function(callback, element) {
|
|
|
+ var requestAnimationFrame =
|
|
|
+ window.requestAnimationFrame ||
|
|
|
+ window.webkitRequestAnimationFrame ||
|
|
|
+ window.mozRequestAnimationFrame ||
|
|
|
+ window.oRequestAnimationFrame ||
|
|
|
+ window.msRequestAnimationFrame ||
|
|
|
+ function(callback) {
|
|
|
+ return window.setTimeout(function() {
|
|
|
+ callback(Date.now());
|
|
|
+ }, 16);
|
|
|
+ };
|
|
|
+ return requestAnimationFrame.call(window, callback, element);
|
|
|
+ },
|
|
|
+ cancelAnimationFrame = function(id) {
|
|
|
+ var cancelAnimationFrame =
|
|
|
+ window.cancelAnimationFrame ||
|
|
|
+ function(id) {
|
|
|
+ clearTimeout(id);
|
|
|
+ };
|
|
|
+ return cancelAnimationFrame.call(window, id);
|
|
|
+ };
|
|
|
+
|
|
|
+ return {
|
|
|
+ requestAnimationFrame: requestAnimationFrame,
|
|
|
+ cancelAnimationFrame: cancelAnimationFrame
|
|
|
+ };
|
|
|
+ })();
|
|
|
+
|
|
|
+ SmoothieChart.defaultSeriesPresentationOptions = {
|
|
|
+ lineWidth: 1,
|
|
|
+ strokeStyle: '#ffffff'
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Adds a <code>TimeSeries</code> to this chart, with optional presentation options.
|
|
|
+ *
|
|
|
+ * Presentation options should be of the form (defaults shown):
|
|
|
+ *
|
|
|
+ * <pre>
|
|
|
+ * {
|
|
|
+ * lineWidth: 1,
|
|
|
+ * strokeStyle: '#ffffff',
|
|
|
+ * fillStyle: undefined,
|
|
|
+ * tooltipLabel: undefined
|
|
|
+ * }
|
|
|
+ * </pre>
|
|
|
+ */
|
|
|
+ SmoothieChart.prototype.addTimeSeries = function(timeSeries, options) {
|
|
|
+ this.seriesSet.push({timeSeries: timeSeries, options: Util.extend({}, SmoothieChart.defaultSeriesPresentationOptions, options)});
|
|
|
+ if (timeSeries.options.resetBounds && timeSeries.options.resetBoundsInterval > 0) {
|
|
|
+ timeSeries.resetBoundsTimerId = setInterval(
|
|
|
+ function() {
|
|
|
+ timeSeries.resetBounds();
|
|
|
+ },
|
|
|
+ timeSeries.options.resetBoundsInterval
|
|
|
+ );
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Removes the specified <code>TimeSeries</code> from the chart.
|
|
|
+ */
|
|
|
+ SmoothieChart.prototype.removeTimeSeries = function(timeSeries) {
|
|
|
+
|
|
|
+ var numSeries = this.seriesSet.length;
|
|
|
+ for (var i = 0; i < numSeries; i++) {
|
|
|
+ if (this.seriesSet[i].timeSeries === timeSeries) {
|
|
|
+ this.seriesSet.splice(i, 1);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (timeSeries.resetBoundsTimerId) {
|
|
|
+
|
|
|
+ clearInterval(timeSeries.resetBoundsTimerId);
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Gets render options for the specified <code>TimeSeries</code>.
|
|
|
+ *
|
|
|
+ * As you may use a single <code>TimeSeries</code> in multiple charts with different formatting in each usage,
|
|
|
+ * these settings are stored in the chart.
|
|
|
+ */
|
|
|
+ SmoothieChart.prototype.getTimeSeriesOptions = function(timeSeries) {
|
|
|
+
|
|
|
+ var numSeries = this.seriesSet.length;
|
|
|
+ for (var i = 0; i < numSeries; i++) {
|
|
|
+ if (this.seriesSet[i].timeSeries === timeSeries) {
|
|
|
+ return this.seriesSet[i].options;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Brings the specified <code>TimeSeries</code> to the top of the chart. It will be rendered last.
|
|
|
+ */
|
|
|
+ SmoothieChart.prototype.bringToFront = function(timeSeries) {
|
|
|
+
|
|
|
+ var numSeries = this.seriesSet.length;
|
|
|
+ for (var i = 0; i < numSeries; i++) {
|
|
|
+ if (this.seriesSet[i].timeSeries === timeSeries) {
|
|
|
+ var set = this.seriesSet.splice(i, 1);
|
|
|
+ this.seriesSet.push(set[0]);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Instructs the <code>SmoothieChart</code> to start rendering to the provided canvas, with specified delay.
|
|
|
+ *
|
|
|
+ * @param canvas the target canvas element
|
|
|
+ * @param delayMillis an amount of time to wait before a data point is shown. This can prevent the end of the series
|
|
|
+ * from appearing on screen, with new values flashing into view, at the expense of some latency.
|
|
|
+ */
|
|
|
+ SmoothieChart.prototype.streamTo = function(canvas, delayMillis) {
|
|
|
+ this.canvas = canvas;
|
|
|
+ this.delay = delayMillis;
|
|
|
+ this.start();
|
|
|
+ };
|
|
|
+
|
|
|
+ SmoothieChart.prototype.getTooltipEl = function () {
|
|
|
+
|
|
|
+ if (!this.tooltipEl) {
|
|
|
+ this.tooltipEl = document.createElement('div');
|
|
|
+ this.tooltipEl.className = 'smoothie-chart-tooltip';
|
|
|
+ this.tooltipEl.style.position = 'absolute';
|
|
|
+ this.tooltipEl.style.display = 'none';
|
|
|
+ document.body.appendChild(this.tooltipEl);
|
|
|
+ }
|
|
|
+ return this.tooltipEl;
|
|
|
+ };
|
|
|
+
|
|
|
+ SmoothieChart.prototype.updateTooltip = function () {
|
|
|
+ if(!this.options.tooltip){
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ var el = this.getTooltipEl();
|
|
|
+
|
|
|
+ if (!this.mouseover || !this.options.tooltip) {
|
|
|
+ el.style.display = 'none';
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var time = this.lastChartTimestamp;
|
|
|
+
|
|
|
+
|
|
|
+ var t = this.options.scrollBackwards
|
|
|
+ ? time - this.mouseX * this.options.millisPerPixel
|
|
|
+ : time - (this.canvas.offsetWidth - this.mouseX) * this.options.millisPerPixel;
|
|
|
+
|
|
|
+ var data = [];
|
|
|
+
|
|
|
+
|
|
|
+ for (var d = 0; d < this.seriesSet.length; d++) {
|
|
|
+ var timeSeries = this.seriesSet[d].timeSeries;
|
|
|
+ if (timeSeries.disabled) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ var closeIdx = Util.binarySearch(timeSeries.data, t);
|
|
|
+ if (closeIdx > 0 && closeIdx < timeSeries.data.length) {
|
|
|
+ data.push({ series: this.seriesSet[d], index: closeIdx, value: timeSeries.data[closeIdx][1] });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (data.length) {
|
|
|
+ el.innerHTML = this.options.tooltipFormatter.call(this, t, data);
|
|
|
+ el.style.display = 'block';
|
|
|
+ } else {
|
|
|
+ el.style.display = 'none';
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ SmoothieChart.prototype.mousemove = function (evt) {
|
|
|
+ this.mouseover = true;
|
|
|
+ this.mouseX = evt.offsetX;
|
|
|
+ this.mouseY = evt.offsetY;
|
|
|
+ this.mousePageX = evt.pageX;
|
|
|
+ this.mousePageY = evt.pageY;
|
|
|
+ if(!this.options.tooltip){
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ var el = this.getTooltipEl();
|
|
|
+ el.style.top = Math.round(this.mousePageY) + 'px';
|
|
|
+ el.style.left = Math.round(this.mousePageX) + 'px';
|
|
|
+ this.updateTooltip();
|
|
|
+ };
|
|
|
+
|
|
|
+ SmoothieChart.prototype.mouseout = function () {
|
|
|
+ this.mouseover = false;
|
|
|
+ this.mouseX = this.mouseY = -1;
|
|
|
+ if (this.tooltipEl)
|
|
|
+ this.tooltipEl.style.display = 'none';
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Make sure the canvas has the optimal resolution for the device's pixel ratio.
|
|
|
+ */
|
|
|
+ SmoothieChart.prototype.resize = function () {
|
|
|
+ var dpr = !this.options.enableDpiScaling || !window ? 1 : window.devicePixelRatio,
|
|
|
+ width, height;
|
|
|
+ if (this.options.responsive) {
|
|
|
+
|
|
|
+
|
|
|
+ width = this.canvas.offsetWidth;
|
|
|
+ height = this.canvas.offsetHeight;
|
|
|
+
|
|
|
+ if (width !== this.lastWidth) {
|
|
|
+ this.lastWidth = width;
|
|
|
+ this.canvas.setAttribute('width', (Math.floor(width * dpr)).toString());
|
|
|
+ this.canvas.getContext('2d').scale(dpr, dpr);
|
|
|
+ }
|
|
|
+ if (height !== this.lastHeight) {
|
|
|
+ this.lastHeight = height;
|
|
|
+ this.canvas.setAttribute('height', (Math.floor(height * dpr)).toString());
|
|
|
+ this.canvas.getContext('2d').scale(dpr, dpr);
|
|
|
+ }
|
|
|
+ } else if (dpr !== 1) {
|
|
|
+
|
|
|
+
|
|
|
+ width = parseInt(this.canvas.getAttribute('width'));
|
|
|
+ height = parseInt(this.canvas.getAttribute('height'));
|
|
|
+
|
|
|
+ if (!this.originalWidth || (Math.floor(this.originalWidth * dpr) !== width)) {
|
|
|
+ this.originalWidth = width;
|
|
|
+ this.canvas.setAttribute('width', (Math.floor(width * dpr)).toString());
|
|
|
+ this.canvas.style.width = width + 'px';
|
|
|
+ this.canvas.getContext('2d').scale(dpr, dpr);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!this.originalHeight || (Math.floor(this.originalHeight * dpr) !== height)) {
|
|
|
+ this.originalHeight = height;
|
|
|
+ this.canvas.setAttribute('height', (Math.floor(height * dpr)).toString());
|
|
|
+ this.canvas.style.height = height + 'px';
|
|
|
+ this.canvas.getContext('2d').scale(dpr, dpr);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Starts the animation of this chart.
|
|
|
+ */
|
|
|
+ SmoothieChart.prototype.start = function() {
|
|
|
+ if (this.frame) {
|
|
|
+
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ this.canvas.addEventListener('mousemove', this.mousemove);
|
|
|
+ this.canvas.addEventListener('mouseout', this.mouseout);
|
|
|
+
|
|
|
+
|
|
|
+ var animate = function() {
|
|
|
+ this.frame = SmoothieChart.AnimateCompatibility.requestAnimationFrame(function() {
|
|
|
+ if(this.options.nonRealtimeData){
|
|
|
+ var dateZero = new Date(0);
|
|
|
+
|
|
|
+ var maxTimeStamp = this.seriesSet.reduce(function(max, series){
|
|
|
+ var dataSet = series.timeSeries.data;
|
|
|
+ var indexToCheck = Math.round(this.options.displayDataFromPercentile * dataSet.length) - 1;
|
|
|
+ indexToCheck = indexToCheck >= 0 ? indexToCheck : 0;
|
|
|
+ indexToCheck = indexToCheck <= dataSet.length -1 ? indexToCheck : dataSet.length -1;
|
|
|
+ if(dataSet && dataSet.length > 0)
|
|
|
+ {
|
|
|
+
|
|
|
+ var lastDataTimeStamp = dataSet[indexToCheck][0];
|
|
|
+ max = max > lastDataTimeStamp ? max : lastDataTimeStamp;
|
|
|
+ }
|
|
|
+ return max;
|
|
|
+ }.bind(this), dateZero);
|
|
|
+
|
|
|
+ this.render(this.canvas, maxTimeStamp > dateZero ? maxTimeStamp : null);
|
|
|
+ } else {
|
|
|
+ this.render();
|
|
|
+ }
|
|
|
+ animate();
|
|
|
+ }.bind(this));
|
|
|
+ }.bind(this);
|
|
|
+
|
|
|
+ animate();
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ * Stops the animation of this chart.
|
|
|
+ */
|
|
|
+ SmoothieChart.prototype.stop = function() {
|
|
|
+ if (this.frame) {
|
|
|
+ SmoothieChart.AnimateCompatibility.cancelAnimationFrame(this.frame);
|
|
|
+ delete this.frame;
|
|
|
+ this.canvas.removeEventListener('mousemove', this.mousemove);
|
|
|
+ this.canvas.removeEventListener('mouseout', this.mouseout);
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ SmoothieChart.prototype.updateValueRange = function() {
|
|
|
+
|
|
|
+ var chartOptions = this.options,
|
|
|
+ chartMaxValue = Number.NaN,
|
|
|
+ chartMinValue = Number.NaN;
|
|
|
+
|
|
|
+ for (var d = 0; d < this.seriesSet.length; d++) {
|
|
|
+
|
|
|
+ var timeSeries = this.seriesSet[d].timeSeries;
|
|
|
+ if (timeSeries.disabled) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!isNaN(timeSeries.maxValue)) {
|
|
|
+ chartMaxValue = !isNaN(chartMaxValue) ? Math.max(chartMaxValue, timeSeries.maxValue) : timeSeries.maxValue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!isNaN(timeSeries.minValue)) {
|
|
|
+ chartMinValue = !isNaN(chartMinValue) ? Math.min(chartMinValue, timeSeries.minValue) : timeSeries.minValue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (chartOptions.maxValue != null) {
|
|
|
+ chartMaxValue = chartOptions.maxValue;
|
|
|
+ } else {
|
|
|
+ chartMaxValue *= chartOptions.maxValueScale;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (chartOptions.minValue != null) {
|
|
|
+ chartMinValue = chartOptions.minValue;
|
|
|
+ } else {
|
|
|
+ chartMinValue -= Math.abs(chartMinValue * chartOptions.minValueScale - chartMinValue);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (this.options.yRangeFunction) {
|
|
|
+ var range = this.options.yRangeFunction({min: chartMinValue, max: chartMaxValue});
|
|
|
+ chartMinValue = range.min;
|
|
|
+ chartMaxValue = range.max;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!isNaN(chartMaxValue) && !isNaN(chartMinValue)) {
|
|
|
+ var targetValueRange = chartMaxValue - chartMinValue;
|
|
|
+ var valueRangeDiff = (targetValueRange - this.currentValueRange);
|
|
|
+ var minValueDiff = (chartMinValue - this.currentVisMinValue);
|
|
|
+ this.isAnimatingScale = Math.abs(valueRangeDiff) > 0.1 || Math.abs(minValueDiff) > 0.1;
|
|
|
+ this.currentValueRange += chartOptions.scaleSmoothing * valueRangeDiff;
|
|
|
+ this.currentVisMinValue += chartOptions.scaleSmoothing * minValueDiff;
|
|
|
+ }
|
|
|
+
|
|
|
+ this.valueRange = { min: chartMinValue, max: chartMaxValue };
|
|
|
+ };
|
|
|
+
|
|
|
+ SmoothieChart.prototype.render = function(canvas, time) {
|
|
|
+ var nowMillis = Date.now();
|
|
|
+
|
|
|
+
|
|
|
+ if (this.options.limitFPS > 0 && nowMillis - this.lastRenderTimeMillis < (1000/this.options.limitFPS))
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!this.isAnimatingScale) {
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ var maxIdleMillis = Math.min(1000/6, this.options.millisPerPixel);
|
|
|
+
|
|
|
+ if (nowMillis - this.lastRenderTimeMillis < maxIdleMillis) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ this.resize();
|
|
|
+ this.updateTooltip();
|
|
|
+
|
|
|
+ this.lastRenderTimeMillis = nowMillis;
|
|
|
+
|
|
|
+ canvas = canvas || this.canvas;
|
|
|
+ time = time || nowMillis - (this.delay || 0);
|
|
|
+
|
|
|
+
|
|
|
+ time -= time % this.options.millisPerPixel;
|
|
|
+
|
|
|
+ this.lastChartTimestamp = time;
|
|
|
+
|
|
|
+ var context = canvas.getContext('2d'),
|
|
|
+ chartOptions = this.options,
|
|
|
+ dimensions = { top: 0, left: 0, width: canvas.clientWidth, height: canvas.clientHeight },
|
|
|
+
|
|
|
+ oldestValidTime = time - (dimensions.width * chartOptions.millisPerPixel),
|
|
|
+ valueToYPixel = function(value) {
|
|
|
+ var offset = value - this.currentVisMinValue;
|
|
|
+ return this.currentValueRange === 0
|
|
|
+ ? dimensions.height
|
|
|
+ : dimensions.height - (Math.round((offset / this.currentValueRange) * dimensions.height));
|
|
|
+ }.bind(this),
|
|
|
+ timeToXPixel = function(t) {
|
|
|
+ if(chartOptions.scrollBackwards) {
|
|
|
+ return Math.round((time - t) / chartOptions.millisPerPixel);
|
|
|
+ }
|
|
|
+ return Math.round(dimensions.width - ((time - t) / chartOptions.millisPerPixel));
|
|
|
+ };
|
|
|
+
|
|
|
+ this.updateValueRange();
|
|
|
+
|
|
|
+ context.font = chartOptions.labels.fontSize + 'px ' + chartOptions.labels.fontFamily;
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ context.save();
|
|
|
+
|
|
|
+
|
|
|
+ context.translate(dimensions.left, dimensions.top);
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ context.beginPath();
|
|
|
+ context.rect(0, 0, dimensions.width, dimensions.height);
|
|
|
+ context.clip();
|
|
|
+
|
|
|
+
|
|
|
+ context.save();
|
|
|
+ context.fillStyle = chartOptions.grid.fillStyle;
|
|
|
+ context.clearRect(0, 0, dimensions.width, dimensions.height);
|
|
|
+ context.fillRect(0, 0, dimensions.width, dimensions.height);
|
|
|
+ context.restore();
|
|
|
+
|
|
|
+
|
|
|
+ context.save();
|
|
|
+ context.lineWidth = chartOptions.grid.lineWidth;
|
|
|
+ context.strokeStyle = chartOptions.grid.strokeStyle;
|
|
|
+
|
|
|
+ if (chartOptions.grid.millisPerLine > 0) {
|
|
|
+ context.beginPath();
|
|
|
+ for (var t = time - (time % chartOptions.grid.millisPerLine);
|
|
|
+ t >= oldestValidTime;
|
|
|
+ t -= chartOptions.grid.millisPerLine) {
|
|
|
+ var gx = timeToXPixel(t);
|
|
|
+ if (chartOptions.grid.sharpLines) {
|
|
|
+ gx -= 0.5;
|
|
|
+ }
|
|
|
+ context.moveTo(gx, 0);
|
|
|
+ context.lineTo(gx, dimensions.height);
|
|
|
+ }
|
|
|
+ context.stroke();
|
|
|
+ context.closePath();
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ for (var v = 1; v < chartOptions.grid.verticalSections; v++) {
|
|
|
+ var gy = Math.round(v * dimensions.height / chartOptions.grid.verticalSections);
|
|
|
+ if (chartOptions.grid.sharpLines) {
|
|
|
+ gy -= 0.5;
|
|
|
+ }
|
|
|
+ context.beginPath();
|
|
|
+ context.moveTo(0, gy);
|
|
|
+ context.lineTo(dimensions.width, gy);
|
|
|
+ context.stroke();
|
|
|
+ context.closePath();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (chartOptions.grid.borderVisible) {
|
|
|
+ context.beginPath();
|
|
|
+ context.strokeRect(0, 0, dimensions.width, dimensions.height);
|
|
|
+ context.closePath();
|
|
|
+ }
|
|
|
+ context.restore();
|
|
|
+
|
|
|
+
|
|
|
+ if (chartOptions.horizontalLines && chartOptions.horizontalLines.length) {
|
|
|
+ for (var hl = 0; hl < chartOptions.horizontalLines.length; hl++) {
|
|
|
+ var line = chartOptions.horizontalLines[hl],
|
|
|
+ hly = Math.round(valueToYPixel(line.value)) - 0.5;
|
|
|
+ context.strokeStyle = line.color || '#ffffff';
|
|
|
+ context.lineWidth = line.lineWidth || 1;
|
|
|
+ context.beginPath();
|
|
|
+ context.moveTo(0, hly);
|
|
|
+ context.lineTo(dimensions.width, hly);
|
|
|
+ context.stroke();
|
|
|
+ context.closePath();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ for (var d = 0; d < this.seriesSet.length; d++) {
|
|
|
+ context.save();
|
|
|
+ var timeSeries = this.seriesSet[d].timeSeries;
|
|
|
+ if (timeSeries.disabled) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ var dataSet = timeSeries.data,
|
|
|
+ seriesOptions = this.seriesSet[d].options;
|
|
|
+
|
|
|
+
|
|
|
+ timeSeries.dropOldData(oldestValidTime, chartOptions.maxDataSetLength);
|
|
|
+
|
|
|
+
|
|
|
+ context.lineWidth = seriesOptions.lineWidth;
|
|
|
+ context.strokeStyle = seriesOptions.strokeStyle;
|
|
|
+
|
|
|
+ context.beginPath();
|
|
|
+
|
|
|
+ var firstX = 0, firstY = 0, lastX = 0, lastY = 0;
|
|
|
+ for (var i = 0; i < dataSet.length && dataSet.length !== 1; i++) {
|
|
|
+ var x = timeToXPixel(dataSet[i][0]),
|
|
|
+ y = valueToYPixel(dataSet[i][1]);
|
|
|
+
|
|
|
+ if (i === 0) {
|
|
|
+ firstX = x;
|
|
|
+ firstY = y;
|
|
|
+ context.moveTo(x, y);
|
|
|
+ } else {
|
|
|
+ switch (chartOptions.interpolation) {
|
|
|
+ case "linear":
|
|
|
+ case "line": {
|
|
|
+ context.lineTo(x,y);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case "bezier":
|
|
|
+ default: {
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ context.bezierCurveTo(
|
|
|
+ Math.round((lastX + x) / 2), lastY,
|
|
|
+ Math.round((lastX + x)) / 2, y,
|
|
|
+ x, y);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case "step": {
|
|
|
+ context.lineTo(x,lastY);
|
|
|
+ context.lineTo(x,y);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ lastX = x; lastY = y;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (dataSet.length > 1) {
|
|
|
+ if (seriesOptions.fillStyle) {
|
|
|
+
|
|
|
+ if (chartOptions.scrollBackwards) {
|
|
|
+ context.lineTo(lastX, dimensions.height + seriesOptions.lineWidth);
|
|
|
+ context.lineTo(firstX, dimensions.height + seriesOptions.lineWidth);
|
|
|
+ context.lineTo(firstX, firstY);
|
|
|
+ } else {
|
|
|
+ context.lineTo(dimensions.width + seriesOptions.lineWidth + 1, lastY);
|
|
|
+ context.lineTo(dimensions.width + seriesOptions.lineWidth + 1, dimensions.height + seriesOptions.lineWidth + 1);
|
|
|
+ context.lineTo(firstX, dimensions.height + seriesOptions.lineWidth);
|
|
|
+ }
|
|
|
+ context.fillStyle = seriesOptions.fillStyle;
|
|
|
+ context.fill();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (seriesOptions.strokeStyle && seriesOptions.strokeStyle !== 'none') {
|
|
|
+ context.stroke();
|
|
|
+ }
|
|
|
+ context.closePath();
|
|
|
+ }
|
|
|
+ context.restore();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (chartOptions.tooltip && this.mouseX >= 0) {
|
|
|
+
|
|
|
+ context.lineWidth = chartOptions.tooltipLine.lineWidth;
|
|
|
+ context.strokeStyle = chartOptions.tooltipLine.strokeStyle;
|
|
|
+ context.beginPath();
|
|
|
+ context.moveTo(this.mouseX, 0);
|
|
|
+ context.lineTo(this.mouseX, dimensions.height);
|
|
|
+ context.closePath();
|
|
|
+ context.stroke();
|
|
|
+ this.updateTooltip();
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (!chartOptions.labels.disabled && !isNaN(this.valueRange.min) && !isNaN(this.valueRange.max)) {
|
|
|
+ var maxValueString = chartOptions.yMaxFormatter(this.valueRange.max, chartOptions.labels.precision),
|
|
|
+ minValueString = chartOptions.yMinFormatter(this.valueRange.min, chartOptions.labels.precision),
|
|
|
+ maxLabelPos = chartOptions.scrollBackwards ? 0 : dimensions.width - context.measureText(maxValueString).width - 2,
|
|
|
+ minLabelPos = chartOptions.scrollBackwards ? 0 : dimensions.width - context.measureText(minValueString).width - 2;
|
|
|
+ context.fillStyle = chartOptions.labels.fillStyle;
|
|
|
+ context.fillText(maxValueString, maxLabelPos, chartOptions.labels.fontSize);
|
|
|
+ context.fillText(minValueString, minLabelPos, dimensions.height - 2);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if ( chartOptions.labels.showIntermediateLabels
|
|
|
+ && !isNaN(this.valueRange.min) && !isNaN(this.valueRange.max)
|
|
|
+ && chartOptions.grid.verticalSections > 0) {
|
|
|
+
|
|
|
+ var step = (this.valueRange.max - this.valueRange.min) / chartOptions.grid.verticalSections;
|
|
|
+ var stepPixels = dimensions.height / chartOptions.grid.verticalSections;
|
|
|
+ for (var v = 1; v < chartOptions.grid.verticalSections; v++) {
|
|
|
+ var gy = dimensions.height - Math.round(v * stepPixels);
|
|
|
+ if (chartOptions.grid.sharpLines) {
|
|
|
+ gy -= 0.5;
|
|
|
+ }
|
|
|
+ var yValue = chartOptions.yIntermediateFormatter(this.valueRange.min + (v * step), chartOptions.labels.precision);
|
|
|
+
|
|
|
+ intermediateLabelPos =
|
|
|
+ chartOptions.labels.intermediateLabelSameAxis
|
|
|
+ ? (chartOptions.scrollBackwards ? 0 : dimensions.width - context.measureText(yValue).width - 2)
|
|
|
+ : (chartOptions.scrollBackwards ? dimensions.width - context.measureText(yValue).width - 2 : 0);
|
|
|
+
|
|
|
+ context.fillText(yValue, intermediateLabelPos, gy - chartOptions.grid.lineWidth);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (chartOptions.timestampFormatter && chartOptions.grid.millisPerLine > 0) {
|
|
|
+ var textUntilX = chartOptions.scrollBackwards
|
|
|
+ ? context.measureText(minValueString).width
|
|
|
+ : dimensions.width - context.measureText(minValueString).width + 4;
|
|
|
+ for (var t = time - (time % chartOptions.grid.millisPerLine);
|
|
|
+ t >= oldestValidTime;
|
|
|
+ t -= chartOptions.grid.millisPerLine) {
|
|
|
+ var gx = timeToXPixel(t);
|
|
|
+
|
|
|
+ if ((!chartOptions.scrollBackwards && gx < textUntilX) || (chartOptions.scrollBackwards && gx > textUntilX)) {
|
|
|
+
|
|
|
+
|
|
|
+ var tx = new Date(t),
|
|
|
+ ts = chartOptions.timestampFormatter(tx),
|
|
|
+ tsWidth = context.measureText(ts).width;
|
|
|
+
|
|
|
+ textUntilX = chartOptions.scrollBackwards
|
|
|
+ ? gx + tsWidth + 2
|
|
|
+ : gx - tsWidth - 2;
|
|
|
+
|
|
|
+ context.fillStyle = chartOptions.labels.fillStyle;
|
|
|
+ if(chartOptions.scrollBackwards) {
|
|
|
+ context.fillText(ts, gx, dimensions.height - 2);
|
|
|
+ } else {
|
|
|
+ context.fillText(ts, gx - tsWidth, dimensions.height - 2);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (chartOptions.title.text !== '') {
|
|
|
+ context.font = chartOptions.title.fontSize + 'px ' + chartOptions.title.fontFamily;
|
|
|
+ var titleXPos = chartOptions.scrollBackwards ? dimensions.width - context.measureText(chartOptions.title.text).width - 2 : 2;
|
|
|
+ if (chartOptions.title.verticalAlign == 'bottom') {
|
|
|
+ context.textBaseline = 'bottom';
|
|
|
+ var titleYPos = dimensions.height;
|
|
|
+ } else if (chartOptions.title.verticalAlign == 'middle') {
|
|
|
+ context.textBaseline = 'middle';
|
|
|
+ var titleYPos = dimensions.height / 2;
|
|
|
+ } else {
|
|
|
+ context.textBaseline = 'top';
|
|
|
+ var titleYPos = 0;
|
|
|
+ }
|
|
|
+ context.fillStyle = chartOptions.title.fillStyle;
|
|
|
+ context.fillText(chartOptions.title.text, titleXPos, titleYPos);
|
|
|
+ }
|
|
|
+
|
|
|
+ context.restore();
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ SmoothieChart.timeFormatter = function(date) {
|
|
|
+ function pad2(number) { return (number < 10 ? '0' : '') + number }
|
|
|
+ return pad2(date.getHours()) + ':' + pad2(date.getMinutes()) + ':' + pad2(date.getSeconds());
|
|
|
+ };
|
|
|
+
|
|
|
+ exports.TimeSeries = TimeSeries;
|
|
|
+ exports.SmoothieChart = SmoothieChart;
|
|
|
+
|
|
|
+})(typeof exports === 'undefined' ? this : exports);
|
