| /* |
| * 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 BaseAxisPointer, {AxisPointerElementOptions} from './BaseAxisPointer'; |
| import * as viewHelper from './viewHelper'; |
| import * as cartesianAxisHelper from '../../coord/cartesian/cartesianAxisHelper'; |
| import AxisView from '../axis/AxisView'; |
| import CartesianAxisModel from '../../coord/cartesian/AxisModel'; |
| import ExtensionAPI from '../../core/ExtensionAPI'; |
| import { ScaleDataValue, VerticalAlign, HorizontalAlign, CommonAxisPointerOption } from '../../util/types'; |
| import Grid from '../../coord/cartesian/Grid'; |
| import Axis2D from '../../coord/cartesian/Axis2D'; |
| import { PathProps } from 'zrender/src/graphic/Path'; |
| import Model from '../../model/Model'; |
| |
| // Not use top level axisPointer model |
| type AxisPointerModel = Model<CommonAxisPointerOption>; |
| |
| class CartesianAxisPointer extends BaseAxisPointer { |
| |
| /** |
| * @override |
| */ |
| makeElOption( |
| elOption: AxisPointerElementOptions, |
| value: ScaleDataValue, |
| axisModel: CartesianAxisModel, |
| axisPointerModel: AxisPointerModel, |
| api: ExtensionAPI |
| ) { |
| const axis = axisModel.axis; |
| const grid = axis.grid; |
| const axisPointerType = axisPointerModel.get('type'); |
| const otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent(); |
| const pixelValue = axis.toGlobalCoord(axis.dataToCoord(value, true)); |
| |
| if (axisPointerType && axisPointerType !== 'none') { |
| const elStyle = viewHelper.buildElStyle(axisPointerModel); |
| const pointerOption = pointerShapeBuilder[axisPointerType]( |
| axis, pixelValue, otherExtent |
| ); |
| pointerOption.style = elStyle; |
| elOption.graphicKey = pointerOption.type; |
| elOption.pointer = pointerOption; |
| } |
| |
| const layoutInfo = cartesianAxisHelper.layout(grid.model, axisModel); |
| viewHelper.buildCartesianSingleLabelElOption( |
| // @ts-ignore |
| value, elOption, layoutInfo, axisModel, axisPointerModel, api |
| ); |
| } |
| |
| /** |
| * @override |
| */ |
| getHandleTransform( |
| value: ScaleDataValue, |
| axisModel: CartesianAxisModel, |
| axisPointerModel: AxisPointerModel |
| ) { |
| const layoutInfo = cartesianAxisHelper.layout(axisModel.axis.grid.model, axisModel, { |
| labelInside: false |
| }); |
| // @ts-ignore |
| layoutInfo.labelMargin = axisPointerModel.get(['handle', 'margin']); |
| const pos = viewHelper.getTransformedPosition(axisModel.axis, value, layoutInfo); |
| return { |
| x: pos[0], |
| y: pos[1], |
| rotation: layoutInfo.rotation + (layoutInfo.labelDirection < 0 ? Math.PI : 0) |
| }; |
| } |
| |
| /** |
| * @override |
| */ |
| updateHandleTransform( |
| transform: { |
| x: number, y: number, |
| rotation: number |
| }, |
| delta: number[], |
| axisModel: CartesianAxisModel, |
| axisPointerModel: AxisPointerModel |
| ) { |
| const axis = axisModel.axis; |
| const grid = axis.grid; |
| const axisExtent = axis.getGlobalExtent(true); |
| const otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent(); |
| const dimIndex = axis.dim === 'x' ? 0 : 1; |
| |
| const currPosition = [transform.x, transform.y]; |
| currPosition[dimIndex] += delta[dimIndex]; |
| currPosition[dimIndex] = Math.min(axisExtent[1], currPosition[dimIndex]); |
| currPosition[dimIndex] = Math.max(axisExtent[0], currPosition[dimIndex]); |
| |
| const cursorOtherValue = (otherExtent[1] + otherExtent[0]) / 2; |
| const cursorPoint = [cursorOtherValue, cursorOtherValue]; |
| cursorPoint[dimIndex] = currPosition[dimIndex]; |
| |
| // Make tooltip do not overlap axisPointer and in the middle of the grid. |
| const tooltipOptions: { |
| verticalAlign?: VerticalAlign |
| align?: HorizontalAlign |
| }[] = [ |
| {verticalAlign: 'middle'}, |
| {align: 'center'} |
| ]; |
| |
| return { |
| x: currPosition[0], |
| y: currPosition[1], |
| rotation: transform.rotation, |
| cursorPoint: cursorPoint, |
| tooltipOption: tooltipOptions[dimIndex] |
| }; |
| } |
| } |
| |
| function getCartesian(grid: Grid, axis: Axis2D) { |
| const opt = {} as { |
| xAxisIndex?: number |
| yAxisIndex?: number |
| }; |
| opt[axis.dim + 'AxisIndex' as 'xAxisIndex' | 'yAxisIndex'] = axis.index; |
| return grid.getCartesian(opt); |
| } |
| |
| const pointerShapeBuilder = { |
| |
| line: function (axis: Axis2D, pixelValue: number, otherExtent: number[]): PathProps & { type: 'Line'} { |
| const targetShape = viewHelper.makeLineShape( |
| [pixelValue, otherExtent[0]], |
| [pixelValue, otherExtent[1]], |
| getAxisDimIndex(axis) |
| ); |
| return { |
| type: 'Line', |
| subPixelOptimize: true, |
| shape: targetShape |
| }; |
| }, |
| |
| shadow: function (axis: Axis2D, pixelValue: number, otherExtent: number[]): PathProps & { type: 'Rect'} { |
| const bandWidth = Math.max(1, axis.getBandWidth()); |
| const span = otherExtent[1] - otherExtent[0]; |
| return { |
| type: 'Rect', |
| shape: viewHelper.makeRectShape( |
| [pixelValue - bandWidth / 2, otherExtent[0]], |
| [bandWidth, span], |
| getAxisDimIndex(axis) |
| ) |
| }; |
| } |
| }; |
| |
| function getAxisDimIndex(axis: Axis2D) { |
| return axis.dim === 'x' ? 0 : 1; |
| } |
| |
| export default CartesianAxisPointer; |