highcharts_rails 0.1.0

data/vendor/assets/javascripts/js/modules/annotations.src.js

@@ -0,0 +1,408 @@
+/**
+ * @license Highcharts JS v5.0.6 (2016-12-07)
+ *
+ * (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';
+
+        var defined = H.defined,
+            isNumber = H.isNumber,
+            inArray = H.inArray,
+            isArray = H.isArray,
+            merge = H.merge,
+            Chart = H.Chart,
+            extend = H.extend,
+            each = H.each;
+
+        var ALIGN_FACTOR,
+            ALLOWED_SHAPES;
+
+        ALLOWED_SHAPES = ['path', 'rect', 'circle'];
+
+        ALIGN_FACTOR = {
+            top: 0,
+            left: 0,
+            center: 0.5,
+            middle: 0.5,
+            bottom: 1,
+            right: 1
+        };
+
+        function defaultOptions(shapeType) {
+            var shapeOptions,
+                options;
+
+            options = {
+                xAxis: 0,
+                yAxis: 0,
+                title: {
+                    style: {},
+                    text: '',
+                    x: 0,
+                    y: 0
+                },
+                shape: {
+                    params: {
+                        stroke: '#000000',
+                        fill: 'transparent',
+                        strokeWidth: 2
+                    }
+                }
+            };
+
+            shapeOptions = {
+                circle: {
+                    params: {
+                        x: 0,
+                        y: 0
+                    }
+                }
+            };
+
+            if (shapeOptions[shapeType]) {
+                options.shape = merge(options.shape, shapeOptions[shapeType]);
+            }
+
+            return options;
+        }
+
+        function translatePath(d, xAxis, yAxis, xOffset, yOffset) {
+            var len = d.length,
+                i = 0;
+
+            while (i < len) {
+                if (isNumber(d[i]) && isNumber(d[i + 1])) {
+                    d[i] = xAxis.toPixels(d[i]) - xOffset;
+                    d[i + 1] = yAxis.toPixels(d[i + 1]) - yOffset;
+                    i += 2;
+                } else {
+                    i += 1;
+                }
+            }
+
+            return d;
+        }
+
+
+        // Define annotation prototype
+        var Annotation = function() {
+            this.init.apply(this, arguments);
+        };
+        Annotation.prototype = {
+            /* 
+             * Initialize the annotation
+             */
+            init: function(chart, options) {
+                var shapeType = options.shape && options.shape.type;
+
+                this.chart = chart;
+                this.options = merge({}, defaultOptions(shapeType), options);
+            },
+
+            /*
+             * Render the annotation
+             */
+            render: function(redraw) {
+                var annotation = this,
+                    chart = this.chart,
+                    renderer = annotation.chart.renderer,
+                    group = annotation.group,
+                    title = annotation.title,
+                    shape = annotation.shape,
+                    options = annotation.options,
+                    titleOptions = options.title,
+                    shapeOptions = options.shape;
+
+                if (!group) {
+                    group = annotation.group = renderer.g();
+                }
+
+
+                if (!shape && shapeOptions && inArray(shapeOptions.type, ALLOWED_SHAPES) !== -1) {
+                    shape = annotation.shape = renderer[options.shape.type](shapeOptions.params);
+                    shape.add(group);
+                }
+
+                if (!title && titleOptions) {
+                    title = annotation.title = renderer.label(titleOptions);
+                    title.add(group);
+                }
+
+                group.add(chart.annotations.group);
+
+                // link annotations to point or series
+                annotation.linkObjects();
+
+                if (redraw !== false) {
+                    annotation.redraw();
+                }
+            },
+
+            /*
+             * Redraw the annotation title or shape after options update
+             */
+            redraw: function() {
+                var options = this.options,
+                    chart = this.chart,
+                    group = this.group,
+                    title = this.title,
+                    shape = this.shape,
+                    linkedTo = this.linkedObject,
+                    xAxis = chart.xAxis[options.xAxis],
+                    yAxis = chart.yAxis[options.yAxis],
+                    width = options.width,
+                    height = options.height,
+                    anchorY = ALIGN_FACTOR[options.anchorY],
+                    anchorX = ALIGN_FACTOR[options.anchorX],
+                    shapeParams,
+                    linkType,
+                    series,
+                    param,
+                    bbox,
+                    x,
+                    y;
+
+                if (linkedTo) {
+                    linkType = (linkedTo instanceof H.Point) ? 'point' :
+                        (linkedTo instanceof H.Series) ? 'series' : null;
+
+                    if (linkType === 'point') {
+                        options.xValue = linkedTo.x;
+                        options.yValue = linkedTo.y;
+                        series = linkedTo.series;
+                    } else if (linkType === 'series') {
+                        series = linkedTo;
+                    }
+
+                    if (group.visibility !== series.group.visibility) {
+                        group.attr({
+                            visibility: series.group.visibility
+                        });
+                    }
+                }
+
+
+                // Based on given options find annotation pixel position
+                x = (defined(options.xValue) ? xAxis.toPixels(options.xValue + xAxis.minPointOffset) - xAxis.minPixelPadding : options.x);
+                y = defined(options.yValue) ? yAxis.toPixels(options.yValue) : options.y;
+
+                if (!isNumber(x) || !isNumber(y)) {
+                    return;
+                }
+
+
+                if (title) {
+                    title.attr(options.title);
+                    title.css(options.title.style);
+                }
+
+                if (shape) {
+                    shapeParams = extend({}, options.shape.params);
+
+                    if (options.units === 'values') {
+                        for (param in shapeParams) {
+                            if (inArray(param, ['width', 'x']) > -1) {
+                                shapeParams[param] = xAxis.translate(shapeParams[param]);
+                            } else if (inArray(param, ['height', 'y']) > -1) {
+                                shapeParams[param] = yAxis.translate(shapeParams[param]);
+                            }
+                        }
+
+                        if (shapeParams.width) {
+                            shapeParams.width -= xAxis.toPixels(0) - xAxis.left;
+                        }
+
+                        if (shapeParams.x) {
+                            shapeParams.x += xAxis.minPixelPadding;
+                        }
+
+                        if (options.shape.type === 'path') {
+                            translatePath(shapeParams.d, xAxis, yAxis, x, y);
+                        }
+                    }
+
+                    // move the center of the circle to shape x/y
+                    if (options.shape.type === 'circle') {
+                        shapeParams.x += shapeParams.r;
+                        shapeParams.y += shapeParams.r;
+                    }
+
+                    shape.attr(shapeParams);
+                }
+
+                group.bBox = null;
+
+                // If annotation width or height is not defined in options use bounding box size
+                if (!isNumber(width)) {
+                    bbox = group.getBBox();
+                    width = bbox.width;
+                }
+
+                if (!isNumber(height)) {
+                    // get bbox only if it wasn't set before
+                    if (!bbox) {
+                        bbox = group.getBBox();
+                    }
+
+                    height = bbox.height;
+                }
+
+                // Calculate anchor point
+                if (!isNumber(anchorX)) {
+                    anchorX = ALIGN_FACTOR.center;
+                }
+
+                if (!isNumber(anchorY)) {
+                    anchorY = ALIGN_FACTOR.center;
+                }
+
+                // Translate group according to its dimension and anchor point
+                x = x - width * anchorX;
+                y = y - height * anchorY;
+
+                if (defined(group.translateX) && defined(group.translateY)) {
+                    group.animate({
+                        translateX: x,
+                        translateY: y
+                    });
+                } else {
+                    group.translate(x, y);
+                }
+            },
+
+            /*
+             * Destroy the annotation
+             */
+            destroy: function() {
+                var annotation = this,
+                    chart = this.chart,
+                    allItems = chart.annotations.allItems,
+                    index = allItems.indexOf(annotation);
+
+                if (index > -1) {
+                    allItems.splice(index, 1);
+                }
+
+                each(['title', 'shape', 'group'], function(element) {
+                    if (annotation[element]) {
+                        annotation[element].destroy();
+                        annotation[element] = null;
+                    }
+                });
+
+                annotation.group = annotation.title = annotation.shape = annotation.chart = annotation.options = null;
+            },
+
+            /*
+             * Update the annotation with a given options
+             */
+            update: function(options, redraw) {
+                extend(this.options, options);
+
+                // update link to point or series
+                this.linkObjects();
+
+                this.render(redraw);
+            },
+
+            linkObjects: function() {
+                var annotation = this,
+                    chart = annotation.chart,
+                    linkedTo = annotation.linkedObject,
+                    linkedId = linkedTo && (linkedTo.id || linkedTo.options.id),
+                    options = annotation.options,
+                    id = options.linkedTo;
+
+                if (!defined(id)) {
+                    annotation.linkedObject = null;
+                } else if (!defined(linkedTo) || id !== linkedId) {
+                    annotation.linkedObject = chart.get(id);
+                }
+            }
+        };
+
+
+        // Add annotations methods to chart prototype
+        extend(Chart.prototype, {
+            annotations: {
+                /*
+                 * Unified method for adding annotations to the chart
+                 */
+                add: function(options, redraw) {
+                    var annotations = this.allItems,
+                        chart = this.chart,
+                        item,
+                        len;
+
+                    if (!isArray(options)) {
+                        options = [options];
+                    }
+
+                    len = options.length;
+
+                    while (len--) {
+                        item = new Annotation(chart, options[len]);
+                        annotations.push(item);
+                        item.render(redraw);
+                    }
+                },
+
+                /**
+                 * Redraw all annotations, method used in chart events
+                 */
+                redraw: function() {
+                    each(this.allItems, function(annotation) {
+                        annotation.redraw();
+                    });
+                }
+            }
+        });
+
+
+        // Initialize on chart load
+        Chart.prototype.callbacks.push(function(chart) {
+            var options = chart.options.annotations,
+                group;
+
+            group = chart.renderer.g('annotations');
+            group.attr({
+                zIndex: 7
+            });
+            group.add();
+
+            // initialize empty array for annotations
+            chart.annotations.allItems = [];
+
+            // link chart object to annotations
+            chart.annotations.chart = chart;
+
+            // link annotations group element to the chart
+            chart.annotations.group = group;
+
+            if (isArray(options) && options.length > 0) {
+                chart.annotations.add(chart.options.annotations);
+            }
+
+            // update annotations after chart redraw
+            H.addEvent(chart, 'redraw', function() {
+                chart.annotations.redraw();
+            });
+        });
+
+    }(Highcharts));
+}));