ShowEasy/EuroTran/WebApp/Ueditor/third-party/highcharts/modules/annotations.src.js

(function (Highcharts, HighchartsAdapter) {
    var UNDEFINED,
        ALIGN_FACTOR,
        ALLOWED_SHAPES,
        Chart = Highcharts.Chart,
        extend = Highcharts.extend,
        each = Highcharts.each;

    ALLOWED_SHAPES = ["path", "rect", "circle"];

    ALIGN_FACTOR = {
        top: 0,
        left: 0,
        center: 0.5,
        middle: 0.5,
        bottom: 1,
        right: 1
    };

    // Highcharts helper methods
    var inArray = HighchartsAdapter.inArray,
        merge = Highcharts.merge;

    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 isArray(obj) {
        return Object.prototype.toString.call(obj) === '[object Array]';
    }

    function isNumber(n) {
        return typeof n === 'number';
    }

    function defined(obj) {
        return obj !== UNDEFINED && obj !== null;
    }

    function translatePath(d, xAxis, yAxis, xOffset, yOffset) {
        var len = d.length,
            i = 0;

        while (i < len) {
            if (typeof d[i] === 'number' && typeof d[i + 1] === 'number') {
                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],
                resetBBox = false,
                shapeParams,
                linkType,
                series,
                param,
                bbox,
                x,
                y;

            if (linkedTo) {
                linkType = (linkedTo instanceof Highcharts.Point) ? 'point' :
                    (linkedTo instanceof Highcharts.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 (isNaN(x) || isNaN(y) || !isNumber(x) || !isNumber(y)) {
                return;
            }

            if (title) {
                title.attr(options.title);
                title.css(options.title.style);
                resetBBox = true;
            }

            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;
                }

                resetBBox = true;
                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 (chart.animation && 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
        Highcharts.addEvent(chart, 'redraw', function () {
            chart.annotations.redraw();
        });
    });
}(Highcharts, HighchartsAdapter));