src/component/axisPointer/CartesianAxisPointer.ts - master - githubmirror/echarts

src/component/axisPointer/CartesianAxisPointer.ts
198 строк7 KB
100pah
fix&feature:
06 мар 2026, 13:17
06 мар 2026, 13:17dbfaf6a
/*
* 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 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';
import { mathMax, mathMin } from '../../util/number';
import type GlobalModel from '../../model/Global';

// 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 thisExtent = axis.getGlobalExtent();
        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,
                thisExtent,
                otherExtent,
                axisPointerModel.get('seriesDataIndices'),
                axisPointerModel.ecModel
            );
            pointerOption.style = elStyle;
            elOption.graphicKey = pointerOption.type;
            elOption.pointer = pointerOption;
        }

        const layoutInfo = cartesianAxisHelper.layout(grid.getRect(), axisModel);
        viewHelper.buildCartesianSingleLabelElOption(
            value, elOption, layoutInfo, axisModel, axisPointerModel, api
        );
    }

    /**
     * @override
     */
    getHandleTransform(
        value: ScaleDataValue,
        axisModel: CartesianAxisModel,
        axisPointerModel: AxisPointerModel
    ) {
        const layoutInfo: viewHelper.AxisTransformedPositionLayoutInfo = cartesianAxisHelper.layout(
            axisModel.axis.grid.getRect(), axisModel, {labelInside: false}
        );
        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] = mathMin(axisExtent[1], currPosition[dimIndex]);
        currPosition[dimIndex] = mathMax(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,
        thisExtent: 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,
        thisExtent: number[],
        otherExtent: number[],
        seriesDataIndices: CommonAxisPointerOption['seriesDataIndices'],
        ecModel: GlobalModel
    ): PathProps & { type: 'Rect'} {

        const bandWidth = viewHelper.calcAxisPointerShadowBandWidth(axis, seriesDataIndices, ecModel);
        const otherSpan = otherExtent[1] - otherExtent[0];
        const [min, max] = viewHelper.calcAxisPointerShadowEnds(pixelValue, thisExtent, bandWidth);
        return {
            type: 'Rect',
            shape: viewHelper.makeRectShape(
                [min, otherExtent[0]],
                [max - min, otherSpan],
                getAxisDimIndex(axis)
            )
        };
    }
};

function getAxisDimIndex(axis: Axis2D) {
    return axis.dim === 'x' ? 0 : 1;
}

export default CartesianAxisPointer;