cione-comp-lib
Version:
`$ yarn add cione-comp-lib` 或者 `$ npm i cione-comp-lib -S`
370 lines (369 loc) • 13.4 kB
JavaScript
import { each, isObject, indexOf, keys } from "../../../../zrender/lib/core/util.mjs";
import { getLayoutRect } from "../../util/layout.mjs";
import { estimateLabelUnionRect, createScaleByModel, getDataDimensionsOnAxis, ifAxisCrossZero, niceScaleExtent } from "../axisHelper.mjs";
import Cartesian2D, { cartesian2DDimensions } from "./Cartesian2D.mjs";
import Axis2D from "./Axis2D.mjs";
import { SINGLE_REFERRING } from "../../util/model.mjs";
import { isCartesian2DSeries, findAxisModels } from "./cartesianAxisHelper.mjs";
import { isIntervalOrLogScale } from "../../scale/helper.mjs";
import { alignScaleTicks } from "../axisAlignTicks.mjs";
var Grid = function() {
function Grid2(gridModel, ecModel, api) {
this.type = "grid";
this._coordsMap = {};
this._coordsList = [];
this._axesMap = {};
this._axesList = [];
this.axisPointerEnabled = true;
this.dimensions = cartesian2DDimensions;
this._initCartesian(gridModel, ecModel, api);
this.model = gridModel;
}
Grid2.prototype.getRect = function() {
return this._rect;
};
Grid2.prototype.update = function(ecModel, api) {
var axesMap = this._axesMap;
this._updateScale(ecModel, this.model);
function updateAxisTicks(axes) {
var alignTo;
var axesIndices = keys(axes);
var len = axesIndices.length;
if (!len) {
return;
}
var axisNeedsAlign = [];
for (var i = len - 1; i >= 0; i--) {
var idx = +axesIndices[i];
var axis = axes[idx];
var model = axis.model;
var scale = axis.scale;
if (isIntervalOrLogScale(scale) && model.get("alignTicks") && model.get("interval") == null) {
axisNeedsAlign.push(axis);
} else {
niceScaleExtent(scale, model);
if (isIntervalOrLogScale(scale)) {
alignTo = axis;
}
}
}
if (axisNeedsAlign.length) {
if (!alignTo) {
alignTo = axisNeedsAlign.pop();
niceScaleExtent(alignTo.scale, alignTo.model);
}
each(axisNeedsAlign, function(axis2) {
alignScaleTicks(axis2.scale, axis2.model, alignTo.scale);
});
}
}
updateAxisTicks(axesMap.x);
updateAxisTicks(axesMap.y);
var onZeroRecords = {};
each(axesMap.x, function(xAxis) {
fixAxisOnZero(axesMap, "y", xAxis, onZeroRecords);
});
each(axesMap.y, function(yAxis) {
fixAxisOnZero(axesMap, "x", yAxis, onZeroRecords);
});
this.resize(this.model, api);
};
Grid2.prototype.resize = function(gridModel, api, ignoreContainLabel) {
var boxLayoutParams = gridModel.getBoxLayoutParams();
var isContainLabel = !ignoreContainLabel && gridModel.get("containLabel");
var gridRect = getLayoutRect(boxLayoutParams, {
width: api.getWidth(),
height: api.getHeight()
});
this._rect = gridRect;
var axesList = this._axesList;
adjustAxes();
if (isContainLabel) {
each(axesList, function(axis) {
if (!axis.model.get(["axisLabel", "inside"])) {
var labelUnionRect = estimateLabelUnionRect(axis);
if (labelUnionRect) {
var dim = axis.isHorizontal() ? "height" : "width";
var margin = axis.model.get(["axisLabel", "margin"]);
gridRect[dim] -= labelUnionRect[dim] + margin;
if (axis.position === "top") {
gridRect.y += labelUnionRect.height + margin;
} else if (axis.position === "left") {
gridRect.x += labelUnionRect.width + margin;
}
}
}
});
adjustAxes();
}
each(this._coordsList, function(coord) {
coord.calcAffineTransform();
});
function adjustAxes() {
each(axesList, function(axis) {
var isHorizontal = axis.isHorizontal();
var extent = isHorizontal ? [0, gridRect.width] : [0, gridRect.height];
var idx = axis.inverse ? 1 : 0;
axis.setExtent(extent[idx], extent[1 - idx]);
updateAxisTransform(axis, isHorizontal ? gridRect.x : gridRect.y);
});
}
};
Grid2.prototype.getAxis = function(dim, axisIndex) {
var axesMapOnDim = this._axesMap[dim];
if (axesMapOnDim != null) {
return axesMapOnDim[axisIndex || 0];
}
};
Grid2.prototype.getAxes = function() {
return this._axesList.slice();
};
Grid2.prototype.getCartesian = function(xAxisIndex, yAxisIndex) {
if (xAxisIndex != null && yAxisIndex != null) {
var key = "x" + xAxisIndex + "y" + yAxisIndex;
return this._coordsMap[key];
}
if (isObject(xAxisIndex)) {
yAxisIndex = xAxisIndex.yAxisIndex;
xAxisIndex = xAxisIndex.xAxisIndex;
}
for (var i = 0, coordList = this._coordsList; i < coordList.length; i++) {
if (coordList[i].getAxis("x").index === xAxisIndex || coordList[i].getAxis("y").index === yAxisIndex) {
return coordList[i];
}
}
};
Grid2.prototype.getCartesians = function() {
return this._coordsList.slice();
};
Grid2.prototype.convertToPixel = function(ecModel, finder, value) {
var target = this._findConvertTarget(finder);
return target.cartesian ? target.cartesian.dataToPoint(value) : target.axis ? target.axis.toGlobalCoord(target.axis.dataToCoord(value)) : null;
};
Grid2.prototype.convertFromPixel = function(ecModel, finder, value) {
var target = this._findConvertTarget(finder);
return target.cartesian ? target.cartesian.pointToData(value) : target.axis ? target.axis.coordToData(target.axis.toLocalCoord(value)) : null;
};
Grid2.prototype._findConvertTarget = function(finder) {
var seriesModel = finder.seriesModel;
var xAxisModel = finder.xAxisModel || seriesModel && seriesModel.getReferringComponents("xAxis", SINGLE_REFERRING).models[0];
var yAxisModel = finder.yAxisModel || seriesModel && seriesModel.getReferringComponents("yAxis", SINGLE_REFERRING).models[0];
var gridModel = finder.gridModel;
var coordsList = this._coordsList;
var cartesian;
var axis;
if (seriesModel) {
cartesian = seriesModel.coordinateSystem;
indexOf(coordsList, cartesian) < 0 && (cartesian = null);
} else if (xAxisModel && yAxisModel) {
cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
} else if (xAxisModel) {
axis = this.getAxis("x", xAxisModel.componentIndex);
} else if (yAxisModel) {
axis = this.getAxis("y", yAxisModel.componentIndex);
} else if (gridModel) {
var grid = gridModel.coordinateSystem;
if (grid === this) {
cartesian = this._coordsList[0];
}
}
return {
cartesian,
axis
};
};
Grid2.prototype.containPoint = function(point) {
var coord = this._coordsList[0];
if (coord) {
return coord.containPoint(point);
}
};
Grid2.prototype._initCartesian = function(gridModel, ecModel, api) {
var _this = this;
var grid = this;
var axisPositionUsed = {
left: false,
right: false,
top: false,
bottom: false
};
var axesMap = {
x: {},
y: {}
};
var axesCount = {
x: 0,
y: 0
};
ecModel.eachComponent("xAxis", createAxisCreator("x"), this);
ecModel.eachComponent("yAxis", createAxisCreator("y"), this);
if (!axesCount.x || !axesCount.y) {
this._axesMap = {};
this._axesList = [];
return;
}
this._axesMap = axesMap;
each(axesMap.x, function(xAxis, xAxisIndex) {
each(axesMap.y, function(yAxis, yAxisIndex) {
var key = "x" + xAxisIndex + "y" + yAxisIndex;
var cartesian = new Cartesian2D(key);
cartesian.master = _this;
cartesian.model = gridModel;
_this._coordsMap[key] = cartesian;
_this._coordsList.push(cartesian);
cartesian.addAxis(xAxis);
cartesian.addAxis(yAxis);
});
});
function createAxisCreator(dimName) {
return function(axisModel, idx) {
if (!isAxisUsedInTheGrid(axisModel, gridModel)) {
return;
}
var axisPosition = axisModel.get("position");
if (dimName === "x") {
if (axisPosition !== "top" && axisPosition !== "bottom") {
axisPosition = axisPositionUsed.bottom ? "top" : "bottom";
}
} else {
if (axisPosition !== "left" && axisPosition !== "right") {
axisPosition = axisPositionUsed.left ? "right" : "left";
}
}
axisPositionUsed[axisPosition] = true;
var axis = new Axis2D(dimName, createScaleByModel(axisModel), [0, 0], axisModel.get("type"), axisPosition);
var isCategory = axis.type === "category";
axis.onBand = isCategory && axisModel.get("boundaryGap");
axis.inverse = axisModel.get("inverse");
axisModel.axis = axis;
axis.model = axisModel;
axis.grid = grid;
axis.index = idx;
grid._axesList.push(axis);
axesMap[dimName][idx] = axis;
axesCount[dimName]++;
};
}
};
Grid2.prototype._updateScale = function(ecModel, gridModel) {
each(this._axesList, function(axis) {
axis.scale.setExtent(Infinity, -Infinity);
if (axis.type === "category") {
var categorySortInfo = axis.model.get("categorySortInfo");
axis.scale.setSortInfo(categorySortInfo);
}
});
ecModel.eachSeries(function(seriesModel) {
if (isCartesian2DSeries(seriesModel)) {
var axesModelMap = findAxisModels(seriesModel);
var xAxisModel = axesModelMap.xAxisModel;
var yAxisModel = axesModelMap.yAxisModel;
if (!isAxisUsedInTheGrid(xAxisModel, gridModel) || !isAxisUsedInTheGrid(yAxisModel, gridModel)) {
return;
}
var cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
var data = seriesModel.getData();
var xAxis = cartesian.getAxis("x");
var yAxis = cartesian.getAxis("y");
unionExtent(data, xAxis);
unionExtent(data, yAxis);
}
}, this);
function unionExtent(data, axis) {
each(getDataDimensionsOnAxis(data, axis.dim), function(dim) {
axis.scale.unionExtentFromData(data, dim);
});
}
};
Grid2.prototype.getTooltipAxes = function(dim) {
var baseAxes = [];
var otherAxes = [];
each(this.getCartesians(), function(cartesian) {
var baseAxis = dim != null && dim !== "auto" ? cartesian.getAxis(dim) : cartesian.getBaseAxis();
var otherAxis = cartesian.getOtherAxis(baseAxis);
indexOf(baseAxes, baseAxis) < 0 && baseAxes.push(baseAxis);
indexOf(otherAxes, otherAxis) < 0 && otherAxes.push(otherAxis);
});
return {
baseAxes,
otherAxes
};
};
Grid2.create = function(ecModel, api) {
var grids = [];
ecModel.eachComponent("grid", function(gridModel, idx) {
var grid = new Grid2(gridModel, ecModel, api);
grid.name = "grid_" + idx;
grid.resize(gridModel, api, true);
gridModel.coordinateSystem = grid;
grids.push(grid);
});
ecModel.eachSeries(function(seriesModel) {
if (!isCartesian2DSeries(seriesModel)) {
return;
}
var axesModelMap = findAxisModels(seriesModel);
var xAxisModel = axesModelMap.xAxisModel;
var yAxisModel = axesModelMap.yAxisModel;
var gridModel = xAxisModel.getCoordSysModel();
var grid = gridModel.coordinateSystem;
seriesModel.coordinateSystem = grid.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex);
});
return grids;
};
Grid2.dimensions = cartesian2DDimensions;
return Grid2;
}();
function isAxisUsedInTheGrid(axisModel, gridModel) {
return axisModel.getCoordSysModel() === gridModel;
}
function fixAxisOnZero(axesMap, otherAxisDim, axis, onZeroRecords) {
axis.getAxesOnZeroOf = function() {
return otherAxisOnZeroOf ? [otherAxisOnZeroOf] : [];
};
var otherAxes = axesMap[otherAxisDim];
var otherAxisOnZeroOf;
var axisModel = axis.model;
var onZero = axisModel.get(["axisLine", "onZero"]);
var onZeroAxisIndex = axisModel.get(["axisLine", "onZeroAxisIndex"]);
if (!onZero) {
return;
}
if (onZeroAxisIndex != null) {
if (canOnZeroToAxis(otherAxes[onZeroAxisIndex])) {
otherAxisOnZeroOf = otherAxes[onZeroAxisIndex];
}
} else {
for (var idx in otherAxes) {
if (otherAxes.hasOwnProperty(idx) && canOnZeroToAxis(otherAxes[idx]) && !onZeroRecords[getOnZeroRecordKey(otherAxes[idx])]) {
otherAxisOnZeroOf = otherAxes[idx];
break;
}
}
}
if (otherAxisOnZeroOf) {
onZeroRecords[getOnZeroRecordKey(otherAxisOnZeroOf)] = true;
}
function getOnZeroRecordKey(axis2) {
return axis2.dim + "_" + axis2.index;
}
}
function canOnZeroToAxis(axis) {
return axis && axis.type !== "category" && axis.type !== "time" && ifAxisCrossZero(axis);
}
function updateAxisTransform(axis, coordBase) {
var axisExtent = axis.getExtent();
var axisExtentSum = axisExtent[0] + axisExtent[1];
axis.toGlobalCoord = axis.dim === "x" ? function(coord) {
return coord + coordBase;
} : function(coord) {
return axisExtentSum - coord + coordBase;
};
axis.toLocalCoord = axis.dim === "x" ? function(coord) {
return coord - coordBase;
} : function(coord) {
return axisExtentSum - coord + coordBase;
};
}
var Grid$1 = Grid;
export { Grid$1 as default };