highcharts-rails 4.2.7 → 5.0.0

data/app/assets/javascripts/highcharts/modules/overlapping-datalabels.js

@@ -0,0 +1,164 @@
+/**
+ * @license Highcharts JS v5.0.0 (2016-09-29)
+ *
+ * (c) 2009-2016 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+(function(factory) {
+    if (typeof module === 'object' && module.exports) {
+        module.exports = factory;
+    } else {
+        factory(Highcharts);
+    }
+}(function(Highcharts) {
+    (function(H) {
+        /**
+         * (c) 2009-2016 Torstein Honsi
+         *
+         * License: www.highcharts.com/license
+         */
+        'use strict';
+        /**
+         * Highcharts module to hide overlapping data labels. This module is included in Highcharts.
+         */
+        var Chart = H.Chart,
+            each = H.each,
+            pick = H.pick,
+            addEvent = H.addEvent;
+
+        // Collect potensial overlapping data labels. Stack labels probably don't need to be 
+        // considered because they are usually accompanied by data labels that lie inside the columns.
+        Chart.prototype.callbacks.push(function(chart) {
+            function collectAndHide() {
+                var labels = [];
+
+                each(chart.series, function(series) {
+                    var dlOptions = series.options.dataLabels,
+                        collections = series.dataLabelCollections || ['dataLabel']; // Range series have two collections
+                    if ((dlOptions.enabled || series._hasPointLabels) && !dlOptions.allowOverlap && series.visible) { // #3866
+                        each(collections, function(coll) {
+                            each(series.points, function(point) {
+                                if (point[coll]) {
+                                    point[coll].labelrank = pick(point.labelrank, point.shapeArgs && point.shapeArgs.height); // #4118
+                                    labels.push(point[coll]);
+                                }
+                            });
+                        });
+                    }
+                });
+                chart.hideOverlappingLabels(labels);
+            }
+
+            // Do it now ...
+            collectAndHide();
+
+            // ... and after each chart redraw
+            addEvent(chart, 'redraw', collectAndHide);
+
+        });
+
+        /**
+         * Hide overlapping labels. Labels are moved and faded in and out on zoom to provide a smooth 
+         * visual imression.
+         */
+        Chart.prototype.hideOverlappingLabels = function(labels) {
+
+            var len = labels.length,
+                label,
+                i,
+                j,
+                label1,
+                label2,
+                isIntersecting,
+                pos1,
+                pos2,
+                parent1,
+                parent2,
+                padding,
+                intersectRect = function(x1, y1, w1, h1, x2, y2, w2, h2) {
+                    return !(
+                        x2 > x1 + w1 ||
+                        x2 + w2 < x1 ||
+                        y2 > y1 + h1 ||
+                        y2 + h2 < y1
+                    );
+                };
+
+            // Mark with initial opacity
+            for (i = 0; i < len; i++) {
+                label = labels[i];
+                if (label) {
+                    label.oldOpacity = label.opacity;
+                    label.newOpacity = 1;
+                }
+            }
+
+            // Prevent a situation in a gradually rising slope, that each label
+            // will hide the previous one because the previous one always has
+            // lower rank.
+            labels.sort(function(a, b) {
+                return (b.labelrank || 0) - (a.labelrank || 0);
+            });
+
+            // Detect overlapping labels
+            for (i = 0; i < len; i++) {
+                label1 = labels[i];
+
+                for (j = i + 1; j < len; ++j) {
+                    label2 = labels[j];
+                    if (label1 && label2 && label1.placed && label2.placed && label1.newOpacity !== 0 && label2.newOpacity !== 0) {
+                        pos1 = label1.alignAttr;
+                        pos2 = label2.alignAttr;
+                        parent1 = label1.parentGroup; // Different panes have different positions
+                        parent2 = label2.parentGroup;
+                        padding = 2 * (label1.box ? 0 : label1.padding); // Substract the padding if no background or border (#4333)
+                        isIntersecting = intersectRect(
+                            pos1.x + parent1.translateX,
+                            pos1.y + parent1.translateY,
+                            label1.width - padding,
+                            label1.height - padding,
+                            pos2.x + parent2.translateX,
+                            pos2.y + parent2.translateY,
+                            label2.width - padding,
+                            label2.height - padding
+                        );
+
+                        if (isIntersecting) {
+                            (label1.labelrank < label2.labelrank ? label1 : label2).newOpacity = 0;
+                        }
+                    }
+                }
+            }
+
+            // Hide or show
+            each(labels, function(label) {
+                var complete,
+                    newOpacity;
+
+                if (label) {
+                    newOpacity = label.newOpacity;
+
+                    if (label.oldOpacity !== newOpacity && label.placed) {
+
+                        // Make sure the label is completely hidden to avoid catching clicks (#4362)
+                        if (newOpacity) {
+                            label.show(true);
+                        } else {
+                            complete = function() {
+                                label.hide();
+                            };
+                        }
+
+                        // Animate or set the opacity					
+                        label.alignAttr.opacity = newOpacity;
+                        label[label.isOld ? 'animate' : 'attr'](label.alignAttr, null, complete);
+
+                    }
+                    label.isOld = true;
+                }
+            });
+        };
+
+    }(Highcharts));
+}));

