this.enable = function (controlType, opt) {
// Disable previous first
this.disable();
this._opt = zrUtil.defaults(zrUtil.clone(opt) || {}, {
zoomOnMouseWheel: true,
moveOnMouseMove: true,
// By default, wheel do not trigger move.
moveOnMouseWheel: false,
preventDefaultMouseMove: true
});
if (controlType == null) {
controlType = true;
}
if (controlType === true || (controlType === 'move' || controlType === 'pan')) {
zr.on('mousedown', mousedownHandler);
zr.on('mousemove', mousemoveHandler);
zr.on('mouseup', mouseupHandler);
}
if (controlType === true || (controlType === 'scale' || controlType === 'zoom')) {
zr.on('mousewheel', mousewheelHandler);
zr.on('pinch', pinchHandler);
}
};
function clipByPanel(controller, cover, data) {
var panel = getPanelByCover(controller, cover);
return (panel && panel !== true)
? panel.clipPath(data, controller._transform)
: zrUtil.clone(data);
}
has && zrUtil.each(keys, function (key) {
if (newOption.hasOwnProperty(key) && hasKeys(newOption[key])) {
thisOption[key] = zrUtil.clone(newOption[key]);
}
else {
delete thisOption[key];
}
});
each(this.stateList, function (state) {
var itemSize = this.itemSize;
var visuals = controller[state];
// Set inactive color for controller if no other color
// attr (like colorAlpha) specified.
if (!visuals) {
visuals = controller[state] = {
color: isCategory ? inactiveColor : [inactiveColor]
};
}
// Consistent symbol and symbolSize if not specified.
if (visuals.symbol == null) {
visuals.symbol = symbolExists
&& zrUtil.clone(symbolExists)
|| (isCategory ? 'roundRect' : ['roundRect']);
}
if (visuals.symbolSize == null) {
visuals.symbolSize = symbolSizeExists
&& zrUtil.clone(symbolSizeExists)
|| (isCategory ? itemSize[0] : [itemSize[0], itemSize[0]]);
}
// Filter square and none.
visuals.symbol = mapVisual(visuals.symbol, function (symbol) {
return (symbol === 'none' || symbol === 'square') ? 'roundRect' : symbol;
});
// Normalize symbolSize
var symbolSize = visuals.symbolSize;
if (symbolSize != null) {
var max = -Infinity;
// symbolSize can be object when categories defined.
eachVisual(symbolSize, function (value) {
value > max && (max = value);
});
visuals.symbolSize = mapVisual(symbolSize, function (value) {
return linearMap(value, [0, max], [0, itemSize[0]], true);
});
}
}, this);
mappingOption.pieceList = zrUtil.map(this._pieceList, function (piece) {
var piece = zrUtil.clone(piece);
if (state !== 'inRange') {
// FIXME
// outOfRange do not support special visual in pieces.
piece.visual = null;
}
return piece;
});
var areas = map(controller._covers, function (cover) {
var brushOption = cover.__brushOption;
var range = zrUtil.clone(brushOption.range);
return {
brushType: brushOption.brushType,
panelId: brushOption.panelId,
range: range
};
});
function updateEl(el, dataIndex, elOption, animatableModel, data, isInit) {
var targetProps = {};
var elOptionStyle = elOption.style || {};
elOption.shape && (targetProps.shape = zrUtil.clone(elOption.shape));
elOption.position && (targetProps.position = elOption.position.slice());
elOption.scale && (targetProps.scale = elOption.scale.slice());
elOption.origin && (targetProps.origin = elOption.origin.slice());
elOption.rotation && (targetProps.rotation = elOption.rotation);
if (el.type === 'image' && elOption.style) {
var targetStyle = targetProps.style = {};
zrUtil.each(['x', 'y', 'width', 'height'], function (prop) {
prepareStyleTransition(prop, targetStyle, elOptionStyle, el.style, isInit);
});
}
if (el.type === 'text' && elOption.style) {
var targetStyle = targetProps.style = {};
zrUtil.each(['x', 'y'], function (prop) {
prepareStyleTransition(prop, targetStyle, elOptionStyle, el.style, isInit);
});
// Compatible with previous: both support
// textFill and fill, textStroke and stroke in 'text' element.
!elOptionStyle.hasOwnProperty('textFill') && elOptionStyle.fill && (
elOptionStyle.textFill = elOptionStyle.fill
);
!elOptionStyle.hasOwnProperty('textStroke') && elOptionStyle.stroke && (
elOptionStyle.textStroke = elOptionStyle.stroke
);
}
if (el.type !== 'group') {
el.useStyle(elOptionStyle);
// Init animation.
if (isInit) {
el.style.opacity = 0;
var targetOpacity = elOptionStyle.opacity;
targetOpacity == null && (targetOpacity = 1);
graphicUtil.initProps(el, {style: {opacity: targetOpacity}}, animatableModel, dataIndex);
}
}
if (isInit) {
el.attr(targetProps);
}
else {
graphicUtil.updateProps(el, targetProps, animatableModel, dataIndex);
}
// z2 must not be null/undefined, otherwise sort error may occur.
el.attr({z2: elOption.z2 || 0, silent: elOption.silent});
elOption.styleEmphasis !== false && graphicUtil.setHoverStyle(el, elOption.styleEmphasis);
}
setActiveIntervals: function (intervals) {
var activeIntervals = this.activeIntervals = zrUtil.clone(intervals);
// Normalize
if (activeIntervals) {
for (var i = activeIntervals.length - 1; i >= 0; i--) {
numberUtil.asc(activeIntervals[i]);
}
}
},
each(sysDims, function (sysDimItem, sysDimIndex) {
var coordDim;
var sysDimItem;
var sysDimItemDimsDef;
var sysDimItemOtherDims;
if (isString(sysDimItem)) {
coordDim = sysDimItem;
sysDimItem = {};
}
else {
coordDim = sysDimItem.name;
var ordinalMeta = sysDimItem.ordinalMeta;
sysDimItem.ordinalMeta = null;
sysDimItem = clone(sysDimItem);
sysDimItem.ordinalMeta = ordinalMeta;
// `coordDimIndex` should not be set directly.
sysDimItemDimsDef = sysDimItem.dimsDef;
sysDimItemOtherDims = sysDimItem.otherDims;
sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex
= sysDimItem.dimsDef = sysDimItem.otherDims = null;
}
var dataDims = encodeDef.get(coordDim);
// negative resultDimIdx means no need to mapping.
if (dataDims === false) {
return;
}
var dataDims = normalizeToArray(dataDims);
// dimensions provides default dim sequences.
if (!dataDims.length) {
for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {
while (availDimIdx < result.length && result[availDimIdx].coordDim != null) {
availDimIdx++;
}
availDimIdx < result.length && dataDims.push(availDimIdx++);
}
}
// Apply templates.
each(dataDims, function (resultDimIdx, coordDimIndex) {
var resultItem = result[resultDimIdx];
applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);
if (resultItem.name == null && sysDimItemDimsDef) {
var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];
!isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {name: sysDimItemDimsDefItem});
resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name;
resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;
}
// FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}
sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);
});
});
function updateCoverByMouse(controller, e, localCursorPoint, isEnd) {
var creatingCover = controller._creatingCover;
var panel = controller._creatingPanel;
var thisBrushOption = controller._brushOption;
var eventParams;
controller._track.push(localCursorPoint.slice());
if (shouldShowCover(controller) || creatingCover) {
if (panel && !creatingCover) {
thisBrushOption.brushMode === 'single' && clearCovers(controller);
var brushOption = zrUtil.clone(thisBrushOption);
brushOption.brushType = determineBrushType(brushOption.brushType, panel);
brushOption.panelId = panel === true ? null : panel.panelId;
creatingCover = controller._creatingCover = createCover(controller, brushOption);
controller._covers.push(creatingCover);
}
if (creatingCover) {
var coverRenderer = coverRenderers[determineBrushType(controller._brushType, panel)];
var coverBrushOption = creatingCover.__brushOption;
coverBrushOption.range = coverRenderer.getCreatingRange(
clipByPanel(controller, creatingCover, controller._track)
);
if (isEnd) {
endCreating(controller, creatingCover);
coverRenderer.updateCommon(controller, creatingCover);
}
updateCoverShape(controller, creatingCover);
eventParams = {isEnd: isEnd};
}
}
else if (
isEnd
&& thisBrushOption.brushMode === 'single'
&& thisBrushOption.removeOnClick
) {
// Help user to remove covers easily, only by a tiny drag, in 'single' mode.
// But a single click do not clear covers, because user may have casual
// clicks (for example, click on other component and do not expect covers
// disappear).
// Only some cover removed, trigger action, but not every click trigger action.
if (getPanelByPoint(controller, e, localCursorPoint) && clearCovers(controller)) {
eventParams = {isEnd: isEnd, removeOnClick: true};
}
}
return eventParams;
}
symbolGroup.eachChild(function (symbolPath) {
symbolPath.setStyle(itemStyle);
symbolPath.hoverStyle = zrUtil.clone(itemHoverStyle);
graphic.setLabelStyle(symbolPath.style, symbolPath.hoverStyle, labelModel, labelHoverModel, {
labelFetcher: data.hostModel,
labelDataIndex: idx,
labelDimIndex: symbolPath.__dimIdx,
defaultText: data.get(data.dimensions[symbolPath.__dimIdx], idx),
autoColor: color,
isRectText: true
});
});
var indicatorModels = zrUtil.map(this.get('indicator') || [], function (indicatorOpt) {
// PENDING
if (indicatorOpt.max != null && indicatorOpt.max > 0 && !indicatorOpt.min) {
indicatorOpt.min = 0;
}
else if (indicatorOpt.min != null && indicatorOpt.min < 0 && !indicatorOpt.max) {
indicatorOpt.max = 0;
}
var iNameTextStyle = nameTextStyle;
if(indicatorOpt.color != null) {
iNameTextStyle = zrUtil.defaults({color: indicatorOpt.color}, nameTextStyle);
}
// Use same configuration
indicatorOpt = zrUtil.merge(zrUtil.clone(indicatorOpt), {
boundaryGap: boundaryGap,
splitNumber: splitNumber,
scale: scale,
axisLine: axisLine,
axisTick: axisTick,
axisLabel: axisLabel,
// Competitable with 2 and use text
name: indicatorOpt.text,
nameLocation: 'end',
nameGap: nameGap,
// min: 0,
nameTextStyle: iNameTextStyle,
triggerEvent: triggerEvent
}, false);
if (!showName) {
indicatorOpt.name = '';
}
if (typeof nameFormatter === 'string') {
var indName = indicatorOpt.name;
indicatorOpt.name = nameFormatter.replace('{value}', indName != null ? indName : '');
}
else if (typeof nameFormatter === 'function') {
indicatorOpt.name = nameFormatter(
indicatorOpt.name, indicatorOpt
);
}
var model = zrUtil.extend(
new Model(indicatorOpt, null, this.ecModel),
axisModelCommonMixin
);
// For triggerEvent.
model.mainType = 'radar';
model.componentIndex = this.componentIndex;
return model;
}, this);
function doEnableBrush(controller, brushOption) {
var zr = controller._zr;
// Consider roam, which takes globalPan too.
if (!controller._enableGlobalPan) {
interactionMutex.take(zr, MUTEX_RESOURCE_KEY, controller._uid);
}
each(controller._handlers, function (handler, eventName) {
zr.on(eventName, handler);
});
controller._brushType = brushOption.brushType;
controller._brushOption = zrUtil.merge(zrUtil.clone(DEFAULT_BRUSH_OPT), brushOption, true);
}
this.resetVisual(function (mappingOption, state) {
if (mode === 'categories') {
mappingOption.mappingMethod = 'category';
mappingOption.categories = zrUtil.clone(categories);
}
else {
mappingOption.dataExtent = this.getExtent();
mappingOption.mappingMethod = 'piecewise';
mappingOption.pieceList = zrUtil.map(this._pieceList, function (piece) {
var piece = zrUtil.clone(piece);
if (state !== 'inRange') {
// FIXME
// outOfRange do not support special visual in pieces.
piece.visual = null;
}
return piece;
});
}
});
zrUtil.each(dataArr, function (item, index) {
var value = modelUtil.getDataItemValue(item);
var newItem;
if (zrUtil.isObject(item)) {
newItem = zrUtil.clone(item);
newItem.value = index;
} else {
newItem = index;
}
idxArr.push(newItem);
if (!zrUtil.isString(value) && (value == null || isNaN(value))) {
value = '';
}
names.push(value + '');
});
each(option[state], function (visualData, visualType) {
if (!VisualMapping.isValidType(visualType)) {
return;
}
var mappingOption = {
type: visualType,
visual: visualData
};
supplementVisualOption && supplementVisualOption(mappingOption, state);
mappings[visualType] = new VisualMapping(mappingOption);
// Prepare a alpha for opacity, for some case that opacity
// is not supported, such as rendering using gradient color.
if (visualType === 'opacity') {
mappingOption = zrUtil.clone(mappingOption);
mappingOption.type = 'colorAlpha';
mappings.__hidden.__alphaForOpacity = new VisualMapping(mappingOption);
}
});
function prepareText(normalStyle, emphasisStyle, visualColor, width, height, upperLabelRect) {
var nodeModel = thisNode.getModel();
var text = zrUtil.retrieve(
seriesModel.getFormattedLabel(
thisNode.dataIndex, 'normal', null, null, upperLabelRect ? 'upperLabel' : 'label'
),
nodeModel.get('name')
);
if (!upperLabelRect && thisLayout.isLeafRoot) {
var iconChar = seriesModel.get('drillDownIcon', true);
text = iconChar ? iconChar + ' ' + text : text;
}
var normalLabelModel = nodeModel.getModel(
upperLabelRect ? PATH_UPPERLABEL_NORMAL : PATH_LABEL_NOAMAL
);
var emphasisLabelModel = nodeModel.getModel(
upperLabelRect ? PATH_UPPERLABEL_EMPHASIS : PATH_LABEL_EMPHASIS
);
var isShow = normalLabelModel.getShallow('show');
graphic.setLabelStyle(
normalStyle, emphasisStyle, normalLabelModel, emphasisLabelModel,
{
defaultText: isShow ? text : null,
autoColor: visualColor,
isRectText: true
}
);
upperLabelRect && (normalStyle.textRect = zrUtil.clone(upperLabelRect));
normalStyle.truncate = (isShow && normalLabelModel.get('ellipsis'))
? {
outerWidth: width,
outerHeight: height,
minChar: 2
}
: null;
}
_onItemClick: function (piece) {
var visualMapModel = this.visualMapModel;
var option = visualMapModel.option;
var selected = zrUtil.clone(option.selected);
var newKey = visualMapModel.getSelectedMapKey(piece);
if (option.selectedMode === 'single') {
selected[newKey] = true;
zrUtil.each(selected, function (o, key) {
selected[key] = key === newKey;
});
} else {
selected[newKey] = !selected[newKey];
}
this.api.dispatchAction({
type: 'selectDataRange',
from: this.uid,
visualMapId: this.visualMapModel.id,
selected: selected
});
}
export function dataTransform(seriesModel, item) {
var data = seriesModel.getData();
var coordSys = seriesModel.coordinateSystem; // 1. If not specify the position with pixel directly
// 2. If `coord` is not a data array. Which uses `xAxis`,
// `yAxis` to specify the coord on each dimension
// parseFloat first because item.x and item.y can be percent string like '20%'
if (item && !hasXAndY(item) && !zrUtil.isArray(item.coord) && coordSys) {
var dims = coordSys.dimensions;
var axisInfo = getAxisInfo(item, data, coordSys, seriesModel); // Clone the option
// Transform the properties xAxis, yAxis, radiusAxis, angleAxis, geoCoord to value
item = zrUtil.clone(item);
if (item.type && markerTypeCalculator[item.type] && axisInfo.baseAxis && axisInfo.valueAxis) {
var otherCoordIndex = indexOf(dims, axisInfo.baseAxis.dim);
var targetCoordIndex = indexOf(dims, axisInfo.valueAxis.dim);
item.coord = markerTypeCalculator[item.type](data, axisInfo.baseDataDim, axisInfo.valueDataDim, otherCoordIndex, targetCoordIndex); // Force to use the value of calculated value.
item.value = item.coord[targetCoordIndex];
} else {
// FIXME Only has one of xAxis and yAxis.
var coord = [item.xAxis != null ? item.xAxis : item.radiusAxis, item.yAxis != null ? item.yAxis : item.angleAxis]; // Each coord support max, min, average
for (var i = 0; i < 2; i++) {
if (markerTypeCalculator[coord[i]]) {
coord[i] = numCalculate(data, data.mapDimension(dims[i]), coord[i]);
}
}
item.coord = coord;
}
}
return item;
}
zrUtil.each(CLONE_PROPERTIES, function (propName) {
target[propName] = zrUtil.clone(source[propName]);
});
var labels = zrUtil.map(angleAxis.getViewLabels(), function (labelItem) {
var labelItem = zrUtil.clone(labelItem);
labelItem.coord = angleAxis.dataToCoord(labelItem.tickValue);
return labelItem;
});
zrUtil.each(panelOpts, function (panelOpts) {
panels[panelOpts.panelId] = zrUtil.clone(panelOpts);
});
function (field) {
volatileOption[field] = zrUtil.clone(tooltipAxisPointerModel.get(field));
}
var markLineTransform = function (seriesModel, coordSys, mlModel, item) {
var data = seriesModel.getData();
// Special type markLine like 'min', 'max', 'average'
var mlType = item.type;
if (!zrUtil.isArray(item)
&& (
mlType === 'min' || mlType === 'max' || mlType === 'average'
// In case
// data: [{
// yAxis: 10
// }]
|| (item.xAxis != null || item.yAxis != null)
)
) {
var valueAxis;
var valueDataDim;
var value;
if (item.yAxis != null || item.xAxis != null) {
valueDataDim = item.yAxis != null ? 'y' : 'x';
valueAxis = coordSys.getAxis(valueDataDim);
value = zrUtil.retrieve(item.yAxis, item.xAxis);
}
else {
var axisInfo = markerHelper.getAxisInfo(item, data, coordSys, seriesModel);
valueDataDim = axisInfo.valueDataDim;
valueAxis = axisInfo.valueAxis;
value = markerHelper.numCalculate(data, valueDataDim, mlType);
}
var valueIndex = valueDataDim === 'x' ? 0 : 1;
var baseIndex = 1 - valueIndex;
var mlFrom = zrUtil.clone(item);
var mlTo = {};
mlFrom.type = null;
mlFrom.coord = [];
mlTo.coord = [];
mlFrom.coord[baseIndex] = -Infinity;
mlTo.coord[baseIndex] = Infinity;
var precision = mlModel.get('precision');
if (precision >= 0 && typeof value === 'number') {
value = +value.toFixed(Math.min(precision, 20));
}
mlFrom.coord[valueIndex] = mlTo.coord[valueIndex] = value;
item = [mlFrom, mlTo, { // Extra option for tooltip and label
type: mlType,
valueIndex: item.valueIndex,
// Force to use the value of calculated value.
value: value
}];
}
item = [
markerHelper.dataTransform(seriesModel, item[0]),
markerHelper.dataTransform(seriesModel, item[1]),
zrUtil.extend({}, item[2])
];
// Avoid line data type is extended by from(to) data type
item[2].type = item[2].type || '';
// Merge from option and to option into line option
zrUtil.merge(item[2], item[0]);
zrUtil.merge(item[2], item[1]);
return item;
};
each(snapshot, function (batchItem, dataZoomId) {
batch.push(zrUtil.clone(batchItem));
});
/**
* @private
* @type {boolean}
*/
this._isZoomActive;
}
DataZoom.defaultOption = {
show: true,
// Icon group
icon: {
zoom: 'M0,13.5h26.9 M13.5,26.9V0 M32.1,13.5H58V58H13.5 V32.1',
back: 'M22,1.4L9.9,13.5l12.3,12.3 M10.3,13.5H54.9v44.6 H10.3v-26'
},
// `zoom`, `back`
title: zrUtil.clone(dataZoomLang.title)
};
var proto = DataZoom.prototype;
proto.render = function (featureModel, ecModel, api, payload) {
this.model = featureModel;
this.ecModel = ecModel;
this.api = api;
updateZoomBtnStatus(featureModel, ecModel, this, payload, api);
updateBackBtnStatus(featureModel, ecModel);
};
proto.onclick = function (ecModel, api, type) {
handlers[type].call(this);
brushOptionList = zrUtil.map(brushOptionList, function (brushOption) {
return zrUtil.merge(zrUtil.clone(DEFAULT_BRUSH_OPT), brushOption, true);
});
clone: function () {
var Ctor = this.constructor;
return new Ctor(zrUtil.clone(this.option));
},
ecModel.eachComponent({mainType: 'brush'}, function (brushModel, brushIndex) {
var thisBrushSelected = {
brushId: brushModel.id,
brushIndex: brushIndex,
brushName: brushModel.name,
areas: zrUtil.clone(brushModel.areas),
selected: []
};
// Every brush component exists in event params, convenient
// for user to find by index.
brushSelected.push(thisBrushSelected);
var brushOption = brushModel.option;
var brushLink = brushOption.brushLink;
var linkedSeriesMap = [];
var selectedDataIndexForLink = [];
var rangeInfoBySeries = [];
var hasBrushExists = 0;
if (!brushIndex) { // Only the first throttle setting works.
throttleType = brushOption.throttleType;
throttleDelay = brushOption.throttleDelay;
}
// Add boundingRect and selectors to range.
var areas = zrUtil.map(brushModel.areas, function (area) {
return bindSelector(
zrUtil.defaults(
{boundingRect: boundingRectBuilders[area.brushType](area)},
area
)
);
});
var visualMappings = visualSolution.createVisualMappings(
brushModel.option, STATE_LIST, function (mappingOption) {
mappingOption.mappingMethod = 'fixed';
}
);
zrUtil.isArray(brushLink) && zrUtil.each(brushLink, function (seriesIndex) {
linkedSeriesMap[seriesIndex] = 1;
});
function linkOthers(seriesIndex) {
return brushLink === 'all' || linkedSeriesMap[seriesIndex];
}
// If no supported brush or no brush on the series,
// all visuals should be in original state.
function brushed(rangeInfoList) {
return !!rangeInfoList.length;
}
/**
* Logic for each series: (If the logic has to be modified one day, do it carefully!)
*
* ( brushed ┬ && ┬hasBrushExist ┬ && linkOthers ) => StepA: ┬record, ┬ StepB: ┬visualByRecord.
* !brushed┘ ├hasBrushExist ┤ └nothing,┘ ├visualByRecord.
* └!hasBrushExist┘ └nothing.
* ( !brushed && ┬hasBrushExist ┬ && linkOthers ) => StepA: nothing, StepB: ┬visualByRecord.
* └!hasBrushExist┘ └nothing.
* ( brushed ┬ && !linkOthers ) => StepA: nothing, StepB: ┬visualByCheck.
* !brushed┘ └nothing.
* ( !brushed && !linkOthers ) => StepA: nothing, StepB: nothing.
*/
// Step A
ecModel.eachSeries(function (seriesModel, seriesIndex) {
var rangeInfoList = rangeInfoBySeries[seriesIndex] = [];
seriesModel.subType === 'parallel'
? stepAParallel(seriesModel, seriesIndex, rangeInfoList)
: stepAOthers(seriesModel, seriesIndex, rangeInfoList);
});
function stepAParallel(seriesModel, seriesIndex) {
var coordSys = seriesModel.coordinateSystem;
hasBrushExists |= coordSys.hasAxisBrushed();
linkOthers(seriesIndex) && coordSys.eachActiveState(
seriesModel.getData(),
function (activeState, dataIndex) {
activeState === 'active' && (selectedDataIndexForLink[dataIndex] = 1);
}
);
}
function stepAOthers(seriesModel, seriesIndex, rangeInfoList) {
var selectorsByBrushType = getSelectorsByBrushType(seriesModel);
if (!selectorsByBrushType || brushModelNotControll(brushModel, seriesIndex)) {
return;
}
zrUtil.each(areas, function (area) {
selectorsByBrushType[area.brushType]
&& brushModel.brushTargetManager.controlSeries(area, seriesModel, ecModel)
&& rangeInfoList.push(area);
hasBrushExists |= brushed(rangeInfoList);
});
if (linkOthers(seriesIndex) && brushed(rangeInfoList)) {
var data = seriesModel.getData();
data.each(function (dataIndex) {
if (checkInRange(selectorsByBrushType, rangeInfoList, data, dataIndex)) {
selectedDataIndexForLink[dataIndex] = 1;
}
});
}
}
// Step B
ecModel.eachSeries(function (seriesModel, seriesIndex) {
var seriesBrushSelected = {
seriesId: seriesModel.id,
seriesIndex: seriesIndex,
seriesName: seriesModel.name,
dataIndex: []
};
// Every series exists in event params, convenient
// for user to find series by seriesIndex.
thisBrushSelected.selected.push(seriesBrushSelected);
var selectorsByBrushType = getSelectorsByBrushType(seriesModel);
var rangeInfoList = rangeInfoBySeries[seriesIndex];
var data = seriesModel.getData();
var getValueState = linkOthers(seriesIndex)
? function (dataIndex) {
return selectedDataIndexForLink[dataIndex]
? (seriesBrushSelected.dataIndex.push(data.getRawIndex(dataIndex)), 'inBrush')
: 'outOfBrush';
}
: function (dataIndex) {
return checkInRange(selectorsByBrushType, rangeInfoList, data, dataIndex)
? (seriesBrushSelected.dataIndex.push(data.getRawIndex(dataIndex)), 'inBrush')
: 'outOfBrush';
};
// If no supported brush or no brush, all visuals are in original state.
(linkOthers(seriesIndex) ? hasBrushExists : brushed(rangeInfoList))
&& visualSolution.applyVisual(
STATE_LIST, visualMappings, data, getValueState
);
});
});
setSelected: function (selected) {
this.option.selected = zrUtil.clone(selected);
},