/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
import Model from '../../model/Model';
|
import GlobalModel from '../../model/Global';
|
import ExtensionAPI from '../../core/ExtensionAPI';
|
import { each, curry, clone, defaults, isArray, indexOf } from 'zrender/src/core/util';
|
import AxisPointerModel, { AxisPointerOption } from './AxisPointerModel';
|
import Axis from '../../coord/Axis';
|
import { TooltipOption } from '../tooltip/TooltipModel';
|
import SeriesModel from '../../model/Series';
|
import {
|
SeriesOption,
|
SeriesTooltipOption,
|
CommonAxisPointerOption,
|
Dictionary,
|
ComponentOption
|
} from '../../util/types';
|
import { AxisBaseModel } from '../../coord/AxisBaseModel';
|
import ComponentModel from '../../model/Component';
|
import { CoordinateSystemMaster } from '../../coord/CoordinateSystem';
|
|
interface LinkGroup {
|
mapper: AxisPointerOption['link'][number]['mapper']
|
/**
|
* { [axisKey]: AxisInfo }
|
*/
|
axesInfo: Dictionary<AxisInfo>
|
}
|
interface AxisInfo {
|
axis: Axis
|
key: string
|
coordSys: CoordinateSystemMaster
|
axisPointerModel: Model<CommonAxisPointerOption>
|
triggerTooltip: boolean
|
involveSeries: boolean
|
snap: boolean
|
useHandle: boolean
|
seriesModels: SeriesModel[]
|
|
linkGroup?: LinkGroup
|
seriesDataCount?: number
|
}
|
|
interface CollectionResult {
|
/**
|
* { [coordSysKey]: { [axisKey]: AxisInfo } }
|
*/
|
coordSysAxesInfo: Dictionary<Dictionary<AxisInfo>>
|
|
/**
|
* { [axisKey]: AxisInfo }
|
*/
|
axesInfo: Dictionary<AxisInfo>
|
/**
|
* { [coordSysKey]: { CoordinateSystemMaster } }
|
*/
|
coordSysMap: Dictionary<CoordinateSystemMaster>
|
|
seriesInvolved: boolean
|
}
|
|
// Build axisPointerModel, mergin tooltip.axisPointer model for each axis.
|
// allAxesInfo should be updated when setOption performed.
|
export function collect(ecModel: GlobalModel, api: ExtensionAPI) {
|
const result: CollectionResult = {
|
/**
|
* key: makeKey(axis.model)
|
* value: {
|
* axis,
|
* coordSys,
|
* axisPointerModel,
|
* triggerTooltip,
|
* involveSeries,
|
* snap,
|
* seriesModels,
|
* seriesDataCount
|
* }
|
*/
|
axesInfo: {},
|
seriesInvolved: false,
|
/**
|
* key: makeKey(coordSys.model)
|
* value: Object: key makeKey(axis.model), value: axisInfo
|
*/
|
coordSysAxesInfo: {},
|
coordSysMap: {}
|
};
|
|
collectAxesInfo(result, ecModel, api);
|
|
// Check seriesInvolved for performance, in case too many series in some chart.
|
result.seriesInvolved && collectSeriesInfo(result, ecModel);
|
|
return result;
|
}
|
|
function collectAxesInfo(result: CollectionResult, ecModel: GlobalModel, api: ExtensionAPI) {
|
const globalTooltipModel = ecModel.getComponent('tooltip');
|
const globalAxisPointerModel = ecModel.getComponent('axisPointer') as AxisPointerModel;
|
// links can only be set on global.
|
const linksOption = globalAxisPointerModel.get('link', true) || [];
|
const linkGroups: LinkGroup[] = [];
|
|
// Collect axes info.
|
each(api.getCoordinateSystems(), function (coordSys) {
|
// Some coordinate system do not support axes, like geo.
|
if (!coordSys.axisPointerEnabled) {
|
return;
|
}
|
|
const coordSysKey = makeKey(coordSys.model);
|
const axesInfoInCoordSys: CollectionResult['coordSysAxesInfo'][string] =
|
result.coordSysAxesInfo[coordSysKey] = {};
|
result.coordSysMap[coordSysKey] = coordSys;
|
|
// Set tooltip (like 'cross') is a convienent way to show axisPointer
|
// for user. So we enable seting tooltip on coordSys model.
|
const coordSysModel = coordSys.model as ComponentModel<ComponentOption & {
|
tooltip: TooltipOption // TODO: Same with top level tooltip?
|
}>;
|
const baseTooltipModel = coordSysModel.getModel('tooltip', globalTooltipModel);
|
|
each(coordSys.getAxes(), curry(saveTooltipAxisInfo, false, null));
|
|
// If axis tooltip used, choose tooltip axis for each coordSys.
|
// Notice this case: coordSys is `grid` but not `cartesian2D` here.
|
if (coordSys.getTooltipAxes
|
&& globalTooltipModel
|
// If tooltip.showContent is set as false, tooltip will not
|
// show but axisPointer will show as normal.
|
&& baseTooltipModel.get('show')
|
) {
|
// Compatible with previous logic. But series.tooltip.trigger: 'axis'
|
// or series.data[n].tooltip.trigger: 'axis' are not support any more.
|
const triggerAxis = baseTooltipModel.get('trigger') === 'axis';
|
const cross = baseTooltipModel.get(['axisPointer', 'type']) === 'cross';
|
const tooltipAxes = coordSys.getTooltipAxes(baseTooltipModel.get(['axisPointer', 'axis']));
|
if (triggerAxis || cross) {
|
each(tooltipAxes.baseAxes, curry(
|
saveTooltipAxisInfo, cross ? 'cross' : true, triggerAxis
|
));
|
}
|
if (cross) {
|
each(tooltipAxes.otherAxes, curry(saveTooltipAxisInfo, 'cross', false));
|
}
|
}
|
|
// fromTooltip: true | false | 'cross'
|
// triggerTooltip: true | false | null
|
function saveTooltipAxisInfo(
|
fromTooltip: boolean | 'cross',
|
triggerTooltip: boolean,
|
axis: Axis
|
) {
|
let axisPointerModel = axis.model.getModel(
|
'axisPointer', globalAxisPointerModel
|
) as Model<CommonAxisPointerOption>;
|
|
const axisPointerShow = axisPointerModel.get('show');
|
if (!axisPointerShow || (
|
axisPointerShow === 'auto'
|
&& !fromTooltip
|
&& !isHandleTrigger(axisPointerModel)
|
)) {
|
return;
|
}
|
|
if (triggerTooltip == null) {
|
triggerTooltip = axisPointerModel.get('triggerTooltip');
|
}
|
|
axisPointerModel = fromTooltip
|
? makeAxisPointerModel(
|
axis, baseTooltipModel, globalAxisPointerModel, ecModel,
|
fromTooltip, triggerTooltip
|
)
|
: axisPointerModel;
|
|
const snap = axisPointerModel.get('snap');
|
const axisKey = makeKey(axis.model);
|
const involveSeries = triggerTooltip || snap || axis.type === 'category';
|
|
// If result.axesInfo[key] exist, override it (tooltip has higher priority).
|
const axisInfo: AxisInfo = result.axesInfo[axisKey] = {
|
key: axisKey,
|
axis: axis,
|
coordSys: coordSys,
|
axisPointerModel: axisPointerModel,
|
triggerTooltip: triggerTooltip,
|
involveSeries: involveSeries,
|
snap: snap,
|
useHandle: isHandleTrigger(axisPointerModel),
|
seriesModels: [],
|
|
linkGroup: null
|
};
|
axesInfoInCoordSys[axisKey] = axisInfo;
|
result.seriesInvolved = result.seriesInvolved || involveSeries;
|
|
const groupIndex = getLinkGroupIndex(linksOption, axis);
|
if (groupIndex != null) {
|
const linkGroup: LinkGroup = linkGroups[groupIndex]
|
|| (linkGroups[groupIndex] = {axesInfo: {}} as LinkGroup);
|
linkGroup.axesInfo[axisKey] = axisInfo;
|
linkGroup.mapper = linksOption[groupIndex].mapper;
|
axisInfo.linkGroup = linkGroup;
|
}
|
}
|
});
|
}
|
|
function makeAxisPointerModel(
|
axis: Axis,
|
baseTooltipModel: Model<TooltipOption>,
|
globalAxisPointerModel: AxisPointerModel,
|
ecModel: GlobalModel,
|
fromTooltip: boolean | 'cross',
|
triggerTooltip: boolean
|
) {
|
const tooltipAxisPointerModel = baseTooltipModel.getModel('axisPointer');
|
const fields = [
|
'type', 'snap', 'lineStyle', 'shadowStyle', 'label',
|
'animation', 'animationDurationUpdate', 'animationEasingUpdate', 'z'
|
] as const;
|
const volatileOption = {} as Pick<AxisPointerOption, typeof fields[number]>;
|
|
each(fields, function (field) {
|
(volatileOption as any)[field] = clone(tooltipAxisPointerModel.get(field));
|
});
|
|
// category axis do not auto snap, otherwise some tick that do not
|
// has value can not be hovered. value/time/log axis default snap if
|
// triggered from tooltip and trigger tooltip.
|
volatileOption.snap = axis.type !== 'category' && !!triggerTooltip;
|
|
// Compatibel with previous behavior, tooltip axis do not show label by default.
|
// Only these properties can be overrided from tooltip to axisPointer.
|
if (tooltipAxisPointerModel.get('type') === 'cross') {
|
volatileOption.type = 'line';
|
}
|
const labelOption = volatileOption.label || (volatileOption.label = {});
|
// Follow the convention, do not show label when triggered by tooltip by default.
|
labelOption.show == null && (labelOption.show = false);
|
|
if (fromTooltip === 'cross') {
|
// When 'cross', both axes show labels.
|
const tooltipAxisPointerLabelShow = tooltipAxisPointerModel.get(['label', 'show']);
|
labelOption.show = tooltipAxisPointerLabelShow != null ? tooltipAxisPointerLabelShow : true;
|
// If triggerTooltip, this is a base axis, which should better not use cross style
|
// (cross style is dashed by default)
|
if (!triggerTooltip) {
|
const crossStyle = volatileOption.lineStyle = tooltipAxisPointerModel.get('crossStyle');
|
crossStyle && defaults(labelOption, crossStyle.textStyle);
|
}
|
}
|
|
return axis.model.getModel(
|
'axisPointer',
|
new Model(volatileOption, globalAxisPointerModel, ecModel)
|
);
|
}
|
|
function collectSeriesInfo(result: CollectionResult, ecModel: GlobalModel) {
|
// Prepare data for axis trigger
|
ecModel.eachSeries(function (seriesModel: SeriesModel<SeriesOption & {
|
tooltip?: SeriesTooltipOption
|
axisPointer?: CommonAxisPointerOption
|
}>) {
|
|
// Notice this case: this coordSys is `cartesian2D` but not `grid`.
|
const coordSys = seriesModel.coordinateSystem;
|
const seriesTooltipTrigger = seriesModel.get(['tooltip', 'trigger'], true);
|
const seriesTooltipShow = seriesModel.get(['tooltip', 'show'], true);
|
if (!coordSys
|
|| seriesTooltipTrigger === 'none'
|
|| seriesTooltipTrigger === false
|
|| seriesTooltipTrigger === 'item'
|
|| seriesTooltipShow === false
|
|| seriesModel.get(['axisPointer', 'show'], true) === false
|
) {
|
return;
|
}
|
|
each(result.coordSysAxesInfo[makeKey(coordSys.model)], function (axisInfo) {
|
const axis = axisInfo.axis;
|
if (coordSys.getAxis(axis.dim) === axis) {
|
axisInfo.seriesModels.push(seriesModel);
|
axisInfo.seriesDataCount == null && (axisInfo.seriesDataCount = 0);
|
axisInfo.seriesDataCount += seriesModel.getData().count();
|
}
|
});
|
|
});
|
}
|
|
/**
|
* For example:
|
* {
|
* axisPointer: {
|
* links: [{
|
* xAxisIndex: [2, 4],
|
* yAxisIndex: 'all'
|
* }, {
|
* xAxisId: ['a5', 'a7'],
|
* xAxisName: 'xxx'
|
* }]
|
* }
|
* }
|
*/
|
function getLinkGroupIndex(linksOption: AxisPointerOption['link'], axis: Axis): number {
|
const axisModel = axis.model;
|
const dim = axis.dim;
|
for (let i = 0; i < linksOption.length; i++) {
|
const linkOption = linksOption[i] || {};
|
if (checkPropInLink(linkOption[dim + 'AxisId' as 'xAxisId'], axisModel.id)
|
|| checkPropInLink(linkOption[dim + 'AxisIndex' as 'xAxisIndex'], axisModel.componentIndex)
|
|| checkPropInLink(linkOption[dim + 'AxisName' as 'xAxisName'], axisModel.name)
|
) {
|
return i;
|
}
|
}
|
}
|
|
function checkPropInLink(linkPropValue: number[] | number | string | string[] | 'all', axisPropValue: number | string) {
|
return linkPropValue === 'all'
|
|| (isArray(linkPropValue) && indexOf(linkPropValue, axisPropValue) >= 0)
|
|| linkPropValue === axisPropValue;
|
}
|
|
export function fixValue(axisModel: AxisBaseModel) {
|
const axisInfo = getAxisInfo(axisModel);
|
if (!axisInfo) {
|
return;
|
}
|
|
const axisPointerModel = axisInfo.axisPointerModel;
|
const scale = axisInfo.axis.scale;
|
const option = axisPointerModel.option;
|
const status = axisPointerModel.get('status');
|
let value = axisPointerModel.get('value');
|
|
// Parse init value for category and time axis.
|
if (value != null) {
|
value = scale.parse(value);
|
}
|
|
const useHandle = isHandleTrigger(axisPointerModel);
|
// If `handle` used, `axisPointer` will always be displayed, so value
|
// and status should be initialized.
|
if (status == null) {
|
option.status = useHandle ? 'show' : 'hide';
|
}
|
|
const extent = scale.getExtent().slice();
|
extent[0] > extent[1] && extent.reverse();
|
|
if (// Pick a value on axis when initializing.
|
value == null
|
// If both `handle` and `dataZoom` are used, value may be out of axis extent,
|
// where we should re-pick a value to keep `handle` displaying normally.
|
|| value > extent[1]
|
) {
|
// Make handle displayed on the end of the axis when init, which looks better.
|
value = extent[1];
|
}
|
if (value < extent[0]) {
|
value = extent[0];
|
}
|
|
option.value = value;
|
|
if (useHandle) {
|
option.status = axisInfo.axis.scale.isBlank() ? 'hide' : 'show';
|
}
|
}
|
|
export function getAxisInfo(axisModel: AxisBaseModel) {
|
const coordSysAxesInfo = (axisModel.ecModel.getComponent('axisPointer') as AxisPointerModel || {})
|
.coordSysAxesInfo as CollectionResult;
|
return coordSysAxesInfo && coordSysAxesInfo.axesInfo[makeKey(axisModel)];
|
}
|
|
export function getAxisPointerModel(axisModel: AxisBaseModel) {
|
const axisInfo = getAxisInfo(axisModel);
|
return axisInfo && axisInfo.axisPointerModel;
|
}
|
|
function isHandleTrigger(axisPointerModel: Model<CommonAxisPointerOption>) {
|
return !!axisPointerModel.get(['handle', 'show']);
|
}
|
|
/**
|
* @param {module:echarts/model/Model} model
|
* @return {string} unique key
|
*/
|
export function makeKey(model: ComponentModel) {
|
return model.type + '||' + model.id;
|
}
|
