/*
|
* 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 singleAxisHelper from '../../coord/single/singleAxisHelper';
|
import AxisView from '../axis/AxisView';
|
import SingleAxis from '../../coord/single/SingleAxis';
|
import Single from '../../coord/single/Single';
|
import { PathProps } from 'zrender/src/graphic/Path';
|
import { ScaleDataValue, VerticalAlign, CommonAxisPointerOption } from '../../util/types';
|
import ExtensionAPI from '../../core/ExtensionAPI';
|
import SingleAxisModel from '../../coord/single/AxisModel';
|
import Model from '../../model/Model';
|
|
const XY = ['x', 'y'] as const;
|
const WH = ['width', 'height'] as const;
|
|
// Not use top level axisPointer model
|
type AxisPointerModel = Model<CommonAxisPointerOption>;
|
|
class SingleAxisPointer extends BaseAxisPointer {
|
|
/**
|
* @override
|
*/
|
makeElOption(
|
elOption: AxisPointerElementOptions,
|
value: ScaleDataValue,
|
axisModel: SingleAxisModel,
|
axisPointerModel: AxisPointerModel,
|
api: ExtensionAPI
|
) {
|
const axis = axisModel.axis;
|
const coordSys = axis.coordinateSystem;
|
const otherExtent = getGlobalExtent(coordSys, 1 - getPointDimIndex(axis));
|
const pixelValue = coordSys.dataToPoint(value)[0];
|
|
const axisPointerType = axisPointerModel.get('type');
|
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 = singleAxisHelper.layout(axisModel);
|
viewHelper.buildCartesianSingleLabelElOption(
|
// @ts-ignore
|
value, elOption, layoutInfo, axisModel, axisPointerModel, api
|
);
|
}
|
|
/**
|
* @override
|
*/
|
getHandleTransform(
|
value: ScaleDataValue,
|
axisModel: SingleAxisModel,
|
axisPointerModel: AxisPointerModel
|
) {
|
const layoutInfo = singleAxisHelper.layout(axisModel, {labelInside: false});
|
// @ts-ignore
|
layoutInfo.labelMargin = axisPointerModel.get(['handle', 'margin']);
|
const position = viewHelper.getTransformedPosition(axisModel.axis, value, layoutInfo);
|
return {
|
x: position[0],
|
y: position[1],
|
rotation: layoutInfo.rotation + (layoutInfo.labelDirection < 0 ? Math.PI : 0)
|
};
|
}
|
|
/**
|
* @override
|
*/
|
updateHandleTransform(
|
transform: {
|
x: number,
|
y: number,
|
rotation: number
|
},
|
delta: number[],
|
axisModel: SingleAxisModel,
|
axisPointerModel: AxisPointerModel
|
) {
|
const axis = axisModel.axis;
|
const coordSys = axis.coordinateSystem;
|
const dimIndex = getPointDimIndex(axis);
|
const axisExtent = getGlobalExtent(coordSys, dimIndex);
|
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 otherExtent = getGlobalExtent(coordSys, 1 - dimIndex);
|
const cursorOtherValue = (otherExtent[1] + otherExtent[0]) / 2;
|
const cursorPoint = [cursorOtherValue, cursorOtherValue];
|
cursorPoint[dimIndex] = currPosition[dimIndex];
|
|
return {
|
x: currPosition[0],
|
y: currPosition[1],
|
rotation: transform.rotation,
|
cursorPoint: cursorPoint,
|
tooltipOption: {
|
verticalAlign: 'middle' as VerticalAlign
|
}
|
};
|
}
|
}
|
|
const pointerShapeBuilder = {
|
|
line: function (axis: SingleAxis, pixelValue: number, otherExtent: number[]): PathProps & {
|
type: 'Line'
|
} {
|
const targetShape = viewHelper.makeLineShape(
|
[pixelValue, otherExtent[0]],
|
[pixelValue, otherExtent[1]],
|
getPointDimIndex(axis)
|
);
|
return {
|
type: 'Line',
|
subPixelOptimize: true,
|
shape: targetShape
|
};
|
},
|
|
shadow: function (axis: SingleAxis, pixelValue: number, otherExtent: number[]): PathProps & {
|
type: 'Rect'
|
} {
|
const bandWidth = axis.getBandWidth();
|
const span = otherExtent[1] - otherExtent[0];
|
return {
|
type: 'Rect',
|
shape: viewHelper.makeRectShape(
|
[pixelValue - bandWidth / 2, otherExtent[0]],
|
[bandWidth, span],
|
getPointDimIndex(axis)
|
)
|
};
|
}
|
};
|
|
function getPointDimIndex(axis: SingleAxis): number {
|
return axis.isHorizontal() ? 0 : 1;
|
}
|
|
function getGlobalExtent(coordSys: Single, dimIndex: number) {
|
const rect = coordSys.getRect();
|
return [rect[XY[dimIndex]], rect[XY[dimIndex]] + rect[WH[dimIndex]]];
|
}
|
|
export default SingleAxisPointer;
|
