add initState, rename animated_container

sky/sdk/lib/widgets/material.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import '../animation/animation_performance.dart';
 import '../painting/box_painter.dart';
 import 'animated_component.dart';
-import 'animated_container.dart';
+import 'animation_builder.dart';
 import 'basic.dart';
 import 'default_text_style.dart';
 import 'theme.dart';
 
 enum MaterialType { canvas, card, circle, button }
 
 const Map<MaterialType, double> edges = const {
   MaterialType.canvas: null,
   MaterialType.card: 2.0,
   MaterialType.circle: null,
   MaterialType.button: 2.0,
 };
 
 const Duration _kAnimateShadowDuration = const Duration(milliseconds: 100);
 const Duration _kAnimateColorDuration = const Duration(milliseconds: 100);
 
 class Material extends AnimatedComponent {
 
   Material({
     String key,
     this.child,
-    MaterialType type: MaterialType.card,
-    int level: 0,
-    Color color: null
+    this.type: MaterialType.card,
+    this.level: 0,
+    this.color
   }) : super(key: key) {
-    if (level == null) level = 0;
-    _container = new AnimatedContainer()
+    assert(level != null);
+  }
+
+  Widget child;
+  MaterialType type;
+  int level;
+  Color color;
+
+  AnimationBuilder _builder;
+
+  void initState() {
+    _builder = new AnimationBuilder()
       ..shadow = new AnimatedType<double>(level.toDouble())
       ..backgroundColor = _getBackgroundColor(type, color)
       ..borderRadius = edges[type]
       ..shape = type == MaterialType.circle ? Shape.circle : Shape.rectangle;
-    watchPerformance(_container.createPerformance(
-        [_container.shadow], duration: _kAnimateShadowDuration));
-    watchPerformance(_container.createPerformance(
-        [_container.backgroundColor], duration: _kAnimateColorDuration));
+    watchPerformance(_builder.createPerformance(
+        [_builder.shadow], duration: _kAnimateShadowDuration));
+    watchPerformance(_builder.createPerformance(
+        [_builder.backgroundColor], duration: _kAnimateColorDuration));
+    super.initState();
   }
 
-  Widget child;
-
-  AnimatedContainer _container;
-
   void syncFields(Material source) {
     child = source.child;
-    _container.syncFields(source._container);
+    type = source.type;
+    level = source.level;
+    color = source.color;
+    _builder.updateFields(
+      shadow: new AnimatedType<double>(level.toDouble()),
+      backgroundColor: _getBackgroundColor(type, color),
+      borderRadius: edges[type],
+      shape: type == MaterialType.circle ? Shape.circle : Shape.rectangle
+    );

[Matt Perry, 2015/07/13 17:37:45]

It's unfortunate the amount of boilerplate this adds. The nice thing about
AnimationBuilder IMO was that it took care of animating/updating all its
variables behind the scenes. Now we have to (a) keep a copy of them on each
Widget and (b) tell AnimationBuilder which ones we want to update. It would be
nice if there were a way to keep the old automagic.

     super.syncFields(source);
   }
 
   AnimatedColor _getBackgroundColor(MaterialType type, Color color) {
     if (color == null) {
       switch (type) {
         case MaterialType.canvas:
           color = Theme.of(this).canvasColor;
           break;
         case MaterialType.card:
           color = Theme.of(this).cardColor;
           break;
         default:
           break;
       }
     }
     return color == null ? null : new AnimatedColor(color);
   }
 
   Widget build() {
-    return _container.build(
+    return _builder.build(
         new DefaultTextStyle(style: Theme.of(this).text.body1, child: child)
     );
   }
 
 }