| // |
| // Copyright 2014 Google Inc. All rights reserved. |
| // |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file or at |
| // https://developers.google.com/open-source/licenses/bsd |
| // |
| |
| part of charted.charts; |
| |
| /// Displays either one or two dimension axes and zero or more measure axis. |
| /// The number of measure axes displayed is zero in charts like bubble chart |
| /// which contain two dimension axes. |
| class DefaultCartesianAreaImpl implements CartesianArea { |
| /// Default identifiers used by the measure axes |
| static const MEASURE_AXIS_IDS = const <String>['_default']; |
| |
| /// Orientations used by measure axes. First, when "x" axis is the primary |
| /// and the only dimension. Second, when "y" axis is the primary and the only |
| /// dimension. |
| static const MEASURE_AXIS_ORIENTATIONS = const [ |
| const [ORIENTATION_LEFT, ORIENTATION_RIGHT], |
| const [ORIENTATION_BOTTOM, ORIENTATION_TOP] |
| ]; |
| |
| /// Orientations used by the dimension axes. First, when "x" is the |
| /// primary dimension and the last one for cases where "y" axis is primary |
| /// dimension. |
| static const DIMENSION_AXIS_ORIENTATIONS = const [ |
| const [ORIENTATION_BOTTOM, ORIENTATION_LEFT], |
| const [ORIENTATION_LEFT, ORIENTATION_BOTTOM] |
| ]; |
| |
| /// Mapping of measure axis Id to it's axis. |
| final _measureAxes = new LinkedHashMap<String, DefaultChartAxisImpl>(); |
| |
| /// Mapping of dimension column index to it's axis. |
| final _dimensionAxes = new LinkedHashMap<int, DefaultChartAxisImpl>(); |
| |
| /// Disposer for all change stream subscriptions related to data. |
| final _dataEventsDisposer = new SubscriptionsDisposer(); |
| |
| /// Disposer for all change stream subscriptions related to config. |
| final _configEventsDisposer = new SubscriptionsDisposer(); |
| |
| @override |
| final Element host; |
| |
| @override |
| final bool useTwoDimensionAxes; |
| |
| @override |
| final bool useRowColoring; |
| |
| /// Indicates whether any renderers need bands on primary dimension |
| final List<int> dimensionsUsingBands = []; |
| |
| @override |
| final ChartState state; |
| |
| @override |
| _ChartAreaLayout layout = new _ChartAreaLayout(); |
| |
| @override |
| Selection upperBehaviorPane; |
| |
| @override |
| Selection lowerBehaviorPane; |
| |
| @override |
| bool isReady = false; |
| |
| @override |
| ChartTheme theme; |
| |
| ChartData _data; |
| ChartConfig _config; |
| bool _autoUpdate = false; |
| |
| SelectionScope _scope; |
| Selection _svg; |
| Selection visualization; |
| |
| Iterable<ChartSeries> _series; |
| |
| bool _pendingLegendUpdate = false; |
| bool _pendingAxisConfigUpdate = false; |
| List<ChartBehavior> _behaviors = []; |
| Map<ChartSeries, _ChartSeriesInfo> _seriesInfoCache = {}; |
| |
| StreamController<ChartEvent> _valueMouseOverController; |
| StreamController<ChartEvent> _valueMouseOutController; |
| StreamController<ChartEvent> _valueMouseClickController; |
| StreamController<ChartArea> _chartAxesUpdatedController; |
| |
| DefaultCartesianAreaImpl( |
| this.host, |
| ChartData data, |
| ChartConfig config, |
| bool autoUpdate, |
| this.useTwoDimensionAxes, |
| this.useRowColoring, |
| this.state) |
| : _autoUpdate = autoUpdate { |
| assert(host != null); |
| assert(isNotInline(host)); |
| |
| this.data = data; |
| this.config = config; |
| theme = new QuantumChartTheme(); |
| |
| Transition.defaultEasingType = theme.transitionEasingType; |
| Transition.defaultEasingMode = theme.transitionEasingMode; |
| Transition.defaultDurationMilliseconds = |
| theme.transitionDurationMilliseconds; |
| } |
| |
| void dispose() { |
| _configEventsDisposer.dispose(); |
| _dataEventsDisposer.dispose(); |
| _config?.legend?.dispose(); |
| |
| if (_valueMouseOverController != null) { |
| _valueMouseOverController.close(); |
| _valueMouseOverController = null; |
| } |
| if (_valueMouseOutController != null) { |
| _valueMouseOutController.close(); |
| _valueMouseOutController = null; |
| } |
| if (_valueMouseClickController != null) { |
| _valueMouseClickController.close(); |
| _valueMouseClickController = null; |
| } |
| if (_chartAxesUpdatedController != null) { |
| _chartAxesUpdatedController.close(); |
| _chartAxesUpdatedController = null; |
| } |
| if (_behaviors.isNotEmpty) { |
| _behaviors.forEach((behavior) => behavior.dispose()); |
| } |
| } |
| |
| static bool isNotInline(Element e) => |
| e != null && e.getComputedStyle().display != 'inline'; |
| |
| /// Set new data for this chart. If [value] is [Observable], subscribes to |
| /// changes and updates the chart when data changes. |
| @override |
| set data(ChartData value) { |
| _data = value; |
| _dataEventsDisposer.dispose(); |
| _pendingLegendUpdate = true; |
| |
| if (autoUpdate && _data != null && _data is Observable) { |
| _dataEventsDisposer.add((_data as Observable).changes.listen((_) { |
| _pendingLegendUpdate = true; |
| draw(); |
| })); |
| } |
| } |
| |
| @override |
| ChartData get data => _data; |
| |
| /// Set new config for this chart. If [value] is [Observable], subscribes to |
| /// changes and updates the chart when series or dimensions change. |
| @override |
| set config(ChartConfig value) { |
| _config = value; |
| _configEventsDisposer.dispose(); |
| _pendingLegendUpdate = true; |
| _pendingAxisConfigUpdate = true; |
| |
| if (_config != null && _config is Observable) { |
| _configEventsDisposer.add((_config as Observable).changes.listen((_) { |
| _pendingAxisConfigUpdate = true; |
| _pendingLegendUpdate = true; |
| draw(); |
| })); |
| } |
| } |
| |
| @override |
| ChartConfig get config => _config; |
| |
| @override |
| set autoUpdate(bool value) { |
| if (_autoUpdate != value) { |
| _autoUpdate = value; |
| this.data = _data; |
| this.config = _config; |
| } |
| } |
| |
| @override |
| bool get autoUpdate => _autoUpdate; |
| |
| /// Gets measure axis from cache - creates a new instance of _ChartAxis |
| /// if one was not already created for the given [axisId]. |
| DefaultChartAxisImpl _getMeasureAxis(String axisId) { |
| _measureAxes.putIfAbsent(axisId, () { |
| var axisConf = config.getMeasureAxis(axisId), |
| axis = axisConf != null |
| ? new DefaultChartAxisImpl.withAxisConfig(this, axisConf) |
| : new DefaultChartAxisImpl(this); |
| return axis; |
| }); |
| |
| return _measureAxes[axisId]; |
| } |
| |
| /// Gets a dimension axis from cache - creates a new instance of _ChartAxis |
| /// if one was not already created for the given dimension [column]. |
| DefaultChartAxisImpl _getDimensionAxis(int column) { |
| _dimensionAxes.putIfAbsent(column, () { |
| var axisConf = config.getDimensionAxis(column); |
| var axis = axisConf != null |
| ? new DefaultChartAxisImpl.withAxisConfig(this, axisConf) |
| : new DefaultChartAxisImpl(this); |
| return axis; |
| }); |
| return _dimensionAxes[column]; |
| } |
| |
| /// All columns rendered by a series must be of the same type. |
| bool _isSeriesValid(ChartSeries s) { |
| var first = data.columns.elementAt(s.measures.first).type; |
| return s.measures.every((i) => |
| (i < data.columns.length) && data.columns.elementAt(i).type == first); |
| } |
| |
| @override |
| Iterable<Scale> get dimensionScales => |
| config.dimensions.map((int column) => _getDimensionAxis(column).scale); |
| |
| @override |
| Iterable<Scale> measureScales(ChartSeries series) { |
| var axisIds = isNullOrEmpty(series.measureAxisIds) |
| ? MEASURE_AXIS_IDS |
| : series.measureAxisIds; |
| return axisIds.map((String id) => _getMeasureAxis(id).scale); |
| } |
| |
| /// Computes the size of chart and if changed from the previous time |
| /// size was computed, sets attributes on svg element |
| Rect _computeChartSize() { |
| int width = host.clientWidth, height = host.clientHeight; |
| |
| if (config.minimumSize != null) { |
| width = max([width, config.minimumSize.width]).toInt(); |
| height = max([height, config.minimumSize.height]).toInt(); |
| } |
| |
| AbsoluteRect padding = theme.padding; |
| num paddingLeft = config.isRTL ? padding.end : padding.start; |
| Rect current = new Rect( |
| paddingLeft, |
| padding.top, |
| width - (padding.start + padding.end), |
| height - (padding.top + padding.bottom)); |
| if (layout.chartArea == null || layout.chartArea != current) { |
| _svg.attr('width', width.toString()); |
| _svg.attr('height', height.toString()); |
| layout.chartArea = current; |
| |
| var transform = 'translate(${paddingLeft},${padding.top})'; |
| visualization.first.attributes['transform'] = transform; |
| lowerBehaviorPane.first.attributes['transform'] = transform; |
| upperBehaviorPane.first.attributes['transform'] = transform; |
| } |
| return layout.chartArea; |
| } |
| |
| @override |
| draw({bool preRender: false, Future schedulePostRender}) { |
| assert(data != null && config != null); |
| assert(config.series != null && config.series.isNotEmpty); |
| |
| // One time initialization. |
| // Each [ChartArea] has it's own [SelectionScope] |
| if (_scope == null) { |
| _scope = new SelectionScope.element(host); |
| _svg = _scope.append('svg:svg')..classed('chart-canvas'); |
| if (!isNullOrEmpty(theme.filters)) { |
| var element = _svg.first, |
| defs = Namespace.createChildElement('defs', element) |
| ..append(new SvgElement.svg(theme.filters, |
| treeSanitizer: new NullTreeSanitizer())); |
| _svg.first.append(defs); |
| } |
| |
| lowerBehaviorPane = _svg.append('g')..classed('lower-render-pane'); |
| visualization = _svg.append('g')..classed('chart-render-pane'); |
| upperBehaviorPane = _svg.append('g')..classed('upper-render-pane'); |
| |
| if (_behaviors.isNotEmpty) { |
| _behaviors |
| .forEach((b) => b.init(this, upperBehaviorPane, lowerBehaviorPane)); |
| } |
| } |
| |
| // Compute chart sizes and filter out unsupported series |
| _computeChartSize(); |
| var series = config.series |
| .where((s) => _isSeriesValid(s) && s.renderer.prepare(this, s)), |
| selection = visualization |
| .selectAll('.series-group') |
| .data(series, (x) => x.hashCode), |
| axesDomainCompleter = new Completer(); |
| |
| // Wait till the axes are rendered before rendering series. |
| // In an SVG, z-index is based on the order of nodes in the DOM. |
| axesDomainCompleter.future.then((_) { |
| selection.enter.append('svg:g')..classed('series-group'); |
| String transform = |
| 'translate(${layout.renderArea.x},${layout.renderArea.y})'; |
| |
| selection.each((_s, _, Element group) { |
| ChartSeries s = _s; |
| _ChartSeriesInfo info = _seriesInfoCache[s]; |
| if (info == null) { |
| info = _seriesInfoCache[s] = new _ChartSeriesInfo(this, s); |
| } |
| info.check(); |
| group.attributes['transform'] = transform; |
| (s.renderer as CartesianRenderer) |
| ?.draw(group, schedulePostRender: schedulePostRender); |
| }); |
| |
| // A series that was rendered earlier isn't there anymore, remove it |
| selection.exit |
| ..each((_s, _, __) { |
| ChartSeries s = _s; |
| var info = _seriesInfoCache.remove(s); |
| info?.dispose(); |
| }) |
| ..remove(); |
| |
| // Notify on the stream that the chart has been updated. |
| isReady = true; |
| _chartAxesUpdatedController?.add(this); |
| }); |
| |
| // Save the list of valid series and initialize axes. |
| _series = series; |
| _updateAxisConfig(); |
| _initAxes(preRender: preRender); |
| |
| // Render the chart, now that the axes layer is already in DOM. |
| axesDomainCompleter.complete(); |
| |
| // Updates the legend if required. |
| _updateLegend(); |
| } |
| |
| String _orientRTL(String orientation) => orientation; |
| |
| /// Initialize the axes - required even if the axes are not being displayed. |
| _initAxes({bool preRender: false}) { |
| var measureAxisUsers = <String, List<ChartSeries>>{}; |
| var keysToRemove = _measureAxes.keys.toList(); |
| |
| // Create necessary measures axes. |
| // If measure axes were not configured on the series, default is used. |
| _series.forEach((ChartSeries s) { |
| var measureAxisIds = |
| isNullOrEmpty(s.measureAxisIds) ? MEASURE_AXIS_IDS : s.measureAxisIds; |
| measureAxisIds.forEach((axisId) { |
| if (keysToRemove.contains(axisId)) { |
| keysToRemove.remove(axisId); |
| } |
| _getMeasureAxis(axisId); // Creates axis if required |
| var users = measureAxisUsers[axisId]; |
| if (users == null) { |
| measureAxisUsers[axisId] = [s]; |
| } else { |
| users.add(s); |
| } |
| }); |
| }); |
| |
| for (var key in keysToRemove) { |
| _measureAxes.remove(key); |
| } |
| |
| // Now that we know a list of series using each measure axis, configure |
| // the input domain of each axis. |
| measureAxisUsers.forEach((String id, List<ChartSeries> listOfSeries) { |
| var sampleCol = listOfSeries.first.measures.first, |
| sampleColSpec = data.columns.elementAt(sampleCol), |
| axis = _getMeasureAxis(id); |
| List<num> domain; |
| |
| if (sampleColSpec.useOrdinalScale) { |
| throw new UnsupportedError( |
| 'Ordinal measure axes are not currently supported.'); |
| } else { |
| // Extent is available because [ChartRenderer.prepare] was already |
| // called (when checking for valid series in [draw]. |
| var extents = listOfSeries |
| .map((s) => (s.renderer as CartesianRenderer).extent) |
| .toList(); |
| var lowest = min(extents.map((e) => e.min as num)); |
| var highest = max(extents.map((e) => e.max as num)); |
| |
| // Use default domain if lowest and highest are the same, right now |
| // lowest is always 0 unless it is less than 0 - change to lowest when |
| // we make use of it. |
| domain = highest == lowest |
| ? (highest == 0 |
| ? [0, 1] |
| : (highest < 0 ? [highest, 0] : [0, highest])) |
| : (lowest <= 0 ? [lowest, highest] : [0, highest]); |
| } |
| axis.initAxisDomain(sampleCol, false, domain); |
| }); |
| |
| // Configure dimension axes. |
| int dimensionAxesCount = useTwoDimensionAxes ? 2 : 1; |
| config.dimensions.take(dimensionAxesCount).forEach((int column) { |
| var axis = _getDimensionAxis(column); |
| var sampleColumnSpec = data.columns.elementAt(column); |
| |
| Iterable values = data.rows |
| .map((row) => row.elementAt(column)); |
| |
| if (sampleColumnSpec.useOrdinalScale) { |
| List<String> domain = values.map((v) => v.toString()).toList(); |
| axis.initAxisDomain(column, true, domain); |
| } else { |
| var extent = new Extent.items(values.cast<num>()); |
| List<num> domain = [extent.min, extent.max]; |
| axis.initAxisDomain(column, true, domain); |
| } |
| }); |
| |
| // See if any dimensions need "band" on the axis. |
| dimensionsUsingBands.clear(); |
| List<bool> usingBands = [false, false]; |
| _series.forEach((ChartSeries s) => |
| (s.renderer as CartesianRenderer).dimensionsUsingBand.forEach((x) { |
| if (x <= 1 && !(usingBands[x])) { |
| usingBands[x] = true; |
| dimensionsUsingBands.add(config.dimensions.elementAt(x)); |
| } |
| })); |
| |
| // List of measure and dimension axes that are displayed |
| assert(isNullOrEmpty(config.displayedMeasureAxes) || |
| config.displayedMeasureAxes.length < 2); |
| var measureAxesCount = dimensionAxesCount == 1 ? 2 : 0; |
| var displayedMeasureAxes = (isNullOrEmpty(config.displayedMeasureAxes) |
| ? _measureAxes.keys.take(measureAxesCount) |
| : config.displayedMeasureAxes.take(measureAxesCount)) |
| .toList(growable: false); |
| var displayedDimensionAxes = |
| config.dimensions.take(dimensionAxesCount).toList(growable: false); |
| |
| // Compute size of the dimension axes |
| if (config.renderDimensionAxes != false) { |
| var dimensionAxisOrientations = config.isLeftAxisPrimary |
| ? DIMENSION_AXIS_ORIENTATIONS.last |
| : DIMENSION_AXIS_ORIENTATIONS.first; |
| for (int i = 0, len = displayedDimensionAxes.length; i < len; ++i) { |
| var axis = _dimensionAxes[displayedDimensionAxes[i]], |
| orientation = _orientRTL(dimensionAxisOrientations[i]); |
| axis.prepareToDraw(orientation); |
| layout._axes[orientation] = axis.size; |
| } |
| } |
| |
| // Compute size of the measure axes |
| if (displayedMeasureAxes.isNotEmpty) { |
| var measureAxisOrientations = config.isLeftAxisPrimary |
| ? MEASURE_AXIS_ORIENTATIONS.last |
| : MEASURE_AXIS_ORIENTATIONS.first; |
| displayedMeasureAxes.asMap().forEach((int index, String key) { |
| var axis = _measureAxes[key]; |
| var orientation = _orientRTL(measureAxisOrientations[index]); |
| axis.prepareToDraw(orientation); |
| layout._axes[orientation] = axis.size; |
| }); |
| } |
| |
| // Consolidate all the information that we collected into final layout |
| _computeLayout( |
| displayedMeasureAxes.isEmpty && config.renderDimensionAxes == false); |
| |
| // Domains for all axes have been taken care of and _ChartAxis ensures |
| // that the scale is initialized on visible axes. Initialize the scale on |
| // all invisible measure scales. |
| if (_measureAxes.length != displayedMeasureAxes.length) { |
| _measureAxes.keys.forEach((String axisId) { |
| if (displayedMeasureAxes.contains(axisId)) return; |
| _getMeasureAxis(axisId).initAxisScale([layout.renderArea.height, 0]); |
| }); |
| } |
| |
| // Draw the visible measure axes, if any. |
| if (displayedMeasureAxes.isNotEmpty) { |
| var axisGroups = visualization |
| .selectAll('.measure-axis-group') |
| .data(displayedMeasureAxes); |
| // Update measure axis (add/remove/update) |
| axisGroups.enter.append('svg:g'); |
| axisGroups.each((_axisId, index, group) { |
| String axisId = _axisId; |
| _getMeasureAxis(axisId).draw(group, _scope, preRender: preRender); |
| group.attributes['class'] = 'measure-axis-group measure-${index}'; |
| }); |
| axisGroups.exit.remove(); |
| } |
| |
| // Draw the dimension axes, unless asked not to. |
| if (config.renderDimensionAxes != false) { |
| var dimAxisGroups = visualization |
| .selectAll('.dimension-axis-group') |
| .data(displayedDimensionAxes); |
| // Update dimension axes (add/remove/update) |
| dimAxisGroups.enter.append('svg:g'); |
| dimAxisGroups.each((_column, index, group) { |
| int column = _column; |
| _getDimensionAxis(column).draw(group, _scope, preRender: preRender); |
| group.attributes['class'] = 'dimension-axis-group dim-${index}'; |
| }); |
| dimAxisGroups.exit.remove(); |
| } else { |
| // Initialize scale on invisible axis |
| var dimensionAxisOrientations = config.isLeftAxisPrimary |
| ? DIMENSION_AXIS_ORIENTATIONS.last |
| : DIMENSION_AXIS_ORIENTATIONS.first; |
| for (int i = 0; i < dimensionAxesCount; ++i) { |
| var column = config.dimensions.elementAt(i), |
| axis = _dimensionAxes[column], |
| orientation = dimensionAxisOrientations[i]; |
| axis.initAxisScale(orientation == ORIENTATION_LEFT |
| ? [layout.renderArea.height, 0] |
| : [0, layout.renderArea.width]); |
| } |
| } |
| } |
| |
| // Compute chart render area size and positions of all elements |
| _computeLayout(bool notRenderingAxes) { |
| if (notRenderingAxes) { |
| layout.renderArea = |
| new Rect(0, 0, layout.chartArea.height, layout.chartArea.width); |
| return; |
| } |
| |
| var top = layout.axes[ORIENTATION_TOP], |
| left = layout.axes[ORIENTATION_LEFT], |
| bottom = layout.axes[ORIENTATION_BOTTOM], |
| right = layout.axes[ORIENTATION_RIGHT]; |
| |
| var renderAreaHeight = layout.chartArea.height - |
| (top.height + layout.axes[ORIENTATION_BOTTOM].height), |
| renderAreaWidth = layout.chartArea.width - |
| (left.width + layout.axes[ORIENTATION_RIGHT].width); |
| |
| layout.renderArea = |
| new Rect(left.width, top.height, renderAreaWidth, renderAreaHeight); |
| |
| layout._axes |
| ..[ORIENTATION_TOP] = new Rect(left.width, 0, renderAreaWidth, top.height) |
| ..[ORIENTATION_RIGHT] = new Rect( |
| left.width + renderAreaWidth, top.y, right.width, renderAreaHeight) |
| ..[ORIENTATION_BOTTOM] = new Rect(left.width, |
| top.height + renderAreaHeight, renderAreaWidth, bottom.height) |
| ..[ORIENTATION_LEFT] = |
| new Rect(left.width, top.height, left.width, renderAreaHeight); |
| } |
| |
| // Updates the legend, if configuration changed since the last |
| // time the legend was updated. |
| _updateLegend() { |
| if (!_pendingLegendUpdate) return; |
| if (_config == null || _config.legend == null || _series.isEmpty) return; |
| |
| var legend = <ChartLegendItem>[]; |
| List<List<ChartSeries>> seriesByColumn = |
| new List<List<ChartSeries>>.generate( |
| data.columns.length, (_) => <ChartSeries>[]); |
| |
| _series.forEach((s) => s.measures.forEach((m) => seriesByColumn[m].add(s))); |
| |
| seriesByColumn.asMap().forEach((int i, List<ChartSeries> s) { |
| if (s.length == 0) return; |
| legend.add(new ChartLegendItem( |
| index: i, |
| label: data.columns.elementAt(i).label, |
| series: s, |
| color: theme.getColorForKey(i))); |
| }); |
| |
| _config.legend.update(legend, this); |
| _pendingLegendUpdate = false; |
| } |
| |
| // Updates the AxisConfig, if configuration chagned since the last time the |
| // AxisConfig was updated. |
| void _updateAxisConfig() { |
| if (!_pendingAxisConfigUpdate) return; |
| _series.forEach((ChartSeries s) { |
| var measureAxisIds = |
| isNullOrEmpty(s.measureAxisIds) ? MEASURE_AXIS_IDS : s.measureAxisIds; |
| measureAxisIds.forEach((axisId) { |
| var axis = _getMeasureAxis(axisId); // Creates axis if required |
| axis.config = config.getMeasureAxis(axisId); |
| }); |
| }); |
| |
| int dimensionAxesCount = useTwoDimensionAxes ? 2 : 1; |
| config.dimensions.take(dimensionAxesCount).forEach((int column) { |
| var axis = _getDimensionAxis(column); |
| axis.config = config.getDimensionAxis(column); |
| }); |
| |
| _pendingAxisConfigUpdate = false; |
| } |
| |
| @override |
| Stream<ChartEvent> get onMouseUp => |
| host.onMouseUp.map((MouseEvent e) => new DefaultChartEventImpl(e, this)); |
| |
| @override |
| Stream<ChartEvent> get onMouseDown => host.onMouseDown |
| .map((MouseEvent e) => new DefaultChartEventImpl(e, this)); |
| |
| @override |
| Stream<ChartEvent> get onMouseOver => host.onMouseOver |
| .map((MouseEvent e) => new DefaultChartEventImpl(e, this)); |
| |
| @override |
| Stream<ChartEvent> get onMouseOut => |
| host.onMouseOut.map((MouseEvent e) => new DefaultChartEventImpl(e, this)); |
| |
| @override |
| Stream<ChartEvent> get onMouseMove => host.onMouseMove |
| .map((MouseEvent e) => new DefaultChartEventImpl(e, this)); |
| |
| @override |
| Stream<ChartEvent> get onValueClick { |
| if (_valueMouseClickController == null) { |
| _valueMouseClickController = new StreamController.broadcast(sync: true); |
| } |
| return _valueMouseClickController.stream; |
| } |
| |
| @override |
| Stream<ChartEvent> get onValueMouseOver { |
| if (_valueMouseOverController == null) { |
| _valueMouseOverController = new StreamController.broadcast(sync: true); |
| } |
| return _valueMouseOverController.stream; |
| } |
| |
| @override |
| Stream<ChartEvent> get onValueMouseOut { |
| if (_valueMouseOutController == null) { |
| _valueMouseOutController = new StreamController.broadcast(sync: true); |
| } |
| return _valueMouseOutController.stream; |
| } |
| |
| @override |
| Stream<ChartArea> get onChartAxesUpdated { |
| if (_chartAxesUpdatedController == null) { |
| _chartAxesUpdatedController = new StreamController.broadcast(sync: true); |
| } |
| return _chartAxesUpdatedController.stream; |
| } |
| |
| @override |
| void addChartBehavior(ChartBehavior behavior) { |
| if (behavior == null || _behaviors.contains(behavior)) return; |
| _behaviors.add(behavior); |
| if (upperBehaviorPane != null && lowerBehaviorPane != null) { |
| behavior.init(this, upperBehaviorPane, lowerBehaviorPane); |
| } |
| } |
| |
| @override |
| void removeChartBehavior(ChartBehavior behavior) { |
| if (behavior == null || !_behaviors.contains(behavior)) return; |
| if (upperBehaviorPane != null && lowerBehaviorPane != null) { |
| behavior.dispose(); |
| } |
| _behaviors.remove(behavior); |
| } |
| } |
| |
| class _ChartAreaLayout implements ChartAreaLayout { |
| final _axes = <String, Rect>{ |
| ORIENTATION_LEFT: const Rect(), |
| ORIENTATION_RIGHT: const Rect(), |
| ORIENTATION_TOP: const Rect(), |
| ORIENTATION_BOTTOM: const Rect() |
| }; |
| |
| UnmodifiableMapView<String, Rect> _axesView; |
| |
| @override |
| get axes => _axesView; |
| |
| @override |
| Rect renderArea = const Rect(); |
| |
| @override |
| Rect chartArea = const Rect(); |
| |
| _ChartAreaLayout() { |
| _axesView = new UnmodifiableMapView(_axes); |
| } |
| } |
| |
| class _ChartSeriesInfo { |
| CartesianRenderer _renderer; |
| SubscriptionsDisposer _disposer = new SubscriptionsDisposer(); |
| |
| ChartSeries _series; |
| DefaultCartesianAreaImpl _area; |
| _ChartSeriesInfo(this._area, this._series); |
| |
| _click(ChartEvent e) { |
| var state = _area.state; |
| if (state != null) { |
| if (state.isHighlighted(e.column, e.row)) { |
| state.unhighlight(e.column, e.row); |
| } else { |
| state.highlight(e.column, e.row); |
| } |
| } |
| if (_area._valueMouseClickController != null) { |
| _area._valueMouseClickController.add(e); |
| } |
| } |
| |
| _mouseOver(ChartEvent e) { |
| var state = _area.state; |
| if (state != null) { |
| state.hovered = new Pair(e.column, e.row); |
| } |
| if (_area._valueMouseOverController != null) { |
| _area._valueMouseOverController.add(e); |
| } |
| } |
| |
| _mouseOut(ChartEvent e) { |
| var state = _area.state; |
| if (state != null) { |
| var current = state.hovered; |
| if (current != null && |
| current.first == e.column && |
| current.last == e.row) { |
| state.hovered = null; |
| } |
| } |
| if (_area._valueMouseOutController != null) { |
| _area._valueMouseOutController.add(e); |
| } |
| } |
| |
| check() { |
| if (_renderer != _series.renderer) { |
| dispose(); |
| if (_series.renderer is ChartRendererBehaviorSource) { |
| _disposer.addAll([ |
| _series.renderer.onValueClick.listen(_click), |
| _series.renderer.onValueMouseOver.listen(_mouseOver), |
| _series.renderer.onValueMouseOut.listen(_mouseOut) |
| ]); |
| } |
| } |
| _renderer = _series.renderer as CartesianRenderer; |
| } |
| |
| dispose() { |
| _renderer?.dispose(); |
| _disposer.dispose(); |
| } |
| } |
