| Server IP : 49.231.201.246 / Your IP : 216.73.216.149 Web Server : Apache/2.4.18 (Ubuntu) System : Linux 246 4.4.0-210-generic #242-Ubuntu SMP Fri Apr 16 09:57:56 UTC 2021 x86_64 User : root ( 0) PHP Version : 7.0.33-0ubuntu0.16.04.16 Disable Function : exec,passthru,shell_exec,system,proc_open,popen,pcntl_exec MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON Directory : /var/www/html/ppaobm/backend/web/assets/16c36a2e/es-modules/parts-more/ |
Upload File : |
/* *
* (c) 2010-2019 Torstein Honsi
*
* License: www.highcharts.com/license
*/
'use strict';
import H from '../parts/Globals.js';
import '../parts/Utilities.js';
import '../parts/Options.js';
import '../parts/Series.js';
import '../parts/Point.js';
var correctFloat = H.correctFloat,
isNumber = H.isNumber,
pick = H.pick,
objectEach = H.objectEach,
arrayMin = H.arrayMin,
arrayMax = H.arrayMax,
addEvent = H.addEvent,
Axis = H.Axis,
Chart = H.Chart,
Point = H.Point,
Series = H.Series,
seriesType = H.seriesType,
seriesTypes = H.seriesTypes;
addEvent(Axis, 'afterInit', function () {
if (!this.isXAxis) {
this.waterfallStacks = {};
}
});
addEvent(Chart, 'beforeRedraw', function () {
var axes = this.axes,
series = this.series,
i = series.length;
while (i--) {
if (series[i].options.stacking) {
axes.forEach(function (axis) {
if (!axis.isXAxis) {
axis.waterfallStacks = {};
}
});
i = 0;
}
}
});
/**
* A waterfall chart displays sequentially introduced positive or negative
* values in cumulative columns.
*
* @sample highcharts/demo/waterfall/
* Waterfall chart
* @sample highcharts/plotoptions/waterfall-inverted/
* Horizontal (inverted) waterfall
* @sample highcharts/plotoptions/waterfall-stacked/
* Stacked waterfall chart
*
* @extends plotOptions.column
* @product highcharts
* @optionparent plotOptions.waterfall
*/
seriesType('waterfall', 'column', {
/**
* @type {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
* @apioption plotOptions.waterfall.color
*/
/**
* The color used specifically for positive point columns. When not
* specified, the general series color is used.
*
* In styled mode, the waterfall colors can be set with the
* `.highcharts-point-negative`, `.highcharts-sum` and
* `.highcharts-intermediate-sum` classes.
*
* @sample {highcharts} highcharts/demo/waterfall/
* Waterfall
*
* @type {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
* @product highcharts
* @apioption plotOptions.waterfall.upColor
*/
dataLabels: {
/** @ignore-option */
inside: true
},
/**
* The width of the line connecting waterfall columns.
*
* @product highcharts
*/
lineWidth: 1,
/**
* The color of the line that connects columns in a waterfall series.
*
* In styled mode, the stroke can be set with the `.highcharts-graph` class.
*
* @type {Highcharts.ColorString}
* @since 3.0
* @product highcharts
*/
lineColor: '#333333',
/**
* A name for the dash style to use for the line connecting the columns
* of the waterfall series. Possible values: Dash, DashDot, Dot, LongDash,
* LongDashDot, LongDashDotDot, ShortDash, ShortDashDot, ShortDashDotDot,
* ShortDot, Solid
*
* In styled mode, the stroke dash-array can be set with the
* `.highcharts-graph` class.
*
* @type {Highcharts.DashStyleValue}
* @since 3.0
* @product highcharts
*/
dashStyle: 'Dot',
/**
* The color of the border of each waterfall column.
*
* In styled mode, the border stroke can be set with the
* `.highcharts-point` class.
*
* @type {Highcharts.ColorString}
* @since 3.0
* @product highcharts
*/
borderColor: '#333333',
states: {
hover: {
lineWidthPlus: 0 // #3126
}
}
// Prototype members
}, {
pointValKey: 'y',
// Property needed to prevent lines between the columns from disappearing
// when negativeColor is used.
showLine: true,
// After generating points, set y-values for all sums.
generatePoints: function () {
var point,
len,
i,
y;
// Parent call:
seriesTypes.column.prototype.generatePoints.apply(this);
for (i = 0, len = this.points.length; i < len; i++) {
point = this.points[i];
y = this.processedYData[i];
// override point value for sums
// #3710 Update point does not propagate to sum
if (point.isIntermediateSum || point.isSum) {
point.y = correctFloat(y);
}
}
},
// Translate data points from raw values
translate: function () {
var series = this,
options = series.options,
yAxis = series.yAxis,
len,
i,
points,
point,
shapeArgs,
y,
yValue,
previousY,
previousIntermediate,
range,
minPointLength = pick(options.minPointLength, 5),
halfMinPointLength = minPointLength / 2,
threshold = options.threshold,
stacking = options.stacking,
tooltipY,
actualStack = yAxis.waterfallStacks[series.stackKey],
actualStackX,
total,
pointY,
yPos,
hPos;
// run column series translate
seriesTypes.column.prototype.translate.apply(series);
previousY = previousIntermediate = threshold;
points = series.points;
for (i = 0, len = points.length; i < len; i++) {
// cache current point object
point = points[i];
yValue = series.processedYData[i];
shapeArgs = point.shapeArgs;
range = [0, yValue];
pointY = point.y;
// code responsible for correct positions of stacked points
// starts here
if (stacking) {
if (actualStack) {
actualStackX = actualStack[i];
if (stacking === 'overlap') {
total = actualStackX.threshold + actualStackX.total;
actualStackX.total -= pointY;
y = pointY >= 0 ? total : total - pointY;
} else {
if (pointY >= 0) {
total = actualStackX.threshold +
actualStackX.posTotal;
actualStackX.posTotal -= pointY;
y = total;
} else {
total = actualStackX.threshold +
actualStackX.negTotal;
actualStackX.negTotal -= pointY;
y = total - pointY;
}
}
if (!point.isSum) {
// the connectorThreshold property is later used in
// getCrispPath function to draw a connector line in a
// correct place
actualStackX.connectorThreshold =
actualStackX.threshold + actualStackX.stackTotal;
}
if (yAxis.reversed) {
yPos = (pointY >= 0) ? (y - pointY) : (y + pointY);
hPos = y;
} else {
yPos = y;
hPos = y - pointY;
}
point.below = yPos <= pick(threshold, 0);
shapeArgs.y = yAxis.translate(yPos, 0, 1, 0, 1);
shapeArgs.height = Math.abs(shapeArgs.y -
yAxis.translate(hPos, 0, 1, 0, 1));
}
} else {
// up points
y = Math.max(previousY, previousY + pointY) + range[0];
shapeArgs.y = yAxis.translate(y, 0, 1, 0, 1);
// sum points
if (point.isSum) {
shapeArgs.y = yAxis.translate(range[1], 0, 1, 0, 1);
shapeArgs.height = Math.min(
yAxis.translate(range[0], 0, 1, 0, 1),
yAxis.len
) - shapeArgs.y; // #4256
} else if (point.isIntermediateSum) {
if (pointY >= 0) {
yPos = range[1] + previousIntermediate;
hPos = previousIntermediate;
} else {
yPos = previousIntermediate;
hPos = range[1] + previousIntermediate;
}
if (yAxis.reversed) {
// swapping values
yPos ^= hPos;
hPos ^= yPos;
yPos ^= hPos;
}
shapeArgs.y = yAxis.translate(yPos, 0, 1, 0, 1);
shapeArgs.height = Math.abs(shapeArgs.y - Math.min(
yAxis.translate(hPos, 0, 1, 0, 1),
yAxis.len
));
previousIntermediate += range[1];
// If it's not the sum point, update previous stack end position
// and get shape height (#3886)
} else {
shapeArgs.height = yValue > 0 ?
yAxis.translate(previousY, 0, 1, 0, 1) - shapeArgs.y :
yAxis.translate(previousY, 0, 1, 0, 1) -
yAxis.translate(previousY - yValue, 0, 1, 0, 1);
previousY += yValue;
point.below = previousY < pick(threshold, 0);
}
// #3952 Negative sum or intermediate sum not rendered correctly
if (shapeArgs.height < 0) {
shapeArgs.y += shapeArgs.height;
shapeArgs.height *= -1;
}
}
point.plotY = shapeArgs.y = Math.round(shapeArgs.y) -
(series.borderWidth % 2) / 2;
// #3151
shapeArgs.height = Math.max(Math.round(shapeArgs.height), 0.001);
point.yBottom = shapeArgs.y + shapeArgs.height;
if (shapeArgs.height <= minPointLength && !point.isNull) {
shapeArgs.height = minPointLength;
shapeArgs.y -= halfMinPointLength;
point.plotY = shapeArgs.y;
if (point.y < 0) {
point.minPointLengthOffset = -halfMinPointLength;
} else {
point.minPointLengthOffset = halfMinPointLength;
}
} else {
if (point.isNull) {
shapeArgs.width = 0;
}
point.minPointLengthOffset = 0;
}
// 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,
// #3710 Update point does not propagate to sum
points = options.data,
point,
dataLength = yData.length,
threshold = options.threshold || 0,
subSum,
sum,
dataMin,
dataMax,
y,
i;
sum = subSum = dataMin = dataMax = 0;
for (i = 0; i < dataLength; i++) {
y = yData[i];
point = points && points[i] ? points[i] : {};
if (y === 'sum' || point.isSum) {
yData[i] = correctFloat(sum);
} else if (y === 'intermediateSum' || point.isIntermediateSum) {
yData[i] = correctFloat(subSum);
subSum = 0;
} else {
sum += y;
subSum += y;
}
dataMin = Math.min(sum, dataMin);
dataMax = Math.max(sum, dataMax);
}
Series.prototype.processData.call(this, force);
// Record extremes only if stacking was not set:
if (!options.stacking) {
series.dataMin = dataMin + threshold;
series.dataMax = dataMax;
}
},
// Return y value or string if point is sum
toYData: function (pt) {
if (pt.isSum) {
// #3245 Error when first element is Sum or Intermediate Sum
return (pt.x === 0 ? null : 'sum');
}
if (pt.isIntermediateSum) {
return (pt.x === 0 ? null : 'intermediateSum'); // #3245
}
return pt.y;
},
// Postprocess mapping between options and SVG attributes
pointAttribs: function (point, state) {
var upColor = this.options.upColor,
attr;
// Set or reset up color (#3710, update to negative)
if (upColor && !point.options.color) {
point.color = point.y > 0 ? upColor : null;
}
attr = seriesTypes.column.prototype.pointAttribs.call(
this,
point,
state
);
// The dashStyle option in waterfall applies to the graph, not
// the points
delete attr.dashstyle;
return attr;
},
// Return an empty path initially, because we need to know the stroke-width
// in order to set the final path.
getGraphPath: function () {
return ['M', 0, 0];
},
// Draw columns' connector lines
getCrispPath: function () {
var data = this.data,
yAxis = this.yAxis,
length = data.length,
graphNormalizer = Math.round(this.graph.strokeWidth()) % 2 / 2,
borderNormalizer = Math.round(this.borderWidth) % 2 / 2,
reversedXAxis = this.xAxis.reversed,
reversedYAxis = this.yAxis.reversed,
stacking = this.options.stacking,
path = [],
connectorThreshold,
prevStack,
prevStackX,
prevPoint,
yPos,
isPos,
prevArgs,
pointArgs,
i,
d;
for (i = 1; i < length; i++) {
pointArgs = data[i].shapeArgs;
prevPoint = data[i - 1];
prevArgs = data[i - 1].shapeArgs;
prevStack = yAxis.waterfallStacks[this.stackKey];
isPos = prevPoint.y > 0 ? -prevArgs.height : 0;
if (prevStack) {
prevStackX = prevStack[i - 1];
// y position of the connector is different when series are
// stacked, yAxis is reversed and it also depends on point's
// value
if (stacking) {
connectorThreshold = prevStackX.connectorThreshold;
yPos = Math.round(
(yAxis.translate(connectorThreshold, 0, 1, 0, 1) +
(reversedYAxis ? isPos : 0))
) - graphNormalizer;
} else {
yPos = prevArgs.y + prevPoint.minPointLengthOffset +
borderNormalizer - graphNormalizer;
}
d = [
'M',
prevArgs.x + (reversedXAxis ? 0 : prevArgs.width),
yPos,
'L',
pointArgs.x + (reversedXAxis ? pointArgs.width : 0),
yPos
];
}
if (
!stacking &&
(prevPoint.y < 0 && !reversedYAxis) ||
(prevPoint.y > 0 && reversedYAxis)
) {
d[2] += prevArgs.height;
d[5] += prevArgs.height;
}
path = path.concat(d);
}
return path;
},
// The graph is initially drawn with an empty definition, then updated with
// crisp rendering.
drawGraph: function () {
Series.prototype.drawGraph.call(this);
this.graph.attr({
d: this.getCrispPath()
});
},
// Waterfall has stacking along the x-values too.
setStackedPoints: function () {
var series = this,
options = series.options,
waterfallStacks = series.yAxis.waterfallStacks,
seriesThreshold = options.threshold,
stackThreshold = seriesThreshold || 0,
interSum = seriesThreshold || 0,
stackKey = series.stackKey,
xData = series.xData,
xLength = xData.length,
actualStack,
actualStackX,
posTotal,
negTotal,
xPoint,
yVal,
x;
// code responsible for creating stacks for waterfall series
if (series.visible || !series.chart.options.chart.ignoreHiddenSeries) {
if (!waterfallStacks[stackKey]) {
waterfallStacks[stackKey] = {};
}
actualStack = waterfallStacks[stackKey];
for (var i = 0; i < xLength; i++) {
x = xData[i];
if (!actualStack[x]) {
actualStack[x] = {
negTotal: 0,
posTotal: 0,
total: 0,
stackTotal: 0,
threshold: 0,
stackState: [stackThreshold]
};
}
actualStackX = actualStack[x];
yVal = series.yData[i];
if (yVal >= 0) {
actualStackX.posTotal += yVal;
} else {
actualStackX.negTotal += yVal;
}
// points do not exist yet, so raw data is used
xPoint = options.data[i];
posTotal = actualStackX.posTotal;
negTotal = actualStackX.negTotal;
if (xPoint && xPoint.isIntermediateSum) {
// swapping values
stackThreshold ^= interSum;
interSum ^= stackThreshold;
stackThreshold ^= interSum;
} else if (xPoint && xPoint.isSum) {
stackThreshold = seriesThreshold;
}
actualStackX.stackTotal = posTotal + negTotal;
actualStackX.total = actualStackX.stackTotal;
actualStackX.threshold = stackThreshold;
actualStackX.stackState[0] = stackThreshold;
actualStackX.stackState.push(actualStackX.stackTotal);
stackThreshold += actualStackX.stackTotal;
}
}
},
// Extremes for a non-stacked series are recorded in processData.
// In case of stacking, use Series.stackedYData to calculate extremes.
getExtremes: function () {
var stacking = this.options.stacking,
yAxis,
waterfallStacks,
stackedYNeg,
stackedYPos,
states,
firstState;
if (stacking) {
yAxis = this.yAxis;
waterfallStacks = yAxis.waterfallStacks;
stackedYNeg = this.stackedYNeg = [];
stackedYPos = this.stackedYPos = [];
// the visible y range can be different when stacking is set to
// overlap and different when it's set to normal
if (stacking === 'overlap') {
objectEach(waterfallStacks[this.stackKey], function (stackX) {
states = [];
stackX.stackState.forEach(function (state, stateIndex) {
firstState = stackX.stackState[0];
if (stateIndex) {
states.push(state + firstState);
} else {
states.push(firstState);
}
});
stackedYNeg.push(arrayMin(states));
stackedYPos.push(arrayMax(states));
});
} else {
objectEach(waterfallStacks[this.stackKey], function (stackX) {
stackedYNeg.push(stackX.negTotal + stackX.threshold);
stackedYPos.push(stackX.posTotal + stackX.threshold);
});
}
this.dataMin = arrayMin(stackedYNeg);
this.dataMax = arrayMax(stackedYPos);
}
}
// Point members
}, {
getClassName: function () {
var className = Point.prototype.getClassName.call(this);
if (this.isSum) {
className += ' highcharts-sum';
} else if (this.isIntermediateSum) {
className += ' highcharts-intermediate-sum';
}
return className;
},
// Pass the null test in ColumnSeries.translate.
isValid: function () {
return isNumber(this.y, true) || this.isSum || this.isIntermediateSum;
}
});
/**
* A `waterfall` series. If the [type](#series.waterfall.type) option
* is not specified, it is inherited from [chart.type](#chart.type).
*
* @extends series,plotOptions.waterfall
* @excluding dataParser, dataURL
* @product highcharts
* @apioption series.waterfall
*/
/**
* An array of data points for the series. For the `waterfall` series
* type, points can be given in the following ways:
*
* 1. An array of numerical values. In this case, the numerical values will be
* interpreted as `y` options. The `x` values will be automatically
* calculated, either starting at 0 and incremented by 1, or from
* `pointStart` and `pointInterval` given in the series options. If the axis
* has categories, these will be used. Example:
* ```js
* data: [0, 5, 3, 5]
* ```
*
* 2. An array of arrays with 2 values. In this case, the values correspond to
* `x,y`. If the first value is a string, it is applied as the name of the
* point, and the `x` value is inferred.
* ```js
* data: [
* [0, 7],
* [1, 8],
* [2, 3]
* ]
* ```
*
* 3. An array of objects with named values. The following snippet shows only a
* few settings, see the complete options set below. If the total number of
* data points exceeds the series'
* [turboThreshold](#series.waterfall.turboThreshold), this option is not
* available.
* ```js
* data: [{
* x: 1,
* y: 8,
* name: "Point2",
* color: "#00FF00"
* }, {
* x: 1,
* y: 8,
* name: "Point1",
* color: "#FF00FF"
* }]
* ```
*
* @sample {highcharts} highcharts/chart/reflow-true/
* Numerical values
* @sample {highcharts} highcharts/series/data-array-of-arrays/
* Arrays of numeric x and y
* @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
* Arrays of datetime x and y
* @sample {highcharts} highcharts/series/data-array-of-name-value/
* Arrays of point.name and y
* @sample {highcharts} highcharts/series/data-array-of-objects/
* Config objects
*
* @type {Array<number|Array<(number|string),(number|null)>|null|*>}
* @extends series.line.data
* @excluding marker
* @product highcharts
* @apioption series.waterfall.data
*/
/**
* When this property is true, the points acts as a summary column for
* the values added or substracted since the last intermediate sum,
* or since the start of the series. The `y` value is ignored.
*
* @sample {highcharts} highcharts/demo/waterfall/
* Waterfall
*
* @type {boolean}
* @default false
* @product highcharts
* @apioption series.waterfall.data.isIntermediateSum
*/
/**
* When this property is true, the point display the total sum across
* the entire series. The `y` value is ignored.
*
* @sample {highcharts} highcharts/demo/waterfall/
* Waterfall
*
* @type {boolean}
* @default false
* @product highcharts
* @apioption series.waterfall.data.isSum
*/