/** * @license Highcharts JS v6.0.4 (2017-12-15) * Gantt series * * (c) 2016 Lars A. V. Cabrera * * --- WORK IN PROGRESS --- * * License: www.highcharts.com/license */ 'use strict'; (function(factory) { if (typeof module === 'object' && module.exports) { module.exports = factory; } else { factory(Highcharts); } }(function(Highcharts) { (function(H) { /** * (c) 2016 Highsoft AS * Authors: Lars A. V. Cabrera * * License: www.highcharts.com/license */ var dateFormat = H.dateFormat, each = H.each, isObject = H.isObject, pick = H.pick, wrap = H.wrap, Axis = H.Axis, Chart = H.Chart, Tick = H.Tick; // Enum for which side the axis is on. // Maps to axis.side var axisSide = { top: 0, right: 1, bottom: 2, left: 3, 0: 'top', 1: 'right', 2: 'bottom', 3: 'left' }; /** * Checks if an axis is the outer axis in its dimension. Since * axes are placed outwards in order, the axis with the highest * index is the outermost axis. * * Example: If there are multiple x-axes at the top of the chart, * this function returns true if the axis supplied is the last * of the x-axes. * * @return true if the axis is the outermost axis in its dimension; * false if not */ Axis.prototype.isOuterAxis = function() { var axis = this, thisIndex = -1, isOuter = true; each(this.chart.axes, function(otherAxis, index) { if (otherAxis.side === axis.side) { if (otherAxis === axis) { // Get the index of the axis in question thisIndex = index; // Check thisIndex >= 0 in case thisIndex has // not been found yet } else if (thisIndex >= 0 && index > thisIndex) { // There was an axis on the same side with a // higher index. Exit the loop. isOuter = false; return; } } }); // There were either no other axes on the same side, // or the other axes were not farther from the chart return isOuter; }; /** * Shortcut function to Tick.label.getBBox().width. * * @return {number} width - the width of the tick label */ Tick.prototype.getLabelWidth = function() { return this.label.getBBox().width; }; /** * Get the maximum label length. * This function can be used in states where the axis.maxLabelLength has not * been set. * * @param {boolean} force - Optional parameter to force a new calculation, even * if a value has already been set * @return {number} maxLabelLength - the maximum label length of the axis */ Axis.prototype.getMaxLabelLength = function(force) { var tickPositions = this.tickPositions, ticks = this.ticks, maxLabelLength = 0; if (!this.maxLabelLength || force) { each(tickPositions, function(tick) { tick = ticks[tick]; if (tick && tick.labelLength > maxLabelLength) { maxLabelLength = tick.labelLength; } }); this.maxLabelLength = maxLabelLength; } return this.maxLabelLength; }; /** * Adds the axis defined in axis.options.title */ Axis.prototype.addTitle = function() { var axis = this, renderer = axis.chart.renderer, axisParent = axis.axisParent, horiz = axis.horiz, opposite = axis.opposite, options = axis.options, axisTitleOptions = options.title, hasData, showAxis, textAlign; // For reuse in Axis.render hasData = axis.hasData(); axis.showAxis = showAxis = hasData || pick(options.showEmpty, true); // Disregard title generation in original Axis.getOffset() options.title = ''; if (!axis.axisTitle) { textAlign = axisTitleOptions.textAlign; if (!textAlign) { textAlign = (horiz ? { low: 'left', middle: 'center', high: 'right' } : { low: opposite ? 'right' : 'left', middle: 'center', high: opposite ? 'left' : 'right' })[axisTitleOptions.align]; } axis.axisTitle = renderer.text( axisTitleOptions.text, 0, 0, axisTitleOptions.useHTML ) .attr({ zIndex: 7, rotation: axisTitleOptions.rotation || 0, align: textAlign }) .addClass('highcharts-axis-title') .css(axisTitleOptions.style) // Add to axisParent instead of axisGroup, to ignore the space // it takes .add(axisParent); axis.axisTitle.isNew = true; } // hide or show the title depending on whether showEmpty is set axis.axisTitle[showAxis ? 'show' : 'hide'](true); }; /** * Add custom date formats */ H.dateFormats = { // Week number W: function(timestamp) { var date = new Date(timestamp), day = date.getUTCDay() === 0 ? 7 : date.getUTCDay(), time = date.getTime(), startOfYear = new Date(date.getUTCFullYear(), 0, 1, -6), dayNumber; date.setDate(date.getUTCDate() + 4 - day); dayNumber = Math.floor((time - startOfYear) / 86400000); return 1 + Math.floor(dayNumber / 7); }, // First letter of the day of the week, e.g. 'M' for 'Monday'. E: function(timestamp) { return dateFormat('%a', timestamp, true).charAt(0); } }; /** * Prevents adding the last tick label if the axis is not a category axis. * * Since numeric labels are normally placed at starts and ends of a range of * value, and this module makes the label point at the value, an "extra" label * would appear. * * @param {function} proceed - the original function */ wrap(Tick.prototype, 'addLabel', function(proceed) { var axis = this.axis, isCategoryAxis = axis.options.categories !== undefined, tickPositions = axis.tickPositions, lastTick = tickPositions[tickPositions.length - 1], isLastTick = this.pos !== lastTick; if (!axis.options.grid || isCategoryAxis || isLastTick) { proceed.apply(this); } }); /** * Center tick labels vertically and horizontally between ticks * * @param {function} proceed - the original function * * @return {object} object - an object containing x and y positions * for the tick */ wrap(Tick.prototype, 'getLabelPosition', function(proceed, x, y, label) { var retVal = proceed.apply(this, Array.prototype.slice.call(arguments, 1)), axis = this.axis, options = axis.options, tickInterval = options.tickInterval || 1, newX, newPos, axisHeight, fontSize, labelMetrics, lblB, lblH, labelCenter; // Only center tick labels if axis has option grid: true if (options.grid) { fontSize = options.labels.style.fontSize; labelMetrics = axis.chart.renderer.fontMetrics(fontSize, label); lblB = labelMetrics.b; lblH = labelMetrics.h; if (axis.horiz && options.categories === undefined) { // Center x position axisHeight = axis.axisGroup.getBBox().height; newPos = this.pos + tickInterval / 2; retVal.x = axis.translate(newPos) + axis.left; labelCenter = (axisHeight / 2) + (lblH / 2) - Math.abs(lblH - lblB); // Center y position if (axis.side === axisSide.top) { retVal.y = y - labelCenter; } else { retVal.y = y + labelCenter; } } else { // Center y position if (options.categories === undefined) { newPos = this.pos + (tickInterval / 2); retVal.y = axis.translate(newPos) + axis.top + (lblB / 2); } // Center x position newX = (this.getLabelWidth() / 2) - (axis.maxLabelLength / 2); if (axis.side === axisSide.left) { retVal.x += newX; } else { retVal.x -= newX; } } } return retVal; }); /** * Draw vertical ticks extra long to create cell floors and roofs. * Overrides the tickLength for vertical axes. * * @param {function} proceed - the original function * @returns {array} retVal - */ wrap(Axis.prototype, 'tickSize', function(proceed) { var axis = this, retVal = proceed.apply(axis, Array.prototype.slice.call(arguments, 1)), labelPadding, distance; if (axis.options.grid && !axis.horiz) { labelPadding = (Math.abs(axis.defaultLeftAxisOptions.labels.x) * 2); if (!axis.maxLabelLength) { axis.maxLabelLength = axis.getMaxLabelLength(); } distance = axis.maxLabelLength + labelPadding; retVal[0] = distance; } return retVal; }); /** * Disregards space required by axisTitle, by adding axisTitle to axisParent * instead of axisGroup, and disregarding margins and offsets related to * axisTitle. * * @param {function} proceed - the original function */ wrap(Axis.prototype, 'getOffset', function(proceed) { var axis = this, axisOffset = axis.chart.axisOffset, side = axis.side, axisHeight, tickSize, options = axis.options, axisTitleOptions = options.title, addTitle = axisTitleOptions && axisTitleOptions.text && axisTitleOptions.enabled !== false; if (axis.options.grid && isObject(axis.options.title)) { tickSize = axis.tickSize('tick')[0]; if (axisOffset[side] && tickSize) { axisHeight = axisOffset[side] + tickSize; } if (addTitle) { // Use the custom addTitle() to add it, while preventing making room // for it axis.addTitle(); } proceed.apply(axis, Array.prototype.slice.call(arguments, 1)); axisOffset[side] = pick(axisHeight, axisOffset[side]); // Put axis options back after original Axis.getOffset() has been called options.title = axisTitleOptions; } else { proceed.apply(axis, Array.prototype.slice.call(arguments, 1)); } }); /** * Prevents rotation of labels when squished, as rotating them would not * help. * * @param {function} proceed - the original function */ wrap(Axis.prototype, 'renderUnsquish', function(proceed) { if (this.options.grid) { this.labelRotation = 0; this.options.labels.rotation = 0; } proceed.apply(this); }); /** * Places leftmost tick at the start of the axis, to create a left wall. * * @param {function} proceed - the original function */ wrap(Axis.prototype, 'setOptions', function(proceed, userOptions) { var axis = this; if (userOptions.grid && axis.horiz) { userOptions.startOnTick = true; userOptions.minPadding = 0; userOptions.endOnTick = true; } proceed.apply(this, Array.prototype.slice.call(arguments, 1)); }); /** * Draw an extra line on the far side of the the axisLine, * creating cell roofs of a grid. * * @param {function} proceed - the original function */ wrap(Axis.prototype, 'render', function(proceed) { var axis = this, options = axis.options, labelPadding, distance, lineWidth, linePath, yStartIndex, yEndIndex, xStartIndex, xEndIndex, renderer = axis.chart.renderer, axisGroupBox; if (options.grid) { labelPadding = (Math.abs(axis.defaultLeftAxisOptions.labels.x) * 2); distance = axis.maxLabelLength + labelPadding; lineWidth = options.lineWidth; // Remove right wall before rendering if (axis.rightWall) { axis.rightWall.destroy(); } // Call original Axis.render() to obtain axis.axisLine and // axis.axisGroup proceed.apply(axis); axisGroupBox = axis.axisGroup.getBBox(); // Add right wall on horizontal axes if (axis.horiz) { axis.rightWall = renderer.path([ 'M', axisGroupBox.x + axis.width + 1, // account for left wall axisGroupBox.y, 'L', axisGroupBox.x + axis.width + 1, // account for left wall axisGroupBox.y + axisGroupBox.height ]) .attr({ stroke: options.tickColor || '#ccd6eb', 'stroke-width': options.tickWidth || 1, zIndex: 7, class: 'grid-wall' }) .add(axis.axisGroup); } if (axis.isOuterAxis() && axis.axisLine) { if (axis.horiz) { // -1 to avoid adding distance each time the chart updates distance = axisGroupBox.height - 1; } if (lineWidth) { linePath = axis.getLinePath(lineWidth); xStartIndex = linePath.indexOf('M') + 1; xEndIndex = linePath.indexOf('L') + 1; yStartIndex = linePath.indexOf('M') + 2; yEndIndex = linePath.indexOf('L') + 2; // Negate distance if top or left axis if (axis.side === axisSide.top || axis.side === axisSide.left) { distance = -distance; } // If axis is horizontal, reposition line path vertically if (axis.horiz) { linePath[yStartIndex] = linePath[yStartIndex] + distance; linePath[yEndIndex] = linePath[yEndIndex] + distance; } else { // If axis is vertical, reposition line path horizontally linePath[xStartIndex] = linePath[xStartIndex] + distance; linePath[xEndIndex] = linePath[xEndIndex] + distance; } if (!axis.axisLineExtra) { axis.axisLineExtra = renderer.path(linePath) .attr({ stroke: options.lineColor, 'stroke-width': lineWidth, zIndex: 7 }) .add(axis.axisGroup); } else { axis.axisLineExtra.animate({ d: linePath }); } // show or hide the line depending on options.showEmpty axis.axisLine[axis.showAxis ? 'show' : 'hide'](true); } } } else { proceed.apply(axis); } }); /** * Wraps chart rendering with the following customizations: * 1. Prohibit timespans of multitudes of a time unit * 2. Draw cell walls on vertical axes * * @param {function} proceed - the original function */ wrap(Chart.prototype, 'render', function(proceed) { // 25 is optimal height for default fontSize (11px) // 25 / 11 ≈ 2.28 var fontSizeToCellHeightRatio = 25 / 11, fontMetrics, fontSize; each(this.axes, function(axis) { var options = axis.options; if (options.grid) { fontSize = options.labels.style.fontSize; fontMetrics = axis.chart.renderer.fontMetrics(fontSize); // Prohibit timespans of multitudes of a time unit, // e.g. two days, three weeks, etc. if (options.type === 'datetime') { options.units = [ ['millisecond', [1]], ['second', [1]], ['minute', [1]], ['hour', [1]], ['day', [1]], ['week', [1]], ['month', [1]], ['year', null] ]; } // Make tick marks taller, creating cell walls of a grid. // Use cellHeight axis option if set if (axis.horiz) { options.tickLength = options.cellHeight || fontMetrics.h * fontSizeToCellHeightRatio; } else { options.tickWidth = 1; if (!options.lineWidth) { options.lineWidth = 1; } } } }); // Call original Chart.render() proceed.apply(this); }); }(Highcharts)); (function(H) { /** * X-range series module * * (c) 2010-2017 Torstein Honsi, Lars A. V. Cabrera * * License: www.highcharts.com/license */ /** * @todo * - JSDoc * - New series checklist */ var defined = H.defined, color = H.Color, columnType = H.seriesTypes.column, each = H.each, isNumber = H.isNumber, isObject = H.isObject, merge = H.merge, pick = H.pick, seriesType = H.seriesType, seriesTypes = H.seriesTypes, wrap = H.wrap, Axis = H.Axis, Point = H.Point, Series = H.Series; /** * The X-range series displays ranges on the X axis, typically time intervals * with a start and end date. * * @extends {plotOptions.column} * @excluding boostThreshold,crisp,cropThreshold,depth,edgeColor,edgeWidth, * findNearestPointBy,getExtremesFromAll,grouping,groupPadding, * negativeColor,pointInterval,pointIntervalUnit,pointPlacement, * pointRange,pointStart,softThreshold,stacking,threshold,data * @product highcharts * @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 * @since 6.0.0 * @optionparent plotOptions.xrange */ seriesType('xrange', 'column', { /** * In an X-range series, this option makes all points of the same Y-axis * category the same color. */ colorByPoint: true, dataLabels: { verticalAlign: 'middle', inside: true, /** * The default formatter for X-range data labels displays the percentage * of the partial fill amount. */ formatter: function() { var point = this.point, amount = point.partialFill; if (isObject(amount)) { amount = amount.amount; } if (!defined(amount)) { amount = 0; } return (amount * 100) + '%'; } }, tooltip: { headerFormat: '{point.x} - {point.x2}
', pointFormat: '\u25CF {series.name}: {point.yCategory}
' }, borderRadius: 3, pointRange: 0 /** * 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 * @type {Object} * @product highcharts * @apioption plotOptions.xrange.partialFill */ /** * The fill color to be used for partial fills. Defaults to a darker shade * of the point color. * * @type {Color} * @product highcharts * @apioption plotOptions.xrange.partialFill.fill */ }, { type: 'xrange', parallelArrays: ['x', 'x2', 'y'], requireSorting: false, animate: seriesTypes.line.prototype.animate, cropShoulder: 1, getExtremesFromAll: true, /** * Borrow the column series metrics, but with swapped axes. This gives free * access to features like groupPadding, grouping, pointWidth etc. */ getColumnMetrics: function() { var metrics, chart = this.chart; function swapAxes() { each(chart.series, 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. */ 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; }, translatePoint: function(point) { var series = this, xAxis = series.xAxis, metrics = series.columnMetrics, minPointLength = series.options.minPointLength || 0, plotX = point.plotX, posX = pick(point.x2, point.x + (point.len || 0)), plotX2 = xAxis.translate(posX, 0, 0, 0, 1), length = plotX2 - plotX, widthDifference, shapeArgs, partialFill, inverted = this.chart.inverted, borderWidth = pick(series.options.borderWidth, 1), crisper = borderWidth % 2 / 2, dlLeft, dlRight, dlWidth; if (minPointLength) { widthDifference = minPointLength - length; if (widthDifference < 0) { widthDifference = 0; } plotX -= widthDifference / 2; plotX2 += widthDifference / 2; } plotX = Math.max(plotX, -10); plotX2 = Math.min(Math.max(plotX2, -10), xAxis.len + 10); point.shapeArgs = { x: Math.floor(Math.min(plotX, plotX2)) + crisper, y: Math.floor(point.plotY + metrics.offset) + crisper, width: Math.round(Math.abs(plotX2 - plotX)), height: Math.round(metrics.width), 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 = Math.min(xAxis.len, Math.max(0, dlLeft)); dlRight = Math.max(0, Math.min(dlRight, 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 point.tooltipPos[0] += inverted ? 0 : length / 2; point.tooltipPos[1] -= inverted ? length / 2 : metrics.width / 2; // 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 }; point.clipRectArgs = { x: shapeArgs.x, y: shapeArgs.y, width: Math.round(shapeArgs.width * partialFill), height: shapeArgs.height }; } }, translate: function() { columnType.prototype.translate.apply(this, arguments); each(this.points, 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. * * @param {Object} point an instance of Point in the series * @param {string} verb 'animate' (animates changes) or 'attr' (sets * options) * @returns {void} */ 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, fill, state = point.selected && 'select', cutOff = seriesOpts.stacking && !seriesOpts.borderRadius; if (!point.isNull) { // Original graphic if (graphic) { // update point.graphicOriginal[verb]( merge(shapeArgs) ); } else { point.graphic = graphic = renderer.g('point') .addClass(point.getClassName()) .add(point.group || series.group); point.graphicOriginal = renderer[type](shapeArgs) .addClass(point.getClassName()) .addClass('highcharts-partfill-original') .add(graphic); } // Partial fill graphic if (partShapeArgs) { if (point.graphicOverlay) { point.graphicOverlay[verb]( merge(partShapeArgs) ); point.clipRect.animate( merge(clipRectArgs) ); } else { point.clipRect = renderer.clipRect( clipRectArgs.x, clipRectArgs.y, clipRectArgs.width, clipRectArgs.height ); point.graphicOverlay = renderer[type](partShapeArgs) .addClass('highcharts-partfill-overlay') .add(graphic) .clip(point.clipRect); } } // Presentational point.graphicOriginal .attr(series.pointAttribs(point, state)) .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(point.color || series.color).brighten(-0.3).get() ); point.graphicOverlay .attr(series.pointAttribs(point, state)) .attr({ 'fill': fill }) .shadow(seriesOpts.shadow, null, cutOff); } } else if (graphic) { point.graphic = graphic.destroy(); // #1269 } }, drawPoints: function() { var series = this, chart = this.chart, options = series.options, animationLimit = options.animationLimit || 250, verb = chart.pointCount < animationLimit ? 'animate' : 'attr'; // draw the columns each(series.points, function(point) { series.drawPoint(point, verb); }); } /** * 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; } */ // Point class properties }, { /** * Extend init so that `colorByPoint` for x-range means that one color is * applied per Y axis category. */ init: function() { Point.prototype.init.apply(this, arguments); var colors, series = this.series, colorCount = series.chart.options.chart.colorCount; if (!this.y) { this.y = 0; } if (series.options.colorByPoint) { colors = series.options.colors || series.chart.options.colors; colorCount = colors.length; if (!this.options.color && colors[this.y % colorCount]) { this.color = colors[this.y % colorCount]; } } this.colorIndex = this.y % colorCount; return this; }, // 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'], isValid: function() { return typeof this.x === 'number' && typeof this.x2 === 'number'; } }); /** * Max x2 should be considered in xAxis extremes */ wrap(Axis.prototype, 'getSeriesExtremes', function(proceed) { var axis = this, axisSeries = axis.series, dataMax, modMax; proceed.call(axis); if (axis.isXAxis) { dataMax = pick(axis.dataMax, -Number.MAX_VALUE); each(axisSeries, function(series) { if (series.x2Data) { each(series.x2Data, 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). * * For options that apply to multiple series, it is recommended to add * them to the [plotOptions.series](#plotOptions.series) options structure. * To apply to all series of this specific type, apply it to [plotOptions. * xrange](#plotOptions.xrange). * * @type {Object} * @extends series,plotOptions.xrange * @excluding boostThreshold,crisp,cropThreshold,depth,edgeColor,edgeWidth, * findNearestPointBy,getExtremesFromAll,grouping,groupPadding, * negativeColor,pointInterval,pointIntervalUnit,pointPlacement, * pointRange,pointStart,softThreshold,stacking,threshold,data * @product highcharts highstock * @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" * }] * ``` * * @type {Array} * @extends series.line.data * @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 * @product highcharts highstock * @apioption series.xrange.data */ /** * The ending X value of the range point. * * @sample {highcharts} highcharts/demo/x-range * X-range * @type {Number} * @product highcharts * @apioption plotOptions.xrange.data.x2 */ /** * 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 * @type {Object|Number} * @product highcharts * @apioption plotOptions.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 * @apioption plotOptions.xrange.data.partialFill.amount */ /** * The fill color to be used for partial fills. Defaults to a darker shade * of the point color. * * @type {Color} * @product highcharts * @apioption plotOptions.xrange.data.partialFill.fill */ }(Highcharts)); (function() { /** * (c) 2016 Highsoft AS * Authors: Lars A. V. Cabrera * * License: www.highcharts.com/license */ // }()); }));