cione-comp-lib
Version:
`$ yarn add cione-comp-lib` 或者 `$ npm i cione-comp-lib -S`
305 lines (304 loc) • 12.1 kB
JavaScript
import { createHashMap, each as each$1, clone } from "../../../../zrender/lib/core/util.mjs";
import { rotate, translate, create } from "../../../../zrender/lib/core/matrix.mjs";
import { getLayoutRect } from "../../util/layout.mjs";
import { createScaleByModel, niceScaleExtent } from "../axisHelper.mjs";
import ParallelAxis from "./ParallelAxis.mjs";
import { applyTransform } from "../../util/graphic.mjs";
import { round as round$1 } from "../../util/number.mjs";
import sliderMove from "../../component/helper/sliderMove.mjs";
var each = each$1;
var mathMin = Math.min;
var mathMax = Math.max;
var mathFloor = Math.floor;
var mathCeil = Math.ceil;
var round = round$1;
var PI = Math.PI;
var Parallel = function() {
function Parallel2(parallelModel, ecModel, api) {
this.type = "parallel";
this._axesMap = createHashMap();
this._axesLayout = {};
this.dimensions = parallelModel.dimensions;
this._model = parallelModel;
this._init(parallelModel, ecModel, api);
}
Parallel2.prototype._init = function(parallelModel, ecModel, api) {
var dimensions = parallelModel.dimensions;
var parallelAxisIndex = parallelModel.parallelAxisIndex;
each(dimensions, function(dim, idx) {
var axisIndex = parallelAxisIndex[idx];
var axisModel = ecModel.getComponent("parallelAxis", axisIndex);
var axis = this._axesMap.set(dim, new ParallelAxis(dim, createScaleByModel(axisModel), [0, 0], axisModel.get("type"), axisIndex));
var isCategory = axis.type === "category";
axis.onBand = isCategory && axisModel.get("boundaryGap");
axis.inverse = axisModel.get("inverse");
axisModel.axis = axis;
axis.model = axisModel;
axis.coordinateSystem = axisModel.coordinateSystem = this;
}, this);
};
Parallel2.prototype.update = function(ecModel, api) {
this._updateAxesFromSeries(this._model, ecModel);
};
Parallel2.prototype.containPoint = function(point) {
var layoutInfo = this._makeLayoutInfo();
var axisBase = layoutInfo.axisBase;
var layoutBase = layoutInfo.layoutBase;
var pixelDimIndex = layoutInfo.pixelDimIndex;
var pAxis = point[1 - pixelDimIndex];
var pLayout = point[pixelDimIndex];
return pAxis >= axisBase && pAxis <= axisBase + layoutInfo.axisLength && pLayout >= layoutBase && pLayout <= layoutBase + layoutInfo.layoutLength;
};
Parallel2.prototype.getModel = function() {
return this._model;
};
Parallel2.prototype._updateAxesFromSeries = function(parallelModel, ecModel) {
ecModel.eachSeries(function(seriesModel) {
if (!parallelModel.contains(seriesModel, ecModel)) {
return;
}
var data = seriesModel.getData();
each(this.dimensions, function(dim) {
var axis = this._axesMap.get(dim);
axis.scale.unionExtentFromData(data, data.mapDimension(dim));
niceScaleExtent(axis.scale, axis.model);
}, this);
}, this);
};
Parallel2.prototype.resize = function(parallelModel, api) {
this._rect = getLayoutRect(parallelModel.getBoxLayoutParams(), {
width: api.getWidth(),
height: api.getHeight()
});
this._layoutAxes();
};
Parallel2.prototype.getRect = function() {
return this._rect;
};
Parallel2.prototype._makeLayoutInfo = function() {
var parallelModel = this._model;
var rect = this._rect;
var xy = ["x", "y"];
var wh = ["width", "height"];
var layout = parallelModel.get("layout");
var pixelDimIndex = layout === "horizontal" ? 0 : 1;
var layoutLength = rect[wh[pixelDimIndex]];
var layoutExtent = [0, layoutLength];
var axisCount = this.dimensions.length;
var axisExpandWidth = restrict(parallelModel.get("axisExpandWidth"), layoutExtent);
var axisExpandCount = restrict(parallelModel.get("axisExpandCount") || 0, [0, axisCount]);
var axisExpandable = parallelModel.get("axisExpandable") && axisCount > 3 && axisCount > axisExpandCount && axisExpandCount > 1 && axisExpandWidth > 0 && layoutLength > 0;
var axisExpandWindow = parallelModel.get("axisExpandWindow");
var winSize;
if (!axisExpandWindow) {
winSize = restrict(axisExpandWidth * (axisExpandCount - 1), layoutExtent);
var axisExpandCenter = parallelModel.get("axisExpandCenter") || mathFloor(axisCount / 2);
axisExpandWindow = [axisExpandWidth * axisExpandCenter - winSize / 2];
axisExpandWindow[1] = axisExpandWindow[0] + winSize;
} else {
winSize = restrict(axisExpandWindow[1] - axisExpandWindow[0], layoutExtent);
axisExpandWindow[1] = axisExpandWindow[0] + winSize;
}
var axisCollapseWidth = (layoutLength - winSize) / (axisCount - axisExpandCount);
axisCollapseWidth < 3 && (axisCollapseWidth = 0);
var winInnerIndices = [mathFloor(round(axisExpandWindow[0] / axisExpandWidth, 1)) + 1, mathCeil(round(axisExpandWindow[1] / axisExpandWidth, 1)) - 1];
var axisExpandWindow0Pos = axisCollapseWidth / axisExpandWidth * axisExpandWindow[0];
return {
layout,
pixelDimIndex,
layoutBase: rect[xy[pixelDimIndex]],
layoutLength,
axisBase: rect[xy[1 - pixelDimIndex]],
axisLength: rect[wh[1 - pixelDimIndex]],
axisExpandable,
axisExpandWidth,
axisCollapseWidth,
axisExpandWindow,
axisCount,
winInnerIndices,
axisExpandWindow0Pos
};
};
Parallel2.prototype._layoutAxes = function() {
var rect = this._rect;
var axes = this._axesMap;
var dimensions = this.dimensions;
var layoutInfo = this._makeLayoutInfo();
var layout = layoutInfo.layout;
axes.each(function(axis) {
var axisExtent = [0, layoutInfo.axisLength];
var idx = axis.inverse ? 1 : 0;
axis.setExtent(axisExtent[idx], axisExtent[1 - idx]);
});
each(dimensions, function(dim, idx) {
var posInfo = (layoutInfo.axisExpandable ? layoutAxisWithExpand : layoutAxisWithoutExpand)(idx, layoutInfo);
var positionTable = {
horizontal: {
x: posInfo.position,
y: layoutInfo.axisLength
},
vertical: {
x: 0,
y: posInfo.position
}
};
var rotationTable = {
horizontal: PI / 2,
vertical: 0
};
var position = [positionTable[layout].x + rect.x, positionTable[layout].y + rect.y];
var rotation = rotationTable[layout];
var transform = create();
rotate(transform, transform, rotation);
translate(transform, transform, position);
this._axesLayout[dim] = {
position,
rotation,
transform,
axisNameAvailableWidth: posInfo.axisNameAvailableWidth,
axisLabelShow: posInfo.axisLabelShow,
nameTruncateMaxWidth: posInfo.nameTruncateMaxWidth,
tickDirection: 1,
labelDirection: 1
};
}, this);
};
Parallel2.prototype.getAxis = function(dim) {
return this._axesMap.get(dim);
};
Parallel2.prototype.dataToPoint = function(value, dim) {
return this.axisCoordToPoint(this._axesMap.get(dim).dataToCoord(value), dim);
};
Parallel2.prototype.eachActiveState = function(data, callback, start, end) {
start == null && (start = 0);
end == null && (end = data.count());
var axesMap = this._axesMap;
var dimensions = this.dimensions;
var dataDimensions = [];
var axisModels = [];
each$1(dimensions, function(axisDim) {
dataDimensions.push(data.mapDimension(axisDim));
axisModels.push(axesMap.get(axisDim).model);
});
var hasActiveSet = this.hasAxisBrushed();
for (var dataIndex = start; dataIndex < end; dataIndex++) {
var activeState = void 0;
if (!hasActiveSet) {
activeState = "normal";
} else {
activeState = "active";
var values = data.getValues(dataDimensions, dataIndex);
for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
var state = axisModels[j].getActiveState(values[j]);
if (state === "inactive") {
activeState = "inactive";
break;
}
}
}
callback(activeState, dataIndex);
}
};
Parallel2.prototype.hasAxisBrushed = function() {
var dimensions = this.dimensions;
var axesMap = this._axesMap;
var hasActiveSet = false;
for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
if (axesMap.get(dimensions[j]).model.getActiveState() !== "normal") {
hasActiveSet = true;
}
}
return hasActiveSet;
};
Parallel2.prototype.axisCoordToPoint = function(coord, dim) {
var axisLayout = this._axesLayout[dim];
return applyTransform([coord, 0], axisLayout.transform);
};
Parallel2.prototype.getAxisLayout = function(dim) {
return clone(this._axesLayout[dim]);
};
Parallel2.prototype.getSlidedAxisExpandWindow = function(point) {
var layoutInfo = this._makeLayoutInfo();
var pixelDimIndex = layoutInfo.pixelDimIndex;
var axisExpandWindow = layoutInfo.axisExpandWindow.slice();
var winSize = axisExpandWindow[1] - axisExpandWindow[0];
var extent = [0, layoutInfo.axisExpandWidth * (layoutInfo.axisCount - 1)];
if (!this.containPoint(point)) {
return {
behavior: "none",
axisExpandWindow
};
}
var pointCoord = point[pixelDimIndex] - layoutInfo.layoutBase - layoutInfo.axisExpandWindow0Pos;
var delta;
var behavior = "slide";
var axisCollapseWidth = layoutInfo.axisCollapseWidth;
var triggerArea = this._model.get("axisExpandSlideTriggerArea");
var useJump = triggerArea[0] != null;
if (axisCollapseWidth) {
if (useJump && axisCollapseWidth && pointCoord < winSize * triggerArea[0]) {
behavior = "jump";
delta = pointCoord - winSize * triggerArea[2];
} else if (useJump && axisCollapseWidth && pointCoord > winSize * (1 - triggerArea[0])) {
behavior = "jump";
delta = pointCoord - winSize * (1 - triggerArea[2]);
} else {
(delta = pointCoord - winSize * triggerArea[1]) >= 0 && (delta = pointCoord - winSize * (1 - triggerArea[1])) <= 0 && (delta = 0);
}
delta *= layoutInfo.axisExpandWidth / axisCollapseWidth;
delta ? sliderMove(delta, axisExpandWindow, extent, "all") : behavior = "none";
} else {
var winSize2 = axisExpandWindow[1] - axisExpandWindow[0];
var pos = extent[1] * pointCoord / winSize2;
axisExpandWindow = [mathMax(0, pos - winSize2 / 2)];
axisExpandWindow[1] = mathMin(extent[1], axisExpandWindow[0] + winSize2);
axisExpandWindow[0] = axisExpandWindow[1] - winSize2;
}
return {
axisExpandWindow,
behavior
};
};
return Parallel2;
}();
function restrict(len, extent) {
return mathMin(mathMax(len, extent[0]), extent[1]);
}
function layoutAxisWithoutExpand(axisIndex, layoutInfo) {
var step = layoutInfo.layoutLength / (layoutInfo.axisCount - 1);
return {
position: step * axisIndex,
axisNameAvailableWidth: step,
axisLabelShow: true
};
}
function layoutAxisWithExpand(axisIndex, layoutInfo) {
var layoutLength = layoutInfo.layoutLength;
var axisExpandWidth = layoutInfo.axisExpandWidth;
var axisCount = layoutInfo.axisCount;
var axisCollapseWidth = layoutInfo.axisCollapseWidth;
var winInnerIndices = layoutInfo.winInnerIndices;
var position;
var axisNameAvailableWidth = axisCollapseWidth;
var axisLabelShow = false;
var nameTruncateMaxWidth;
if (axisIndex < winInnerIndices[0]) {
position = axisIndex * axisCollapseWidth;
nameTruncateMaxWidth = axisCollapseWidth;
} else if (axisIndex <= winInnerIndices[1]) {
position = layoutInfo.axisExpandWindow0Pos + axisIndex * axisExpandWidth - layoutInfo.axisExpandWindow[0];
axisNameAvailableWidth = axisExpandWidth;
axisLabelShow = true;
} else {
position = layoutLength - (axisCount - 1 - axisIndex) * axisCollapseWidth;
nameTruncateMaxWidth = axisCollapseWidth;
}
return {
position,
axisNameAvailableWidth,
axisLabelShow,
nameTruncateMaxWidth
};
}
var Parallel$1 = Parallel;
export { Parallel$1 as default };