highcharts_rails 0.1.0

data/vendor/assets/javascripts/js/modules/broken-axis.src.js

@@ -0,0 +1,338 @@
+/**
+ * @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 pick = H.pick,
+            wrap = H.wrap,
+            each = H.each,
+            extend = H.extend,
+            fireEvent = H.fireEvent,
+            Axis = H.Axis,
+            Series = H.Series;
+
+        function stripArguments() {
+            return Array.prototype.slice.call(arguments, 1);
+        }
+
+        extend(Axis.prototype, {
+            isInBreak: function(brk, val) {
+                var ret,
+                    repeat = brk.repeat || Infinity,
+                    from = brk.from,
+                    length = brk.to - brk.from,
+                    test = (val >= from ? (val - from) % repeat : repeat - ((from - val) % repeat));
+
+                if (!brk.inclusive) {
+                    ret = test < length && test !== 0;
+                } else {
+                    ret = test <= length;
+                }
+                return ret;
+            },
+
+            isInAnyBreak: function(val, testKeep) {
+
+                var breaks = this.options.breaks,
+                    i = breaks && breaks.length,
+                    inbrk,
+                    keep,
+                    ret;
+
+
+                if (i) {
+
+                    while (i--) {
+                        if (this.isInBreak(breaks[i], val)) {
+                            inbrk = true;
+                            if (!keep) {
+                                keep = pick(breaks[i].showPoints, this.isXAxis ? false : true);
+                            }
+                        }
+                    }
+
+                    if (inbrk && testKeep) {
+                        ret = inbrk && !keep;
+                    } else {
+                        ret = inbrk;
+                    }
+                }
+                return ret;
+            }
+        });
+
+        wrap(Axis.prototype, 'setTickPositions', function(proceed) {
+            proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+
+            if (this.options.breaks) {
+                var axis = this,
+                    tickPositions = this.tickPositions,
+                    info = this.tickPositions.info,
+                    newPositions = [],
+                    i;
+
+                for (i = 0; i < tickPositions.length; i++) {
+                    if (!axis.isInAnyBreak(tickPositions[i])) {
+                        newPositions.push(tickPositions[i]);
+                    }
+                }
+
+                this.tickPositions = newPositions;
+                this.tickPositions.info = info;
+            }
+        });
+
+        wrap(Axis.prototype, 'init', function(proceed, chart, userOptions) {
+            // Force Axis to be not-ordinal when breaks are defined
+            if (userOptions.breaks && userOptions.breaks.length) {
+                userOptions.ordinal = false;
+            }
+
+            proceed.call(this, chart, userOptions);
+
+            if (this.options.breaks) {
+
+                var axis = this;
+
+                axis.isBroken = true;
+
+                this.val2lin = function(val) {
+                    var nval = val,
+                        brk,
+                        i;
+
+                    for (i = 0; i < axis.breakArray.length; i++) {
+                        brk = axis.breakArray[i];
+                        if (brk.to <= val) {
+                            nval -= brk.len;
+                        } else if (brk.from >= val) {
+                            break;
+                        } else if (axis.isInBreak(brk, val)) {
+                            nval -= (val - brk.from);
+                            break;
+                        }
+                    }
+
+                    return nval;
+                };
+
+                this.lin2val = function(val) {
+                    var nval = val,
+                        brk,
+                        i;
+
+                    for (i = 0; i < axis.breakArray.length; i++) {
+                        brk = axis.breakArray[i];
+                        if (brk.from >= nval) {
+                            break;
+                        } else if (brk.to < nval) {
+                            nval += brk.len;
+                        } else if (axis.isInBreak(brk, nval)) {
+                            nval += brk.len;
+                        }
+                    }
+                    return nval;
+                };
+
+                this.setExtremes = function(newMin, newMax, redraw, animation, eventArguments) {
+                    // If trying to set extremes inside a break, extend it to before and after the break ( #3857 )
+                    while (this.isInAnyBreak(newMin)) {
+                        newMin -= this.closestPointRange;
+                    }
+                    while (this.isInAnyBreak(newMax)) {
+                        newMax -= this.closestPointRange;
+                    }
+                    Axis.prototype.setExtremes.call(this, newMin, newMax, redraw, animation, eventArguments);
+                };
+
+                this.setAxisTranslation = function(saveOld) {
+                    Axis.prototype.setAxisTranslation.call(this, saveOld);
+
+                    var breaks = axis.options.breaks,
+                        breakArrayT = [], // Temporary one
+                        breakArray = [],
+                        length = 0,
+                        inBrk,
+                        repeat,
+                        brk,
+                        min = axis.userMin || axis.min,
+                        max = axis.userMax || axis.max,
+                        start,
+                        i,
+                        j;
+
+                    // Min & max check (#4247)
+                    for (i in breaks) {
+                        brk = breaks[i];
+                        repeat = brk.repeat || Infinity;
+                        if (axis.isInBreak(brk, min)) {
+                            min += (brk.to % repeat) - (min % repeat);
+                        }
+                        if (axis.isInBreak(brk, max)) {
+                            max -= (max % repeat) - (brk.from % repeat);
+                        }
+                    }
+
+                    // Construct an array holding all breaks in the axis
+                    for (i in breaks) {
+                        brk = breaks[i];
+                        start = brk.from;
+                        repeat = brk.repeat || Infinity;
+
+                        while (start - repeat > min) {
+                            start -= repeat;
+                        }
+                        while (start < min) {
+                            start += repeat;
+                        }
+
+                        for (j = start; j < max; j += repeat) {
+                            breakArrayT.push({
+                                value: j,
+                                move: 'in'
+                            });
+                            breakArrayT.push({
+                                value: j + (brk.to - brk.from),
+                                move: 'out',
+                                size: brk.breakSize
+                            });
+                        }
+                    }
+
+                    breakArrayT.sort(function(a, b) {
+                        var ret;
+                        if (a.value === b.value) {
+                            ret = (a.move === 'in' ? 0 : 1) - (b.move === 'in' ? 0 : 1);
+                        } else {
+                            ret = a.value - b.value;
+                        }
+                        return ret;
+                    });
+
+                    // Simplify the breaks
+                    inBrk = 0;
+                    start = min;
+
+                    for (i in breakArrayT) {
+                        brk = breakArrayT[i];
+                        inBrk += (brk.move === 'in' ? 1 : -1);
+
+                        if (inBrk === 1 && brk.move === 'in') {
+                            start = brk.value;
+                        }
+                        if (inBrk === 0) {
+                            breakArray.push({
+                                from: start,
+                                to: brk.value,
+                                len: brk.value - start - (brk.size || 0)
+                            });
+                            length += brk.value - start - (brk.size || 0);
+                        }
+                    }
+
+                    axis.breakArray = breakArray;
+
+                    fireEvent(axis, 'afterBreaks');
+
+                    axis.transA *= ((max - axis.min) / (max - min - length));
+
+                    axis.min = min;
+                    axis.max = max;
+                };
+            }
+        });
+
+        wrap(Series.prototype, 'generatePoints', function(proceed) {
+
+            proceed.apply(this, stripArguments(arguments));
+
+            var series = this,
+                xAxis = series.xAxis,
+                yAxis = series.yAxis,
+                points = series.points,
+                point,
+                i = points.length,
+                connectNulls = series.options.connectNulls,
+                nullGap;
+
+
+            if (xAxis && yAxis && (xAxis.options.breaks || yAxis.options.breaks)) {
+                while (i--) {
+                    point = points[i];
+
+                    nullGap = point.y === null && connectNulls === false; // respect nulls inside the break (#4275)
+                    if (!nullGap && (xAxis.isInAnyBreak(point.x, true) || yAxis.isInAnyBreak(point.y, true))) {
+                        points.splice(i, 1);
+                        if (this.data[i]) {
+                            this.data[i].destroyElements(); // removes the graphics for this point if they exist
+                        }
+                    }
+                }
+            }
+
+        });
+
+        function drawPointsWrapped(proceed) {
+            proceed.apply(this);
+            this.drawBreaks(this.xAxis, ['x']);
+            this.drawBreaks(this.yAxis, pick(this.pointArrayMap, ['y']));
+        }
+
+        H.Series.prototype.drawBreaks = function(axis, keys) {
+            var series = this,
+                points = series.points,
+                breaks,
+                threshold,
+                eventName,
+                y;
+
+            if (!axis) {
+                return; // #5950
+            }
+
+            each(keys, function(key) {
+                breaks = axis.breakArray || [];
+                threshold = axis.isXAxis ? axis.min : pick(series.options.threshold, axis.min);
+                each(points, function(point) {
+                    y = pick(point['stack' + key.toUpperCase()], point[key]);
+                    each(breaks, function(brk) {
+                        eventName = false;
+
+                        if ((threshold < brk.from && y > brk.to) || (threshold > brk.from && y < brk.from)) {
+                            eventName = 'pointBreak';
+                        } else if ((threshold < brk.from && y > brk.from && y < brk.to) || (threshold > brk.from && y > brk.to && y < brk.from)) { // point falls inside the break
+                            eventName = 'pointInBreak';
+                        }
+                        if (eventName) {
+                            fireEvent(axis, eventName, {
+                                point: point,
+                                brk: brk
+                            });
+                        }
+                    });
+                });
+            });
+        };
+
+        wrap(H.seriesTypes.column.prototype, 'drawPoints', drawPointsWrapped);
+        wrap(H.Series.prototype, 'drawPoints', drawPointsWrapped);
+
+    }(Highcharts));
+}));