summaryrefslogtreecommitdiff
path: root/html/includes/js/highcharts-more.src.js
diff options
context:
space:
mode:
Diffstat (limited to 'html/includes/js/highcharts-more.src.js')
-rw-r--r--html/includes/js/highcharts-more.src.js2575
1 files changed, 2575 insertions, 0 deletions
diff --git a/html/includes/js/highcharts-more.src.js b/html/includes/js/highcharts-more.src.js
new file mode 100644
index 0000000..df65b08
--- /dev/null
+++ b/html/includes/js/highcharts-more.src.js
@@ -0,0 +1,2575 @@
+// ==ClosureCompiler==
+// @compilation_level SIMPLE_OPTIMIZATIONS
+
+/**
+ * @license Highcharts JS v4.0.4 (2014-09-02)
+ *
+ * (c) 2009-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+// JSLint options:
+/*global Highcharts, HighchartsAdapter, document, window, navigator, setInterval, clearInterval, clearTimeout, setTimeout, location, jQuery, $, console */
+
+(function (Highcharts, UNDEFINED) {
+var arrayMin = Highcharts.arrayMin,
+ arrayMax = Highcharts.arrayMax,
+ each = Highcharts.each,
+ extend = Highcharts.extend,
+ merge = Highcharts.merge,
+ map = Highcharts.map,
+ pick = Highcharts.pick,
+ pInt = Highcharts.pInt,
+ defaultPlotOptions = Highcharts.getOptions().plotOptions,
+ seriesTypes = Highcharts.seriesTypes,
+ extendClass = Highcharts.extendClass,
+ splat = Highcharts.splat,
+ wrap = Highcharts.wrap,
+ Axis = Highcharts.Axis,
+ Tick = Highcharts.Tick,
+ Point = Highcharts.Point,
+ Pointer = Highcharts.Pointer,
+ CenteredSeriesMixin = Highcharts.CenteredSeriesMixin,
+ TrackerMixin = Highcharts.TrackerMixin,
+ Series = Highcharts.Series,
+ math = Math,
+ mathRound = math.round,
+ mathFloor = math.floor,
+ mathMax = math.max,
+ Color = Highcharts.Color,
+ noop = function () {};/**
+ * The Pane object allows options that are common to a set of X and Y axes.
+ *
+ * In the future, this can be extended to basic Highcharts and Highstock.
+ */
+function Pane(options, chart, firstAxis) {
+ this.init.call(this, options, chart, firstAxis);
+}
+
+// Extend the Pane prototype
+extend(Pane.prototype, {
+
+ /**
+ * Initiate the Pane object
+ */
+ init: function (options, chart, firstAxis) {
+ var pane = this,
+ backgroundOption,
+ defaultOptions = pane.defaultOptions;
+
+ pane.chart = chart;
+
+ // Set options
+ if (chart.angular) { // gauges
+ defaultOptions.background = {}; // gets extended by this.defaultBackgroundOptions
+ }
+ pane.options = options = merge(defaultOptions, options);
+
+ backgroundOption = options.background;
+
+ // To avoid having weighty logic to place, update and remove the backgrounds,
+ // push them to the first axis' plot bands and borrow the existing logic there.
+ if (backgroundOption) {
+ each([].concat(splat(backgroundOption)).reverse(), function (config) {
+ var backgroundColor = config.backgroundColor; // if defined, replace the old one (specific for gradients)
+ config = merge(pane.defaultBackgroundOptions, config);
+ if (backgroundColor) {
+ config.backgroundColor = backgroundColor;
+ }
+ config.color = config.backgroundColor; // due to naming in plotBands
+ firstAxis.options.plotBands.unshift(config);
+ });
+ }
+ },
+
+ /**
+ * The default options object
+ */
+ defaultOptions: {
+ // background: {conditional},
+ center: ['50%', '50%'],
+ size: '85%',
+ startAngle: 0
+ //endAngle: startAngle + 360
+ },
+
+ /**
+ * The default background options
+ */
+ defaultBackgroundOptions: {
+ shape: 'circle',
+ borderWidth: 1,
+ borderColor: 'silver',
+ backgroundColor: {
+ linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+ stops: [
+ [0, '#FFF'],
+ [1, '#DDD']
+ ]
+ },
+ from: -Number.MAX_VALUE, // corrected to axis min
+ innerRadius: 0,
+ to: Number.MAX_VALUE, // corrected to axis max
+ outerRadius: '105%'
+ }
+
+});
+var axisProto = Axis.prototype,
+ tickProto = Tick.prototype;
+
+/**
+ * Augmented methods for the x axis in order to hide it completely, used for the X axis in gauges
+ */
+var hiddenAxisMixin = {
+ getOffset: noop,
+ redraw: function () {
+ this.isDirty = false; // prevent setting Y axis dirty
+ },
+ render: function () {
+ this.isDirty = false; // prevent setting Y axis dirty
+ },
+ setScale: noop,
+ setCategories: noop,
+ setTitle: noop
+};
+
+/**
+ * Augmented methods for the value axis
+ */
+/*jslint unparam: true*/
+var radialAxisMixin = {
+ isRadial: true,
+
+ /**
+ * The default options extend defaultYAxisOptions
+ */
+ defaultRadialGaugeOptions: {
+ labels: {
+ align: 'center',
+ x: 0,
+ y: null // auto
+ },
+ minorGridLineWidth: 0,
+ minorTickInterval: 'auto',
+ minorTickLength: 10,
+ minorTickPosition: 'inside',
+ minorTickWidth: 1,
+ tickLength: 10,
+ tickPosition: 'inside',
+ tickWidth: 2,
+ title: {
+ rotation: 0
+ },
+ zIndex: 2 // behind dials, points in the series group
+ },
+
+ // Circular axis around the perimeter of a polar chart
+ defaultRadialXOptions: {
+ gridLineWidth: 1, // spokes
+ labels: {
+ align: null, // auto
+ distance: 15,
+ x: 0,
+ y: null // auto
+ },
+ maxPadding: 0,
+ minPadding: 0,
+ showLastLabel: false,
+ tickLength: 0
+ },
+
+ // Radial axis, like a spoke in a polar chart
+ defaultRadialYOptions: {
+ gridLineInterpolation: 'circle',
+ labels: {
+ align: 'right',
+ x: -3,
+ y: -2
+ },
+ showLastLabel: false,
+ title: {
+ x: 4,
+ text: null,
+ rotation: 90
+ }
+ },
+
+ /**
+ * Merge and set options
+ */
+ setOptions: function (userOptions) {
+
+ var options = this.options = merge(
+ this.defaultOptions,
+ this.defaultRadialOptions,
+ userOptions
+ );
+
+ // Make sure the plotBands array is instanciated for each Axis (#2649)
+ if (!options.plotBands) {
+ options.plotBands = [];
+ }
+
+ },
+
+ /**
+ * Wrap the getOffset method to return zero offset for title or labels in a radial
+ * axis
+ */
+ getOffset: function () {
+ // Call the Axis prototype method (the method we're in now is on the instance)
+ axisProto.getOffset.call(this);
+
+ // Title or label offsets are not counted
+ this.chart.axisOffset[this.side] = 0;
+
+ // Set the center array
+ this.center = this.pane.center = CenteredSeriesMixin.getCenter.call(this.pane);
+ },
+
+
+ /**
+ * Get the path for the axis line. This method is also referenced in the getPlotLinePath
+ * method.
+ */
+ getLinePath: function (lineWidth, radius) {
+ var center = this.center;
+ radius = pick(radius, center[2] / 2 - this.offset);
+
+ return this.chart.renderer.symbols.arc(
+ this.left + center[0],
+ this.top + center[1],
+ radius,
+ radius,
+ {
+ start: this.startAngleRad,
+ end: this.endAngleRad,
+ open: true,
+ innerR: 0
+ }
+ );
+ },
+
+ /**
+ * Override setAxisTranslation by setting the translation to the difference
+ * in rotation. This allows the translate method to return angle for
+ * any given value.
+ */
+ setAxisTranslation: function () {
+
+ // Call uber method
+ axisProto.setAxisTranslation.call(this);
+
+ // Set transA and minPixelPadding
+ if (this.center) { // it's not defined the first time
+ if (this.isCircular) {
+
+ this.transA = (this.endAngleRad - this.startAngleRad) /
+ ((this.max - this.min) || 1);
+
+
+ } else {
+ this.transA = (this.center[2] / 2) / ((this.max - this.min) || 1);
+ }
+
+ if (this.isXAxis) {
+ this.minPixelPadding = this.transA * this.minPointOffset;
+ } else {
+ // This is a workaround for regression #2593, but categories still don't position correctly.
+ // TODO: Implement true handling of Y axis categories on gauges.
+ this.minPixelPadding = 0;
+ }
+ }
+ },
+
+ /**
+ * In case of auto connect, add one closestPointRange to the max value right before
+ * tickPositions are computed, so that ticks will extend passed the real max.
+ */
+ beforeSetTickPositions: function () {
+ if (this.autoConnect) {
+ this.max += (this.categories && 1) || this.pointRange || this.closestPointRange || 0; // #1197, #2260
+ }
+ },
+
+ /**
+ * Override the setAxisSize method to use the arc's circumference as length. This
+ * allows tickPixelInterval to apply to pixel lengths along the perimeter
+ */
+ setAxisSize: function () {
+
+ axisProto.setAxisSize.call(this);
+
+ if (this.isRadial) {
+
+ // Set the center array
+ this.center = this.pane.center = Highcharts.CenteredSeriesMixin.getCenter.call(this.pane);
+
+ // The sector is used in Axis.translate to compute the translation of reversed axis points (#2570)
+ if (this.isCircular) {
+ this.sector = this.endAngleRad - this.startAngleRad;
+ }
+
+ // Axis len is used to lay out the ticks
+ this.len = this.width = this.height = this.center[2] * pick(this.sector, 1) / 2;
+
+
+ }
+ },
+
+ /**
+ * Returns the x, y coordinate of a point given by a value and a pixel distance
+ * from center
+ */
+ getPosition: function (value, length) {
+ return this.postTranslate(
+ this.isCircular ? this.translate(value) : 0, // #2848
+ pick(this.isCircular ? length : this.translate(value), this.center[2] / 2) - this.offset
+ );
+ },
+
+ /**
+ * Translate from intermediate plotX (angle), plotY (axis.len - radius) to final chart coordinates.
+ */
+ postTranslate: function (angle, radius) {
+
+ var chart = this.chart,
+ center = this.center;
+
+ angle = this.startAngleRad + angle;
+
+ return {
+ x: chart.plotLeft + center[0] + Math.cos(angle) * radius,
+ y: chart.plotTop + center[1] + Math.sin(angle) * radius
+ };
+
+ },
+
+ /**
+ * Find the path for plot bands along the radial axis
+ */
+ getPlotBandPath: function (from, to, options) {
+ var center = this.center,
+ startAngleRad = this.startAngleRad,
+ fullRadius = center[2] / 2,
+ radii = [
+ pick(options.outerRadius, '100%'),
+ options.innerRadius,
+ pick(options.thickness, 10)
+ ],
+ percentRegex = /%$/,
+ start,
+ end,
+ open,
+ isCircular = this.isCircular, // X axis in a polar chart
+ ret;
+
+ // Polygonal plot bands
+ if (this.options.gridLineInterpolation === 'polygon') {
+ ret = this.getPlotLinePath(from).concat(this.getPlotLinePath(to, true));
+
+ // Circular grid bands
+ } else {
+
+ // Plot bands on Y axis (radial axis) - inner and outer radius depend on to and from
+ if (!isCircular) {
+ radii[0] = this.translate(from);
+ radii[1] = this.translate(to);
+ }
+
+ // Convert percentages to pixel values
+ radii = map(radii, function (radius) {
+ if (percentRegex.test(radius)) {
+ radius = (pInt(radius, 10) * fullRadius) / 100;
+ }
+ return radius;
+ });
+
+ // Handle full circle
+ if (options.shape === 'circle' || !isCircular) {
+ start = -Math.PI / 2;
+ end = Math.PI * 1.5;
+ open = true;
+ } else {
+ start = startAngleRad + this.translate(from);
+ end = startAngleRad + this.translate(to);
+ }
+
+
+ ret = this.chart.renderer.symbols.arc(
+ this.left + center[0],
+ this.top + center[1],
+ radii[0],
+ radii[0],
+ {
+ start: start,
+ end: end,
+ innerR: pick(radii[1], radii[0] - radii[2]),
+ open: open
+ }
+ );
+ }
+
+ return ret;
+ },
+
+ /**
+ * Find the path for plot lines perpendicular to the radial axis.
+ */
+ getPlotLinePath: function (value, reverse) {
+ var axis = this,
+ center = axis.center,
+ chart = axis.chart,
+ end = axis.getPosition(value),
+ xAxis,
+ xy,
+ tickPositions,
+ ret;
+
+ // Spokes
+ if (axis.isCircular) {
+ ret = ['M', center[0] + chart.plotLeft, center[1] + chart.plotTop, 'L', end.x, end.y];
+
+ // Concentric circles
+ } else if (axis.options.gridLineInterpolation === 'circle') {
+ value = axis.translate(value);
+ if (value) { // a value of 0 is in the center
+ ret = axis.getLinePath(0, value);
+ }
+ // Concentric polygons
+ } else {
+ // Find the X axis in the same pane
+ each(chart.xAxis, function (a) {
+ if (a.pane === axis.pane) {
+ xAxis = a;
+ }
+ });
+ ret = [];
+ value = axis.translate(value);
+ tickPositions = xAxis.tickPositions;
+ if (xAxis.autoConnect) {
+ tickPositions = tickPositions.concat([tickPositions[0]]);
+ }
+ // Reverse the positions for concatenation of polygonal plot bands
+ if (reverse) {
+ tickPositions = [].concat(tickPositions).reverse();
+ }
+
+ each(tickPositions, function (pos, i) {
+ xy = xAxis.getPosition(pos, value);
+ ret.push(i ? 'L' : 'M', xy.x, xy.y);
+ });
+
+ }
+ return ret;
+ },
+
+ /**
+ * Find the position for the axis title, by default inside the gauge
+ */
+ getTitlePosition: function () {
+ var center = this.center,
+ chart = this.chart,
+ titleOptions = this.options.title;
+
+ return {
+ x: chart.plotLeft + center[0] + (titleOptions.x || 0),
+ y: chart.plotTop + center[1] - ({ high: 0.5, middle: 0.25, low: 0 }[titleOptions.align] *
+ center[2]) + (titleOptions.y || 0)
+ };
+ }
+
+};
+/*jslint unparam: false*/
+
+/**
+ * Override axisProto.init to mix in special axis instance functions and function overrides
+ */
+wrap(axisProto, 'init', function (proceed, chart, userOptions) {
+ var axis = this,
+ angular = chart.angular,
+ polar = chart.polar,
+ isX = userOptions.isX,
+ isHidden = angular && isX,
+ isCircular,
+ startAngleRad,
+ endAngleRad,
+ options,
+ chartOptions = chart.options,
+ paneIndex = userOptions.pane || 0,
+ pane,
+ paneOptions;
+
+ // Before prototype.init
+ if (angular) {
+ extend(this, isHidden ? hiddenAxisMixin : radialAxisMixin);
+ isCircular = !isX;
+ if (isCircular) {
+ this.defaultRadialOptions = this.defaultRadialGaugeOptions;
+ }
+
+ } else if (polar) {
+ //extend(this, userOptions.isX ? radialAxisMixin : radialAxisMixin);
+ extend(this, radialAxisMixin);
+ isCircular = isX;
+ this.defaultRadialOptions = isX ? this.defaultRadialXOptions : merge(this.defaultYAxisOptions, this.defaultRadialYOptions);
+
+ }
+
+ // Run prototype.init
+ proceed.call(this, chart, userOptions);
+
+ if (!isHidden && (angular || polar)) {
+ options = this.options;
+
+ // Create the pane and set the pane options.
+ if (!chart.panes) {
+ chart.panes = [];
+ }
+ this.pane = pane = chart.panes[paneIndex] = chart.panes[paneIndex] || new Pane(
+ splat(chartOptions.pane)[paneIndex],
+ chart,
+ axis
+ );
+ paneOptions = pane.options;
+
+
+ // Disable certain features on angular and polar axes
+ chart.inverted = false;
+ chartOptions.chart.zoomType = null;
+
+ // Start and end angle options are
+ // given in degrees relative to top, while internal computations are
+ // in radians relative to right (like SVG).
+ this.startAngleRad = startAngleRad = (paneOptions.startAngle - 90) * Math.PI / 180;
+ this.endAngleRad = endAngleRad = (pick(paneOptions.endAngle, paneOptions.startAngle + 360) - 90) * Math.PI / 180;
+ this.offset = options.offset || 0;
+
+ this.isCircular = isCircular;
+
+ // Automatically connect grid lines?
+ if (isCircular && userOptions.max === UNDEFINED && endAngleRad - startAngleRad === 2 * Math.PI) {
+ this.autoConnect = true;
+ }
+ }
+
+});
+
+/**
+ * Add special cases within the Tick class' methods for radial axes.
+ */
+wrap(tickProto, 'getPosition', function (proceed, horiz, pos, tickmarkOffset, old) {
+ var axis = this.axis;
+
+ return axis.getPosition ?
+ axis.getPosition(pos) :
+ proceed.call(this, horiz, pos, tickmarkOffset, old);
+});
+
+/**
+ * Wrap the getLabelPosition function to find the center position of the label
+ * based on the distance option
+ */
+wrap(tickProto, 'getLabelPosition', function (proceed, x, y, label, horiz, labelOptions, tickmarkOffset, index, step) {
+ var axis = this.axis,
+ optionsY = labelOptions.y,
+ ret,
+ align = labelOptions.align,
+ angle = ((axis.translate(this.pos) + axis.startAngleRad + Math.PI / 2) / Math.PI * 180) % 360;
+
+ if (axis.isRadial) {
+ ret = axis.getPosition(this.pos, (axis.center[2] / 2) + pick(labelOptions.distance, -25));
+
+ // Automatically rotated
+ if (labelOptions.rotation === 'auto') {
+ label.attr({
+ rotation: angle
+ });
+
+ // Vertically centered
+ } else if (optionsY === null) {
+ optionsY = axis.chart.renderer.fontMetrics(label.styles.fontSize).b - label.getBBox().height / 2;
+ }
+
+ // Automatic alignment
+ if (align === null) {
+ if (axis.isCircular) {
+ if (angle > 20 && angle < 160) {
+ align = 'left'; // right hemisphere
+ } else if (angle > 200 && angle < 340) {
+ align = 'right'; // left hemisphere
+ } else {
+ align = 'center'; // top or bottom
+ }
+ } else {
+ align = 'center';
+ }
+ label.attr({
+ align: align
+ });
+ }
+
+ ret.x += labelOptions.x;
+ ret.y += optionsY;
+
+ } else {
+ ret = proceed.call(this, x, y, label, horiz, labelOptions, tickmarkOffset, index, step);
+ }
+ return ret;
+});
+
+/**
+ * Wrap the getMarkPath function to return the path of the radial marker
+ */
+wrap(tickProto, 'getMarkPath', function (proceed, x, y, tickLength, tickWidth, horiz, renderer) {
+ var axis = this.axis,
+ endPoint,
+ ret;
+
+ if (axis.isRadial) {
+ endPoint = axis.getPosition(this.pos, axis.center[2] / 2 + tickLength);
+ ret = [
+ 'M',
+ x,
+ y,
+ 'L',
+ endPoint.x,
+ endPoint.y
+ ];
+ } else {
+ ret = proceed.call(this, x, y, tickLength, tickWidth, horiz, renderer);
+ }
+ return ret;
+});/*
+ * The AreaRangeSeries class
+ *
+ */
+
+/**
+ * Extend the default options with map options
+ */
+defaultPlotOptions.arearange = merge(defaultPlotOptions.area, {
+ lineWidth: 1,
+ marker: null,
+ threshold: null,
+ tooltip: {
+ pointFormat: '<span style="color:{series.color}">\u25CF</span> {series.name}: <b>{point.low}</b> - <b>{point.high}</b><br/>'
+ },
+ trackByArea: true,
+ dataLabels: {
+ align: null,
+ verticalAlign: null,
+ xLow: 0,
+ xHigh: 0,
+ yLow: 0,
+ yHigh: 0
+ },
+ states: {
+ hover: {
+ halo: false
+ }
+ }
+});
+
+/**
+ * Add the series type
+ */
+seriesTypes.arearange = extendClass(seriesTypes.area, {
+ type: 'arearange',
+ pointArrayMap: ['low', 'high'],
+ toYData: function (point) {
+ return [point.low, point.high];
+ },
+ pointValKey: 'low',
+
+ /**
+ * Extend getSegments to force null points if the higher value is null. #1703.
+ */
+ getSegments: function () {
+ var series = this;
+
+ each(series.points, function (point) {
+ if (!series.options.connectNulls && (point.low === null || point.high === null)) {
+ point.y = null;
+ } else if (point.low === null && point.high !== null) {
+ point.y = point.high;
+ }
+ });
+ Series.prototype.getSegments.call(this);
+ },
+
+ /**
+ * Translate data points from raw values x and y to plotX and plotY
+ */
+ translate: function () {
+ var series = this,
+ yAxis = series.yAxis;
+
+ seriesTypes.area.prototype.translate.apply(series);
+
+ // Set plotLow and plotHigh
+ each(series.points, function (point) {
+
+ var low = point.low,
+ high = point.high,
+ plotY = point.plotY;
+
+ if (high === null && low === null) {
+ point.y = null;
+ } else if (low === null) {
+ point.plotLow = point.plotY = null;
+ point.plotHigh = yAxis.translate(high, 0, 1, 0, 1);
+ } else if (high === null) {
+ point.plotLow = plotY;
+ point.plotHigh = null;
+ } else {
+ point.plotLow = plotY;
+ point.plotHigh = yAxis.translate(high, 0, 1, 0, 1);
+ }
+ });
+ },
+
+ /**
+ * Extend the line series' getSegmentPath method by applying the segment
+ * path to both lower and higher values of the range
+ */
+ getSegmentPath: function (segment) {
+
+ var lowSegment,
+ highSegment = [],
+ i = segment.length,
+ baseGetSegmentPath = Series.prototype.getSegmentPath,
+ point,
+ linePath,
+ lowerPath,
+ options = this.options,
+ step = options.step,
+ higherPath;
+
+ // Remove nulls from low segment
+ lowSegment = HighchartsAdapter.grep(segment, function (point) {
+ return point.plotLow !== null;
+ });
+
+ // Make a segment with plotX and plotY for the top values
+ while (i--) {
+ point = segment[i];
+ if (point.plotHigh !== null) {
+ highSegment.push({
+ plotX: point.plotX,
+ plotY: point.plotHigh
+ });
+ }
+ }
+
+ // Get the paths
+ lowerPath = baseGetSegmentPath.call(this, lowSegment);
+ if (step) {
+ if (step === true) {
+ step = 'left';
+ }
+ options.step = { left: 'right', center: 'center', right: 'left' }[step]; // swap for reading in getSegmentPath
+ }
+ higherPath = baseGetSegmentPath.call(this, highSegment);
+ options.step = step;
+
+ // Create a line on both top and bottom of the range
+ linePath = [].concat(lowerPath, higherPath);
+
+ // For the area path, we need to change the 'move' statement into 'lineTo' or 'curveTo'
+ higherPath[0] = 'L'; // this probably doesn't work for spline
+ this.areaPath = this.areaPath.concat(lowerPath, higherPath);
+
+ return linePath;
+ },
+
+ /**
+ * Extend the basic drawDataLabels method by running it for both lower and higher
+ * values.
+ */
+ drawDataLabels: function () {
+
+ var data = this.data,
+ length = data.length,
+ i,
+ originalDataLabels = [],
+ seriesProto = Series.prototype,
+ dataLabelOptions = this.options.dataLabels,
+ align = dataLabelOptions.align,
+ point,
+ inverted = this.chart.inverted;
+
+ if (dataLabelOptions.enabled || this._hasPointLabels) {
+
+ // Step 1: set preliminary values for plotY and dataLabel and draw the upper labels
+ i = length;
+ while (i--) {
+ point = data[i];
+
+ // Set preliminary values
+ point.y = point.high;
+ point._plotY = point.plotY;
+ point.plotY = point.plotHigh;
+
+ // Store original data labels and set preliminary label objects to be picked up
+ // in the uber method
+ originalDataLabels[i] = point.dataLabel;
+ point.dataLabel = point.dataLabelUpper;
+
+ // Set the default offset
+ point.below = false;
+ if (inverted) {
+ if (!align) {
+ dataLabelOptions.align = 'left';
+ }
+ dataLabelOptions.x = dataLabelOptions.xHigh;
+ } else {
+ dataLabelOptions.y = dataLabelOptions.yHigh;
+ }
+ }
+
+ if (seriesProto.drawDataLabels) {
+ seriesProto.drawDataLabels.apply(this, arguments); // #1209
+ }
+
+ // Step 2: reorganize and handle data labels for the lower values
+ i = length;
+ while (i--) {
+ point = data[i];
+
+ // Move the generated labels from step 1, and reassign the original data labels
+ point.dataLabelUpper = point.dataLabel;
+ point.dataLabel = originalDataLabels[i];
+
+ // Reset values
+ point.y = point.low;
+ point.plotY = point._plotY;
+
+ // Set the default offset
+ point.below = true;
+ if (inverted) {
+ if (!align) {
+ dataLabelOptions.align = 'right';
+ }
+ dataLabelOptions.x = dataLabelOptions.xLow;
+ } else {
+ dataLabelOptions.y = dataLabelOptions.yLow;
+ }
+ }
+ if (seriesProto.drawDataLabels) {
+ seriesProto.drawDataLabels.apply(this, arguments);
+ }
+ }
+
+ dataLabelOptions.align = align;
+
+ },
+
+ alignDataLabel: function () {
+ seriesTypes.column.prototype.alignDataLabel.apply(this, arguments);
+ },
+
+ getSymbol: noop,
+
+ drawPoints: noop
+});/**
+ * The AreaSplineRangeSeries class
+ */
+
+defaultPlotOptions.areasplinerange = merge(defaultPlotOptions.arearange);
+
+/**
+ * AreaSplineRangeSeries object
+ */
+seriesTypes.areasplinerange = extendClass(seriesTypes.arearange, {
+ type: 'areasplinerange',
+ getPointSpline: seriesTypes.spline.prototype.getPointSpline
+});
+
+(function () {
+
+ var colProto = seriesTypes.column.prototype;
+
+ /**
+ * The ColumnRangeSeries class
+ */
+ defaultPlotOptions.columnrange = merge(defaultPlotOptions.column, defaultPlotOptions.arearange, {
+ lineWidth: 1,
+ pointRange: null
+ });
+
+ /**
+ * ColumnRangeSeries object
+ */
+ seriesTypes.columnrange = extendClass(seriesTypes.arearange, {
+ type: 'columnrange',
+ /**
+ * Translate data points from raw values x and y to plotX and plotY
+ */
+ translate: function () {
+ var series = this,
+ yAxis = series.yAxis,
+ plotHigh;
+
+ colProto.translate.apply(series);
+
+ // Set plotLow and plotHigh
+ each(series.points, function (point) {
+ var shapeArgs = point.shapeArgs,
+ minPointLength = series.options.minPointLength,
+ heightDifference,
+ height,
+ y;
+
+ point.tooltipPos = null; // don't inherit from column
+ point.plotHigh = plotHigh = yAxis.translate(point.high, 0, 1, 0, 1);
+ point.plotLow = point.plotY;
+
+ // adjust shape
+ y = plotHigh;
+ height = point.plotY - plotHigh;
+
+ if (height < minPointLength) {
+ heightDifference = (minPointLength - height);
+ height += heightDifference;
+ y -= heightDifference / 2;
+ }
+ shapeArgs.height = height;
+ shapeArgs.y = y;
+ });
+ },
+ trackerGroups: ['group', 'dataLabelsGroup'],
+ drawGraph: noop,
+ pointAttrToOptions: colProto.pointAttrToOptions,
+ drawPoints: colProto.drawPoints,
+ drawTracker: colProto.drawTracker,
+ animate: colProto.animate,
+ getColumnMetrics: colProto.getColumnMetrics
+ });
+}());
+
+/*
+ * The GaugeSeries class
+ */
+
+
+
+/**
+ * Extend the default options
+ */
+defaultPlotOptions.gauge = merge(defaultPlotOptions.line, {
+ dataLabels: {
+ enabled: true,
+ defer: false,
+ y: 15,
+ borderWidth: 1,
+ borderColor: 'silver',
+ borderRadius: 3,
+ crop: false,
+ style: {
+ fontWeight: 'bold'
+ },
+ verticalAlign: 'top',
+ zIndex: 2
+ },
+ dial: {
+ // radius: '80%',
+ // backgroundColor: 'black',
+ // borderColor: 'silver',
+ // borderWidth: 0,
+ // baseWidth: 3,
+ // topWidth: 1,
+ // baseLength: '70%' // of radius
+ // rearLength: '10%'
+ },
+ pivot: {
+ //radius: 5,
+ //borderWidth: 0
+ //borderColor: 'silver',
+ //backgroundColor: 'black'
+ },
+ tooltip: {
+ headerFormat: ''
+ },
+ showInLegend: false
+});
+
+/**
+ * Extend the point object
+ */
+var GaugePoint = extendClass(Point, {
+ /**
+ * Don't do any hover colors or anything
+ */
+ setState: function (state) {
+ this.state = state;
+ }
+});
+
+
+/**
+ * Add the series type
+ */
+var GaugeSeries = {
+ type: 'gauge',
+ pointClass: GaugePoint,
+
+ // chart.angular will be set to true when a gauge series is present, and this will
+ // be used on the axes
+ angular: true,
+ drawGraph: noop,
+ fixedBox: true,
+ forceDL: true,
+ trackerGroups: ['group', 'dataLabelsGroup'],
+
+ /**
+ * Calculate paths etc
+ */
+ translate: function () {
+
+ var series = this,
+ yAxis = series.yAxis,
+ options = series.options,
+ center = yAxis.center;
+
+ series.generatePoints();
+
+ each(series.points, function (point) {
+
+ var dialOptions = merge(options.dial, point.dial),
+ radius = (pInt(pick(dialOptions.radius, 80)) * center[2]) / 200,
+ baseLength = (pInt(pick(dialOptions.baseLength, 70)) * radius) / 100,
+ rearLength = (pInt(pick(dialOptions.rearLength, 10)) * radius) / 100,
+ baseWidth = dialOptions.baseWidth || 3,
+ topWidth = dialOptions.topWidth || 1,
+ overshoot = options.overshoot,
+ rotation = yAxis.startAngleRad + yAxis.translate(point.y, null, null, null, true);
+
+ // Handle the wrap and overshoot options
+ if (overshoot && typeof overshoot === 'number') {
+ overshoot = overshoot / 180 * Math.PI;
+ rotation = Math.max(yAxis.startAngleRad - overshoot, Math.min(yAxis.endAngleRad + overshoot, rotation));
+
+ } else if (options.wrap === false) {
+ rotation = Math.max(yAxis.startAngleRad, Math.min(yAxis.endAngleRad, rotation));
+ }
+
+ rotation = rotation * 180 / Math.PI;
+
+ point.shapeType = 'path';
+ point.shapeArgs = {
+ d: dialOptions.path || [
+ 'M',
+ -rearLength, -baseWidth / 2,
+ 'L',
+ baseLength, -baseWidth / 2,
+ radius, -topWidth / 2,
+ radius, topWidth / 2,
+ baseLength, baseWidth / 2,
+ -rearLength, baseWidth / 2,
+ 'z'
+ ],
+ translateX: center[0],
+ translateY: center[1],
+ rotation: rotation
+ };
+
+ // Positions for data label
+ point.plotX = center[0];
+ point.plotY = center[1];
+ });
+ },
+
+ /**
+ * Draw the points where each point is one needle
+ */
+ drawPoints: function () {
+
+ var series = this,
+ center = series.yAxis.center,
+ pivot = series.pivot,
+ options = series.options,
+ pivotOptions = options.pivot,
+ renderer = series.chart.renderer;
+
+ each(series.points, function (point) {
+
+ var graphic = point.graphic,
+ shapeArgs = point.shapeArgs,
+ d = shapeArgs.d,
+ dialOptions = merge(options.dial, point.dial); // #1233
+
+ if (graphic) {
+ graphic.animate(shapeArgs);
+ shapeArgs.d = d; // animate alters it
+ } else {
+ point.graphic = renderer[point.shapeType](shapeArgs)
+ .attr({
+ stroke: dialOptions.borderColor || 'none',
+ 'stroke-width': dialOptions.borderWidth || 0,
+ fill: dialOptions.backgroundColor || 'black',
+ rotation: shapeArgs.rotation // required by VML when animation is false
+ })
+ .add(series.group);
+ }
+ });
+
+ // Add or move the pivot
+ if (pivot) {
+ pivot.animate({ // #1235
+ translateX: center[0],
+ translateY: center[1]
+ });
+ } else {
+ series.pivot = renderer.circle(0, 0, pick(pivotOptions.radius, 5))
+ .attr({
+ 'stroke-width': pivotOptions.borderWidth || 0,
+ stroke: pivotOptions.borderColor || 'silver',
+ fill: pivotOptions.backgroundColor || 'black'
+ })
+ .translate(center[0], center[1])
+ .add(series.group);
+ }
+ },
+
+ /**
+ * Animate the arrow up from startAngle
+ */
+ animate: function (init) {
+ var series = this;
+
+ if (!init) {
+ each(series.points, function (point) {
+ var graphic = point.graphic;
+
+ if (graphic) {
+ // start value
+ graphic.attr({
+ rotation: series.yAxis.startAngleRad * 180 / Math.PI
+ });
+
+ // animate
+ graphic.animate({
+ rotation: point.shapeArgs.rotation
+ }, series.options.animation);
+ }
+ });
+
+ // delete this function to allow it only once
+ series.animate = null;
+ }
+ },
+
+ render: function () {
+ this.group = this.plotGroup(
+ 'group',
+ 'series',
+ this.visible ? 'visible' : 'hidden',
+ this.options.zIndex,
+ this.chart.seriesGroup
+ );
+ Series.prototype.render.call(this);
+ this.group.clip(this.chart.clipRect);
+ },
+
+ /**
+ * Extend the basic setData method by running processData and generatePoints immediately,
+ * in order to access the points from the legend.
+ */
+ setData: function (data, redraw) {
+ Series.prototype.setData.call(this, data, false);
+ this.processData();
+ this.generatePoints();
+ if (pick(redraw, true)) {
+ this.chart.redraw();
+ }
+ },
+
+ /**
+ * If the tracking module is loaded, add the point tracker
+ */
+ drawTracker: TrackerMixin && TrackerMixin.drawTrackerPoint
+};
+seriesTypes.gauge = extendClass(seriesTypes.line, GaugeSeries);
+
+/* ****************************************************************************
+ * Start Box plot series code *
+ *****************************************************************************/
+
+// Set default options
+defaultPlotOptions.boxplot = merge(defaultPlotOptions.column, {
+ fillColor: '#FFFFFF',
+ lineWidth: 1,
+ //medianColor: null,
+ medianWidth: 2,
+ states: {
+ hover: {
+ brightness: -0.3
+ }
+ },
+ //stemColor: null,
+ //stemDashStyle: 'solid'
+ //stemWidth: null,
+ threshold: null,
+ tooltip: {
+ pointFormat: '<span style="color:{series.color}">\u25CF</span> <b> {series.name}</b><br/>' +
+ 'Maximum: {point.high}<br/>' +
+ 'Upper quartile: {point.q3}<br/>' +
+ 'Median: {point.median}<br/>' +
+ 'Lower quartile: {point.q1}<br/>' +
+ 'Minimum: {point.low}<br/>'
+
+ },
+ //whiskerColor: null,
+ whiskerLength: '50%',
+ whiskerWidth: 2
+});
+
+// Create the series object
+seriesTypes.boxplot = extendClass(seriesTypes.column, {
+ type: 'boxplot',
+ pointArrayMap: ['low', 'q1', 'median', 'q3', 'high'], // array point configs are mapped to this
+ toYData: function (point) { // return a plain array for speedy calculation
+ return [point.low, point.q1, point.median, point.q3, point.high];
+ },
+ pointValKey: 'high', // defines the top of the tracker
+
+ /**
+ * One-to-one mapping from options to SVG attributes
+ */
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ fill: 'fillColor',
+ stroke: 'color',
+ 'stroke-width': 'lineWidth'
+ },
+
+ /**
+ * Disable data labels for box plot
+ */
+ drawDataLabels: noop,
+
+ /**
+ * Translate data points from raw values x and y to plotX and plotY
+ */
+ translate: function () {
+ var series = this,
+ yAxis = series.yAxis,
+ pointArrayMap = series.pointArrayMap;
+
+ seriesTypes.column.prototype.translate.apply(series);
+
+ // do the translation on each point dimension
+ each(series.points, function (point) {
+ each(pointArrayMap, function (key) {
+ if (point[key] !== null) {
+ point[key + 'Plot'] = yAxis.translate(point[key], 0, 1, 0, 1);
+ }
+ });
+ });
+ },
+
+ /**
+ * Draw the data points
+ */
+ drawPoints: function () {
+ var series = this, //state = series.state,
+ points = series.points,
+ options = series.options,
+ chart = series.chart,
+ renderer = chart.renderer,
+ pointAttr,
+ q1Plot,
+ q3Plot,
+ highPlot,
+ lowPlot,
+ medianPlot,
+ crispCorr,
+ crispX,
+ graphic,
+ stemPath,
+ stemAttr,
+ boxPath,
+ whiskersPath,
+ whiskersAttr,
+ medianPath,
+ medianAttr,
+ width,
+ left,
+ right,
+ halfWidth,
+ shapeArgs,
+ color,
+ doQuartiles = series.doQuartiles !== false, // error bar inherits this series type but doesn't do quartiles
+ whiskerLength = parseInt(series.options.whiskerLength, 10) / 100;
+
+
+ each(points, function (point) {
+
+ graphic = point.graphic;
+ shapeArgs = point.shapeArgs; // the box
+ stemAttr = {};
+ whiskersAttr = {};
+ medianAttr = {};
+ color = point.color || series.color;
+
+ if (point.plotY !== UNDEFINED) {
+
+ pointAttr = point.pointAttr[point.selected ? 'selected' : ''];
+
+ // crisp vector coordinates
+ width = shapeArgs.width;
+ left = mathFloor(shapeArgs.x);
+ right = left + width;
+ halfWidth = mathRound(width / 2);
+ //crispX = mathRound(left + halfWidth) + crispCorr;
+ q1Plot = mathFloor(doQuartiles ? point.q1Plot : point.lowPlot);// + crispCorr;
+ q3Plot = mathFloor(doQuartiles ? point.q3Plot : point.lowPlot);// + crispCorr;
+ highPlot = mathFloor(point.highPlot);// + crispCorr;
+ lowPlot = mathFloor(point.lowPlot);// + crispCorr;
+
+ // Stem attributes
+ stemAttr.stroke = point.stemColor || options.stemColor || color;
+ stemAttr['stroke-width'] = pick(point.stemWidth, options.stemWidth, options.lineWidth);
+ stemAttr.dashstyle = point.stemDashStyle || options.stemDashStyle;
+
+ // Whiskers attributes
+ whiskersAttr.stroke = point.whiskerColor || options.whiskerColor || color;
+ whiskersAttr['stroke-width'] = pick(point.whiskerWidth, options.whiskerWidth, options.lineWidth);
+
+ // Median attributes
+ medianAttr.stroke = point.medianColor || options.medianColor || color;
+ medianAttr['stroke-width'] = pick(point.medianWidth, options.medianWidth, options.lineWidth);
+ medianAttr['stroke-linecap'] = 'round'; // #1638
+
+
+ // The stem
+ crispCorr = (stemAttr['stroke-width'] % 2) / 2;
+ crispX = left + halfWidth + crispCorr;
+ stemPath = [
+ // stem up
+ 'M',
+ crispX, q3Plot,
+ 'L',
+ crispX, highPlot,
+
+ // stem down
+ 'M',
+ crispX, q1Plot,
+ 'L',
+ crispX, lowPlot
+ ];
+
+ // The box
+ if (doQuartiles) {
+ crispCorr = (pointAttr['stroke-width'] % 2) / 2;
+ crispX = mathFloor(crispX) + crispCorr;
+ q1Plot = mathFloor(q1Plot) + crispCorr;
+ q3Plot = mathFloor(q3Plot) + crispCorr;
+ left += crispCorr;
+ right += crispCorr;
+ boxPath = [
+ 'M',
+ left, q3Plot,
+ 'L',
+ left, q1Plot,
+ 'L',
+ right, q1Plot,
+ 'L',
+ right, q3Plot,
+ 'L',
+ left, q3Plot,
+ 'z'
+ ];
+ }
+
+ // The whiskers
+ if (whiskerLength) {
+ crispCorr = (whiskersAttr['stroke-width'] % 2) / 2;
+ highPlot = highPlot + crispCorr;
+ lowPlot = lowPlot + crispCorr;
+ whiskersPath = [
+ // High whisker
+ 'M',
+ crispX - halfWidth * whiskerLength,
+ highPlot,
+ 'L',
+ crispX + halfWidth * whiskerLength,
+ highPlot,
+
+ // Low whisker
+ 'M',
+ crispX - halfWidth * whiskerLength,
+ lowPlot,
+ 'L',
+ crispX + halfWidth * whiskerLength,
+ lowPlot
+ ];
+ }
+
+ // The median
+ crispCorr = (medianAttr['stroke-width'] % 2) / 2;
+ medianPlot = mathRound(point.medianPlot) + crispCorr;
+ medianPath = [
+ 'M',
+ left,
+ medianPlot,
+ 'L',
+ right,
+ medianPlot
+ ];
+
+ // Create or update the graphics
+ if (graphic) { // update
+
+ point.stem.animate({ d: stemPath });
+ if (whiskerLength) {
+ point.whiskers.animate({ d: whiskersPath });
+ }
+ if (doQuartiles) {
+ point.box.animate({ d: boxPath });
+ }
+ point.medianShape.animate({ d: medianPath });
+
+ } else { // create new
+ point.graphic = graphic = renderer.g()
+ .add(series.group);
+
+ point.stem = renderer.path(stemPath)
+ .attr(stemAttr)
+ .add(graphic);
+
+ if (whiskerLength) {
+ point.whiskers = renderer.path(whiskersPath)
+ .attr(whiskersAttr)
+ .add(graphic);
+ }
+ if (doQuartiles) {
+ point.box = renderer.path(boxPath)
+ .attr(pointAttr)
+ .add(graphic);
+ }
+ point.medianShape = renderer.path(medianPath)
+ .attr(medianAttr)
+ .add(graphic);
+ }
+ }
+ });
+
+ }
+
+
+});
+
+/* ****************************************************************************
+ * End Box plot series code *
+ *****************************************************************************/
+/* ****************************************************************************
+ * Start error bar series code *
+ *****************************************************************************/
+
+// 1 - set default options
+defaultPlotOptions.errorbar = merge(defaultPlotOptions.boxplot, {
+ color: '#000000',
+ grouping: false,
+ linkedTo: ':previous',
+ tooltip: {
+ pointFormat: '<span style="color:{series.color}">\u25CF</span> {series.name}: <b>{point.low}</b> - <b>{point.high}</b><br/>'
+ },
+ whiskerWidth: null
+});
+
+// 2 - Create the series object
+seriesTypes.errorbar = extendClass(seriesTypes.boxplot, {
+ type: 'errorbar',
+ pointArrayMap: ['low', 'high'], // array point configs are mapped to this
+ toYData: function (point) { // return a plain array for speedy calculation
+ return [point.low, point.high];
+ },
+ pointValKey: 'high', // defines the top of the tracker
+ doQuartiles: false,
+ drawDataLabels: seriesTypes.arearange ? seriesTypes.arearange.prototype.drawDataLabels : noop,
+
+ /**
+ * Get the width and X offset, either on top of the linked series column
+ * or standalone
+ */
+ getColumnMetrics: function () {
+ return (this.linkedParent && this.linkedParent.columnMetrics) ||
+ seriesTypes.column.prototype.getColumnMetrics.call(this);
+ }
+});
+
+/* ****************************************************************************
+ * End error bar series code *
+ *****************************************************************************/
+/* ****************************************************************************
+ * Start Waterfall series code *
+ *****************************************************************************/
+
+// 1 - set default options
+defaultPlotOptions.waterfall = merge(defaultPlotOptions.column, {
+ lineWidth: 1,
+ lineColor: '#333',
+ dashStyle: 'dot',
+ borderColor: '#333',
+ states: {
+ hover: {
+ lineWidthPlus: 0 // #3126
+ }
+ }
+});
+
+
+// 2 - Create the series object
+seriesTypes.waterfall = extendClass(seriesTypes.column, {
+ type: 'waterfall',
+
+ upColorProp: 'fill',
+
+ pointArrayMap: ['low', 'y'],
+
+ pointValKey: 'y',
+
+ /**
+ * Init waterfall series, force stacking
+ */
+ init: function (chart, options) {
+ // force stacking
+ options.stacking = true;
+
+ seriesTypes.column.prototype.init.call(this, chart, options);
+ },
+
+
+ /**
+ * Translate data points from raw values
+ */
+ translate: function () {
+ var series = this,
+ options = series.options,
+ yAxis = series.yAxis,
+ len,
+ i,
+ points,
+ point,
+ shapeArgs,
+ stack,
+ y,
+ previousY,
+ previousIntermediate,
+ stackPoint,
+ threshold = options.threshold,
+ tooltipY;
+
+ // run column series translate
+ seriesTypes.column.prototype.translate.apply(this);
+
+ previousY = previousIntermediate = threshold;
+ points = series.points;
+
+ for (i = 0, len = points.length; i < len; i++) {
+ // cache current point object
+ point = points[i];
+ shapeArgs = point.shapeArgs;
+
+ // get current stack
+ stack = series.getStack(i);
+ stackPoint = stack.points[series.index + ',' + i];
+
+ // override point value for sums
+ if (isNaN(point.y)) {
+ point.y = series.yData[i];
+ }
+
+ // up points
+ y = mathMax(previousY, previousY + point.y) + stackPoint[0];
+ shapeArgs.y = yAxis.translate(y, 0, 1);
+
+
+ // sum points
+ if (point.isSum) {
+ shapeArgs.y = yAxis.translate(stackPoint[1], 0, 1);
+ shapeArgs.height = yAxis.translate(stackPoint[0], 0, 1) - shapeArgs.y;
+
+ } else if (point.isIntermediateSum) {
+ shapeArgs.y = yAxis.translate(stackPoint[1], 0, 1);
+ shapeArgs.height = yAxis.translate(previousIntermediate, 0, 1) - shapeArgs.y;
+ previousIntermediate = stackPoint[1];
+
+ // if it's not the sum point, update previous stack end position
+ } else {
+ previousY += stack.total;
+ }
+
+ // negative points
+ if (shapeArgs.height < 0) {
+ shapeArgs.y += shapeArgs.height;
+ shapeArgs.height *= -1;
+ }
+
+ point.plotY = shapeArgs.y = mathRound(shapeArgs.y) - (series.borderWidth % 2) / 2;
+ shapeArgs.height = mathMax(mathRound(shapeArgs.height), 0.001); // #3151
+ point.yBottom = shapeArgs.y + shapeArgs.height;
+
+ // Correct tooltip placement (#3014)
+ tooltipY = point.plotY + (point.negative ? shapeArgs.height : 0);
+ if (series.chart.inverted) {
+ point.tooltipPos[0] = yAxis.len - tooltipY;
+ } else {
+ point.tooltipPos[1] = tooltipY;
+ }
+
+ }
+ },
+
+ /**
+ * Call default processData then override yData to reflect waterfall's extremes on yAxis
+ */
+ processData: function (force) {
+ var series = this,
+ options = series.options,
+ yData = series.yData,
+ points = series.points,
+ point,
+ dataLength = yData.length,
+ threshold = options.threshold || 0,
+ subSum,
+ sum,
+ dataMin,
+ dataMax,
+ y,
+ i;
+
+ sum = subSum = dataMin = dataMax = threshold;
+
+ for (i = 0; i < dataLength; i++) {
+ y = yData[i];
+ point = points && points[i] ? points[i] : {};
+
+ if (y === "sum" || point.isSum) {
+ yData[i] = sum;
+ } else if (y === "intermediateSum" || point.isIntermediateSum) {
+ yData[i] = subSum;
+ } else {
+ sum += y;
+ subSum += y;
+ }
+ dataMin = Math.min(sum, dataMin);
+ dataMax = Math.max(sum, dataMax);
+ }
+
+ Series.prototype.processData.call(this, force);
+
+ // Record extremes
+ series.dataMin = dataMin;
+ series.dataMax = dataMax;
+ },
+
+ /**
+ * Return y value or string if point is sum
+ */
+ toYData: function (pt) {
+ if (pt.isSum) {
+ return (pt.x === 0 ? null : "sum"); //#3245 Error when first element is Sum or Intermediate Sum
+ } else if (pt.isIntermediateSum) {
+ return (pt.x === 0 ? null : "intermediateSum"); //#3245
+ }
+ return pt.y;
+ },
+
+ /**
+ * Postprocess mapping between options and SVG attributes
+ */
+ getAttribs: function () {
+ seriesTypes.column.prototype.getAttribs.apply(this, arguments);
+
+ var series = this,
+ options = series.options,
+ stateOptions = options.states,
+ upColor = options.upColor || series.color,
+ hoverColor = Highcharts.Color(upColor).brighten(0.1).get(),
+ seriesDownPointAttr = merge(series.pointAttr),
+ upColorProp = series.upColorProp;
+
+ seriesDownPointAttr[''][upColorProp] = upColor;
+ seriesDownPointAttr.hover[upColorProp] = stateOptions.hover.upColor || hoverColor;
+ seriesDownPointAttr.select[upColorProp] = stateOptions.select.upColor || upColor;
+
+ each(series.points, function (point) {
+ if (point.y > 0 && !point.color) {
+ point.pointAttr = seriesDownPointAttr;
+ point.color = upColor;
+ }
+ });
+ },
+
+ /**
+ * Draw columns' connector lines
+ */
+ getGraphPath: function () {
+
+ var data = this.data,
+ length = data.length,
+ lineWidth = this.options.lineWidth + this.borderWidth,
+ normalizer = mathRound(lineWidth) % 2 / 2,
+ path = [],
+ M = 'M',
+ L = 'L',
+ prevArgs,
+ pointArgs,
+ i,
+ d;
+
+ for (i = 1; i < length; i++) {
+ pointArgs = data[i].shapeArgs;
+ prevArgs = data[i - 1].shapeArgs;
+
+ d = [
+ M,
+ prevArgs.x + prevArgs.width, prevArgs.y + normalizer,
+ L,
+ pointArgs.x, prevArgs.y + normalizer
+ ];
+
+ if (data[i - 1].y < 0) {
+ d[2] += prevArgs.height;
+ d[5] += prevArgs.height;
+ }
+
+ path = path.concat(d);
+ }
+
+ return path;
+ },
+
+ /**
+ * Extremes are recorded in processData
+ */
+ getExtremes: noop,
+
+ /**
+ * Return stack for given index
+ */
+ getStack: function (i) {
+ var axis = this.yAxis,
+ stacks = axis.stacks,
+ key = this.stackKey;
+
+ if (this.processedYData[i] < this.options.threshold) {
+ key = '-' + key;
+ }
+
+ return stacks[key][i];
+ },
+
+ drawGraph: Series.prototype.drawGraph
+});
+
+/* ****************************************************************************
+ * End Waterfall series code *
+ *****************************************************************************/
+/* ****************************************************************************
+ * Start Bubble series code *
+ *****************************************************************************/
+
+// 1 - set default options
+defaultPlotOptions.bubble = merge(defaultPlotOptions.scatter, {
+ dataLabels: {
+ formatter: function () { // #2945
+ return this.point.z;
+ },
+ inside: true,
+ style: {
+ color: 'white',
+ textShadow: '0px 0px 3px black'
+ },
+ verticalAlign: 'middle'
+ },
+ // displayNegative: true,
+ marker: {
+ // fillOpacity: 0.5,
+ lineColor: null, // inherit from series.color
+ lineWidth: 1
+ },
+ minSize: 8,
+ maxSize: '20%',
+ // negativeColor: null,
+ // sizeBy: 'area'
+ states: {
+ hover: {
+ halo: {
+ size: 5
+ }
+ }
+ },
+ tooltip: {
+ pointFormat: '({point.x}, {point.y}), Size: {point.z}'
+ },
+ turboThreshold: 0,
+ zThreshold: 0
+});
+
+var BubblePoint = extendClass(Point, {
+ haloPath: function () {
+ return Point.prototype.haloPath.call(this, this.shapeArgs.r + this.series.options.states.hover.halo.size);
+ }
+});
+
+// 2 - Create the series object
+seriesTypes.bubble = extendClass(seriesTypes.scatter, {
+ type: 'bubble',
+ pointClass: BubblePoint,
+ pointArrayMap: ['y', 'z'],
+ parallelArrays: ['x', 'y', 'z'],
+ trackerGroups: ['group', 'dataLabelsGroup'],
+ bubblePadding: true,
+
+ /**
+ * Mapping between SVG attributes and the corresponding options
+ */
+ pointAttrToOptions: {
+ stroke: 'lineColor',
+ 'stroke-width': 'lineWidth',
+ fill: 'fillColor'
+ },
+
+ /**
+ * Apply the fillOpacity to all fill positions
+ */
+ applyOpacity: function (fill) {
+ var markerOptions = this.options.marker,
+ fillOpacity = pick(markerOptions.fillOpacity, 0.5);
+
+ // When called from Legend.colorizeItem, the fill isn't predefined
+ fill = fill || markerOptions.fillColor || this.color;
+
+ if (fillOpacity !== 1) {
+ fill = Color(fill).setOpacity(fillOpacity).get('rgba');
+ }
+ return fill;
+ },
+
+ /**
+ * Extend the convertAttribs method by applying opacity to the fill
+ */
+ convertAttribs: function () {
+ var obj = Series.prototype.convertAttribs.apply(this, arguments);
+
+ obj.fill = this.applyOpacity(obj.fill);
+
+ return obj;
+ },
+
+ /**
+ * Get the radius for each point based on the minSize, maxSize and each point's Z value. This
+ * must be done prior to Series.translate because the axis needs to add padding in
+ * accordance with the point sizes.
+ */
+ getRadii: function (zMin, zMax, minSize, maxSize) {
+ var len,
+ i,
+ pos,
+ zData = this.zData,
+ radii = [],
+ sizeByArea = this.options.sizeBy !== 'width',
+ zRange;
+
+ // Set the shape type and arguments to be picked up in drawPoints
+ for (i = 0, len = zData.length; i < len; i++) {
+ zRange = zMax - zMin;
+ pos = zRange > 0 ? // relative size, a number between 0 and 1
+ (zData[i] - zMin) / (zMax - zMin) :
+ 0.5;
+ if (sizeByArea && pos >= 0) {
+ pos = Math.sqrt(pos);
+ }
+ radii.push(math.ceil(minSize + pos * (maxSize - minSize)) / 2);
+ }
+ this.radii = radii;
+ },
+
+ /**
+ * Perform animation on the bubbles
+ */
+ animate: function (init) {
+ var animation = this.options.animation;
+
+ if (!init) { // run the animation
+ each(this.points, function (point) {
+ var graphic = point.graphic,
+ shapeArgs = point.shapeArgs;
+
+ if (graphic && shapeArgs) {
+ // start values
+ graphic.attr('r', 1);
+
+ // animate
+ graphic.animate({
+ r: shapeArgs.r
+ }, animation);
+ }
+ });
+
+ // delete this function to allow it only once
+ this.animate = null;
+ }
+ },
+
+ /**
+ * Extend the base translate method to handle bubble size
+ */
+ translate: function () {
+
+ var i,
+ data = this.data,
+ point,
+ radius,
+ radii = this.radii;
+
+ // Run the parent method
+ seriesTypes.scatter.prototype.translate.call(this);
+
+ // Set the shape type and arguments to be picked up in drawPoints
+ i = data.length;
+
+ while (i--) {
+ point = data[i];
+ radius = radii ? radii[i] : 0; // #1737
+
+ // Flag for negativeColor to be applied in Series.js
+ point.negative = point.z < (this.options.zThreshold || 0);
+
+ if (radius >= this.minPxSize / 2) {
+ // Shape arguments
+ point.shapeType = 'circle';
+ point.shapeArgs = {
+ x: point.plotX,
+ y: point.plotY,
+ r: radius
+ };
+
+ // Alignment box for the data label
+ point.dlBox = {
+ x: point.plotX - radius,
+ y: point.plotY - radius,
+ width: 2 * radius,
+ height: 2 * radius
+ };
+ } else { // below zThreshold
+ point.shapeArgs = point.plotY = point.dlBox = UNDEFINED; // #1691
+ }
+ }
+ },
+
+ /**
+ * Get the series' symbol in the legend
+ *
+ * @param {Object} legend The legend object
+ * @param {Object} item The series (this) or point
+ */
+ drawLegendSymbol: function (legend, item) {
+ var radius = pInt(legend.itemStyle.fontSize) / 2;
+
+ item.legendSymbol = this.chart.renderer.circle(
+ radius,
+ legend.baseline - radius,
+ radius
+ ).attr({
+ zIndex: 3
+ }).add(item.legendGroup);
+ item.legendSymbol.isMarker = true;
+
+ },
+
+ drawPoints: seriesTypes.column.prototype.drawPoints,
+ alignDataLabel: seriesTypes.column.prototype.alignDataLabel
+});
+
+/**
+ * Add logic to pad each axis with the amount of pixels
+ * necessary to avoid the bubbles to overflow.
+ */
+Axis.prototype.beforePadding = function () {
+ var axis = this,
+ axisLength = this.len,
+ chart = this.chart,
+ pxMin = 0,
+ pxMax = axisLength,
+ isXAxis = this.isXAxis,
+ dataKey = isXAxis ? 'xData' : 'yData',
+ min = this.min,
+ extremes = {},
+ smallestSize = math.min(chart.plotWidth, chart.plotHeight),
+ zMin = Number.MAX_VALUE,
+ zMax = -Number.MAX_VALUE,
+ range = this.max - min,
+ transA = axisLength / range,
+ activeSeries = [];
+
+ // Handle padding on the second pass, or on redraw
+ if (this.tickPositions) {
+ each(this.series, function (series) {
+
+ var seriesOptions = series.options,
+ zData;
+
+ if (series.bubblePadding && (series.visible || !chart.options.chart.ignoreHiddenSeries)) {
+
+ // Correction for #1673
+ axis.allowZoomOutside = true;
+
+ // Cache it
+ activeSeries.push(series);
+
+ if (isXAxis) { // because X axis is evaluated first
+
+ // For each series, translate the size extremes to pixel values
+ each(['minSize', 'maxSize'], function (prop) {
+ var length = seriesOptions[prop],
+ isPercent = /%$/.test(length);
+
+ length = pInt(length);
+ extremes[prop] = isPercent ?
+ smallestSize * length / 100 :
+ length;
+
+ });
+ series.minPxSize = extremes.minSize;
+
+ // Find the min and max Z
+ zData = series.zData;
+ if (zData.length) { // #1735
+ zMin = pick(seriesOptions.zMin, math.min(
+ zMin,
+ math.max(
+ arrayMin(zData),
+ seriesOptions.displayNegative === false ? seriesOptions.zThreshold : -Number.MAX_VALUE
+ )
+ ));
+ zMax = pick(seriesOptions.zMax, math.max(zMax, arrayMax(zData)));
+ }
+ }
+ }
+ });
+
+ each(activeSeries, function (series) {
+
+ var data = series[dataKey],
+ i = data.length,
+ radius;
+
+ if (isXAxis) {
+ series.getRadii(zMin, zMax, extremes.minSize, extremes.maxSize);
+ }
+
+ if (range > 0) {
+ while (i--) {
+ if (typeof data[i] === 'number') {
+ radius = series.radii[i];
+ pxMin = Math.min(((data[i] - min) * transA) - radius, pxMin);
+ pxMax = Math.max(((data[i] - min) * transA) + radius, pxMax);
+ }
+ }
+ }
+ });
+
+ if (activeSeries.length && range > 0 && pick(this.options.min, this.userMin) === UNDEFINED && pick(this.options.max, this.userMax) === UNDEFINED) {
+ pxMax -= axisLength;
+ transA *= (axisLength + pxMin - pxMax) / axisLength;
+ this.min += pxMin / transA;
+ this.max += pxMax / transA;
+ }
+ }
+};
+
+/* ****************************************************************************
+ * End Bubble series code *
+ *****************************************************************************/
+
+(function () {
+
+ /**
+ * Extensions for polar charts. Additionally, much of the geometry required for polar charts is
+ * gathered in RadialAxes.js.
+ *
+ */
+
+ var seriesProto = Series.prototype,
+ pointerProto = Pointer.prototype,
+ colProto;
+
+ /**
+ * Translate a point's plotX and plotY from the internal angle and radius measures to
+ * true plotX, plotY coordinates
+ */
+ seriesProto.toXY = function (point) {
+ var xy,
+ chart = this.chart,
+ plotX = point.plotX,
+ plotY = point.plotY,
+ clientX;
+
+ // Save rectangular plotX, plotY for later computation
+ point.rectPlotX = plotX;
+ point.rectPlotY = plotY;
+
+ // Record the angle in degrees for use in tooltip
+ clientX = ((plotX / Math.PI * 180) + this.xAxis.pane.options.startAngle) % 360;
+ if (clientX < 0) { // #2665
+ clientX += 360;
+ }
+ point.clientX = clientX;
+
+
+ // Find the polar plotX and plotY
+ xy = this.xAxis.postTranslate(point.plotX, this.yAxis.len - plotY);
+ point.plotX = point.polarPlotX = xy.x - chart.plotLeft;
+ point.plotY = point.polarPlotY = xy.y - chart.plotTop;
+ };
+
+ /**
+ * Order the tooltip points to get the mouse capture ranges correct. #1915.
+ */
+ seriesProto.orderTooltipPoints = function (points) {
+ if (this.chart.polar) {
+ points.sort(function (a, b) {
+ return a.clientX - b.clientX;
+ });
+
+ // Wrap mouse tracking around to capture movement on the segment to the left
+ // of the north point (#1469, #2093).
+ if (points[0]) {
+ points[0].wrappedClientX = points[0].clientX + 360;
+ points.push(points[0]);
+ }
+ }
+ };
+
+
+ /**
+ * Add some special init logic to areas and areasplines
+ */
+ function initArea(proceed, chart, options) {
+ proceed.call(this, chart, options);
+ if (this.chart.polar) {
+
+ /**
+ * Overridden method to close a segment path. While in a cartesian plane the area
+ * goes down to the threshold, in the polar chart it goes to the center.
+ */
+ this.closeSegment = function (path) {
+ var center = this.xAxis.center;
+ path.push(
+ 'L',
+ center[0],
+ center[1]
+ );
+ };
+
+ // Instead of complicated logic to draw an area around the inner area in a stack,
+ // just draw it behind
+ this.closedStacks = true;
+ }
+ }
+
+ if (seriesTypes.area) {
+ wrap(seriesTypes.area.prototype, 'init', initArea);
+ }
+ if (seriesTypes.areaspline) {
+ wrap(seriesTypes.areaspline.prototype, 'init', initArea);
+ }
+
+ if (seriesTypes.spline) {
+ /**
+ * Overridden method for calculating a spline from one point to the next
+ */
+ wrap(seriesTypes.spline.prototype, 'getPointSpline', function (proceed, segment, point, i) {
+
+ var ret,
+ smoothing = 1.5, // 1 means control points midway between points, 2 means 1/3 from the point, 3 is 1/4 etc;
+ denom = smoothing + 1,
+ plotX,
+ plotY,
+ lastPoint,
+ nextPoint,
+ lastX,
+ lastY,
+ nextX,
+ nextY,
+ leftContX,
+ leftContY,
+ rightContX,
+ rightContY,
+ distanceLeftControlPoint,
+ distanceRightControlPoint,
+ leftContAngle,
+ rightContAngle,
+ jointAngle;
+
+
+ if (this.chart.polar) {
+
+ plotX = point.plotX;
+ plotY = point.plotY;
+ lastPoint = segment[i - 1];
+ nextPoint = segment[i + 1];
+
+ // Connect ends
+ if (this.connectEnds) {
+ if (!lastPoint) {
+ lastPoint = segment[segment.length - 2]; // not the last but the second last, because the segment is already connected
+ }
+ if (!nextPoint) {
+ nextPoint = segment[1];
+ }
+ }
+
+ // find control points
+ if (lastPoint && nextPoint) {
+
+ lastX = lastPoint.plotX;
+ lastY = lastPoint.plotY;
+ nextX = nextPoint.plotX;
+ nextY = nextPoint.plotY;
+ leftContX = (smoothing * plotX + lastX) / denom;
+ leftContY = (smoothing * plotY + lastY) / denom;
+ rightContX = (smoothing * plotX + nextX) / denom;
+ rightContY = (smoothing * plotY + nextY) / denom;
+ distanceLeftControlPoint = Math.sqrt(Math.pow(leftContX - plotX, 2) + Math.pow(leftContY - plotY, 2));
+ distanceRightControlPoint = Math.sqrt(Math.pow(rightContX - plotX, 2) + Math.pow(rightContY - plotY, 2));
+ leftContAngle = Math.atan2(leftContY - plotY, leftContX - plotX);
+ rightContAngle = Math.atan2(rightContY - plotY, rightContX - plotX);
+ jointAngle = (Math.PI / 2) + ((leftContAngle + rightContAngle) / 2);
+
+
+ // Ensure the right direction, jointAngle should be in the same quadrant as leftContAngle
+ if (Math.abs(leftContAngle - jointAngle) > Math.PI / 2) {
+ jointAngle -= Math.PI;
+ }
+
+ // Find the corrected control points for a spline straight through the point
+ leftContX = plotX + Math.cos(jointAngle) * distanceLeftControlPoint;
+ leftContY = plotY + Math.sin(jointAngle) * distanceLeftControlPoint;
+ rightContX = plotX + Math.cos(Math.PI + jointAngle) * distanceRightControlPoint;
+ rightContY = plotY + Math.sin(Math.PI + jointAngle) * distanceRightControlPoint;
+
+ // Record for drawing in next point
+ point.rightContX = rightContX;
+ point.rightContY = rightContY;
+
+ }
+
+
+ // moveTo or lineTo
+ if (!i) {
+ ret = ['M', plotX, plotY];
+ } else { // curve from last point to this
+ ret = [
+ 'C',
+ lastPoint.rightContX || lastPoint.plotX,
+ lastPoint.rightContY || lastPoint.plotY,
+ leftContX || plotX,
+ leftContY || plotY,
+ plotX,
+ plotY
+ ];
+ lastPoint.rightContX = lastPoint.rightContY = null; // reset for updating series later
+ }
+
+
+ } else {
+ ret = proceed.call(this, segment, point, i);
+ }
+ return ret;
+ });
+ }
+
+ /**
+ * Extend translate. The plotX and plotY values are computed as if the polar chart were a
+ * cartesian plane, where plotX denotes the angle in radians and (yAxis.len - plotY) is the pixel distance from
+ * center.
+ */
+ wrap(seriesProto, 'translate', function (proceed) {
+
+ // Run uber method
+ proceed.call(this);
+
+ // Postprocess plot coordinates
+ if (this.chart.polar && !this.preventPostTranslate) {
+ var points = this.points,
+ i = points.length;
+ while (i--) {
+ // Translate plotX, plotY from angle and radius to true plot coordinates
+ this.toXY(points[i]);
+ }
+ }
+ });
+
+ /**
+ * Extend getSegmentPath to allow connecting ends across 0 to provide a closed circle in
+ * line-like series.
+ */
+ wrap(seriesProto, 'getSegmentPath', function (proceed, segment) {
+
+ var points = this.points;
+
+ // Connect the path
+ if (this.chart.polar && this.options.connectEnds !== false &&
+ segment[segment.length - 1] === points[points.length - 1] && points[0].y !== null) {
+ this.connectEnds = true; // re-used in splines
+ segment = [].concat(segment, [points[0]]);
+ }
+
+ // Run uber method
+ return proceed.call(this, segment);
+
+ });
+
+
+ function polarAnimate(proceed, init) {
+ var chart = this.chart,
+ animation = this.options.animation,
+ group = this.group,
+ markerGroup = this.markerGroup,
+ center = this.xAxis.center,
+ plotLeft = chart.plotLeft,
+ plotTop = chart.plotTop,
+ attribs;
+
+ // Specific animation for polar charts
+ if (chart.polar) {
+
+ // Enable animation on polar charts only in SVG. In VML, the scaling is different, plus animation
+ // would be so slow it would't matter.
+ if (chart.renderer.isSVG) {
+
+ if (animation === true) {
+ animation = {};
+ }
+
+ // Initialize the animation
+ if (init) {
+
+ // Scale down the group and place it in the center
+ attribs = {
+ translateX: center[0] + plotLeft,
+ translateY: center[1] + plotTop,
+ scaleX: 0.001, // #1499
+ scaleY: 0.001
+ };
+
+ group.attr(attribs);
+ if (markerGroup) {
+ //markerGroup.attrSetters = group.attrSetters;
+ markerGroup.attr(attribs);
+ }
+
+ // Run the animation
+ } else {
+ attribs = {
+ translateX: plotLeft,
+ translateY: plotTop,
+ scaleX: 1,
+ scaleY: 1
+ };
+ group.animate(attribs, animation);
+ if (markerGroup) {
+ markerGroup.animate(attribs, animation);
+ }
+
+ // Delete this function to allow it only once
+ this.animate = null;
+ }
+ }
+
+ // For non-polar charts, revert to the basic animation
+ } else {
+ proceed.call(this, init);
+ }
+ }
+
+ // Define the animate method for regular series
+ wrap(seriesProto, 'animate', polarAnimate);
+
+ /**
+ * Throw in a couple of properties to let setTooltipPoints know we're indexing the points
+ * in degrees (0-360), not plot pixel width.
+ */
+ wrap(seriesProto, 'setTooltipPoints', function (proceed, renew) {
+
+ if (this.chart.polar) {
+ extend(this.xAxis, {
+ tooltipLen: 360 // degrees are the resolution unit of the tooltipPoints array
+ });
+ }
+ // Run uber method
+ return proceed.call(this, renew);
+ });
+
+
+ if (seriesTypes.column) {
+
+ colProto = seriesTypes.column.prototype;
+ /**
+ * Define the animate method for columnseries
+ */
+ wrap(colProto, 'animate', polarAnimate);
+
+
+ /**
+ * Extend the column prototype's translate method
+ */
+ wrap(colProto, 'translate', function (proceed) {
+
+ var xAxis = this.xAxis,
+ len = this.yAxis.len,
+ center = xAxis.center,
+ startAngleRad = xAxis.startAngleRad,
+ renderer = this.chart.renderer,
+ start,
+ points,
+ point,
+ i;
+
+ this.preventPostTranslate = true;
+
+ // Run uber method
+ proceed.call(this);
+
+ // Postprocess plot coordinates
+ if (xAxis.isRadial) {
+ points = this.points;
+ i = points.length;
+ while (i--) {
+ point = points[i];
+ start = point.barX + startAngleRad;
+ point.shapeType = 'path';
+ point.shapeArgs = {
+ d: renderer.symbols.arc(
+ center[0],
+ center[1],
+ len - point.plotY,
+ null,
+ {
+ start: start,
+ end: start + point.pointWidth,
+ innerR: len - pick(point.yBottom, len)
+ }
+ )
+ };
+ // Provide correct plotX, plotY for tooltip
+ this.toXY(point);
+ point.tooltipPos = [point.plotX, point.plotY];
+ point.ttBelow = point.plotY > center[1];
+ }
+ }
+ });
+
+
+ /**
+ * Align column data labels outside the columns. #1199.
+ */
+ wrap(colProto, 'alignDataLabel', function (proceed, point, dataLabel, options, alignTo, isNew) {
+
+ if (this.chart.polar) {
+ var angle = point.rectPlotX / Math.PI * 180,
+ align,
+ verticalAlign;
+
+ // Align nicely outside the perimeter of the columns
+ if (options.align === null) {
+ if (angle > 20 && angle < 160) {
+ align = 'left'; // right hemisphere
+ } else if (angle > 200 && angle < 340) {
+ align = 'right'; // left hemisphere
+ } else {
+ align = 'center'; // top or bottom
+ }
+ options.align = align;
+ }
+ if (options.verticalAlign === null) {
+ if (angle < 45 || angle > 315) {
+ verticalAlign = 'bottom'; // top part
+ } else if (angle > 135 && angle < 225) {
+ verticalAlign = 'top'; // bottom part
+ } else {
+ verticalAlign = 'middle'; // left or right
+ }
+ options.verticalAlign = verticalAlign;
+ }
+
+ seriesProto.alignDataLabel.call(this, point, dataLabel, options, alignTo, isNew);
+ } else {
+ proceed.call(this, point, dataLabel, options, alignTo, isNew);
+ }
+
+ });
+ }
+
+
+ /**
+ * Extend the mouse tracker to return the tooltip position index in terms of
+ * degrees rather than pixels
+ */
+ wrap(pointerProto, 'getIndex', function (proceed, e) {
+ var ret,
+ chart = this.chart,
+ center,
+ x,
+ y;
+
+ if (chart.polar) {
+ center = chart.xAxis[0].center;
+ x = e.chartX - center[0] - chart.plotLeft;
+ y = e.chartY - center[1] - chart.plotTop;
+
+ ret = 180 - Math.round(Math.atan2(x, y) / Math.PI * 180);
+
+ } else {
+
+ // Run uber method
+ ret = proceed.call(this, e);
+ }
+ return ret;
+ });
+
+ /**
+ * Extend getCoordinates to prepare for polar axis values
+ */
+ wrap(pointerProto, 'getCoordinates', function (proceed, e) {
+ var chart = this.chart,
+ ret = {
+ xAxis: [],
+ yAxis: []
+ };
+
+ if (chart.polar) {
+
+ each(chart.axes, function (axis) {
+ var isXAxis = axis.isXAxis,
+ center = axis.center,
+ x = e.chartX - center[0] - chart.plotLeft,
+ y = e.chartY - center[1] - chart.plotTop;
+
+ ret[isXAxis ? 'xAxis' : 'yAxis'].push({
+ axis: axis,
+ value: axis.translate(
+ isXAxis ?
+ Math.PI - Math.atan2(x, y) : // angle
+ Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)), // distance from center
+ true
+ )
+ });
+ });
+
+ } else {
+ ret = proceed.call(this, e);
+ }
+
+ return ret;
+ });
+
+}());
+
+}(Highcharts));
generated by cgit (git 2.34.1) at 2025-06-15 21:55:43 +0000