function axisTrigger(payload, ecModel, api) {
	        var currTrigger = payload.currTrigger;
	        var point = [payload.x, payload.y];
	        var finder = payload;
	        var dispatchAction = payload.dispatchAction || zrUtil.bind(api.dispatchAction, api);
	        var coordSysAxesInfo = ecModel.getComponent('axisPointer').coordSysAxesInfo;

	        if (illegalPoint(point)) {
	            // Used in the default behavior of `connection`: use the sample seriesIndex
	            // and dataIndex. And also used in the tooltipView trigger.
	            point = findPointFromSeries({
	                seriesIndex: finder.seriesIndex,
	                // Do not use dataIndexInside from other ec instance.
	                // FIXME: auto detect it?
	                dataIndex: finder.dataIndex
	            }, ecModel).point;
	        }
	        var isIllegalPoint = illegalPoint(point);

	        // Axis and value can be specified when calling dispatchAction({type: 'updateAxisPointer'}).
	        // Notice: In this case, it is difficult to get the `point` (which is necessary to show
	        // tooltip, so if point is not given, we just use the point found by sample seriesIndex
	        // and dataIndex.
	        var inputAxesInfo = finder.axesInfo;

	        var axesInfo = coordSysAxesInfo.axesInfo;
	        var shouldHide = currTrigger === 'leave' || illegalPoint(point);
	        var outputFinder = {};

	        var showValueMap = {};
	        var dataByCoordSys = {list: [], map: {}};
	        var updaters = {
	            showPointer: curry(showPointer, showValueMap),
	            showTooltip: curry(showTooltip, dataByCoordSys)
	        };

	        // Process for triggered axes.
	        each(coordSysAxesInfo.coordSysMap, function (coordSys, coordSysKey) {
	            // If a point given, it must be contained by the coordinate system.
	            var coordSysContainsPoint = isIllegalPoint || coordSys.containPoint(point);

	            each(coordSysAxesInfo.coordSysAxesInfo[coordSysKey], function (axisInfo, key) {
	                var axis = axisInfo.axis;
	                var inputAxisInfo = findInputAxisInfo(inputAxesInfo, axisInfo);
	                // If no inputAxesInfo, no axis is restricted.
	                if (!shouldHide && coordSysContainsPoint && (!inputAxesInfo || inputAxisInfo)) {
	                    var val = inputAxisInfo && inputAxisInfo.value;
	                    if (val == null && !isIllegalPoint) {
	                        val = axis.pointToData(point);
	                    }
	                    val != null && processOnAxis(axisInfo, val, updaters, false, outputFinder);
	                }
	            });
	        });

	        // Process for linked axes.
	        var linkTriggers = {};
	        each(axesInfo, function (tarAxisInfo, tarKey) {
	            var linkGroup = tarAxisInfo.linkGroup;

	            // If axis has been triggered in the previous stage, it should not be triggered by link.
	            if (linkGroup && !showValueMap[tarKey]) {
	                each(linkGroup.axesInfo, function (srcAxisInfo, srcKey) {
	                    var srcValItem = showValueMap[srcKey];
	                    // If srcValItem exist, source axis is triggered, so link to target axis.
	                    if (srcAxisInfo !== tarAxisInfo && srcValItem) {
	                        var val = srcValItem.value;
	                        linkGroup.mapper && (val = tarAxisInfo.axis.scale.parse(linkGroup.mapper(
	                            val, makeMapperParam(srcAxisInfo), makeMapperParam(tarAxisInfo)
	                        )));
	                        linkTriggers[tarAxisInfo.key] = val;
	                    }
	                });
	            }
	        });
	        each(linkTriggers, function (val, tarKey) {
	            processOnAxis(axesInfo[tarKey], val, updaters, true, outputFinder);
	        });

	        updateModelActually(showValueMap, axesInfo, outputFinder);
	        dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction);
	        dispatchHighDownActually(axesInfo, dispatchAction, api);

	        return outputFinder;
	    }
Basic logic: check all axis, if they do not demand show/highlight,
then hide/downplay them.

@param {Object} coordSysAxesInfo
@param {Object} payload
@param {string} [payload.currTrigger] 'click' | 'mousemove' | 'leave'
@param {Array.<number>} [payload.x] x and y, which are mandatory, specify a point to
             trigger axisPointer and tooltip.
@param {Array.<number>} [payload.y] x and y, which are mandatory, specify a point to
             trigger axisPointer and tooltip.
@param {Object} [payload.seriesIndex] finder, optional, restrict target axes.
@param {Object} [payload.dataIndex] finder, restrict target axes.
@param {Object} [payload.axesInfo] finder, restrict target axes.
       [{
         axisDim: 'x'|'y'|'angle'|...,
         axisIndex: ...,
         value: ...
       }, ...]
@param {Function} [payload.dispatchAction]
@param {Object} [payload.tooltipOption]
@param {Object|Array.<number>|Function} [payload.position] Tooltip position,
       which can be specified in dispatchAction
@param {module:echarts/model/Global} ecModel
@param {module:echarts/ExtensionAPI} api
@return {Object} content of event obj for echarts.connect.