Flutter进阶之实现动画效果（八）

import 'package:flutter/animation.dart';
import 'package:flutter/material.dart';

abstract class MergeTweenable {
 T get empty;

 Tween tweenTo(T other);

 bool operator <(T other);
}

class MergeTween> extends Tween> {
 final _tweens = >[];

 MergeTween(List begin, List end) : super(begin: begin, end: end) {
 final bMax = begin.length;
 final eMax = end.length;
 var b = 0;
 var e = 0;
 while (b + e  lerp(double t) => new List.generate(
 _tweens.length,
  (i) => _tweens[i].lerp(t)
 );
}

import 'package:flutter/material.dart';
import 'package:flutter/animation.dart';
import 'dart:ui' show lerpDouble;
import 'dart:math';
import 'color_palette.dart';
import 'tween.dart';

class BarChart {
 BarChart(this.stacks);

 final List stacks;

 factory BarChart.empty(Size size) {
 return new BarChart([]);
 }

 factory BarChart.random(Size size, Random random) {
 const stackWidthFraction = 0.75;
 final stackRanks = _selectRanks(random, 10);
 final stackCount = stackRanks.length;
 final stackDistance = size.width / (1+stackCount);
 final stackWidth = stackDistance * stackWidthFraction;
 final startX = stackDistance - stackWidth/2;
 final stacks = new List.generate(
 stackCount,
 (i) {
 final barRanks = _selectRanks(random, ColorPalette.primary.length ~/ 2);
 final bars = new List.generate(
  barRanks.length,
  (j) => new Bar(
  barRanks[j],
  random.nextDouble() * size.height / 2,
  ColorPalette.primary[barRanks[j]],
  )
 );
 return new BarStack(
  stackRanks[i],
  startX + i * stackDistance,
  stackWidth,
  bars
 );
 }
 );
 return new BarChart(stacks);
 }

 static List _selectRanks(Random random, int cap) {
 final ranks = [];
 var rank = 0;
 while(true) {
 rank += random.nextInt(2);
 if(cap <= rank) break;
 ranks.add(rank);
 rank++;
 }
 return ranks;
 }
}

class BarChartTween extends Tween {
 BarChartTween(BarChart begin, BarChart end)
 : _stacksTween = new MergeTween(begin.stacks, end.stacks),
 super(begin: begin, end: end);

 final MergeTween _stacksTween;

 @override
 BarChart lerp(double t) => new BarChart(_stacksTween.lerp(t));
}

class BarStack implements MergeTweenable {
 BarStack(this.rank, this.x, this.width, this.bars);

 final int rank;
 final double x;
 final double width;
 final List bars;

 @override
 BarStack get empty => new BarStack(rank, x, 0.0, []);

 @override
 bool operator <(BarStack other) => rank  tweenTo(BarStack other) => new BarStackTween(this, other);
}

class BarStackTween extends Tween {
 BarStackTween(BarStack begin, BarStack end)
 : _barsTween = new MergeTween(begin.bars, end.bars),
 super(begin: begin, end: end) {
 assert(begin.rank == end.rank);
 }

 final MergeTween _barsTween;

 @override
 BarStack lerp(double t) => new BarStack(
 begin.rank,
 lerpDouble(begin.x, end.x, t),
 lerpDouble(begin.width, end.width, t),
 _barsTween.lerp(t)
 );
}

class Bar extends MergeTweenable {
 Bar(this.rank, this.height, this.color);
 final int rank;
 final double height;
 final Color color;

 @override
 Bar get empty => new Bar(rank, 0.0, color);

 @override
 bool operator <(Bar other) => rank  tweenTo(Bar other) => new BarTween(this, other);

 static Bar lerp(Bar begin, Bar end, double t) {
 assert(begin.rank == end.rank);
 return new Bar(
 begin.rank,
 lerpDouble(begin.height, end.height, t),
 Color.lerp(begin.color, end.color, t)
 );
 }
}

class BarTween extends Tween {
 BarTween(Bar begin, Bar end) : super(begin: begin, end: end) {
 assert(begin.rank == end.rank);
 }

 @override
 Bar lerp(double t) => Bar.lerp(begin, end, t);
}

class BarChartPainter extends CustomPainter {
 BarChartPainter(Animation animation)
 : animation = animation,
 super(repaint: animation);

 final Animation animation;

 @override
 void paint(Canvas canvas, Size size) {
 final barPaint = new Paint()..style = PaintingStyle.fill;
 final linePaint = new Paint()
 ..style = PaintingStyle.stroke
 ..color = Colors.white
 /**
 *当style设置为PaintingStyle.stroke时绘制边缘有多宽
 宽度以与路径方向正交的方向测量的逻辑像素给出
 */
 ..strokeWidth = 1.0;
 final linePath = new Path();
 final chart = animation.value;
 for(final stack in chart.stacks) {
 var y = size.height;
 for(final bar in stack.bars) {
 barPaint.color = bar.color;
 canvas.drawRect(
  new Rect.fromLTWH(
  stack.x,
  y - bar.height,
  stack.width,
  bar.height
  ),
  barPaint,
 );
 if(y  false;
}