|
|
|
@ -33,11 +33,10 @@ import '../scatter_plot/point_renderer.dart' show PointRenderer;
|
|
|
|
import '../scatter_plot/point_renderer_config.dart' show PointRendererConfig;
|
|
|
|
import '../scatter_plot/point_renderer_config.dart' show PointRendererConfig;
|
|
|
|
import 'line_renderer_config.dart' show LineRendererConfig;
|
|
|
|
import 'line_renderer_config.dart' show LineRendererConfig;
|
|
|
|
|
|
|
|
|
|
|
|
const styleSegmentsKey = const AttributeKey<List<_LineRendererElement>>(
|
|
|
|
const styleSegmentsKey =
|
|
|
|
'LineRenderer.styleSegments');
|
|
|
|
AttributeKey<List<_LineRendererElement>>('LineRenderer.styleSegments');
|
|
|
|
|
|
|
|
|
|
|
|
const lineStackIndexKey =
|
|
|
|
const lineStackIndexKey = AttributeKey<int>('LineRenderer.lineStackIndex');
|
|
|
|
const AttributeKey<int>('LineRenderer.lineStackIndex');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
// Configuration used to extend the clipping area to extend the draw bounds.
|
|
|
|
// Configuration used to extend the clipping area to extend the draw bounds.
|
|
|
|
@ -69,9 +68,9 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
final _currentKeys = <String>[];
|
|
|
|
final _currentKeys = <String>[];
|
|
|
|
|
|
|
|
|
|
|
|
factory LineRenderer({String rendererId, LineRendererConfig config}) {
|
|
|
|
factory LineRenderer({String rendererId, LineRendererConfig config}) {
|
|
|
|
return new LineRenderer._internal(
|
|
|
|
return LineRenderer._internal(
|
|
|
|
rendererId: rendererId ?? 'line',
|
|
|
|
rendererId: rendererId ?? 'line',
|
|
|
|
config: config ?? new LineRendererConfig());
|
|
|
|
config: config ?? LineRendererConfig());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
LineRenderer._internal({String rendererId, this.config})
|
|
|
|
LineRenderer._internal({String rendererId, this.config})
|
|
|
|
@ -79,8 +78,8 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
rendererId: rendererId,
|
|
|
|
rendererId: rendererId,
|
|
|
|
layoutPaintOrder: config.layoutPaintOrder,
|
|
|
|
layoutPaintOrder: config.layoutPaintOrder,
|
|
|
|
symbolRenderer: config.symbolRenderer) {
|
|
|
|
symbolRenderer: config.symbolRenderer) {
|
|
|
|
_pointRenderer = new PointRenderer<D>(
|
|
|
|
_pointRenderer = PointRenderer<D>(
|
|
|
|
config: new PointRendererConfig<D>(radiusPx: this.config.radiusPx));
|
|
|
|
config: PointRendererConfig<D>(radiusPx: this.config.radiusPx));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@override
|
|
|
|
@override
|
|
|
|
@ -96,13 +95,13 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
void configureSeries(List<MutableSeries<D>> seriesList) {
|
|
|
|
void configureSeries(List<MutableSeries<D>> seriesList) {
|
|
|
|
assignMissingColors(seriesList, emptyCategoryUsesSinglePalette: false);
|
|
|
|
assignMissingColors(seriesList, emptyCategoryUsesSinglePalette: false);
|
|
|
|
|
|
|
|
|
|
|
|
seriesList.forEach((MutableSeries series) {
|
|
|
|
seriesList.forEach((series) {
|
|
|
|
// Add a default area color function which applies the configured
|
|
|
|
// Add a default area color function which applies the configured
|
|
|
|
// areaOpacity value to the datum's current color.
|
|
|
|
// areaOpacity value to the datum's current color.
|
|
|
|
series.areaColorFn ??= (int index) {
|
|
|
|
series.areaColorFn ??= (index) {
|
|
|
|
final color = series.colorFn(index);
|
|
|
|
final color = series.colorFn(index);
|
|
|
|
|
|
|
|
|
|
|
|
return new Color(
|
|
|
|
return Color(
|
|
|
|
r: color.r,
|
|
|
|
r: color.r,
|
|
|
|
g: color.g,
|
|
|
|
g: color.g,
|
|
|
|
b: color.b,
|
|
|
|
b: color.b,
|
|
|
|
@ -123,7 +122,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
series.measureUpperBoundFn != null &&
|
|
|
|
series.measureUpperBoundFn != null &&
|
|
|
|
series.measureLowerBoundFn != null);
|
|
|
|
series.measureLowerBoundFn != null);
|
|
|
|
|
|
|
|
|
|
|
|
seriesList.forEach((MutableSeries<D> series) {
|
|
|
|
seriesList.forEach((series) {
|
|
|
|
final colorFn = series.colorFn;
|
|
|
|
final colorFn = series.colorFn;
|
|
|
|
final areaColorFn = series.areaColorFn;
|
|
|
|
final areaColorFn = series.areaColorFn;
|
|
|
|
final domainFn = series.domainFn;
|
|
|
|
final domainFn = series.domainFn;
|
|
|
|
@ -136,7 +135,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
final styleSegments = <_LineRendererElement<D>>[];
|
|
|
|
final styleSegments = <_LineRendererElement<D>>[];
|
|
|
|
var styleSegmentsIndex = 0;
|
|
|
|
var styleSegmentsIndex = 0;
|
|
|
|
|
|
|
|
|
|
|
|
final usedKeys = new Set<String>();
|
|
|
|
final usedKeys = Set<String>();
|
|
|
|
|
|
|
|
|
|
|
|
// Configure style segments for each series.
|
|
|
|
// Configure style segments for each series.
|
|
|
|
String previousSegmentKey;
|
|
|
|
String previousSegmentKey;
|
|
|
|
@ -163,8 +162,8 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
// Compare strokeWidthPx to 2 decimals of precision. Any less and you
|
|
|
|
// Compare strokeWidthPx to 2 decimals of precision. Any less and you
|
|
|
|
// can't see any difference in the canvas anyways.
|
|
|
|
// can't see any difference in the canvas anyways.
|
|
|
|
final strokeWidthPxRounded = (strokeWidthPx * 100).round() / 100;
|
|
|
|
final strokeWidthPxRounded = (strokeWidthPx * 100).round() / 100;
|
|
|
|
var styleKey = '${series.id}__${styleSegmentsIndex}__${color}'
|
|
|
|
var styleKey = '${series.id}__${styleSegmentsIndex}__$color'
|
|
|
|
'__${dashPattern}__${strokeWidthPxRounded}';
|
|
|
|
'__${dashPattern}__$strokeWidthPxRounded';
|
|
|
|
|
|
|
|
|
|
|
|
if (styleKey != previousSegmentKey) {
|
|
|
|
if (styleKey != previousSegmentKey) {
|
|
|
|
// If we have a repeated style segment, update the repeat index and
|
|
|
|
// If we have a repeated style segment, update the repeat index and
|
|
|
|
@ -173,8 +172,8 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
if (usedKeys.isNotEmpty && usedKeys.contains(styleKey)) {
|
|
|
|
if (usedKeys.isNotEmpty && usedKeys.contains(styleKey)) {
|
|
|
|
styleSegmentsIndex++;
|
|
|
|
styleSegmentsIndex++;
|
|
|
|
|
|
|
|
|
|
|
|
styleKey = '${series.id}__${styleSegmentsIndex}__${color}'
|
|
|
|
styleKey = '${series.id}__${styleSegmentsIndex}__$color'
|
|
|
|
'__${dashPattern}__${strokeWidthPxRounded}';
|
|
|
|
'__${dashPattern}__$strokeWidthPxRounded';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Make sure that the previous style segment extends to the current
|
|
|
|
// Make sure that the previous style segment extends to the current
|
|
|
|
@ -185,11 +184,11 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Create a new style segment.
|
|
|
|
// Create a new style segment.
|
|
|
|
currentDetails = new _LineRendererElement<D>()
|
|
|
|
currentDetails = _LineRendererElement<D>()
|
|
|
|
..color = color
|
|
|
|
..color = color
|
|
|
|
..areaColor = areaColor
|
|
|
|
..areaColor = areaColor
|
|
|
|
..dashPattern = dashPattern
|
|
|
|
..dashPattern = dashPattern
|
|
|
|
..domainExtent = new _Range<D>(domain, domain)
|
|
|
|
..domainExtent = _Range<D>(domain, domain)
|
|
|
|
..strokeWidthPx = strokeWidthPx
|
|
|
|
..strokeWidthPx = strokeWidthPx
|
|
|
|
..styleKey = styleKey
|
|
|
|
..styleKey = styleKey
|
|
|
|
..roundEndCaps = config.roundEndCaps;
|
|
|
|
..roundEndCaps = config.roundEndCaps;
|
|
|
|
@ -273,7 +272,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return (int i) => curOffsets[domainFn(i)];
|
|
|
|
return (i) => curOffsets[domainFn(i)];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Merge the line map and the new series so that the new elements are mixed
|
|
|
|
/// Merge the line map and the new series so that the new elements are mixed
|
|
|
|
@ -285,7 +284,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
void _mergeIntoSeriesMap(List<ImmutableSeries<D>> seriesList) {
|
|
|
|
void _mergeIntoSeriesMap(List<ImmutableSeries<D>> seriesList) {
|
|
|
|
List<MapEntry<String, List<_AnimatedElements<D>>>> newLineMap = [];
|
|
|
|
List<MapEntry<String, List<_AnimatedElements<D>>>> newLineMap = [];
|
|
|
|
|
|
|
|
|
|
|
|
seriesList.forEach((ImmutableSeries<D> series) {
|
|
|
|
seriesList.forEach((series) {
|
|
|
|
final key = series.id;
|
|
|
|
final key = series.id;
|
|
|
|
|
|
|
|
|
|
|
|
// First, add all the series from the old map that have been removed from
|
|
|
|
// First, add all the series from the old map that have been removed from
|
|
|
|
@ -332,7 +331,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
|
|
|
|
|
|
|
|
_mergeIntoSeriesMap(seriesList);
|
|
|
|
_mergeIntoSeriesMap(seriesList);
|
|
|
|
|
|
|
|
|
|
|
|
seriesList.forEach((ImmutableSeries<D> series) {
|
|
|
|
seriesList.forEach((series) {
|
|
|
|
final domainAxis = series.getAttr(domainAxisKey) as ImmutableAxis<D>;
|
|
|
|
final domainAxis = series.getAttr(domainAxisKey) as ImmutableAxis<D>;
|
|
|
|
final lineKey = series.id;
|
|
|
|
final lineKey = series.id;
|
|
|
|
final stackIndex = series.getAttr(lineStackIndexKey);
|
|
|
|
final stackIndex = series.getAttr(lineStackIndexKey);
|
|
|
|
@ -372,12 +371,12 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
// later to display only the relevant parts of data. This ensures that
|
|
|
|
// later to display only the relevant parts of data. This ensures that
|
|
|
|
// styles that visually depend on the start location, such as dash
|
|
|
|
// styles that visually depend on the start location, such as dash
|
|
|
|
// patterns, are not disrupted by other changes in style.
|
|
|
|
// patterns, are not disrupted by other changes in style.
|
|
|
|
styleSegments.forEach((_LineRendererElement styleSegment) {
|
|
|
|
styleSegments.forEach((styleSegment) {
|
|
|
|
final styleKey = styleSegment.styleKey;
|
|
|
|
final styleKey = styleSegment.styleKey;
|
|
|
|
|
|
|
|
|
|
|
|
// If we already have an AnimatingPoint for that index, use it.
|
|
|
|
// If we already have an AnimatingPoint for that index, use it.
|
|
|
|
var animatingElements = elementsList.firstWhere(
|
|
|
|
var animatingElements = elementsList.firstWhere(
|
|
|
|
(_AnimatedElements elements) => elements.styleKey == styleKey,
|
|
|
|
(elements) => elements.styleKey == styleKey,
|
|
|
|
orElse: () => null);
|
|
|
|
orElse: () => null);
|
|
|
|
|
|
|
|
|
|
|
|
if (animatingElements != null) {
|
|
|
|
if (animatingElements != null) {
|
|
|
|
@ -398,7 +397,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
final animatingLines = <_AnimatedLine<D>>[];
|
|
|
|
final animatingLines = <_AnimatedLine<D>>[];
|
|
|
|
|
|
|
|
|
|
|
|
for (var index = 0; index < lineElementList.length; index++) {
|
|
|
|
for (var index = 0; index < lineElementList.length; index++) {
|
|
|
|
animatingLines.add(new _AnimatedLine<D>(
|
|
|
|
animatingLines.add(_AnimatedLine<D>(
|
|
|
|
key: lineElementList[index].styleKey,
|
|
|
|
key: lineElementList[index].styleKey,
|
|
|
|
overlaySeries: series.overlaySeries)
|
|
|
|
overlaySeries: series.overlaySeries)
|
|
|
|
..setNewTarget(lineElementList[index]));
|
|
|
|
..setNewTarget(lineElementList[index]));
|
|
|
|
@ -410,7 +409,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
animatingAreas = <_AnimatedArea<D>>[];
|
|
|
|
animatingAreas = <_AnimatedArea<D>>[];
|
|
|
|
|
|
|
|
|
|
|
|
for (var index = 0; index < areaElementList.length; index++) {
|
|
|
|
for (var index = 0; index < areaElementList.length; index++) {
|
|
|
|
animatingAreas.add(new _AnimatedArea<D>(
|
|
|
|
animatingAreas.add(_AnimatedArea<D>(
|
|
|
|
key: areaElementList[index].styleKey,
|
|
|
|
key: areaElementList[index].styleKey,
|
|
|
|
overlaySeries: series.overlaySeries)
|
|
|
|
overlaySeries: series.overlaySeries)
|
|
|
|
..setNewTarget(areaElementList[index]));
|
|
|
|
..setNewTarget(areaElementList[index]));
|
|
|
|
@ -424,14 +423,14 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
animatingBounds ??= <_AnimatedArea<D>>[];
|
|
|
|
animatingBounds ??= <_AnimatedArea<D>>[];
|
|
|
|
|
|
|
|
|
|
|
|
for (var index = 0; index < boundsElementList.length; index++) {
|
|
|
|
for (var index = 0; index < boundsElementList.length; index++) {
|
|
|
|
animatingBounds.add(new _AnimatedArea<D>(
|
|
|
|
animatingBounds.add(_AnimatedArea<D>(
|
|
|
|
key: boundsElementList[index].styleKey,
|
|
|
|
key: boundsElementList[index].styleKey,
|
|
|
|
overlaySeries: series.overlaySeries)
|
|
|
|
overlaySeries: series.overlaySeries)
|
|
|
|
..setNewTarget(boundsElementList[index]));
|
|
|
|
..setNewTarget(boundsElementList[index]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
animatingElements = new _AnimatedElements<D>()
|
|
|
|
animatingElements = _AnimatedElements<D>()
|
|
|
|
..styleKey = styleSegment.styleKey
|
|
|
|
..styleKey = styleSegment.styleKey
|
|
|
|
..allPoints = allPointList
|
|
|
|
..allPoints = allPointList
|
|
|
|
..lines = animatingLines
|
|
|
|
..lines = animatingLines
|
|
|
|
@ -458,7 +457,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
// than we did in the previous chart draw cycle.
|
|
|
|
// than we did in the previous chart draw cycle.
|
|
|
|
// TODO: Nicer animations for incoming segments.
|
|
|
|
// TODO: Nicer animations for incoming segments.
|
|
|
|
if (index >= animatingElements.lines.length) {
|
|
|
|
if (index >= animatingElements.lines.length) {
|
|
|
|
animatingElements.lines.add(new _AnimatedLine<D>(
|
|
|
|
animatingElements.lines.add(_AnimatedLine<D>(
|
|
|
|
key: lineElement.styleKey,
|
|
|
|
key: lineElement.styleKey,
|
|
|
|
overlaySeries: series.overlaySeries));
|
|
|
|
overlaySeries: series.overlaySeries));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -473,7 +472,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
// cycle than we did in the previous chart draw cycle.
|
|
|
|
// cycle than we did in the previous chart draw cycle.
|
|
|
|
// TODO: Nicer animations for incoming segments.
|
|
|
|
// TODO: Nicer animations for incoming segments.
|
|
|
|
if (index >= animatingElements.areas.length) {
|
|
|
|
if (index >= animatingElements.areas.length) {
|
|
|
|
animatingElements.areas.add(new _AnimatedArea<D>(
|
|
|
|
animatingElements.areas.add(_AnimatedArea<D>(
|
|
|
|
key: areaElement.styleKey,
|
|
|
|
key: areaElement.styleKey,
|
|
|
|
overlaySeries: series.overlaySeries));
|
|
|
|
overlaySeries: series.overlaySeries));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -489,7 +488,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
// cycle than we did in the previous chart draw cycle.
|
|
|
|
// cycle than we did in the previous chart draw cycle.
|
|
|
|
// TODO: Nicer animations for incoming segments.
|
|
|
|
// TODO: Nicer animations for incoming segments.
|
|
|
|
if (index >= animatingElements.bounds.length) {
|
|
|
|
if (index >= animatingElements.bounds.length) {
|
|
|
|
animatingElements.bounds.add(new _AnimatedArea<D>(
|
|
|
|
animatingElements.bounds.add(_AnimatedArea<D>(
|
|
|
|
key: boundElement.styleKey,
|
|
|
|
key: boundElement.styleKey,
|
|
|
|
overlaySeries: series.overlaySeries));
|
|
|
|
overlaySeries: series.overlaySeries));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -506,7 +505,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
// Animate out lines that don't exist anymore.
|
|
|
|
// Animate out lines that don't exist anymore.
|
|
|
|
_seriesLineMap.forEach((String key, List<_AnimatedElements<D>> elements) {
|
|
|
|
_seriesLineMap.forEach((key, elements) {
|
|
|
|
for (var element in elements) {
|
|
|
|
for (var element in elements) {
|
|
|
|
if (element.lines != null) {
|
|
|
|
if (element.lines != null) {
|
|
|
|
for (var line in element.lines) {
|
|
|
|
for (var line in element.lines) {
|
|
|
|
@ -599,10 +598,10 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
final linePointList = lineSegments[index];
|
|
|
|
final linePointList = lineSegments[index];
|
|
|
|
|
|
|
|
|
|
|
|
// Update the set of areas that still exist in the series data.
|
|
|
|
// Update the set of areas that still exist in the series data.
|
|
|
|
final lineStyleKey = '${styleKey}__line__${index}';
|
|
|
|
final lineStyleKey = '${styleKey}__line__$index';
|
|
|
|
_currentKeys.add(lineStyleKey);
|
|
|
|
_currentKeys.add(lineStyleKey);
|
|
|
|
|
|
|
|
|
|
|
|
lineElements.add(new _LineRendererElement<D>()
|
|
|
|
lineElements.add(_LineRendererElement<D>()
|
|
|
|
..points = linePointList
|
|
|
|
..points = linePointList
|
|
|
|
..color = color
|
|
|
|
..color = color
|
|
|
|
..areaColor = areaColor
|
|
|
|
..areaColor = areaColor
|
|
|
|
@ -622,10 +621,10 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
final areaPointList = areaSegments[index];
|
|
|
|
final areaPointList = areaSegments[index];
|
|
|
|
|
|
|
|
|
|
|
|
// Update the set of areas that still exist in the series data.
|
|
|
|
// Update the set of areas that still exist in the series data.
|
|
|
|
final areaStyleKey = '${styleKey}__area_${index}';
|
|
|
|
final areaStyleKey = '${styleKey}__area_$index';
|
|
|
|
_currentKeys.add(areaStyleKey);
|
|
|
|
_currentKeys.add(areaStyleKey);
|
|
|
|
|
|
|
|
|
|
|
|
areaElements.add(new _AreaRendererElement<D>()
|
|
|
|
areaElements.add(_AreaRendererElement<D>()
|
|
|
|
..points = areaPointList
|
|
|
|
..points = areaPointList
|
|
|
|
..color = color
|
|
|
|
..color = color
|
|
|
|
..areaColor = areaColor
|
|
|
|
..areaColor = areaColor
|
|
|
|
@ -643,10 +642,10 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
for (var index = 0; index < boundsSegment.length; index++) {
|
|
|
|
for (var index = 0; index < boundsSegment.length; index++) {
|
|
|
|
final boundsPointList = boundsSegment[index];
|
|
|
|
final boundsPointList = boundsSegment[index];
|
|
|
|
|
|
|
|
|
|
|
|
final boundsStyleKey = '${styleKey}__bounds_${index}';
|
|
|
|
final boundsStyleKey = '${styleKey}__bounds_$index';
|
|
|
|
_currentKeys.add(boundsStyleKey);
|
|
|
|
_currentKeys.add(boundsStyleKey);
|
|
|
|
|
|
|
|
|
|
|
|
boundsElements.add(new _AreaRendererElement<D>()
|
|
|
|
boundsElements.add(_AreaRendererElement<D>()
|
|
|
|
..points = boundsPointList
|
|
|
|
..points = boundsPointList
|
|
|
|
..color = color
|
|
|
|
..color = color
|
|
|
|
..areaColor = areaColor
|
|
|
|
..areaColor = areaColor
|
|
|
|
@ -858,7 +857,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
final areaPointList = <_DatumPoint<D>>[];
|
|
|
|
final areaPointList = <_DatumPoint<D>>[];
|
|
|
|
|
|
|
|
|
|
|
|
// Add all points for upper bounds.
|
|
|
|
// Add all points for upper bounds.
|
|
|
|
areaPointList.addAll(pointList.map((datumPoint) => new _DatumPoint.from(
|
|
|
|
areaPointList.addAll(pointList.map((datumPoint) => _DatumPoint.from(
|
|
|
|
datumPoint,
|
|
|
|
datumPoint,
|
|
|
|
datumPoint.x,
|
|
|
|
datumPoint.x,
|
|
|
|
initializeFromZero
|
|
|
|
initializeFromZero
|
|
|
|
@ -869,7 +868,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
|
|
|
|
|
|
|
|
// Add all points for lower bounds, in reverse order.
|
|
|
|
// Add all points for lower bounds, in reverse order.
|
|
|
|
areaPointList.addAll(pointList.reversed.map((datumPoint) =>
|
|
|
|
areaPointList.addAll(pointList.reversed.map((datumPoint) =>
|
|
|
|
new _DatumPoint.from(
|
|
|
|
_DatumPoint.from(
|
|
|
|
datumPoint,
|
|
|
|
datumPoint,
|
|
|
|
datumPoint.x,
|
|
|
|
datumPoint.x,
|
|
|
|
initializeFromZero
|
|
|
|
initializeFromZero
|
|
|
|
@ -902,7 +901,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
final endPosition = domainAxis.getLocation(details.domainExtent.end) ??
|
|
|
|
final endPosition = domainAxis.getLocation(details.domainExtent.end) ??
|
|
|
|
drawBounds.right.toDouble();
|
|
|
|
drawBounds.right.toDouble();
|
|
|
|
|
|
|
|
|
|
|
|
return new _Range<num>(startPosition, endPosition);
|
|
|
|
return _Range<num>(startPosition, endPosition);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@override
|
|
|
|
@override
|
|
|
|
@ -919,9 +918,8 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
if (animationPercent == 1.0) {
|
|
|
|
if (animationPercent == 1.0) {
|
|
|
|
final keysToRemove = <String>[];
|
|
|
|
final keysToRemove = <String>[];
|
|
|
|
|
|
|
|
|
|
|
|
_seriesLineMap.forEach((String key, List<_AnimatedElements<D>> elements) {
|
|
|
|
_seriesLineMap.forEach((key, elements) {
|
|
|
|
elements.removeWhere(
|
|
|
|
elements.removeWhere((element) => element.animatingOut);
|
|
|
|
(_AnimatedElements<D> element) => element.animatingOut);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (elements.isEmpty) {
|
|
|
|
if (elements.isEmpty) {
|
|
|
|
keysToRemove.add(key);
|
|
|
|
keysToRemove.add(key);
|
|
|
|
@ -931,16 +929,15 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
keysToRemove.forEach(_seriesLineMap.remove);
|
|
|
|
keysToRemove.forEach(_seriesLineMap.remove);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
_seriesLineMap.forEach((String key, List<_AnimatedElements<D>> elements) {
|
|
|
|
_seriesLineMap.forEach((key, elements) {
|
|
|
|
if (config.includeArea) {
|
|
|
|
if (config.includeArea) {
|
|
|
|
elements
|
|
|
|
elements
|
|
|
|
.map<List<_AnimatedArea<D>>>(
|
|
|
|
.map<List<_AnimatedArea<D>>>(
|
|
|
|
(_AnimatedElements<D> animatingElement) =>
|
|
|
|
(animatingElement) => animatingElement.areas)
|
|
|
|
animatingElement.areas)
|
|
|
|
.expand<_AnimatedArea<D>>((areas) => areas)
|
|
|
|
.expand<_AnimatedArea<D>>((List<_AnimatedArea<D>> areas) => areas)
|
|
|
|
.map<_AreaRendererElement<D>>((animatingArea) =>
|
|
|
|
.map<_AreaRendererElement<D>>((_AnimatedArea<D> animatingArea) =>
|
|
|
|
|
|
|
|
animatingArea?.getCurrentArea(animationPercent))
|
|
|
|
animatingArea?.getCurrentArea(animationPercent))
|
|
|
|
.forEach((_AreaRendererElement area) {
|
|
|
|
.forEach((area) {
|
|
|
|
if (area != null) {
|
|
|
|
if (area != null) {
|
|
|
|
canvas.drawPolygon(
|
|
|
|
canvas.drawPolygon(
|
|
|
|
clipBounds: _getClipBoundsForExtent(area.positionExtent),
|
|
|
|
clipBounds: _getClipBoundsForExtent(area.positionExtent),
|
|
|
|
@ -953,12 +950,11 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
if (_hasMeasureBounds) {
|
|
|
|
if (_hasMeasureBounds) {
|
|
|
|
elements
|
|
|
|
elements
|
|
|
|
.map<List<_AnimatedArea<D>>>(
|
|
|
|
.map<List<_AnimatedArea<D>>>(
|
|
|
|
(_AnimatedElements<D> animatingElement) =>
|
|
|
|
(animatingElement) => animatingElement.bounds)
|
|
|
|
animatingElement.bounds)
|
|
|
|
.expand<_AnimatedArea<D>>((bounds) => bounds)
|
|
|
|
.expand<_AnimatedArea<D>>((List<_AnimatedArea<D>> bounds) => bounds)
|
|
|
|
.map<_AreaRendererElement<D>>((animatingBounds) =>
|
|
|
|
.map<_AreaRendererElement<D>>((_AnimatedArea<D> animatingBounds) =>
|
|
|
|
|
|
|
|
animatingBounds?.getCurrentArea(animationPercent))
|
|
|
|
animatingBounds?.getCurrentArea(animationPercent))
|
|
|
|
.forEach((_AreaRendererElement bound) {
|
|
|
|
.forEach((bound) {
|
|
|
|
if (bound != null) {
|
|
|
|
if (bound != null) {
|
|
|
|
canvas.drawPolygon(
|
|
|
|
canvas.drawPolygon(
|
|
|
|
clipBounds: _getClipBoundsForExtent(bound.positionExtent),
|
|
|
|
clipBounds: _getClipBoundsForExtent(bound.positionExtent),
|
|
|
|
@ -971,12 +967,11 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
if (config.includeLine) {
|
|
|
|
if (config.includeLine) {
|
|
|
|
elements
|
|
|
|
elements
|
|
|
|
.map<List<_AnimatedLine<D>>>(
|
|
|
|
.map<List<_AnimatedLine<D>>>(
|
|
|
|
(_AnimatedElements<D> animatingElement) =>
|
|
|
|
(animatingElement) => animatingElement.lines)
|
|
|
|
animatingElement.lines)
|
|
|
|
.expand<_AnimatedLine<D>>((lines) => lines)
|
|
|
|
.expand<_AnimatedLine<D>>((List<_AnimatedLine<D>> lines) => lines)
|
|
|
|
.map<_LineRendererElement<D>>((animatingLine) =>
|
|
|
|
.map<_LineRendererElement<D>>((_AnimatedLine<D> animatingLine) =>
|
|
|
|
|
|
|
|
animatingLine?.getCurrentLine(animationPercent))
|
|
|
|
animatingLine?.getCurrentLine(animationPercent))
|
|
|
|
.forEach((_LineRendererElement line) {
|
|
|
|
.forEach((line) {
|
|
|
|
if (line != null) {
|
|
|
|
if (line != null) {
|
|
|
|
canvas.drawLine(
|
|
|
|
canvas.drawLine(
|
|
|
|
clipBounds: _getClipBoundsForExtent(line.positionExtent),
|
|
|
|
clipBounds: _getClipBoundsForExtent(line.positionExtent),
|
|
|
|
@ -1009,7 +1004,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
? clamp((extent.start), drawBounds.left, drawBounds.right)
|
|
|
|
? clamp((extent.start), drawBounds.left, drawBounds.right)
|
|
|
|
: clamp((extent.end), drawBounds.left, drawBounds.right);
|
|
|
|
: clamp((extent.end), drawBounds.left, drawBounds.right);
|
|
|
|
|
|
|
|
|
|
|
|
return new Rectangle<num>(
|
|
|
|
return Rectangle<num>(
|
|
|
|
left,
|
|
|
|
left,
|
|
|
|
drawBounds.top - drawBoundTopExtensionPx,
|
|
|
|
drawBounds.top - drawBoundTopExtensionPx,
|
|
|
|
right - left,
|
|
|
|
right - left,
|
|
|
|
@ -1035,7 +1030,7 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
? measureAxis.getLocation(measureValue + measureOffsetValue)
|
|
|
|
? measureAxis.getLocation(measureValue + measureOffsetValue)
|
|
|
|
: null;
|
|
|
|
: null;
|
|
|
|
|
|
|
|
|
|
|
|
return new _DatumPoint<D>(
|
|
|
|
return _DatumPoint<D>(
|
|
|
|
datum: datum,
|
|
|
|
datum: datum,
|
|
|
|
domain: domainValue,
|
|
|
|
domain: domainValue,
|
|
|
|
series: series,
|
|
|
|
series: series,
|
|
|
|
@ -1054,18 +1049,18 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
return nearest;
|
|
|
|
return nearest;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
_seriesLineMap.values.forEach((List<_AnimatedElements<D>> seriesSegments) {
|
|
|
|
_seriesLineMap.values.forEach((seriesSegments) {
|
|
|
|
_DatumPoint<D> nearestPoint;
|
|
|
|
_DatumPoint<D> nearestPoint;
|
|
|
|
double nearestDomainDistance = 10000.0;
|
|
|
|
double nearestDomainDistance = 10000.0;
|
|
|
|
double nearestMeasureDistance = 10000.0;
|
|
|
|
double nearestMeasureDistance = 10000.0;
|
|
|
|
double nearestRelativeDistance = 10000.0;
|
|
|
|
double nearestRelativeDistance = 10000.0;
|
|
|
|
|
|
|
|
|
|
|
|
seriesSegments.forEach((_AnimatedElements<D> segment) {
|
|
|
|
seriesSegments.forEach((segment) {
|
|
|
|
if (segment.overlaySeries) {
|
|
|
|
if (segment.overlaySeries) {
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
segment.allPoints.forEach((Point p) {
|
|
|
|
segment.allPoints.forEach((p) {
|
|
|
|
// Don't look at points not in the drawArea.
|
|
|
|
// Don't look at points not in the drawArea.
|
|
|
|
if (p.x < componentBounds.left || p.x > componentBounds.right) {
|
|
|
|
if (p.x < componentBounds.left || p.x > componentBounds.right) {
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
@ -1108,8 +1103,8 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
|
|
|
|
|
|
|
|
// Found a point, add it to the list.
|
|
|
|
// Found a point, add it to the list.
|
|
|
|
if (nearestPoint != null) {
|
|
|
|
if (nearestPoint != null) {
|
|
|
|
nearest.add(new DatumDetails<D>(
|
|
|
|
nearest.add(DatumDetails<D>(
|
|
|
|
chartPosition: new Point<double>(nearestPoint.x, nearestPoint.y),
|
|
|
|
chartPosition: Point<double>(nearestPoint.x, nearestPoint.y),
|
|
|
|
datum: nearestPoint.datum,
|
|
|
|
datum: nearestPoint.datum,
|
|
|
|
domain: nearestPoint.domain,
|
|
|
|
domain: nearestPoint.domain,
|
|
|
|
series: nearestPoint.series,
|
|
|
|
series: nearestPoint.series,
|
|
|
|
@ -1134,9 +1129,9 @@ class LineRenderer<D> extends BaseCartesianRenderer<D> {
|
|
|
|
|
|
|
|
|
|
|
|
final point = _getPoint(seriesDatum.datum, details.domain, series,
|
|
|
|
final point = _getPoint(seriesDatum.datum, details.domain, series,
|
|
|
|
domainAxis, details.measure, details.measureOffset, measureAxis);
|
|
|
|
domainAxis, details.measure, details.measureOffset, measureAxis);
|
|
|
|
final chartPosition = new Point<double>(point.x, point.y);
|
|
|
|
final chartPosition = Point<double>(point.x, point.y);
|
|
|
|
|
|
|
|
|
|
|
|
return new DatumDetails.from(details, chartPosition: chartPosition);
|
|
|
|
return DatumDetails.from(details, chartPosition: chartPosition);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -1151,7 +1146,7 @@ class _DatumPoint<D> extends Point<double> {
|
|
|
|
: super(x, y);
|
|
|
|
: super(x, y);
|
|
|
|
|
|
|
|
|
|
|
|
factory _DatumPoint.from(_DatumPoint<D> other, [double x, double y]) {
|
|
|
|
factory _DatumPoint.from(_DatumPoint<D> other, [double x, double y]) {
|
|
|
|
return new _DatumPoint<D>(
|
|
|
|
return _DatumPoint<D>(
|
|
|
|
datum: other.datum,
|
|
|
|
datum: other.datum,
|
|
|
|
domain: other.domain,
|
|
|
|
domain: other.domain,
|
|
|
|
series: other.series,
|
|
|
|
series: other.series,
|
|
|
|
@ -1175,13 +1170,11 @@ class _LineRendererElement<D> {
|
|
|
|
bool roundEndCaps;
|
|
|
|
bool roundEndCaps;
|
|
|
|
|
|
|
|
|
|
|
|
_LineRendererElement<D> clone() {
|
|
|
|
_LineRendererElement<D> clone() {
|
|
|
|
return new _LineRendererElement<D>()
|
|
|
|
return _LineRendererElement<D>()
|
|
|
|
..points = new List<_DatumPoint<D>>.from(points)
|
|
|
|
..points = List<_DatumPoint<D>>.from(points)
|
|
|
|
..color = color != null ? new Color.fromOther(color: color) : null
|
|
|
|
..color = color != null ? Color.fromOther(color: color) : null
|
|
|
|
..areaColor =
|
|
|
|
..areaColor = areaColor != null ? Color.fromOther(color: areaColor) : null
|
|
|
|
areaColor != null ? new Color.fromOther(color: areaColor) : null
|
|
|
|
..dashPattern = dashPattern != null ? List<int>.from(dashPattern) : null
|
|
|
|
..dashPattern =
|
|
|
|
|
|
|
|
dashPattern != null ? new List<int>.from(dashPattern) : null
|
|
|
|
|
|
|
|
..domainExtent = domainExtent
|
|
|
|
..domainExtent = domainExtent
|
|
|
|
..measureAxisPosition = measureAxisPosition
|
|
|
|
..measureAxisPosition = measureAxisPosition
|
|
|
|
..positionExtent = positionExtent
|
|
|
|
..positionExtent = positionExtent
|
|
|
|
@ -1207,7 +1200,7 @@ class _LineRendererElement<D> {
|
|
|
|
lastPoint = previousPoint;
|
|
|
|
lastPoint = previousPoint;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
previousPoint =
|
|
|
|
previousPoint =
|
|
|
|
new _DatumPoint<D>.from(targetPoint, targetPoint.x, lastPoint.y);
|
|
|
|
_DatumPoint<D>.from(targetPoint, targetPoint.x, lastPoint.y);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
final x = ((targetPoint.x - previousPoint.x) * animationPercent) +
|
|
|
|
final x = ((targetPoint.x - previousPoint.x) * animationPercent) +
|
|
|
|
@ -1224,9 +1217,9 @@ class _LineRendererElement<D> {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (points.length - 1 >= pointIndex) {
|
|
|
|
if (points.length - 1 >= pointIndex) {
|
|
|
|
points[pointIndex] = new _DatumPoint<D>.from(targetPoint, x, y);
|
|
|
|
points[pointIndex] = _DatumPoint<D>.from(targetPoint, x, y);
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
points.add(new _DatumPoint<D>.from(targetPoint, x, y));
|
|
|
|
points.add(_DatumPoint<D>.from(targetPoint, x, y));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -1278,7 +1271,7 @@ class _AnimatedLine<D> {
|
|
|
|
for (var index = 0; index < newTarget.points.length; index++) {
|
|
|
|
for (var index = 0; index < newTarget.points.length; index++) {
|
|
|
|
var targetPoint = newTarget.points[index];
|
|
|
|
var targetPoint = newTarget.points[index];
|
|
|
|
|
|
|
|
|
|
|
|
newPoints.add(new _DatumPoint<D>.from(targetPoint, targetPoint.x,
|
|
|
|
newPoints.add(_DatumPoint<D>.from(targetPoint, targetPoint.x,
|
|
|
|
newTarget.measureAxisPosition.roundToDouble()));
|
|
|
|
newTarget.measureAxisPosition.roundToDouble()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -1328,11 +1321,10 @@ class _AreaRendererElement<D> {
|
|
|
|
String styleKey;
|
|
|
|
String styleKey;
|
|
|
|
|
|
|
|
|
|
|
|
_AreaRendererElement<D> clone() {
|
|
|
|
_AreaRendererElement<D> clone() {
|
|
|
|
return new _AreaRendererElement<D>()
|
|
|
|
return _AreaRendererElement<D>()
|
|
|
|
..points = new List<_DatumPoint<D>>.from(points)
|
|
|
|
..points = List<_DatumPoint<D>>.from(points)
|
|
|
|
..color = color != null ? new Color.fromOther(color: color) : null
|
|
|
|
..color = color != null ? Color.fromOther(color: color) : null
|
|
|
|
..areaColor =
|
|
|
|
..areaColor = areaColor != null ? Color.fromOther(color: areaColor) : null
|
|
|
|
areaColor != null ? new Color.fromOther(color: areaColor) : null
|
|
|
|
|
|
|
|
..domainExtent = domainExtent
|
|
|
|
..domainExtent = domainExtent
|
|
|
|
..measureAxisPosition = measureAxisPosition
|
|
|
|
..measureAxisPosition = measureAxisPosition
|
|
|
|
..positionExtent = positionExtent
|
|
|
|
..positionExtent = positionExtent
|
|
|
|
@ -1356,7 +1348,7 @@ class _AreaRendererElement<D> {
|
|
|
|
lastPoint = previousPoint;
|
|
|
|
lastPoint = previousPoint;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
previousPoint =
|
|
|
|
previousPoint =
|
|
|
|
new _DatumPoint<D>.from(targetPoint, targetPoint.x, lastPoint.y);
|
|
|
|
_DatumPoint<D>.from(targetPoint, targetPoint.x, lastPoint.y);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
final x = ((targetPoint.x - previousPoint.x) * animationPercent) +
|
|
|
|
final x = ((targetPoint.x - previousPoint.x) * animationPercent) +
|
|
|
|
@ -1373,9 +1365,9 @@ class _AreaRendererElement<D> {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (points.length - 1 >= pointIndex) {
|
|
|
|
if (points.length - 1 >= pointIndex) {
|
|
|
|
points[pointIndex] = new _DatumPoint<D>.from(targetPoint, x, y);
|
|
|
|
points[pointIndex] = _DatumPoint<D>.from(targetPoint, x, y);
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
points.add(new _DatumPoint<D>.from(targetPoint, x, y));
|
|
|
|
points.add(_DatumPoint<D>.from(targetPoint, x, y));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -1423,7 +1415,7 @@ class _AnimatedArea<D> {
|
|
|
|
for (var index = 0; index < newTarget.points.length; index++) {
|
|
|
|
for (var index = 0; index < newTarget.points.length; index++) {
|
|
|
|
var targetPoint = newTarget.points[index];
|
|
|
|
var targetPoint = newTarget.points[index];
|
|
|
|
|
|
|
|
|
|
|
|
newPoints.add(new _DatumPoint<D>.from(targetPoint, targetPoint.x,
|
|
|
|
newPoints.add(_DatumPoint<D>.from(targetPoint, targetPoint.x,
|
|
|
|
newTarget.measureAxisPosition.roundToDouble()));
|
|
|
|
newTarget.measureAxisPosition.roundToDouble()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
Brett Morgan
6 years ago
committed by
GitHub