devextreme
Version:
HTML5 JavaScript Component Suite for Responsive Web Development
1,171 lines (1,144 loc) • 64.8 kB
JavaScript
/**
* DevExtreme (viz/chart.js)
* Version: 20.1.7
* Build date: Tue Aug 25 2020
*
* Copyright (c) 2012 - 2020 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
*/
"use strict";
var _common = require("../core/utils/common");
var _extend2 = require("../core/utils/extend");
var _array = require("../core/utils/array");
var _iterator = require("../core/utils/iterator");
var _component_registrator = require("../core/component_registrator");
var _component_registrator2 = _interopRequireDefault(_component_registrator);
var _utils = require("./core/utils");
var _type = require("../core/utils/type");
var _math = require("../core/utils/math");
var _base_chart = require("./chart_components/base_chart");
var _multi_axes_synchronizer = require("./chart_components/multi_axes_synchronizer");
var _multi_axes_synchronizer2 = _interopRequireDefault(_multi_axes_synchronizer);
var _advanced_chart = require("./chart_components/advanced_chart");
var _scroll_bar = require("./chart_components/scroll_bar");
var _scroll_bar2 = _interopRequireDefault(_scroll_bar);
var _crosshair = require("./chart_components/crosshair");
var _crosshair2 = _interopRequireDefault(_crosshair);
var _range_data_calculator = require("./series/helpers/range_data_calculator");
var _layout_manager = require("./chart_components/layout_manager");
var _layout_manager2 = _interopRequireDefault(_layout_manager);
var _range = require("./translators/range");
var _range2 = _interopRequireDefault(_range);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
"default": obj
}
}
var DEFAULT_PANE_NAME = "default";
var VISUAL_RANGE = "VISUAL_RANGE";
var DEFAULT_PANES = [{
name: DEFAULT_PANE_NAME,
border: {}
}];
var DISCRETE = "discrete";
var _isArray = Array.isArray;
function getFirstAxisNameForPane(axes, paneName, defaultPane) {
var result;
for (var i = 0; i < axes.length; i++) {
if (axes[i].pane === paneName || void 0 === axes[i].pane && paneName === defaultPane) {
result = axes[i].name;
break
}
}
if (!result) {
result = axes[0].name
}
return result
}
function changeVisibilityAxisGrids(axis, gridVisibility, minorGridVisibility) {
var gridOpt = axis.getOptions().grid;
var minorGridOpt = axis.getOptions().minorGrid;
gridOpt.visible = gridVisibility;
minorGridOpt && (minorGridOpt.visible = minorGridVisibility)
}
function hideGridsOnNonFirstValueAxisForPane(axesForPane) {
var axisShown = false;
var hiddenStubAxis = [];
var minorGridVisibility = axesForPane.some(function(axis) {
var minorGridOptions = axis.getOptions().minorGrid;
return minorGridOptions && minorGridOptions.visible
});
var gridVisibility = axesForPane.some(function(axis) {
var gridOptions = axis.getOptions().grid;
return gridOptions && gridOptions.visible
});
if (axesForPane.length > 1) {
axesForPane.forEach(function(axis) {
var gridOpt = axis.getOptions().grid;
if (axisShown) {
changeVisibilityAxisGrids(axis, false, false)
} else {
if (gridOpt && gridOpt.visible) {
if (axis.getTranslator().getBusinessRange().isEmpty()) {
changeVisibilityAxisGrids(axis, false, false);
hiddenStubAxis.push(axis)
} else {
axisShown = true;
changeVisibilityAxisGrids(axis, gridVisibility, minorGridVisibility)
}
}
}
});
!axisShown && hiddenStubAxis.length && changeVisibilityAxisGrids(hiddenStubAxis[0], gridVisibility, minorGridVisibility)
}
}
function findAxisOptions(valueAxes, valueAxesOptions, axisName) {
var result;
var axInd;
for (axInd = 0; axInd < valueAxesOptions.length; axInd++) {
if (valueAxesOptions[axInd].name === axisName) {
result = valueAxesOptions[axInd];
result.priority = axInd;
break
}
}
if (!result) {
for (axInd = 0; axInd < valueAxes.length; axInd++) {
if (valueAxes[axInd].name === axisName) {
result = valueAxes[axInd].getOptions();
result.priority = valueAxes[axInd].priority;
break
}
}
}
return result
}
function findAxis(paneName, axisName, axes) {
var axis;
var i;
for (i = 0; i < axes.length; i++) {
axis = axes[i];
if (axis.name === axisName && axis.pane === paneName) {
return axis
}
}
if (paneName) {
return findAxis(void 0, axisName, axes)
}
}
function compareAxes(a, b) {
return a.priority - b.priority
}
function doesPaneExist(panes, paneName) {
var found = false;
(0, _iterator.each)(panes, function(_, pane) {
if (pane.name === paneName) {
found = true;
return false
}
});
return found
}
var prepareSegmentRectPoints = function(left, top, width, height, borderOptions) {
var maxSW = ~~((width < height ? width : height) / 2);
var sw = borderOptions.width || 0;
var newSW = sw < maxSW ? sw : maxSW;
left += newSW / 2;
top += newSW / 2;
width -= newSW;
height -= newSW;
var right = left + width;
var bottom = top + height;
var points = [];
var segments = [];
var segmentSequence;
var visiblyOpt = 0;
var prevSegmentVisibility = 0;
var allSegment = {
top: [
[left, top],
[right, top]
],
right: [
[right, top],
[right, bottom]
],
bottom: [
[right, bottom],
[left, bottom]
],
left: [
[left, bottom],
[left, top]
]
};
(0, _iterator.each)(allSegment, function(seg) {
var visibility = !!borderOptions[seg];
visiblyOpt = 2 * visiblyOpt + ~~visibility
});
switch (visiblyOpt) {
case 13:
case 9:
segmentSequence = ["left", "top", "right", "bottom"];
break;
case 11:
segmentSequence = ["bottom", "left", "top", "right"];
break;
default:
segmentSequence = ["top", "right", "bottom", "left"]
}(0, _iterator.each)(segmentSequence, function(_, seg) {
var segmentVisibility = !!borderOptions[seg];
if (!prevSegmentVisibility && segments.length) {
points.push(segments);
segments = []
}
if (segmentVisibility) {
(0, _iterator.each)(allSegment[seg].slice(prevSegmentVisibility), function(_, segment) {
segments = segments.concat(segment)
})
}
prevSegmentVisibility = ~~segmentVisibility
});
segments.length && points.push(segments);
1 === points.length && (points = points[0]);
return {
points: points,
pathType: 15 === visiblyOpt ? "area" : "line"
}
};
function accumulate(field, src1, src2, auxSpacing) {
var val1 = src1[field] || 0;
var val2 = src2[field] || 0;
return val1 + val2 + (val1 && val2 ? auxSpacing : 0)
}
function pickMax(field, src1, src2) {
return pickMaxValue(src1[field], src2[field])
}
function pickMaxValue(val1, val2) {
return Math.max(val1 || 0, val2 || 0)
}
function getAxisMargins(axis) {
return axis.getMargins()
}
function getHorizontalAxesMargins(axes, getMarginsFunc) {
return axes.reduce(function(margins, axis) {
var axisMargins = getMarginsFunc(axis);
var paneMargins = margins.panes[axis.pane] = margins.panes[axis.pane] || {};
var spacing = axis.getMultipleAxesSpacing();
paneMargins.top = accumulate("top", paneMargins, axisMargins, spacing);
paneMargins.bottom = accumulate("bottom", paneMargins, axisMargins, spacing);
paneMargins.left = pickMax("left", paneMargins, axisMargins);
paneMargins.right = pickMax("right", paneMargins, axisMargins);
margins.top = pickMax("top", paneMargins, margins);
margins.bottom = pickMax("bottom", paneMargins, margins);
margins.left = pickMax("left", paneMargins, margins);
margins.right = pickMax("right", paneMargins, margins);
return margins
}, {
panes: {}
})
}
function getVerticalAxesMargins(axes) {
return axes.reduce(function(margins, axis) {
var axisMargins = axis.getMargins();
var paneMargins = margins.panes[axis.pane] = margins.panes[axis.pane] || {};
var spacing = axis.getMultipleAxesSpacing();
paneMargins.top = pickMax("top", paneMargins, axisMargins);
paneMargins.bottom = pickMax("bottom", paneMargins, axisMargins);
paneMargins.left = accumulate("left", paneMargins, axisMargins, spacing);
paneMargins.right = accumulate("right", paneMargins, axisMargins, spacing);
margins.top = pickMax("top", paneMargins, margins);
margins.bottom = pickMax("bottom", paneMargins, margins);
margins.left = pickMax("left", paneMargins, margins);
margins.right = pickMax("right", paneMargins, margins);
return margins
}, {
panes: {}
})
}
function performActionOnAxes(axes, action, actionArgument1, actionArgument2, actionArgument3) {
axes.forEach(function(axis) {
axis[action](actionArgument1 && actionArgument1[axis.pane], actionArgument2 && actionArgument2[axis.pane] || actionArgument2, actionArgument3)
})
}
function shrinkCanvases(isRotated, canvases, sizes, verticalMargins, horizontalMargins) {
function getMargin(side, margins, pane) {
var m = (isRotated ? ["left", "right"] : ["top", "bottom"]).indexOf(side) === -1 ? margins : margins.panes[pane] || {};
return m[side]
}
function getMaxMargin(side, margins1, margins2, pane) {
return pickMaxValue(getMargin(side, margins1, pane), getMargin(side, margins2, pane))
}
var getOriginalField = function(field) {
return "original".concat(field[0].toUpperCase()).concat(field.slice(1))
};
function shrink(canvases, paneNames, sizeField, startMargin, endMargin, oppositeMargins) {
paneNames = paneNames.sort(function(p1, p2) {
return canvases[p2][startMargin] - canvases[p1][startMargin]
});
paneNames.forEach(function(pane) {
var canvas = canvases[pane];
oppositeMargins.forEach(function(margin) {
canvas[margin] = canvas[getOriginalField(margin)] + getMaxMargin(margin, verticalMargins, horizontalMargins, pane)
})
});
var firstPane = canvases[paneNames[0]];
var emptySpace = paneNames.reduce(function(space, paneName) {
space -= getMaxMargin(startMargin, verticalMargins, horizontalMargins, paneName) + getMaxMargin(endMargin, verticalMargins, horizontalMargins, paneName);
return space
}, firstPane[sizeField] - firstPane[getOriginalField(endMargin)] - canvases[paneNames[paneNames.length - 1]][getOriginalField(startMargin)]) - _utils.PANE_PADDING * (paneNames.length - 1);
var totalCustomSpace = Object.keys(sizes).reduce(function(prev, key) {
return prev + (sizes[key].unit ? sizes[key].height : 0)
}, 0);
emptySpace -= totalCustomSpace;
paneNames.reduce(function(offset, pane) {
var canvas = canvases[pane];
var paneSize = sizes[pane];
offset -= getMaxMargin(endMargin, verticalMargins, horizontalMargins, pane);
canvas[endMargin] = firstPane[sizeField] - offset;
offset -= paneSize.unit ? paneSize.height : Math.floor(emptySpace * paneSize.height);
canvas[startMargin] = offset;
offset -= getMaxMargin(startMargin, verticalMargins, horizontalMargins, pane) + _utils.PANE_PADDING;
return offset
}, firstPane[sizeField] - firstPane[getOriginalField(endMargin)] - (emptySpace < 0 ? emptySpace : 0))
}
var paneNames = Object.keys(canvases);
if (!isRotated) {
shrink(canvases, paneNames, "height", "top", "bottom", ["left", "right"])
} else {
shrink(canvases, paneNames, "width", "left", "right", ["top", "bottom"])
}
return canvases
}
function drawAxesWithTicks(axes, condition, canvases, panesBorderOptions) {
if (condition) {
performActionOnAxes(axes, "createTicks", canvases);
_multi_axes_synchronizer2.default.synchronize(axes)
}
performActionOnAxes(axes, "draw", !condition && canvases, panesBorderOptions)
}
function shiftAxis(side1, side2) {
var shifts = {};
return function(axis) {
if (!axis.customPositionIsAvailable() || axis.customPositionEqualsToPredefined()) {
var shift = shifts[axis.pane] = shifts[axis.pane] || {
top: 0,
left: 0,
bottom: 0,
right: 0
};
var spacing = axis.getMultipleAxesSpacing();
var margins = axis.getMargins();
axis.shift(shift);
shift[side1] = accumulate(side1, shift, margins, spacing);
shift[side2] = accumulate(side2, shift, margins, spacing)
} else {
axis.shift({
top: 0,
left: 0,
bottom: 0,
right: 0
})
}
}
}
function getCommonSize(side, margins) {
var size = 0;
var pane;
var paneMargins;
for (pane in margins.panes) {
paneMargins = margins.panes[pane];
size += "height" === side ? paneMargins.top + paneMargins.bottom : paneMargins.left + paneMargins.right
}
return size
}
function checkUsedSpace(sizeShortage, side, axes, getMarginFunc) {
var size = 0;
if (sizeShortage[side] > 0) {
size = getCommonSize(side, getMarginFunc(axes, getAxisMargins));
performActionOnAxes(axes, "hideTitle");
sizeShortage[side] -= size - getCommonSize(side, getMarginFunc(axes, getAxisMargins))
}
if (sizeShortage[side] > 0) {
performActionOnAxes(axes, "hideOuterElements")
}
}
function axisAnimationEnabled(drawOptions, pointsToAnimation) {
var pointsCount = pointsToAnimation.reduce(function(sum, count) {
return sum + count
}, 0) / pointsToAnimation.length;
return drawOptions.animate && pointsCount <= drawOptions.animationPointsLimit
}
function collectMarkersInfoBySeries(allSeries, filteredSeries, argAxis) {
var series = [];
var overloadedSeries = {};
var argVisualRange = argAxis.visualRange();
var argTranslator = argAxis.getTranslator();
var argViewPortFilter = (0, _range_data_calculator.getViewPortFilter)(argVisualRange || {});
filteredSeries.forEach(function(s) {
var valAxis = s.getValueAxis();
var valVisualRange = valAxis.getCanvasRange();
var valTranslator = valAxis.getTranslator();
var seriesIndex = allSeries.indexOf(s);
var valViewPortFilter = (0, _range_data_calculator.getViewPortFilter)(valVisualRange || {});
overloadedSeries[seriesIndex] = {};
filteredSeries.forEach(function(sr) {
return overloadedSeries[seriesIndex][allSeries.indexOf(sr)] = 0
});
var seriesPoints = [];
s.getPoints().filter(function(p) {
return p.getOptions().visible && argViewPortFilter(p.argument) && (valViewPortFilter(p.getMinValue(true)) || valViewPortFilter(p.getMaxValue(true)))
}).forEach(function(p) {
var tp = {
seriesIndex: seriesIndex,
argument: p.argument,
value: p.getMaxValue(true),
size: p.bubbleSize || p.getOptions().size
};
if (p.getMinValue(true) !== p.getMaxValue(true)) {
var mp = (0, _extend2.extend)({}, tp);
mp.value = p.getMinValue(true);
mp.x = argTranslator.to(mp.argument, 1);
mp.y = valTranslator.to(mp.value, 1);
seriesPoints.push(mp)
}
tp.x = argTranslator.to(tp.argument, 1);
tp.y = valTranslator.to(tp.value, 1);
seriesPoints.push(tp)
});
overloadedSeries[seriesIndex].pointsCount = seriesPoints.length;
overloadedSeries[seriesIndex].total = 0;
overloadedSeries[seriesIndex].continuousSeries = 0;
series.push({
name: s.name,
index: seriesIndex,
points: seriesPoints
})
});
return {
series: series,
overloadedSeries: overloadedSeries
}
}
function applyAutoHidePointMarkers(allSeries, filteredSeries, overloadedSeries, argAxis) {
var argAxisType = argAxis.getOptions().type;
filteredSeries.forEach(function(s) {
var seriesIndex = allSeries.indexOf(s);
s.autoHidePointMarkers = false;
var tickCount = argAxis.getTicksValues().majorTicksValues.length;
if (s.autoHidePointMarkersEnabled() && (argAxisType === DISCRETE || overloadedSeries[seriesIndex].pointsCount > tickCount)) {
for (var index in overloadedSeries[seriesIndex]) {
var i = parseInt(index);
if (isNaN(i) || overloadedSeries[seriesIndex].total / overloadedSeries[seriesIndex].continuousSeries < 3) {
continue
}
if (i === seriesIndex) {
if (2 * overloadedSeries[i][i] >= overloadedSeries[i].pointsCount) {
s.autoHidePointMarkers = true;
break
}
} else {
if (overloadedSeries[seriesIndex].total >= overloadedSeries[seriesIndex].pointsCount) {
s.autoHidePointMarkers = true;
break
}
}
}
}
})
}
function fastHidingPointMarkersByArea(canvas, markersInfo, series) {
var area = canvas.width * canvas.height;
var seriesPoints = markersInfo.series;
var _loop = function(i) {
var currentSeries = series.filter(function(s) {
return s.name === seriesPoints[i].name
})[0];
var points = seriesPoints[i].points;
var pointSize = points.length ? points[0].size : 0;
var pointsArea = pointSize * pointSize * points.length;
if (pointsArea >= area / seriesPoints.length) {
var index = seriesPoints[i].index;
currentSeries.autoHidePointMarkers = true;
seriesPoints.splice(i, 1);
series.splice(series.indexOf(currentSeries), 1);
delete markersInfo.overloadedSeries[index]
}
};
for (var i = seriesPoints.length - 1; i >= 0; i--) {
_loop(i)
}
}
function updateMarkersInfo(points, overloadedSeries) {
var isContinuousSeries = false;
for (var i = 0; i < points.length - 1; i++) {
var curPoint = points[i];
var size = curPoint.size;
if ((0, _type.isDefined)(curPoint.x) && (0, _type.isDefined)(curPoint.y)) {
for (var j = i + 1; j < points.length; j++) {
var nextPoint = points[j];
var next_x = null === nextPoint || void 0 === nextPoint ? void 0 : nextPoint.x;
var next_y = null === nextPoint || void 0 === nextPoint ? void 0 : nextPoint.y;
if (!(0, _type.isDefined)(next_x) || Math.abs(curPoint.x - next_x) >= size) {
isContinuousSeries &= j !== i + 1;
break
} else {
var distance = (0, _type.isDefined)(next_x) && (0, _type.isDefined)(next_y) && Math.sqrt(Math.pow(curPoint.x - next_x, 2) + Math.pow(curPoint.y - next_y, 2));
if (distance && distance < size) {
overloadedSeries[curPoint.seriesIndex][nextPoint.seriesIndex]++;
overloadedSeries[curPoint.seriesIndex].total++;
if (!isContinuousSeries) {
overloadedSeries[curPoint.seriesIndex].continuousSeries++;
isContinuousSeries = true
}
}
}
}
}
}
}
var dxChart = _advanced_chart.AdvancedChart.inherit({
_themeSection: "chart",
_fontFields: ["crosshair.label.font"],
_setDeprecatedOptions: function() {
this.callBase.apply(this, arguments);
(0, _extend2.extend)(this._deprecatedOptions, {
useAggregation: {
since: "18.1",
message: "Use the 'commonSeriesSettings.aggregation.enabled' or 'series.aggregation.enabled' option instead"
},
"argumentAxis.min": {
since: "18.2",
message: "Use the 'argumentAxis.visualRange' option instead"
},
"argumentAxis.max": {
since: "18.2",
message: "Use the 'argumentAxis.visualRange' option instead"
},
"valueAxis.min": {
since: "18.2",
message: "Use the 'valueAxis.visualRange' option instead"
},
"valueAxis.max": {
since: "18.2",
message: "Use the 'valueAxis.visualRange' option instead"
},
zoomingMode: {
since: "18.2",
message: "Use the 'zoomAndPan' option instead"
},
scrollingMode: {
since: "18.2",
message: "Use the 'zoomAndPan' option instead"
}
})
},
_initCore: function() {
this.paneAxis = {};
this.callBase()
},
_correctAxes: function() {
this._correctValueAxes(true)
},
_getExtraOptions: _common.noop,
_createPanes: function() {
var that = this;
var panes = that.option("panes");
var panesNameCounter = 0;
var defaultPane;
if (!panes || _isArray(panes) && !panes.length) {
panes = DEFAULT_PANES
}
that.callBase();
defaultPane = that.option("defaultPane");
panes = (0, _extend2.extend)(true, [], _isArray(panes) ? panes : [panes]);
(0, _iterator.each)(panes, function(_, pane) {
pane.name = !(0, _type.isDefined)(pane.name) ? DEFAULT_PANE_NAME + panesNameCounter++ : pane.name
});
if ((0, _type.isDefined)(defaultPane)) {
if (!doesPaneExist(panes, defaultPane)) {
that._incidentOccurred("W2101", [defaultPane]);
defaultPane = panes[panes.length - 1].name
}
} else {
defaultPane = panes[panes.length - 1].name
}
that.defaultPane = defaultPane;
panes = that._isRotated() ? panes.reverse() : panes;
return panes
},
_getAxisRenderingOptions: function() {
return {
axisType: "xyAxes",
drawingType: "linear"
}
},
_prepareAxisOptions: function(typeSelector, userOptions, rotated) {
return {
isHorizontal: "argumentAxis" === typeSelector !== rotated,
containerColor: this._themeManager.getOptions("containerBackgroundColor")
}
},
_checkPaneName: function(seriesTheme) {
var paneList = (0, _utils.map)(this.panes, function(pane) {
return pane.name
});
seriesTheme.pane = seriesTheme.pane || this.defaultPane;
return (0, _array.inArray)(seriesTheme.pane, paneList) !== -1
},
_initCustomPositioningAxes: function() {
var that = this;
var argumentAxis = that.getArgumentAxis();
var valueAxisName = argumentAxis.getOptions().customPositionAxis;
var valueAxis = that._valueAxes.filter(function(v) {
return v.pane === argumentAxis.pane && (!valueAxisName || valueAxisName === v.name)
})[0];
that._valueAxes.forEach(function(v) {
if (argumentAxis !== v.getOrthogonalAxis()) {
v.getOrthogonalAxis = function() {
return argumentAxis
};
v.customPositionIsBoundaryOrthogonalAxis = function() {
return argumentAxis.customPositionIsBoundary()
}
}
});
if ((0, _type.isDefined)(valueAxis) && valueAxis !== argumentAxis.getOrthogonalAxis()) {
argumentAxis.getOrthogonalAxis = function() {
return valueAxis
};
argumentAxis.customPositionIsBoundaryOrthogonalAxis = function() {
return that._valueAxes.some(function(v) {
return v.customPositionIsBoundary()
})
}
} else {
if ((0, _type.isDefined)(argumentAxis.getOrthogonalAxis()) && !(0, _type.isDefined)(valueAxis)) {
argumentAxis.getOrthogonalAxis = _common.noop
}
}
},
_resetAxesAnimation: function(isFirstDrawing) {
this._argumentAxes.concat(this._valueAxes).forEach(function(a) {
a.resetApplyingAnimation(isFirstDrawing)
})
},
_axesBoundaryPositioning: function() {
var that = this;
var allAxes = that._argumentAxes.concat(that._valueAxes);
var boundaryStateChanged = false;
allAxes.forEach(function(a) {
if (!a.customPositionIsAvailable()) {
return false
}
var prevBoundaryState = a.customPositionIsBoundary();
a._customBoundaryPosition = a.getCustomBoundaryPosition();
boundaryStateChanged |= prevBoundaryState !== a.customPositionIsBoundary()
});
return boundaryStateChanged
},
_getValueAxis: function(paneName, axisName) {
var that = this;
var valueAxes = that._valueAxes;
var valueAxisOptions = that.option("valueAxis") || {};
var valueAxesOptions = _isArray(valueAxisOptions) ? valueAxisOptions : [valueAxisOptions];
var rotated = that._isRotated();
var crosshairMargins = that._getCrosshairMargins();
var axisOptions;
var axis;
axisName = axisName || getFirstAxisNameForPane(valueAxes, paneName, that.defaultPane);
axis = findAxis(paneName, axisName, valueAxes);
if (!axis) {
axisOptions = findAxisOptions(valueAxes, valueAxesOptions, axisName);
if (!axisOptions) {
that._incidentOccurred("W2102", [axisName]);
axisOptions = {
name: axisName,
priority: valueAxes.length
}
}
axis = that._createAxis(false, that._populateAxesOptions("valueAxis", axisOptions, {
pane: paneName,
name: axisName,
optionPath: _isArray(valueAxisOptions) ? "valueAxis[".concat(axisOptions.priority, "]") : "valueAxis",
crosshairMargin: rotated ? crosshairMargins.y : crosshairMargins.x
}, rotated));
axis.applyVisualRangeSetter(that._getVisualRangeSetter());
valueAxes.push(axis)
}
axis.setPane(paneName);
return axis
},
_correctValueAxes: function(needHideGrids) {
var that = this;
var synchronizeMultiAxes = that._themeManager.getOptions("synchronizeMultiAxes");
var valueAxes = that._valueAxes;
var paneWithAxis = {};
that.series.forEach(function(series) {
var axis = series.getValueAxis();
paneWithAxis[axis.pane] = true
});
that.panes.forEach(function(pane) {
var paneName = pane.name;
if (!paneWithAxis[paneName]) {
that._getValueAxis(paneName)
}
if (needHideGrids && synchronizeMultiAxes) {
hideGridsOnNonFirstValueAxisForPane(valueAxes.filter(function(axis) {
return axis.pane === paneName
}))
}
});
that._valueAxes = valueAxes.filter(function(axis) {
if (!axis.pane) {
axis.setPane(that.defaultPane)
}
return doesPaneExist(that.panes, axis.pane)
}).sort(compareAxes);
var defaultAxis = this.getValueAxis();
that._valueAxes.forEach(function(axis) {
var optionPath = axis.getOptions().optionPath;
if (optionPath) {
var axesWithSamePath = that._valueAxes.filter(function(a) {
return a.getOptions().optionPath === optionPath
});
if (axesWithSamePath.length > 1) {
if (axesWithSamePath.some(function(a) {
return a === defaultAxis
})) {
axesWithSamePath.forEach(function(a) {
if (a !== defaultAxis) {
a.getOptions().optionPath = null
}
})
} else {
axesWithSamePath.forEach(function(a, i) {
if (0 !== i) {
a.getOptions().optionPath = null
}
})
}
}
}
})
},
_getSeriesForPane: function(paneName) {
var paneSeries = [];
(0, _iterator.each)(this.series, function(_, oneSeries) {
if (oneSeries.pane === paneName) {
paneSeries.push(oneSeries)
}
});
return paneSeries
},
_createPanesBorderOptions: function() {
var commonBorderOptions = this._themeManager.getOptions("commonPaneSettings").border;
var panesBorderOptions = {};
this.panes.forEach(function(pane) {
return panesBorderOptions[pane.name] = (0, _extend2.extend)(true, {}, commonBorderOptions, pane.border)
});
return panesBorderOptions
},
_createScrollBar: function() {
var that = this;
var scrollBarOptions = that._themeManager.getOptions("scrollBar") || {};
var scrollBarGroup = that._scrollBarGroup;
if (scrollBarOptions.visible) {
scrollBarOptions.rotated = that._isRotated();
that._scrollBar = (that._scrollBar || new _scroll_bar2.default.ScrollBar(that._renderer, scrollBarGroup)).update(scrollBarOptions)
} else {
scrollBarGroup.linkRemove();
that._scrollBar && that._scrollBar.dispose();
that._scrollBar = null
}
},
_prepareToRender: function(drawOptions) {
var panesBorderOptions = this._createPanesBorderOptions();
this._createPanesBackground();
this._appendAxesGroups();
this._adjustViewport();
return panesBorderOptions
},
_adjustViewport: function() {
var that = this;
var series = that._getVisibleSeries();
var argumentAxis = that.getArgumentAxis();
var useAggregation = series.some(function(s) {
return s.useAggregation()
});
var adjustOnZoom = that._themeManager.getOptions("adjustOnZoom");
var alignToBounds = !argumentAxis.dataVisualRangeIsReduced();
if (!useAggregation && !adjustOnZoom) {
return
}
that._valueAxes.forEach(function(axis) {
return axis.adjust(alignToBounds)
})
},
_recreateSizeDependentObjects: function(isCanvasChanged) {
var that = this;
var series = that._getVisibleSeries();
var useAggregation = series.some(function(s) {
return s.useAggregation()
});
var zoomChanged = that._isZooming();
if (!useAggregation) {
return
}
that._argumentAxes.forEach(function(axis) {
axis.updateCanvas(that._canvas, true)
});
series.forEach(function(series) {
if (series.useAggregation() && (isCanvasChanged || zoomChanged || !series._useAllAggregatedPoints)) {
series.createPoints()
}
});
that._processSeriesFamilies()
},
_isZooming: function() {
var that = this;
var argumentAxis = that.getArgumentAxis();
if (!argumentAxis || !argumentAxis.getTranslator()) {
return false
}
var businessRange = argumentAxis.getTranslator().getBusinessRange();
var zoomRange = argumentAxis.getViewport();
var min = zoomRange ? zoomRange.min : 0;
var max = zoomRange ? zoomRange.max : 0;
if ("logarithmic" === businessRange.axisType) {
min = (0, _utils.getLog)(min, businessRange.base);
max = (0, _utils.getLog)(max, businessRange.base)
}
var viewportDistance = businessRange.axisType === DISCRETE ? (0, _utils.getCategoriesInfo)(businessRange.categories, min, max).categories.length : Math.abs(max - min);
var precision = (0, _math.getPrecision)(viewportDistance);
precision = precision > 1 ? Math.pow(10, precision - 2) : 1;
var zoomChanged = Math.round((that._zoomLength - viewportDistance) * precision) / precision !== 0;
that._zoomLength = viewportDistance;
return zoomChanged
},
_handleSeriesDataUpdated: function() {
var that = this;
var viewport = new _range2.default.Range;
that.series.forEach(function(s) {
viewport.addRange(s.getArgumentRange())
});
that._argumentAxes.forEach(function(axis) {
axis.updateCanvas(that._canvas, true);
axis.setBusinessRange(viewport, that._axesReinitialized)
});
that.callBase()
},
_isLegendInside: function() {
return this._legend && "inside" === this._legend.getPosition()
},
_isRotated: function() {
return this._themeManager.getOptions("rotated")
},
_getLayoutTargets: function() {
return this.panes
},
_applyClipRects: function(panesBorderOptions) {
var that = this;
that._drawPanesBorders(panesBorderOptions);
that._createClipRectsForPanes();
that._applyClipRectsForAxes();
that._fillPanesBackground()
},
_updateLegendPosition: function(drawOptions, legendHasInsidePosition) {
var that = this;
if (drawOptions.drawLegend && that._legend && legendHasInsidePosition) {
var panes = that.panes;
var newCanvas = (0, _extend2.extend)({}, panes[0].canvas);
var layoutManager = new _layout_manager2.default.LayoutManager;
newCanvas.right = panes[panes.length - 1].canvas.right;
newCanvas.bottom = panes[panes.length - 1].canvas.bottom;
layoutManager.layoutInsideLegend(that._legend, newCanvas)
}
},
_allowLegendInsidePosition: function() {
return true
},
_applyExtraSettings: function(series) {
var that = this;
var paneIndex = that._getPaneIndex(series.pane);
var panesClipRects = that._panesClipRects;
var wideClipRect = panesClipRects.wide[paneIndex];
series.setClippingParams(panesClipRects.base[paneIndex].id, wideClipRect && wideClipRect.id, that._getPaneBorderVisibility(paneIndex))
},
_updatePanesCanvases: function(drawOptions) {
if (!drawOptions.recreateCanvas) {
return
}(0, _utils.updatePanesCanvases)(this.panes, this._canvas, this._isRotated())
},
_normalizePanesHeight: function() {
(0, _utils.normalizePanesHeight)(this.panes)
},
_renderScaleBreaks: function() {
this._valueAxes.concat(this._argumentAxes).forEach(function(axis) {
axis.drawScaleBreaks()
})
},
_getArgFilter: function() {
return (0, _range_data_calculator.getViewPortFilter)(this.getArgumentAxis().visualRange() || {})
},
_applyPointMarkersAutoHiding: function() {
var that = this;
var allSeries = that.series;
if (!that._themeManager.getOptions("autoHidePointMarkers")) {
allSeries.forEach(function(s) {
return s.autoHidePointMarkers = false
});
return
}
that.panes.forEach(function(_ref) {
var borderCoords = _ref.borderCoords,
name = _ref.name;
var series = allSeries.filter(function(s) {
return s.pane === name && s.usePointsToDefineAutoHiding()
});
var argAxis = that.getArgumentAxis();
var markersInfo = collectMarkersInfoBySeries(allSeries, series, argAxis);
fastHidingPointMarkersByArea(borderCoords, markersInfo, series);
if (markersInfo.series.length) {
var argVisualRange = argAxis.visualRange();
var argAxisIsDiscrete = argAxis.getOptions().type === DISCRETE;
var sortingCallback = argAxisIsDiscrete ? function(p1, p2) {
return argVisualRange.categories.indexOf(p1.argument) - argVisualRange.categories.indexOf(p2.argument)
} : function(p1, p2) {
return p1.argument - p2.argument
};
var points = [];
markersInfo.series.forEach(function(s) {
return points = points.concat(s.points)
});
points.sort(sortingCallback);
updateMarkersInfo(points, markersInfo.overloadedSeries);
applyAutoHidePointMarkers(allSeries, series, markersInfo.overloadedSeries, argAxis)
}
})
},
_renderAxes: function(drawOptions, panesBorderOptions) {
function calculateTitlesWidth(axes) {
return axes.map(function(axis) {
if (!axis.getTitle) {
return 0
}
var title = axis.getTitle();
return title ? title.bBox.width : 0
})
}
var that = this;
var rotated = that._isRotated();
var synchronizeMultiAxes = that._themeManager.getOptions("synchronizeMultiAxes");
var scrollBar = that._scrollBar ? [that._scrollBar] : [];
var extendedArgAxes = that._isArgumentAxisBeforeScrollBar() ? that._argumentAxes.concat(scrollBar) : scrollBar.concat(that._argumentAxes);
var verticalAxes = rotated ? that._argumentAxes : that._valueAxes;
var verticalElements = rotated ? extendedArgAxes : that._valueAxes;
var horizontalAxes = rotated ? that._valueAxes : that._argumentAxes;
var horizontalElements = rotated ? that._valueAxes : extendedArgAxes;
var allAxes = verticalAxes.concat(horizontalAxes);
var allElements = allAxes.concat(scrollBar);
that._normalizePanesHeight();
that._updatePanesCanvases(drawOptions);
var panesCanvases = that.panes.reduce(function(canvases, pane) {
canvases[pane.name] = (0, _extend2.extend)({}, pane.canvas);
return canvases
}, {});
var paneSizes = that.panes.reduce(function(sizes, pane) {
sizes[pane.name] = {
height: pane.height,
unit: pane.unit
};
return sizes
}, {});
var cleanPanesCanvases = (0, _extend2.extend)(true, {}, panesCanvases);
that._initCustomPositioningAxes();
var needCustomAdjustAxes = that._axesBoundaryPositioning();
if (!drawOptions.adjustAxes && !needCustomAdjustAxes) {
drawAxesWithTicks(verticalAxes, !rotated && synchronizeMultiAxes, panesCanvases, panesBorderOptions);
drawAxesWithTicks(horizontalAxes, rotated && synchronizeMultiAxes, panesCanvases, panesBorderOptions);
performActionOnAxes(allAxes, "prepareAnimation");
that._renderScaleBreaks();
horizontalAxes.forEach(function(a) {
return a.resolveOverlappingForCustomPositioning(verticalAxes)
});
verticalAxes.forEach(function(a) {
return a.resolveOverlappingForCustomPositioning(horizontalAxes)
});
return false
}
if (needCustomAdjustAxes) {
allAxes.forEach(function(a) {
return a.customPositionIsAvailable() && a.shift({
top: 0,
left: 0,
bottom: 0,
right: 0
})
})
}
if (that._scrollBar) {
that._scrollBar.setPane(that.panes)
}
var vAxesMargins = {
panes: {}
};
var hAxesMargins = getHorizontalAxesMargins(horizontalElements, function(axis) {
return axis.estimateMargins(panesCanvases[axis.pane])
});
panesCanvases = shrinkCanvases(rotated, panesCanvases, paneSizes, vAxesMargins, hAxesMargins);
var drawAxesAndSetCanvases = function(isHorizontal) {
var axes = isHorizontal ? horizontalAxes : verticalAxes;
var condition = (isHorizontal ? rotated : !rotated) && synchronizeMultiAxes;
drawAxesWithTicks(axes, condition, panesCanvases, panesBorderOptions);
if (isHorizontal) {
hAxesMargins = getHorizontalAxesMargins(horizontalElements, getAxisMargins)
} else {
vAxesMargins = getVerticalAxesMargins(verticalElements)
}
panesCanvases = shrinkCanvases(rotated, panesCanvases, paneSizes, vAxesMargins, hAxesMargins)
};
drawAxesAndSetCanvases(false);
drawAxesAndSetCanvases(true);
if (that._estimateTickIntervals(verticalAxes, panesCanvases)) {
drawAxesAndSetCanvases(false)
}
var oldTitlesWidth = calculateTitlesWidth(verticalAxes);
var visibleSeries = that._getVisibleSeries();
var pointsToAnimation = that._getPointsToAnimation(visibleSeries);
performActionOnAxes(allElements, "updateSize", panesCanvases, axisAnimationEnabled(drawOptions, pointsToAnimation));
horizontalElements.forEach(shiftAxis("top", "bottom"));
verticalElements.forEach(shiftAxis("left", "right"));
that._renderScaleBreaks();
that.panes.forEach(function(pane) {
(0, _extend2.extend)(pane.canvas, panesCanvases[pane.name])
});
that._valueAxes.forEach(function(axis) {
axis.setInitRange()
});
verticalAxes.forEach(function(axis, i) {
if (axis.hasWrap && axis.hasWrap()) {
var title = axis.getTitle();
var newTitleWidth = title ? title.bBox.width : 0;
var offset = newTitleWidth - oldTitlesWidth[i];
if ("right" === axis.getOptions().position) {
vAxesMargins.right += offset
} else {
vAxesMargins.left += offset;
that.panes.forEach(function(_ref2) {
var name = _ref2.name;
return vAxesMargins.panes[name].left += offset
})
}
panesCanvases = shrinkCanvases(rotated, panesCanvases, paneSizes, vAxesMargins, hAxesMargins);
performActionOnAxes(allElements, "updateSize", panesCanvases, false, false);
oldTitlesWidth = calculateTitlesWidth(verticalAxes)
}
});
if (verticalAxes.some(function(v) {
return v.customPositionIsAvailable() && v.getCustomPosition() !== v._axisPosition
})) {
performActionOnAxes(verticalAxes, "updateSize", panesCanvases, false)
}
horizontalAxes.forEach(function(a) {
return a.resolveOverlappingForCustomPositioning(verticalAxes)
});
verticalAxes.forEach(function(a) {
return a.resolveOverlappingForCustomPositioning(horizontalAxes)
});
return cleanPanesCanvases
},
_estimateTickIntervals: function(axes, canvases) {
return axes.some(function(axis) {
return axis.estimateTickInterval(canvases[axis.pane])
})
},
checkForMoreSpaceForPanesCanvas: function() {
var that = this;
var rotated = that._isRotated();
var panesAreCustomSized = that.panes.filter(function(p) {
return p.unit
}).length === that.panes.length;
var needSpace = false;
if (panesAreCustomSized) {
var needHorizontalSpace = 0;
var needVerticalSpace = 0;
if (rotated) {
var argAxisRightMargin = that.getArgumentAxis().getMargins().right;
var rightPanesIndent = Math.min.apply(Math, that.panes.map(function(p) {
return p.canvas.right
}));
needHorizontalSpace = that._canvas.right + argAxisRightMargin - rightPanesIndent;
} else {
var argAxisBottomMargin = that.getArgumentAxis().getMargins().bottom;
var bottomPanesIndent = Math.min.apply(Math, that.panes.map(function(p) {
return p.canvas.bottom
}));
needVerticalSpace = that._canvas.bottom + argAxisBottomMargin - bottomPanesIndent
}
needSpace = needHorizontalSpace > 0 || needVerticalSpace > 0 ? {
width: needHorizontalSpace,
height: needVerticalSpace
} : false;
if (0 !== needVerticalSpace) {
var realSize = that.getSize();
var customSize = that.option("size");
var container = that._$element[0];
var containerHasStyledHeight = !!container.style.height || (0, _utils.checkElementHasPropertyFromStyleSheet)(container, "height");
if (!rotated && !(customSize && customSize.height) && !containerHasStyledHeight) {
that._forceResize(realSize.width, realSize.height + needVerticalSpace);
needSpace = false
}
}
} else {
needSpace = that.layoutManager.needMoreSpaceForPanesCanvas(that._getLayoutTargets(), rotated, function(pane) {
return {
width: rotated && !!pane.unit,
height: !rotated && !!pane.unit
}
})
}
return needSpace
},
_forceResize: function(width, height) {
this._renderer.resize(width, height);
this._updateSize();
this._setContentSize();
this._preserveOriginalCanvas();
this._updateCanvasClipRect(this._canvas)
},
_shrinkAxes: function(sizeShortage, panesCanvases) {
if (!sizeShortage || !panesCanvases) {
return
}
this._renderer.stopAllAnimations(true);
var that = this;
var rotated = that._isRotated();
var scrollBar = that._scrollBar ? [that._scrollBar] : [];
var extendedArgAxes = that._isArgumentAxisBeforeScrollBar() ? that._argumentAxes.concat(scrollBar) : scrollBar.concat(that._argumentAxes);
var verticalAxes = rotated ? extendedArgAxes : that._valueAxes;
var horizontalAxes = rotated ? that._valueAxes : extendedArgAxes;
var allAxes = verticalAxes.concat(horizontalAxes);
if (sizeShortage.width || sizeShortage.height) {
checkUsedSpace(sizeShortage, "height", horizontalAxes, getHorizontalAxesMargins);
checkUsedSpace(sizeShortage, "width", verticalAxes, getVerticalAxesMargins);
performActionOnAxes(allAxes, "updateSize", panesCanvases);
var paneSizes = that.panes.reduce(function(sizes, pane) {
sizes[pane.name] = {
height: pane.height,
unit: pane.unit
};
return sizes
}, {});
panesCanvases = shrinkCanvases(rotated, panesCanvases, paneSizes, getVerticalAxesMargins(verticalAxes), getHorizontalAxesMargins(horizontalAxes, getAxisMargins));
performActionOnAxes(allAxes, "updateSize", panesCanvases);
horizontalAxes.forEach(shiftAxis("top", "bottom"));
verticalAxes.forEach(shiftAxis("left", "right"));
that.panes.forEach(function(pane) {
return (0, _extend2.extend)(pane.canvas, panesCanvases[pane.name])
})
}
},
_isArgumentAxisBeforeScrollBar: function() {
var that = this;
var argumentAxis =