data/app/assets/javascripts/highcharts/modules/series-label.js

@@ -1,519 +1,544 @@
 /**
- * EXPERIMENTAL Highcharts module to place labels next to a series in a natural position.
+ * @license Highcharts JS v5.0.0 (2016-09-29)
  *
- * TODO:
- * - add column support (box collision detection, boxesToAvoid logic)
- * - other series types, area etc.
- * - avoid data labels, when data labels above, show series label below.
- * - add more options (connector, format, formatter)
- * 
- * http://jsfiddle.net/highcharts/L2u9rpwr/
- * http://jsfiddle.net/highcharts/y5A37/
- * http://jsfiddle.net/highcharts/264Nm/
- * http://jsfiddle.net/highcharts/y5A37/
+ * (c) 2009-2016 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
  */
-/* eslint indent: [2, 4] */
-(function (factory) {
+(function(factory) {
     if (typeof module === 'object' && module.exports) {
         module.exports = factory;
     } else {
         factory(Highcharts);
     }
-}(function (H) {
-
-    var labelDistance = 3,
-        wrap = H.wrap,
-        each = H.each,
-        extend = H.extend,
-        isNumber = H.isNumber,
-        Series = H.Series,
-        SVGRenderer = H.SVGRenderer,
-        Chart = H.Chart;
-
-    H.setOptions({
-        plotOptions: {
-            series: {
-                label: {
-                    enabled: true,
-                    // Allow labels to be placed distant to the graph if necessary, and
-                    // draw a connector line to the graph
-                    connectorAllowed: true,
-                    connectorNeighbourDistance: 24, // If the label is closer than this to a neighbour graph, draw a connector
-                    styles: {
-                        fontWeight: 'bold'
+}(function(Highcharts) {
+    (function(H) {
+        /**
+         * (c) 2009-2016 Torstein Honsi
+         *
+         * License: www.highcharts.com/license
+         */
+        /**
+         * EXPERIMENTAL Highcharts module to place labels next to a series in a natural position.
+         *
+         * TODO:
+         * - add column support (box collision detection, boxesToAvoid logic)
+         * - other series types, area etc.
+         * - avoid data labels, when data labels above, show series label below.
+         * - add more options (connector, format, formatter)
+         * 
+         * http://jsfiddle.net/highcharts/L2u9rpwr/
+         * http://jsfiddle.net/highcharts/y5A37/
+         * http://jsfiddle.net/highcharts/264Nm/
+         * http://jsfiddle.net/highcharts/y5A37/
+         */
+
+        'use strict';
+
+        var labelDistance = 3,
+            wrap = H.wrap,
+            each = H.each,
+            extend = H.extend,
+            isNumber = H.isNumber,
+            Series = H.Series,
+            SVGRenderer = H.SVGRenderer,
+            Chart = H.Chart;
+
+        H.setOptions({
+            plotOptions: {
+                series: {
+                    label: {
+                        enabled: true,
+                        // Allow labels to be placed distant to the graph if necessary, and
+                        // draw a connector line to the graph
+                        connectorAllowed: true,
+                        connectorNeighbourDistance: 24, // If the label is closer than this to a neighbour graph, draw a connector
+                        styles: {
+                            fontWeight: 'bold'
+                        }
+                        // boxesToAvoid: []
                     }
-                    // boxesToAvoid: []
                 }
             }
-        }
-    });
-
-    /**
-     * Counter-clockwise, part of the fast line intersection logic
-     */
-    function ccw(x1, y1, x2, y2, x3, y3) {
-        var cw = ((y3 - y1) * (x2 - x1)) - ((y2 - y1) * (x3 - x1));
-        return cw > 0 ? true : cw < 0 ? false : true;
-    }
+        });
 
-    /**
-     * Detect if two lines intersect
-     */
-    function intersectLine(x1, y1, x2, y2, x3, y3, x4, y4) {
-        return ccw(x1, y1, x3, y3, x4, y4) !== ccw(x2, y2, x3, y3, x4, y4) &&
-            ccw(x1, y1, x2, y2, x3, y3) !== ccw(x1, y1, x2, y2, x4, y4);
-    }
+        /**
+         * Counter-clockwise, part of the fast line intersection logic
+         */
+        function ccw(x1, y1, x2, y2, x3, y3) {
+            var cw = ((y3 - y1) * (x2 - x1)) - ((y2 - y1) * (x3 - x1));
+            return cw > 0 ? true : cw < 0 ? false : true;
+        }
 
-    /**
-     * Detect if a box intersects with a line
-     */
-    function boxIntersectLine(x, y, w, h, x1, y1, x2, y2) {
-        return (
-            intersectLine(x, y, x + w, y,         x1, y1, x2, y2) || // top of label
-            intersectLine(x + w, y, x + w, y + h, x1, y1, x2, y2) || // right of label
-            intersectLine(x, y + h, x + w, y + h, x1, y1, x2, y2) || // bottom of label
-            intersectLine(x, y, x, y + h,         x1, y1, x2, y2)    // left of label
-        );
-    }
+        /**
+         * Detect if two lines intersect
+         */
+        function intersectLine(x1, y1, x2, y2, x3, y3, x4, y4) {
+            return ccw(x1, y1, x3, y3, x4, y4) !== ccw(x2, y2, x3, y3, x4, y4) &&
+                ccw(x1, y1, x2, y2, x3, y3) !== ccw(x1, y1, x2, y2, x4, y4);
+        }
 
-    /**
-     * General symbol definition for labels with connector
-     */
-    SVGRenderer.prototype.symbols.connector = function (x, y, w, h, options) {
-        var anchorX = options && options.anchorX,
-            anchorY = options && options.anchorY,
-            path,
-            yOffset,
-            lateral = w / 2;
-
-        if (isNumber(anchorX) && isNumber(anchorY)) {
-
-            path = ['M', anchorX, anchorY];
-            
-            // Prefer 45 deg connectors
-            yOffset = y - anchorY;
-            if (yOffset < 0) {
-                yOffset = -h - yOffset;
-            }
-            if (yOffset < w) {
-                lateral = anchorX < x + (w / 2) ? yOffset : w - yOffset;
-            }
-            
-            // Anchor below label
-            if (anchorY > y + h) {
-                path.push('L', x + lateral, y + h);
-
-            // Anchor above label
-            } else if (anchorY < y) {
-                path.push('L', x + lateral, y);
-
-            // Anchor left of label
-            } else if (anchorX < x) {
-                path.push('L', x, y + h / 2);
-            
-            // Anchor right of label
-            } else if (anchorX > x + w) {
-                path.push('L', x + w, y + h / 2);
-            }
+        /**
+         * Detect if a box intersects with a line
+         */
+        function boxIntersectLine(x, y, w, h, x1, y1, x2, y2) {
+            return (
+                intersectLine(x, y, x + w, y, x1, y1, x2, y2) || // top of label
+                intersectLine(x + w, y, x + w, y + h, x1, y1, x2, y2) || // right of label
+                intersectLine(x, y + h, x + w, y + h, x1, y1, x2, y2) || // bottom of label
+                intersectLine(x, y, x, y + h, x1, y1, x2, y2) // left of label
+            );
         }
-        return path || [];
-    };
-
-    /**
-     * Points to avoid. In addition to actual data points, the label should avoid
-     * interpolated positions.
-     */
-    Series.prototype.getPointsOnGraph = function () {
-        var distance = 16,
-            points = this.points,
-            point,
-            last,
-            interpolated = [],
-            i,
-            deltaX,
-            deltaY,
-            delta,
-            len,
-            n,
-            j,
-            d,
-            graph = this.graph || this.area,
-            node = graph.element,
-            inverted = this.chart.inverted,
-            paneLeft = inverted ? this.yAxis.pos : this.xAxis.pos,
-            paneTop = inverted ? this.xAxis.pos : this.yAxis.pos;
-
-        // For splines, get the point at length (possible caveat: peaks are not correctly detected)
-        if (this.getPointSpline && node.getPointAtLength) {
-            // If it is animating towards a path definition, use that briefly, and reset
-            if (graph.toD) {
-                d = graph.attr('d');
-                graph.attr({ d: graph.toD });
-            }
-            len = node.getTotalLength();
-            for (i = 0; i < len; i += distance) {
-                point = node.getPointAtLength(i);
-                interpolated.push({
-                    chartX: paneLeft + point.x,
-                    chartY: paneTop + point.y,
-                    plotX: point.x,
-                    plotY: point.y
-                });
-            }
-            if (d) {
-                graph.attr({ d: d });
-            }
-            // Last point
-            point = points[points.length - 1];
-            point.chartX = paneLeft + point.plotX;
-            point.chartY = paneTop + point.plotY;
-            interpolated.push(point);
 
-        // Interpolate
-        } else {
-            len = points.length;
-            for (i = 0; i < len; i += 1) {
+        /**
+         * General symbol definition for labels with connector
+         */
+        SVGRenderer.prototype.symbols.connector = function(x, y, w, h, options) {
+            var anchorX = options && options.anchorX,
+                anchorY = options && options.anchorY,
+                path,
+                yOffset,
+                lateral = w / 2;
+
+            if (isNumber(anchorX) && isNumber(anchorY)) {
+
+                path = ['M', anchorX, anchorY];
+
+                // Prefer 45 deg connectors
+                yOffset = y - anchorY;
+                if (yOffset < 0) {
+                    yOffset = -h - yOffset;
+                }
+                if (yOffset < w) {
+                    lateral = anchorX < x + (w / 2) ? yOffset : w - yOffset;
+                }
+
+                // Anchor below label
+                if (anchorY > y + h) {
+                    path.push('L', x + lateral, y + h);
 
-                point = points[i];
-                last = points[i - 1];
+                    // Anchor above label
+                } else if (anchorY < y) {
+                    path.push('L', x + lateral, y);
 
-                // Absolute coordinates so we can compare different panes
+                    // Anchor left of label
+                } else if (anchorX < x) {
+                    path.push('L', x, y + h / 2);
+
+                    // Anchor right of label
+                } else if (anchorX > x + w) {
+                    path.push('L', x + w, y + h / 2);
+                }
+            }
+            return path || [];
+        };
+
+        /**
+         * Points to avoid. In addition to actual data points, the label should avoid
+         * interpolated positions.
+         */
+        Series.prototype.getPointsOnGraph = function() {
+            var distance = 16,
+                points = this.points,
+                point,
+                last,
+                interpolated = [],
+                i,
+                deltaX,
+                deltaY,
+                delta,
+                len,
+                n,
+                j,
+                d,
+                graph = this.graph || this.area,
+                node = graph.element,
+                inverted = this.chart.inverted,
+                paneLeft = inverted ? this.yAxis.pos : this.xAxis.pos,
+                paneTop = inverted ? this.xAxis.pos : this.yAxis.pos;
+
+            // For splines, get the point at length (possible caveat: peaks are not correctly detected)
+            if (this.getPointSpline && node.getPointAtLength) {
+                // If it is animating towards a path definition, use that briefly, and reset
+                if (graph.toD) {
+                    d = graph.attr('d');
+                    graph.attr({
+                        d: graph.toD
+                    });
+                }
+                len = node.getTotalLength();
+                for (i = 0; i < len; i += distance) {
+                    point = node.getPointAtLength(i);
+                    interpolated.push({
+                        chartX: paneLeft + point.x,
+                        chartY: paneTop + point.y,
+                        plotX: point.x,
+                        plotY: point.y
+                    });
+                }
+                if (d) {
+                    graph.attr({
+                        d: d
+                    });
+                }
+                // Last point
+                point = points[points.length - 1];
                 point.chartX = paneLeft + point.plotX;
                 point.chartY = paneTop + point.plotY;
-
-                // Add interpolated points
-                if (i > 0) {
-                    deltaX = Math.abs(point.chartX - last.chartX);
-                    deltaY = Math.abs(point.chartY - last.chartY);
-                    delta = Math.max(deltaX, deltaY);
-                    if (delta > distance) {
-
-                        n = Math.ceil(delta / distance);
-
-                        for (j = 1; j < n; j += 1) {
-                            interpolated.push({
-                                chartX: last.chartX + (point.chartX - last.chartX) * (j / n),
-                                chartY: last.chartY + (point.chartY - last.chartY) * (j / n),
-                                plotX: last.plotX + (point.plotX - last.plotX) * (j / n),
-                                plotY: last.plotY + (point.plotY - last.plotY) * (j / n)
-                            });
+                interpolated.push(point);
+
+                // Interpolate
+            } else {
+                len = points.length;
+                for (i = 0; i < len; i += 1) {
+
+                    point = points[i];
+                    last = points[i - 1];
+
+                    // Absolute coordinates so we can compare different panes
+                    point.chartX = paneLeft + point.plotX;
+                    point.chartY = paneTop + point.plotY;
+
+                    // Add interpolated points
+                    if (i > 0) {
+                        deltaX = Math.abs(point.chartX - last.chartX);
+                        deltaY = Math.abs(point.chartY - last.chartY);
+                        delta = Math.max(deltaX, deltaY);
+                        if (delta > distance) {
+
+                            n = Math.ceil(delta / distance);
+
+                            for (j = 1; j < n; j += 1) {
+                                interpolated.push({
+                                    chartX: last.chartX + (point.chartX - last.chartX) * (j / n),
+                                    chartY: last.chartY + (point.chartY - last.chartY) * (j / n),
+                                    plotX: last.plotX + (point.plotX - last.plotX) * (j / n),
+                                    plotY: last.plotY + (point.plotY - last.plotY) * (j / n)
+                                });
+                            }
                         }
                     }
-                }
 
-                // Add the real point in order to find positive and negative peaks
-                if (isNumber(point.plotY)) {
-                    interpolated.push(point);
+                    // Add the real point in order to find positive and negative peaks
+                    if (isNumber(point.plotY)) {
+                        interpolated.push(point);
+                    }
                 }
             }
-        }
-        return interpolated;
-    };
-
-    /**
-     * Check whether a proposed label position is clear of other elements
-     */
-    Series.prototype.checkClearPoint = function (x, y, bBox, checkDistance) {
-        var distToOthersSquared = Number.MAX_VALUE, // distance to other graphs
-            distToPointSquared = Number.MAX_VALUE,
-            dist,
-            connectorPoint,
-            connectorEnabled = this.options.label.connectorAllowed,
-
-            chart = this.chart,
-            series,
-            points,
-            leastDistance = 16,
-            withinRange,
-            i,
-            j;
-
-        function intersectRect(r1, r2) {
-            return !(r2.left > r1.right ||
-                r2.right < r1.left ||
-                r2.top > r1.bottom ||
-                r2.bottom < r1.top);
-        }
+            return interpolated;
+        };
 
         /**
-         * Get the weight in order to determine the ideal position. Larger distance to
-         * other series gives more weight. Smaller distance to the actual point (connector points only)
-         * gives more weight.
+         * Check whether a proposed label position is clear of other elements
          */
-        function getWeight(distToOthersSquared, distToPointSquared) {
-            return distToOthersSquared - distToPointSquared;
-        }
+        Series.prototype.checkClearPoint = function(x, y, bBox, checkDistance) {
+            var distToOthersSquared = Number.MAX_VALUE, // distance to other graphs
+                distToPointSquared = Number.MAX_VALUE,
+                dist,
+                connectorPoint,
+                connectorEnabled = this.options.label.connectorAllowed,
+
+                chart = this.chart,
+                series,
+                points,
+                leastDistance = 16,
+                withinRange,
+                i,
+                j;
+
+            function intersectRect(r1, r2) {
+                return !(r2.left > r1.right ||
+                    r2.right < r1.left ||
+                    r2.top > r1.bottom ||
+                    r2.bottom < r1.top);
+            }
 
-        // First check for collision with existing labels
-        for (i = 0; i < chart.boxesToAvoid.length; i += 1) {
-            if (intersectRect(chart.boxesToAvoid[i], {
-                left: x,
-                right: x + bBox.width,
-                top: y,
-                bottom: y + bBox.height
-            })) {
-                return false;
+            /**
+             * Get the weight in order to determine the ideal position. Larger distance to
+             * other series gives more weight. Smaller distance to the actual point (connector points only)
+             * gives more weight.
+             */
+            function getWeight(distToOthersSquared, distToPointSquared) {
+                return distToOthersSquared - distToPointSquared;
             }
-        }
 
-        // For each position, check if the lines around the label intersect with any of the 
-        // graphs
-        for (i = 0; i < chart.series.length; i += 1) {
-            series = chart.series[i];
-            points = series.interpolatedPoints;
-            if (series.visible && points) {
-                for (j = 1; j < points.length; j += 1) {
-                    // If any of the box sides intersect with the line, return
-                    if (boxIntersectLine(
-                            x,
-                            y,
-                            bBox.width,
-                            bBox.height,
-                            points[j - 1].chartX,
-                            points[j - 1].chartY,
-                            points[j].chartX,
-                            points[j].chartY
-                        )) {
-                        return false;
-                    }
+            // First check for collision with existing labels
+            for (i = 0; i < chart.boxesToAvoid.length; i += 1) {
+                if (intersectRect(chart.boxesToAvoid[i], {
+                        left: x,
+                        right: x + bBox.width,
+                        top: y,
+                        bottom: y + bBox.height
+                    })) {
+                    return false;
+                }
+            }
 
-                    // But if it is too far away (a padded box doesn't intersect), also return
-                    if (this === series && !withinRange && checkDistance) {
-                        withinRange = boxIntersectLine(
-                            x - leastDistance,
-                            y - leastDistance,
-                            bBox.width + 2 * leastDistance,
-                            bBox.height + 2 * leastDistance,
-                            points[j - 1].chartX,
-                            points[j - 1].chartY,
-                            points[j].chartX,
-                            points[j].chartY
-                        );
-                    }
+            // For each position, check if the lines around the label intersect with any of the 
+            // graphs
+            for (i = 0; i < chart.series.length; i += 1) {
+                series = chart.series[i];
+                points = series.interpolatedPoints;
+                if (series.visible && points) {
+                    for (j = 1; j < points.length; j += 1) {
+                        // If any of the box sides intersect with the line, return
+                        if (boxIntersectLine(
+                                x,
+                                y,
+                                bBox.width,
+                                bBox.height,
+                                points[j - 1].chartX,
+                                points[j - 1].chartY,
+                                points[j].chartX,
+                                points[j].chartY
+                            )) {
+                            return false;
+                        }
+
+                        // But if it is too far away (a padded box doesn't intersect), also return
+                        if (this === series && !withinRange && checkDistance) {
+                            withinRange = boxIntersectLine(
+                                x - leastDistance,
+                                y - leastDistance,
+                                bBox.width + 2 * leastDistance,
+                                bBox.height + 2 * leastDistance,
+                                points[j - 1].chartX,
+                                points[j - 1].chartY,
+                                points[j].chartX,
+                                points[j].chartY
+                            );
+                        }
 
-                    // Find the squared distance from the center of the label
-                    if (this !== series) {
-                        distToOthersSquared = Math.min(
-                            distToOthersSquared,
-                            Math.pow(x + bBox.width / 2 - points[j].chartX, 2) + Math.pow(y + bBox.height / 2 - points[j].chartY, 2),
-                            Math.pow(x - points[j].chartX, 2) + Math.pow(y - points[j].chartY, 2),
-                            Math.pow(x + bBox.width - points[j].chartX, 2) + Math.pow(y - points[j].chartY, 2),
-                            Math.pow(x + bBox.width - points[j].chartX, 2) + Math.pow(y + bBox.height - points[j].chartY, 2),
-                            Math.pow(x - points[j].chartX, 2) + Math.pow(y + bBox.height - points[j].chartY, 2)
-                        );
+                        // Find the squared distance from the center of the label
+                        if (this !== series) {
+                            distToOthersSquared = Math.min(
+                                distToOthersSquared,
+                                Math.pow(x + bBox.width / 2 - points[j].chartX, 2) + Math.pow(y + bBox.height / 2 - points[j].chartY, 2),
+                                Math.pow(x - points[j].chartX, 2) + Math.pow(y - points[j].chartY, 2),
+                                Math.pow(x + bBox.width - points[j].chartX, 2) + Math.pow(y - points[j].chartY, 2),
+                                Math.pow(x + bBox.width - points[j].chartX, 2) + Math.pow(y + bBox.height - points[j].chartY, 2),
+                                Math.pow(x - points[j].chartX, 2) + Math.pow(y + bBox.height - points[j].chartY, 2)
+                            );
+                        }
                     }
-                }
 
-                // Do we need a connector? 
-                if (connectorEnabled && this === series && ((checkDistance && !withinRange) || 
-                        distToOthersSquared < Math.pow(this.options.label.connectorNeighbourDistance, 2))) {
-                    for (j = 1; j < points.length; j += 1) {
-                        dist = Math.min(
-                            Math.pow(x + bBox.width / 2 - points[j].chartX, 2) + Math.pow(y + bBox.height / 2 - points[j].chartY, 2),
-                            Math.pow(x - points[j].chartX, 2) + Math.pow(y - points[j].chartY, 2),
-                            Math.pow(x + bBox.width - points[j].chartX, 2) + Math.pow(y - points[j].chartY, 2),
-                            Math.pow(x + bBox.width - points[j].chartX, 2) + Math.pow(y + bBox.height - points[j].chartY, 2),
-                            Math.pow(x - points[j].chartX, 2) + Math.pow(y + bBox.height - points[j].chartY, 2)
-                        );
-                        if (dist < distToPointSquared) {
-                            distToPointSquared = dist;
-                            connectorPoint = points[j];
+                    // Do we need a connector? 
+                    if (connectorEnabled && this === series && ((checkDistance && !withinRange) ||
+                            distToOthersSquared < Math.pow(this.options.label.connectorNeighbourDistance, 2))) {
+                        for (j = 1; j < points.length; j += 1) {
+                            dist = Math.min(
+                                Math.pow(x + bBox.width / 2 - points[j].chartX, 2) + Math.pow(y + bBox.height / 2 - points[j].chartY, 2),
+                                Math.pow(x - points[j].chartX, 2) + Math.pow(y - points[j].chartY, 2),
+                                Math.pow(x + bBox.width - points[j].chartX, 2) + Math.pow(y - points[j].chartY, 2),
+                                Math.pow(x + bBox.width - points[j].chartX, 2) + Math.pow(y + bBox.height - points[j].chartY, 2),
+                                Math.pow(x - points[j].chartX, 2) + Math.pow(y + bBox.height - points[j].chartY, 2)
+                            );
+                            if (dist < distToPointSquared) {
+                                distToPointSquared = dist;
+                                connectorPoint = points[j];
+                            }
                         }
+                        withinRange = true;
                     }
-                    withinRange = true;
                 }
             }
-        }
-
-        return !checkDistance || withinRange ? {
-            x: x,
-            y: y,
-            weight: getWeight(distToOthersSquared, connectorPoint ? distToPointSquared : 0),
-            connectorPoint: connectorPoint
-        } : false;
 
-    };
+            return !checkDistance || withinRange ? {
+                x: x,
+                y: y,
+                weight: getWeight(distToOthersSquared, connectorPoint ? distToPointSquared : 0),
+                connectorPoint: connectorPoint
+            } : false;
 
+        };
 
-    /**
-     * The main initiator method that runs on chart level after initiation and redraw. It runs in 
-     * a timeout to prevent locking, and loops over all series, taking all series and labels into
-     * account when placing the labels.
-     */
-    function drawLabels(proceed) {
 
-        var chart = this;
-
-        proceed.call(chart);
+        /**
+         * The main initiator method that runs on chart level after initiation and redraw. It runs in 
+         * a timeout to prevent locking, and loops over all series, taking all series and labels into
+         * account when placing the labels.
+         */
+        function drawLabels(proceed) {
 
-        clearTimeout(chart.seriesLabelTimer);
+            var chart = this;
 
-        chart.seriesLabelTimer = setTimeout(function () {
+            proceed.call(chart);
 
-            chart.boxesToAvoid = [];
+            clearTimeout(chart.seriesLabelTimer);
 
-            // Build the interpolated points
-            each(chart.series, function (series) {
-                var options = series.options.label;
-                if (options.enabled && series.visible && (series.graph || series.area)) {
-                    series.interpolatedPoints = series.getPointsOnGraph();
+            chart.seriesLabelTimer = setTimeout(function() {
 
-                    each(options.boxesToAvoid || [], function (box) {
-                        chart.boxesToAvoid.push(box);
-                    });
-                }
-            });
-
-            each(chart.series, function (series) {
-                var bBox,
-                    x,
-                    y,
-                    results = [],
-                    clearPoint,
-                    i,
-                    best,
-                    inverted = chart.inverted,
-                    paneLeft = inverted ? series.yAxis.pos : series.xAxis.pos,
-                    paneTop = inverted ? series.xAxis.pos : series.yAxis.pos,
-                    paneWidth = chart.inverted ? series.yAxis.len : series.xAxis.len,
-                    paneHeight = chart.inverted ? series.xAxis.len : series.yAxis.len,
-                    points = series.interpolatedPoints;
-
-                function insidePane(x, y, bBox) {
-                    return x > paneLeft && x <= paneLeft + paneWidth - bBox.width && 
-                        y >= paneTop && y <= paneTop + paneHeight - bBox.height;
-                }
+                chart.boxesToAvoid = [];
 
-                if (series.visible && points) {
+                // Build the interpolated points
+                each(chart.series, function(series) {
+                    var options = series.options.label;
+                    if (options.enabled && series.visible && (series.graph || series.area)) {
+                        series.interpolatedPoints = series.getPointsOnGraph();
 
-                    if (!series.labelBySeries) {
-                        series.labelBySeries = chart.renderer.label(series.name, 0, -9999, 'connector')
-                            .css(extend({
-                                color: series.color
-                            }, series.options.label.styles))
-                            .attr({
-                                padding: 0,
-                                opacity: 0,
-                                stroke: series.color,
-                                'stroke-width': 1
-                            })
-                            .add(series.group)
-                            .animate({ opacity: 1 }, { duration: 200 });
+                        each(options.boxesToAvoid || [], function(box) {
+                            chart.boxesToAvoid.push(box);
+                        });
                     }
+                });
 
-                    bBox = series.labelBySeries.getBBox();
-                    bBox.width = Math.round(bBox.width);
+                each(chart.series, function(series) {
+                    var bBox,
+                        x,
+                        y,
+                        results = [],
+                        clearPoint,
+                        i,
+                        best,
+                        inverted = chart.inverted,
+                        paneLeft = inverted ? series.yAxis.pos : series.xAxis.pos,
+                        paneTop = inverted ? series.xAxis.pos : series.yAxis.pos,
+                        paneWidth = chart.inverted ? series.yAxis.len : series.xAxis.len,
+                        paneHeight = chart.inverted ? series.xAxis.len : series.yAxis.len,
+                        points = series.interpolatedPoints;
+
+                    function insidePane(x, y, bBox) {
+                        return x > paneLeft && x <= paneLeft + paneWidth - bBox.width &&
+                            y >= paneTop && y <= paneTop + paneHeight - bBox.height;
+                    }
 
-                    // Ideal positions are centered above or below a point on right side of chart
-                    for (i = points.length - 1; i > 0; i -= 1) {
+                    if (series.visible && points) {
 
-                        // Right - up
-                        x = points[i].chartX + labelDistance;
-                        y = points[i].chartY - bBox.height - labelDistance;
-                        if (insidePane(x, y, bBox)) {
-                            best = series.checkClearPoint(
-                                x,
-                                y,
-                                bBox
-                            );
-                        }
-                        if (best) {
-                            results.push(best);
+                        if (!series.labelBySeries) {
+                            series.labelBySeries = chart.renderer.label(series.name, 0, -9999, 'connector')
+                                .css(extend({
+                                    color: series.color
+                                }, series.options.label.styles))
+                                .attr({
+                                    padding: 0,
+                                    opacity: 0,
+                                    stroke: series.color,
+                                    'stroke-width': 1
+                                })
+                                .add(series.group)
+                                .animate({
+                                    opacity: 1
+                                }, {
+                                    duration: 200
+                                });
                         }
 
-                        // Right - down
-                        x = points[i].chartX + labelDistance;
-                        y = points[i].chartY + labelDistance;
-                        if (insidePane(x, y, bBox)) {
-                            best = series.checkClearPoint(
-                                x,
-                                y,
-                                bBox
-                            );
-                        }
-                        if (best) {
-                            results.push(best);
-                        }
+                        bBox = series.labelBySeries.getBBox();
+                        bBox.width = Math.round(bBox.width);
+
+                        // Ideal positions are centered above or below a point on right side of chart
+                        for (i = points.length - 1; i > 0; i -= 1) {
+
+                            // Right - up
+                            x = points[i].chartX + labelDistance;
+                            y = points[i].chartY - bBox.height - labelDistance;
+                            if (insidePane(x, y, bBox)) {
+                                best = series.checkClearPoint(
+                                    x,
+                                    y,
+                                    bBox
+                                );
+                            }
+                            if (best) {
+                                results.push(best);
+                            }
 
-                        // Left - down
-                        x = points[i].chartX - bBox.width - labelDistance;
-                        y = points[i].chartY + labelDistance;
-                        if (insidePane(x, y, bBox)) {
-                            best = series.checkClearPoint(
-                                x,
-                                y,
-                                bBox
-                            );
-                        }
-                        if (best) {
-                            results.push(best);
-                        }
+                            // Right - down
+                            x = points[i].chartX + labelDistance;
+                            y = points[i].chartY + labelDistance;
+                            if (insidePane(x, y, bBox)) {
+                                best = series.checkClearPoint(
+                                    x,
+                                    y,
+                                    bBox
+                                );
+                            }
+                            if (best) {
+                                results.push(best);
+                            }
 
-                        // Left - up
-                        x = points[i].chartX - bBox.width - labelDistance;
-                        y = points[i].chartY - bBox.height - labelDistance;
-                        if (insidePane(x, y, bBox)) {
-                            best = series.checkClearPoint(
-                                x,
-                                y,
-                                bBox
-                            );
-                        }
-                        if (best) {
-                            results.push(best);
-                        }
+                            // Left - down
+                            x = points[i].chartX - bBox.width - labelDistance;
+                            y = points[i].chartY + labelDistance;
+                            if (insidePane(x, y, bBox)) {
+                                best = series.checkClearPoint(
+                                    x,
+                                    y,
+                                    bBox
+                                );
+                            }
+                            if (best) {
+                                results.push(best);
+                            }
 
-                    }
+                            // Left - up
+                            x = points[i].chartX - bBox.width - labelDistance;
+                            y = points[i].chartY - bBox.height - labelDistance;
+                            if (insidePane(x, y, bBox)) {
+                                best = series.checkClearPoint(
+                                    x,
+                                    y,
+                                    bBox
+                                );
+                            }
+                            if (best) {
+                                results.push(best);
+                            }
+
+                        }
 
-                    // Brute force, try all positions on the chart in a 16x16 grid
-                    if (!results.length) {
-                        for (x = paneLeft + paneWidth - bBox.width; x >= paneLeft; x -= 16) {
-                            for (y = paneTop; y < paneTop + paneHeight - bBox.height; y += 16) {
-                                clearPoint = series.checkClearPoint(x, y, bBox, true);
-                                if (clearPoint) {
-                                    results.push(clearPoint);
+                        // Brute force, try all positions on the chart in a 16x16 grid
+                        if (!results.length) {
+                            for (x = paneLeft + paneWidth - bBox.width; x >= paneLeft; x -= 16) {
+                                for (y = paneTop; y < paneTop + paneHeight - bBox.height; y += 16) {
+                                    clearPoint = series.checkClearPoint(x, y, bBox, true);
+                                    if (clearPoint) {
+                                        results.push(clearPoint);
+                                    }
                                 }
                             }
                         }
-                    }
 
-                    if (results.length) {
+                        if (results.length) {
 
-                        results.sort(function (a, b) {
-                            return b.weight - a.weight;
-                        });
-                        
-                        best = results[0];
-
-                        chart.boxesToAvoid.push({
-                            left: best.x,
-                            right: best.x + bBox.width,
-                            top: best.y,
-                            bottom: best.y + bBox.height
-                        });
+                            results.sort(function(a, b) {
+                                return b.weight - a.weight;
+                            });
 
-                        // Move it if needed
-                        if (Math.round(best.x) !== Math.round(series.labelBySeries.x) || Math.round(best.y) !== Math.round(series.labelBySeries.y)) {
-                            series.labelBySeries
-                                .attr({
-                                    x: best.x - paneLeft,
-                                    y: best.y - paneTop,
-                                    anchorX: best.connectorPoint && best.connectorPoint.plotX,
-                                    anchorY: best.connectorPoint && best.connectorPoint.plotY,
-                                    opacity: 0
-                                })
-                                .animate({ opacity: 1 });
-                        }
+                            best = results[0];
+
+                            chart.boxesToAvoid.push({
+                                left: best.x,
+                                right: best.x + bBox.width,
+                                top: best.y,
+                                bottom: best.y + bBox.height
+                            });
+
+                            // Move it if needed
+                            if (Math.round(best.x) !== Math.round(series.labelBySeries.x) || Math.round(best.y) !== Math.round(series.labelBySeries.y)) {
+                                series.labelBySeries
+                                    .attr({
+                                        x: best.x - paneLeft,
+                                        y: best.y - paneTop,
+                                        anchorX: best.connectorPoint && best.connectorPoint.plotX,
+                                        anchorY: best.connectorPoint && best.connectorPoint.plotY,
+                                        opacity: 0
+                                    })
+                                    .animate({
+                                        opacity: 1
+                                    });
+                            }
 
-                    } else if (series.labelBySeries) {
-                        series.labelBySeries = series.labelBySeries.destroy();
+                        } else if (series.labelBySeries) {
+                            series.labelBySeries = series.labelBySeries.destroy();
+                        }
                     }
-                }
-            });
-        }, 350);
+                });
+            }, 350);
 
-    }
-    wrap(Chart.prototype, 'render', drawLabels);
-    wrap(Chart.prototype, 'redraw', drawLabels);
+        }
+        wrap(Chart.prototype, 'render', drawLabels);
+        wrap(Chart.prototype, 'redraw', drawLabels);
 
+    }(Highcharts));
 }));