forked from qwerty/tupali
703 lines
29 KiB
JavaScript
703 lines
29 KiB
JavaScript
/**
|
|
* @license Highcharts JS v8.1.0 (2020-05-05)
|
|
*
|
|
* X-range series
|
|
*
|
|
* (c) 2010-2019 Torstein Honsi, Lars A. V. Cabrera
|
|
*
|
|
* License: www.highcharts.com/license
|
|
*/
|
|
'use strict';
|
|
(function (factory) {
|
|
if (typeof module === 'object' && module.exports) {
|
|
factory['default'] = factory;
|
|
module.exports = factory;
|
|
} else if (typeof define === 'function' && define.amd) {
|
|
define('highcharts/modules/xrange', ['highcharts'], function (Highcharts) {
|
|
factory(Highcharts);
|
|
factory.Highcharts = Highcharts;
|
|
return factory;
|
|
});
|
|
} else {
|
|
factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
|
|
}
|
|
}(function (Highcharts) {
|
|
var _modules = Highcharts ? Highcharts._modules : {};
|
|
function _registerModule(obj, path, args, fn) {
|
|
if (!obj.hasOwnProperty(path)) {
|
|
obj[path] = fn.apply(null, args);
|
|
}
|
|
}
|
|
_registerModule(_modules, 'modules/xrange.src.js', [_modules['parts/Globals.js'], _modules['parts/Color.js'], _modules['parts/Point.js'], _modules['parts/Utilities.js']], function (H, Color, Point, U) {
|
|
/* *
|
|
*
|
|
* X-range series module
|
|
*
|
|
* (c) 2010-2020 Torstein Honsi, Lars A. V. Cabrera
|
|
*
|
|
* License: www.highcharts.com/license
|
|
*
|
|
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
|
|
*
|
|
* */
|
|
/* *
|
|
* @interface Highcharts.PointOptionsObject in parts/Point.ts
|
|
*/ /**
|
|
* The ending X value of the range point.
|
|
* @name Highcharts.PointOptionsObject#x2
|
|
* @type {number|undefined}
|
|
* @requires modules/xrange
|
|
*/
|
|
var color = Color.parse;
|
|
var addEvent = U.addEvent, clamp = U.clamp, correctFloat = U.correctFloat, defined = U.defined, find = U.find, isNumber = U.isNumber, isObject = U.isObject, merge = U.merge, pick = U.pick, seriesType = U.seriesType;
|
|
var columnType = H.seriesTypes.column, seriesTypes = H.seriesTypes, Axis = H.Axis, Series = H.Series;
|
|
/**
|
|
* Return color of a point based on its category.
|
|
*
|
|
* @private
|
|
* @function getColorByCategory
|
|
*
|
|
* @param {object} series
|
|
* The series which the point belongs to.
|
|
*
|
|
* @param {object} point
|
|
* The point to calculate its color for.
|
|
*
|
|
* @return {object}
|
|
* Returns an object containing the properties color and colorIndex.
|
|
*/
|
|
function getColorByCategory(series, point) {
|
|
var colors = series.options.colors || series.chart.options.colors, colorCount = colors ?
|
|
colors.length :
|
|
series.chart.options.chart.colorCount, colorIndex = point.y % colorCount, color = colors && colors[colorIndex];
|
|
return {
|
|
colorIndex: colorIndex,
|
|
color: color
|
|
};
|
|
}
|
|
/**
|
|
* @private
|
|
* @class
|
|
* @name Highcharts.seriesTypes.xrange
|
|
*
|
|
* @augments Highcharts.Series
|
|
*/
|
|
seriesType('xrange', 'column'
|
|
/**
|
|
* The X-range series displays ranges on the X axis, typically time
|
|
* intervals with a start and end date.
|
|
*
|
|
* @sample {highcharts} highcharts/demo/x-range/
|
|
* X-range
|
|
* @sample {highcharts} highcharts/css/x-range/
|
|
* Styled mode X-range
|
|
* @sample {highcharts} highcharts/chart/inverted-xrange/
|
|
* Inverted X-range
|
|
*
|
|
* @extends plotOptions.column
|
|
* @since 6.0.0
|
|
* @product highcharts highstock gantt
|
|
* @excluding boostThreshold, crisp, cropThreshold, depth, edgeColor,
|
|
* edgeWidth, findNearestPointBy, getExtremesFromAll,
|
|
* negativeColor, pointInterval, pointIntervalUnit,
|
|
* pointPlacement, pointRange, pointStart, softThreshold,
|
|
* stacking, threshold, data, dataSorting
|
|
* @requires modules/xrange
|
|
* @optionparent plotOptions.xrange
|
|
*/
|
|
, {
|
|
/**
|
|
* A partial fill for each point, typically used to visualize how much
|
|
* of a task is performed. The partial fill object can be set either on
|
|
* series or point level.
|
|
*
|
|
* @sample {highcharts} highcharts/demo/x-range
|
|
* X-range with partial fill
|
|
*
|
|
* @product highcharts highstock gantt
|
|
* @apioption plotOptions.xrange.partialFill
|
|
*/
|
|
/**
|
|
* The fill color to be used for partial fills. Defaults to a darker
|
|
* shade of the point color.
|
|
*
|
|
* @type {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
|
|
* @product highcharts highstock gantt
|
|
* @apioption plotOptions.xrange.partialFill.fill
|
|
*/
|
|
/**
|
|
* A partial fill for each point, typically used to visualize how much
|
|
* of a task is performed. See [completed](series.gantt.data.completed).
|
|
*
|
|
* @sample gantt/demo/progress-indicator
|
|
* Gantt with progress indicator
|
|
*
|
|
* @product gantt
|
|
* @apioption plotOptions.gantt.partialFill
|
|
*/
|
|
/**
|
|
* In an X-range series, this option makes all points of the same Y-axis
|
|
* category the same color.
|
|
*/
|
|
colorByPoint: true,
|
|
dataLabels: {
|
|
formatter: function () {
|
|
var point = this.point, amount = point.partialFill;
|
|
if (isObject(amount)) {
|
|
amount = amount.amount;
|
|
}
|
|
if (isNumber(amount) && amount > 0) {
|
|
return correctFloat(amount * 100) + '%';
|
|
}
|
|
},
|
|
inside: true,
|
|
verticalAlign: 'middle'
|
|
},
|
|
tooltip: {
|
|
headerFormat: '<span style="font-size: 10px">{point.x} - {point.x2}</span><br/>',
|
|
pointFormat: '<span style="color:{point.color}">\u25CF</span> {series.name}: <b>{point.yCategory}</b><br/>'
|
|
},
|
|
borderRadius: 3,
|
|
pointRange: 0
|
|
}, {
|
|
type: 'xrange',
|
|
parallelArrays: ['x', 'x2', 'y'],
|
|
requireSorting: false,
|
|
animate: seriesTypes.line.prototype.animate,
|
|
cropShoulder: 1,
|
|
getExtremesFromAll: true,
|
|
autoIncrement: H.noop,
|
|
buildKDTree: H.noop,
|
|
/* eslint-disable valid-jsdoc */
|
|
/**
|
|
* @private
|
|
* @function Highcarts.seriesTypes.xrange#init
|
|
* @return {void}
|
|
*/
|
|
init: function () {
|
|
seriesTypes.column.prototype.init.apply(this, arguments);
|
|
this.options.stacking = void 0; // #13161
|
|
},
|
|
/**
|
|
* Borrow the column series metrics, but with swapped axes. This gives
|
|
* free access to features like groupPadding, grouping, pointWidth etc.
|
|
*
|
|
* @private
|
|
* @function Highcharts.Series#getColumnMetrics
|
|
*
|
|
* @return {Highcharts.ColumnMetricsObject}
|
|
*/
|
|
getColumnMetrics: function () {
|
|
var metrics, chart = this.chart;
|
|
/**
|
|
* @private
|
|
*/
|
|
function swapAxes() {
|
|
chart.series.forEach(function (s) {
|
|
var xAxis = s.xAxis;
|
|
s.xAxis = s.yAxis;
|
|
s.yAxis = xAxis;
|
|
});
|
|
}
|
|
swapAxes();
|
|
metrics = columnType.prototype.getColumnMetrics.call(this);
|
|
swapAxes();
|
|
return metrics;
|
|
},
|
|
/**
|
|
* Override cropData to show a point where x or x2 is outside visible
|
|
* range, but one of them is inside.
|
|
*
|
|
* @private
|
|
* @function Highcharts.Series#cropData
|
|
*
|
|
* @param {Array<number>} xData
|
|
*
|
|
* @param {Array<number>} yData
|
|
*
|
|
* @param {number} min
|
|
*
|
|
* @param {number} max
|
|
*
|
|
* @param {number} [cropShoulder]
|
|
*
|
|
* @return {*}
|
|
*/
|
|
cropData: function (xData, yData, min, max) {
|
|
// Replace xData with x2Data to find the appropriate cropStart
|
|
var cropData = Series.prototype.cropData, crop = cropData.call(this, this.x2Data, yData, min, max);
|
|
// Re-insert the cropped xData
|
|
crop.xData = xData.slice(crop.start, crop.end);
|
|
return crop;
|
|
},
|
|
/**
|
|
* Finds the index of an existing point that matches the given point
|
|
* options.
|
|
*
|
|
* @private
|
|
* @function Highcharts.Series#findPointIndex
|
|
* @param {object} options The options of the point.
|
|
* @returns {number|undefined} Returns index of a matching point,
|
|
* returns undefined if no match is found.
|
|
*/
|
|
findPointIndex: function (options) {
|
|
var _a = this, cropped = _a.cropped, cropStart = _a.cropStart, points = _a.points;
|
|
var id = options.id;
|
|
var pointIndex;
|
|
if (id) {
|
|
var point = find(points, function (point) {
|
|
return point.id === id;
|
|
});
|
|
pointIndex = point ? point.index : void 0;
|
|
}
|
|
if (typeof pointIndex === 'undefined') {
|
|
var point = find(points, function (point) {
|
|
return (point.x === options.x &&
|
|
point.x2 === options.x2 &&
|
|
!point.touched);
|
|
});
|
|
pointIndex = point ? point.index : void 0;
|
|
}
|
|
// Reduce pointIndex if data is cropped
|
|
if (cropped &&
|
|
isNumber(pointIndex) &&
|
|
isNumber(cropStart) &&
|
|
pointIndex >= cropStart) {
|
|
pointIndex -= cropStart;
|
|
}
|
|
return pointIndex;
|
|
},
|
|
/**
|
|
* @private
|
|
* @function Highcharts.Series#translatePoint
|
|
*
|
|
* @param {Highcharts.Point} point
|
|
*/
|
|
translatePoint: function (point) {
|
|
var series = this, xAxis = series.xAxis, yAxis = series.yAxis, metrics = series.columnMetrics, options = series.options, minPointLength = options.minPointLength || 0, plotX = point.plotX, posX = pick(point.x2, point.x + (point.len || 0)), plotX2 = xAxis.translate(posX, 0, 0, 0, 1), length = Math.abs(plotX2 - plotX), widthDifference, shapeArgs, partialFill, inverted = this.chart.inverted, borderWidth = pick(options.borderWidth, 1), crisper = borderWidth % 2 / 2, yOffset = metrics.offset, pointHeight = Math.round(metrics.width), dlLeft, dlRight, dlWidth, clipRectWidth, tooltipYOffset;
|
|
if (minPointLength) {
|
|
widthDifference = minPointLength - length;
|
|
if (widthDifference < 0) {
|
|
widthDifference = 0;
|
|
}
|
|
plotX -= widthDifference / 2;
|
|
plotX2 += widthDifference / 2;
|
|
}
|
|
plotX = Math.max(plotX, -10);
|
|
plotX2 = clamp(plotX2, -10, xAxis.len + 10);
|
|
// Handle individual pointWidth
|
|
if (defined(point.options.pointWidth)) {
|
|
yOffset -= ((Math.ceil(point.options.pointWidth) - pointHeight) / 2);
|
|
pointHeight = Math.ceil(point.options.pointWidth);
|
|
}
|
|
// Apply pointPlacement to the Y axis
|
|
if (options.pointPlacement &&
|
|
isNumber(point.plotY) &&
|
|
yAxis.categories) {
|
|
point.plotY = yAxis.translate(point.y, 0, 1, 0, 1, options.pointPlacement);
|
|
}
|
|
point.shapeArgs = {
|
|
x: Math.floor(Math.min(plotX, plotX2)) + crisper,
|
|
y: Math.floor(point.plotY + yOffset) + crisper,
|
|
width: Math.round(Math.abs(plotX2 - plotX)),
|
|
height: pointHeight,
|
|
r: series.options.borderRadius
|
|
};
|
|
// Align data labels inside the shape and inside the plot area
|
|
dlLeft = point.shapeArgs.x;
|
|
dlRight = dlLeft + point.shapeArgs.width;
|
|
if (dlLeft < 0 || dlRight > xAxis.len) {
|
|
dlLeft = clamp(dlLeft, 0, xAxis.len);
|
|
dlRight = clamp(dlRight, 0, xAxis.len);
|
|
dlWidth = dlRight - dlLeft;
|
|
point.dlBox = merge(point.shapeArgs, {
|
|
x: dlLeft,
|
|
width: dlRight - dlLeft,
|
|
centerX: dlWidth ? dlWidth / 2 : null
|
|
});
|
|
}
|
|
else {
|
|
point.dlBox = null;
|
|
}
|
|
// Tooltip position
|
|
var tooltipPos = point.tooltipPos;
|
|
var xIndex = !inverted ? 0 : 1;
|
|
var yIndex = !inverted ? 1 : 0;
|
|
tooltipYOffset = series.columnMetrics ?
|
|
series.columnMetrics.offset : -metrics.width / 2;
|
|
// Limit position by the correct axis size (#9727)
|
|
tooltipPos[xIndex] = clamp(tooltipPos[xIndex] + ((!inverted ? 1 : -1) * (xAxis.reversed ? -1 : 1) *
|
|
(length / 2)), 0, xAxis.len - 1);
|
|
tooltipPos[yIndex] = clamp(tooltipPos[yIndex] + ((inverted ? -1 : 1) * tooltipYOffset), 0, yAxis.len - 1);
|
|
// Add a partShapeArgs to the point, based on the shapeArgs property
|
|
partialFill = point.partialFill;
|
|
if (partialFill) {
|
|
// Get the partial fill amount
|
|
if (isObject(partialFill)) {
|
|
partialFill = partialFill.amount;
|
|
}
|
|
// If it was not a number, assume 0
|
|
if (!isNumber(partialFill)) {
|
|
partialFill = 0;
|
|
}
|
|
shapeArgs = point.shapeArgs;
|
|
point.partShapeArgs = {
|
|
x: shapeArgs.x,
|
|
y: shapeArgs.y,
|
|
width: shapeArgs.width,
|
|
height: shapeArgs.height,
|
|
r: series.options.borderRadius
|
|
};
|
|
clipRectWidth = Math.max(Math.round(length * partialFill + point.plotX -
|
|
plotX), 0);
|
|
point.clipRectArgs = {
|
|
x: xAxis.reversed ? // #10717
|
|
shapeArgs.x + length - clipRectWidth :
|
|
shapeArgs.x,
|
|
y: shapeArgs.y,
|
|
width: clipRectWidth,
|
|
height: shapeArgs.height
|
|
};
|
|
}
|
|
},
|
|
/**
|
|
* @private
|
|
* @function Highcharts.Series#translate
|
|
*/
|
|
translate: function () {
|
|
columnType.prototype.translate.apply(this, arguments);
|
|
this.points.forEach(function (point) {
|
|
this.translatePoint(point);
|
|
}, this);
|
|
},
|
|
/**
|
|
* Draws a single point in the series. Needed for partial fill.
|
|
*
|
|
* This override turns point.graphic into a group containing the
|
|
* original graphic and an overlay displaying the partial fill.
|
|
*
|
|
* @private
|
|
* @function Highcharts.Series#drawPoint
|
|
*
|
|
* @param {Highcharts.Point} point
|
|
* An instance of Point in the series.
|
|
*
|
|
* @param {"animate"|"attr"} verb
|
|
* 'animate' (animates changes) or 'attr' (sets options)
|
|
*/
|
|
drawPoint: function (point, verb) {
|
|
var series = this, seriesOpts = series.options, renderer = series.chart.renderer, graphic = point.graphic, type = point.shapeType, shapeArgs = point.shapeArgs, partShapeArgs = point.partShapeArgs, clipRectArgs = point.clipRectArgs, pfOptions = point.partialFill, cutOff = seriesOpts.stacking && !seriesOpts.borderRadius, pointState = point.state, stateOpts = (seriesOpts.states[pointState || 'normal'] ||
|
|
{}), pointStateVerb = typeof pointState === 'undefined' ?
|
|
'attr' : verb, pointAttr = series.pointAttribs(point, pointState), animation = pick(series.chart.options.chart.animation, stateOpts.animation), fill;
|
|
if (!point.isNull && point.visible !== false) {
|
|
// Original graphic
|
|
if (graphic) { // update
|
|
graphic.rect[verb](shapeArgs);
|
|
}
|
|
else {
|
|
point.graphic = graphic = renderer.g('point')
|
|
.addClass(point.getClassName())
|
|
.add(point.group || series.group);
|
|
graphic.rect = renderer[type](merge(shapeArgs))
|
|
.addClass(point.getClassName())
|
|
.addClass('highcharts-partfill-original')
|
|
.add(graphic);
|
|
}
|
|
// Partial fill graphic
|
|
if (partShapeArgs) {
|
|
if (graphic.partRect) {
|
|
graphic.partRect[verb](merge(partShapeArgs));
|
|
graphic.partialClipRect[verb](merge(clipRectArgs));
|
|
}
|
|
else {
|
|
graphic.partialClipRect = renderer.clipRect(clipRectArgs.x, clipRectArgs.y, clipRectArgs.width, clipRectArgs.height);
|
|
graphic.partRect =
|
|
renderer[type](partShapeArgs)
|
|
.addClass('highcharts-partfill-overlay')
|
|
.add(graphic)
|
|
.clip(graphic.partialClipRect);
|
|
}
|
|
}
|
|
// Presentational
|
|
if (!series.chart.styledMode) {
|
|
graphic
|
|
.rect[verb](pointAttr, animation)
|
|
.shadow(seriesOpts.shadow, null, cutOff);
|
|
if (partShapeArgs) {
|
|
// Ensure pfOptions is an object
|
|
if (!isObject(pfOptions)) {
|
|
pfOptions = {};
|
|
}
|
|
if (isObject(seriesOpts.partialFill)) {
|
|
pfOptions = merge(pfOptions, seriesOpts.partialFill);
|
|
}
|
|
fill = (pfOptions.fill ||
|
|
color(pointAttr.fill).brighten(-0.3).get() ||
|
|
color(point.color || series.color)
|
|
.brighten(-0.3).get());
|
|
pointAttr.fill = fill;
|
|
graphic
|
|
.partRect[pointStateVerb](pointAttr, animation)
|
|
.shadow(seriesOpts.shadow, null, cutOff);
|
|
}
|
|
}
|
|
}
|
|
else if (graphic) {
|
|
point.graphic = graphic.destroy(); // #1269
|
|
}
|
|
},
|
|
/**
|
|
* @private
|
|
* @function Highcharts.Series#drawPoints
|
|
*/
|
|
drawPoints: function () {
|
|
var series = this, verb = series.getAnimationVerb();
|
|
// Draw the columns
|
|
series.points.forEach(function (point) {
|
|
series.drawPoint(point, verb);
|
|
});
|
|
},
|
|
/**
|
|
* Returns "animate", or "attr" if the number of points is above the
|
|
* animation limit.
|
|
*
|
|
* @private
|
|
* @function Highcharts.Series#getAnimationVerb
|
|
*
|
|
* @return {string}
|
|
*/
|
|
getAnimationVerb: function () {
|
|
return (this.chart.pointCount < (this.options.animationLimit || 250) ?
|
|
'animate' :
|
|
'attr');
|
|
}
|
|
/*
|
|
// Override to remove stroke from points. For partial fill.
|
|
pointAttribs: function () {
|
|
var series = this,
|
|
retVal = columnType.prototype.pointAttribs
|
|
.apply(series, arguments);
|
|
|
|
//retVal['stroke-width'] = 0;
|
|
return retVal;
|
|
}
|
|
//*/
|
|
/* eslint-enable valid-jsdoc */
|
|
}, {
|
|
/**
|
|
* The ending X value of the range point.
|
|
* @name Highcharts.Point#x2
|
|
* @type {number|undefined}
|
|
* @requires modules/xrange
|
|
*/
|
|
/**
|
|
* Extend applyOptions so that `colorByPoint` for x-range means that one
|
|
* color is applied per Y axis category.
|
|
*
|
|
* @private
|
|
* @function Highcharts.Point#applyOptions
|
|
*
|
|
* @return {Highcharts.Series}
|
|
*/
|
|
/* eslint-disable valid-jsdoc */
|
|
/**
|
|
* @private
|
|
*/
|
|
resolveColor: function () {
|
|
var series = this.series, colorByPoint;
|
|
if (series.options.colorByPoint && !this.options.color) {
|
|
colorByPoint = getColorByCategory(series, this);
|
|
if (!series.chart.styledMode) {
|
|
this.color = colorByPoint.color;
|
|
}
|
|
if (!this.options.colorIndex) {
|
|
this.colorIndex = colorByPoint.colorIndex;
|
|
}
|
|
}
|
|
else if (!this.color) {
|
|
this.color = series.color;
|
|
}
|
|
},
|
|
/**
|
|
* Extend init to have y default to 0.
|
|
*
|
|
* @private
|
|
* @function Highcharts.Point#init
|
|
*
|
|
* @return {Highcharts.Point}
|
|
*/
|
|
init: function () {
|
|
Point.prototype.init.apply(this, arguments);
|
|
if (!this.y) {
|
|
this.y = 0;
|
|
}
|
|
return this;
|
|
},
|
|
/**
|
|
* @private
|
|
* @function Highcharts.Point#setState
|
|
*/
|
|
setState: function () {
|
|
Point.prototype.setState.apply(this, arguments);
|
|
this.series.drawPoint(this, this.series.getAnimationVerb());
|
|
},
|
|
/**
|
|
* @private
|
|
* @function Highcharts.Point#getLabelConfig
|
|
*
|
|
* @return {Highcharts.PointLabelObject}
|
|
*/
|
|
// Add x2 and yCategory to the available properties for tooltip formats
|
|
getLabelConfig: function () {
|
|
var point = this, cfg = Point.prototype.getLabelConfig.call(point), yCats = point.series.yAxis.categories;
|
|
cfg.x2 = point.x2;
|
|
cfg.yCategory = point.yCategory = yCats && yCats[point.y];
|
|
return cfg;
|
|
},
|
|
tooltipDateKeys: ['x', 'x2'],
|
|
/**
|
|
* @private
|
|
* @function Highcharts.Point#isValid
|
|
*
|
|
* @return {boolean}
|
|
*/
|
|
isValid: function () {
|
|
return typeof this.x === 'number' &&
|
|
typeof this.x2 === 'number';
|
|
}
|
|
/* eslint-enable valid-jsdoc */
|
|
});
|
|
/**
|
|
* Max x2 should be considered in xAxis extremes
|
|
*/
|
|
addEvent(Axis, 'afterGetSeriesExtremes', function () {
|
|
var axis = this, // eslint-disable-line no-invalid-this
|
|
axisSeries = axis.series, dataMax, modMax;
|
|
if (axis.isXAxis) {
|
|
dataMax = pick(axis.dataMax, -Number.MAX_VALUE);
|
|
axisSeries.forEach(function (series) {
|
|
if (series.x2Data) {
|
|
series.x2Data
|
|
.forEach(function (val) {
|
|
if (val > dataMax) {
|
|
dataMax = val;
|
|
modMax = true;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
if (modMax) {
|
|
axis.dataMax = dataMax;
|
|
}
|
|
}
|
|
});
|
|
/**
|
|
* An `xrange` series. If the [type](#series.xrange.type) option is not
|
|
* specified, it is inherited from [chart.type](#chart.type).
|
|
*
|
|
* @extends series,plotOptions.xrange
|
|
* @excluding boostThreshold, crisp, cropThreshold, depth, edgeColor, edgeWidth,
|
|
* findNearestPointBy, getExtremesFromAll, negativeColor,
|
|
* pointInterval, pointIntervalUnit, pointPlacement, pointRange,
|
|
* pointStart, softThreshold, stacking, threshold, dataSorting
|
|
* @product highcharts highstock gantt
|
|
* @requires modules/xrange
|
|
* @apioption series.xrange
|
|
*/
|
|
/**
|
|
* An array of data points for the series. For the `xrange` series type,
|
|
* points can be given in the following ways:
|
|
*
|
|
* 1. An array of objects with named values. The objects are point configuration
|
|
* objects as seen below.
|
|
* ```js
|
|
* data: [{
|
|
* x: Date.UTC(2017, 0, 1),
|
|
* x2: Date.UTC(2017, 0, 3),
|
|
* name: "Test",
|
|
* y: 0,
|
|
* color: "#00FF00"
|
|
* }, {
|
|
* x: Date.UTC(2017, 0, 4),
|
|
* x2: Date.UTC(2017, 0, 5),
|
|
* name: "Deploy",
|
|
* y: 1,
|
|
* color: "#FF0000"
|
|
* }]
|
|
* ```
|
|
*
|
|
* @sample {highcharts} highcharts/series/data-array-of-objects/
|
|
* Config objects
|
|
*
|
|
* @declare Highcharts.XrangePointOptionsObject
|
|
* @type {Array<*>}
|
|
* @extends series.line.data
|
|
* @product highcharts highstock gantt
|
|
* @apioption series.xrange.data
|
|
*/
|
|
/**
|
|
* The starting X value of the range point.
|
|
*
|
|
* @sample {highcharts} highcharts/demo/x-range
|
|
* X-range
|
|
*
|
|
* @type {number}
|
|
* @product highcharts highstock gantt
|
|
* @apioption series.xrange.data.x
|
|
*/
|
|
/**
|
|
* The ending X value of the range point.
|
|
*
|
|
* @sample {highcharts} highcharts/demo/x-range
|
|
* X-range
|
|
*
|
|
* @type {number}
|
|
* @product highcharts highstock gantt
|
|
* @apioption series.xrange.data.x2
|
|
*/
|
|
/**
|
|
* The Y value of the range point.
|
|
*
|
|
* @sample {highcharts} highcharts/demo/x-range
|
|
* X-range
|
|
*
|
|
* @type {number}
|
|
* @product highcharts highstock gantt
|
|
* @apioption series.xrange.data.y
|
|
*/
|
|
/**
|
|
* A partial fill for each point, typically used to visualize how much of
|
|
* a task is performed. The partial fill object can be set either on series
|
|
* or point level.
|
|
*
|
|
* @sample {highcharts} highcharts/demo/x-range
|
|
* X-range with partial fill
|
|
*
|
|
* @declare Highcharts.XrangePointPartialFillOptionsObject
|
|
* @product highcharts highstock gantt
|
|
* @apioption series.xrange.data.partialFill
|
|
*/
|
|
/**
|
|
* The amount of the X-range point to be filled. Values can be 0-1 and are
|
|
* converted to percentages in the default data label formatter.
|
|
*
|
|
* @type {number}
|
|
* @product highcharts highstock gantt
|
|
* @apioption series.xrange.data.partialFill.amount
|
|
*/
|
|
/**
|
|
* The fill color to be used for partial fills. Defaults to a darker shade
|
|
* of the point color.
|
|
*
|
|
* @type {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
|
|
* @product highcharts highstock gantt
|
|
* @apioption series.xrange.data.partialFill.fill
|
|
*/
|
|
''; // adds doclets above to transpiled file
|
|
|
|
});
|
|
_registerModule(_modules, 'masters/modules/xrange.src.js', [], function () {
|
|
|
|
|
|
});
|
|
})); |