Subversion-Projekte lars-tiefland.ci

/**

 * Highcharts JS v4.1.8 (2015-08-20)

 * Highcharts Broken Axis module

 *

 * Author: Stephane Vanraes, Torstein Honsi

 * License: www.highcharts.com/license

 */

/*global HighchartsAdapter*/

(function (H) {

	"use strict";

	var pick = H.pick,

		wrap = H.wrap,

		extend = H.extend,

		fireEvent = HighchartsAdapter.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;

			if (info && info.totalRange >= axis.closestPointRange) {

				return;

			}

			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.doPostTranslate = 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) {

					if (a.value === b.value) {

						return (a.move === 'in' ? 0 : 1) - (b.move === 'in' ? 0 : 1);

					} else {

						return a.value - b.value;

					}

				});

				// 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

					}

				}

			}

		}

	});

	wrap(H.seriesTypes.column.prototype, 'drawPoints', function (proceed) {

		proceed.apply(this);

		var series = this,

			points = series.points,

			yAxis = series.yAxis,

			breaks = yAxis.breakArray || [],

			threshold = pick(this.options.threshold, yAxis.min),

			eventName,

			point,

			brk,

			i,

			j,

			y;

		for (i = 0; i < points.length; i++) {

			point = points[i];

			y = point.stackY || point.y;

			for (j = 0; j < breaks.length; j++) {

				brk = breaks[j];

				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'; // docs

				}

				if (eventName) {

					fireEvent(yAxis, eventName, {point: point, brk: brk});

				}

			}

		}

	});

}(Highcharts));