You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
339 lines
12 KiB
339 lines
12 KiB
/**
|
|
* @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));
|
|
}));
|