iobroker.ebus 3.2.4 → 3.2.6

package/widgets/ebus/lib/js/flot/jquery.flot.stack.js

@@ -1,220 +1,220 @@
-/* Flot plugin for stacking data sets rather than overlaying them.
-
-Copyright (c) 2007-2014 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 addBottomPoints (s, datapoints) {
-            var formattedPoints = [];
-            for (var i = 0; i < datapoints.points.length; i += 2) {
-                formattedPoints.push(datapoints.points[i]);
-                formattedPoints.push(datapoints.points[i + 1]);
-                formattedPoints.push(0);
-            }
-
-            datapoints.format.push({
-                x: s.bars.horizontal,
-                y: !s.bars.horizontal,
-                number: true,
-                required: false,
-                computeRange: s.yaxis.options.autoScale !== 'none',
-                defaultValue: 0
-            });
-            datapoints.points = formattedPoints;
-            datapoints.pointsize = 3;
-        }
-
-        function stackData(plot, s, datapoints) {
-            if (s.stack == null || s.stack === false) return;
-
-            var needsBottom = s.bars.show || (s.lines.show && s.lines.fill);
-            var hasBottom = datapoints.pointsize > 2 && (s.bars.horizontal ? datapoints.format[2].x : datapoints.format[2].y);
-            // Series data is missing bottom points - need to format
-            if (needsBottom && !hasBottom) {
-                addBottomPoints(s, datapoints);
-            }
-
-            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,
-                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 && needsBottom) {
-                        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);
+/* Flot plugin for stacking data sets rather than overlaying them.
+
+Copyright (c) 2007-2014 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 addBottomPoints (s, datapoints) {
+            var formattedPoints = [];
+            for (var i = 0; i < datapoints.points.length; i += 2) {
+                formattedPoints.push(datapoints.points[i]);
+                formattedPoints.push(datapoints.points[i + 1]);
+                formattedPoints.push(0);
+            }
+
+            datapoints.format.push({
+                x: s.bars.horizontal,
+                y: !s.bars.horizontal,
+                number: true,
+                required: false,
+                computeRange: s.yaxis.options.autoScale !== 'none',
+                defaultValue: 0
+            });
+            datapoints.points = formattedPoints;
+            datapoints.pointsize = 3;
+        }
+
+        function stackData(plot, s, datapoints) {
+            if (s.stack == null || s.stack === false) return;
+
+            var needsBottom = s.bars.show || (s.lines.show && s.lines.fill);
+            var hasBottom = datapoints.pointsize > 2 && (s.bars.horizontal ? datapoints.format[2].x : datapoints.format[2].y);
+            // Series data is missing bottom points - need to format
+            if (needsBottom && !hasBottom) {
+                addBottomPoints(s, datapoints);
+            }
+
+            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,
+                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 && needsBottom) {
+                        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);

package/widgets/ebus/lib/js/flot/jquery.flot.symbol.js

@@ -1,98 +1,98 @@
-/* Flot plugin that adds some extra symbols for plotting points.
-
-Copyright (c) 2007-2014 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", "plus", "ellipse", "rectangle"
-        }
-    }
-
-*/
-
-(function ($) {
-    // we normalize the area of each symbol so it is approximately the
-    // same as a circle of the given radius
-
-    var 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);
-        },
-        rectangle = 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);
-            ctx.lineTo(x, y - size);
-        },
-        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);
-                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);
-        },
-        ellipse = function(ctx, x, y, radius, shadow, fill) {
-            if (!shadow) {
-                ctx.moveTo(x + radius, y);
-                ctx.arc(x, y, radius, 0, Math.PI * 2, false);
-            }
-        },
-        plus = function (ctx, x, y, radius, shadow) {
-            var size = radius * Math.sqrt(Math.PI / 2);
-            ctx.moveTo(x - size, y);
-            ctx.lineTo(x + size, y);
-            ctx.moveTo(x, y + size);
-            ctx.lineTo(x, y - size);
-        },
-        handlers = {
-            square: square,
-            rectangle: rectangle,
-            diamond: diamond,
-            triangle: triangle,
-            cross: cross,
-            ellipse: ellipse,
-            plus: plus
-        };
-
-    square.fill = true;
-    rectangle.fill = true;
-    diamond.fill = true;
-    triangle.fill = true;
-    ellipse.fill = true;
-
-    function init(plot) {
-        plot.drawSymbol = handlers;
-    }
-
-    $.plot.plugins.push({
-        init: init,
-        name: 'symbols',
-        version: '1.0'
-    });
-})(jQuery);
+/* Flot plugin that adds some extra symbols for plotting points.
+
+Copyright (c) 2007-2014 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", "plus", "ellipse", "rectangle"
+        }
+    }
+
+*/
+
+(function ($) {
+    // we normalize the area of each symbol so it is approximately the
+    // same as a circle of the given radius
+
+    var 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);
+        },
+        rectangle = 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);
+            ctx.lineTo(x, y - size);
+        },
+        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);
+                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);
+        },
+        ellipse = function(ctx, x, y, radius, shadow, fill) {
+            if (!shadow) {
+                ctx.moveTo(x + radius, y);
+                ctx.arc(x, y, radius, 0, Math.PI * 2, false);
+            }
+        },
+        plus = function (ctx, x, y, radius, shadow) {
+            var size = radius * Math.sqrt(Math.PI / 2);
+            ctx.moveTo(x - size, y);
+            ctx.lineTo(x + size, y);
+            ctx.moveTo(x, y + size);
+            ctx.lineTo(x, y - size);
+        },
+        handlers = {
+            square: square,
+            rectangle: rectangle,
+            diamond: diamond,
+            triangle: triangle,
+            cross: cross,
+            ellipse: ellipse,
+            plus: plus
+        };
+
+    square.fill = true;
+    rectangle.fill = true;
+    diamond.fill = true;
+    triangle.fill = true;
+    ellipse.fill = true;
+
+    function init(plot) {
+        plot.drawSymbol = handlers;
+    }
+
+    $.plot.plugins.push({
+        init: init,
+        name: 'symbols',
+        version: '1.0'
+    });
+})(jQuery);