Add a new Theme widget to control color and text color of apps

sky/sdk/lib/widgets/widget.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 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 
 import '../base/hit_test.dart';
 import '../rendering/box.dart';
 import '../rendering/object.dart';
 import '../rendering/sky_binding.dart';
 
 export '../rendering/box.dart' show BoxConstraints, BoxDecoration, Border, BorderSide, EdgeDims;
 export '../rendering/flex.dart' show FlexDirection;
 export '../rendering/object.dart' show Point, Size, Rect, Color, Paint, Path;
 
 final bool _shouldLogRenderDuration = false;
 
+typedef void WidgetTreeWalker(Widget);
+
 // All Effen nodes derive from Widget. All nodes have a _parent, a _key and
 // can be sync'd.
 abstract class Widget {
 
   Widget({ String key }) : _key = key {
-    assert(this is AbstractWidgetRoot || this is App || _inRenderDirtyComponents); // you should not build the UI tree ahead of time, build it only during build()
+    assert(_isConstructedDuringBuild());
   }
 
+  // TODO(jackson): Remove this workaround for limitation of Dart mixins
+  Widget._withKey(String key) : _key = key {
+    assert(_isConstructedDuringBuild());
+  }
+
+  // you should not build the UI tree ahead of time, build it only during build()
+  bool _isConstructedDuringBuild() => this is AbstractWidgetRoot || this is App || _inRenderDirtyComponents;
+
   String _key;
   String get key => _key;
 
   Widget _parent;
   Widget get parent => _parent;
 
   bool _mounted = false;
   bool _wasMounted = false;
   bool get mounted => _mounted;
   static bool _notifyingMountStatus = false;
   static Set<Widget> _mountedChanged = new HashSet<Widget>();
 
   void setParent(Widget newParent) {
     assert(!_notifyingMountStatus);
     _parent = newParent;
     if (newParent == null) {
       if (_mounted) {
         _mounted = false;
         _mountedChanged.add(this);
       }
     } else {
       assert(newParent._mounted);
       if (_parent._mounted != _mounted) {
         _mounted = _parent._mounted;
         _mountedChanged.add(this);
       }
     }
   }
 
+  // Override this if you have children and call walker on each child
+  void walkChildren(WidgetTreeWalker walker) { }
+
   static void _notifyMountStatusChanged() {
     try {
       sky.tracing.begin("Widget._notifyMountStatusChanged");
       _notifyingMountStatus = true;
       for (Widget node in _mountedChanged) {
         if (node._wasMounted != node._mounted) {
           if (node._mounted)
             node.didMount();
           else
             node.didUnmount();
@@ skipping 96 matching lines @@
 
 
 // Descendants of TagNode provide a way to tag RenderObjectWrapper and
 // Component nodes with annotations, such as event listeners,
 // stylistic information, etc.
 abstract class TagNode extends Widget {
 
   TagNode(Widget child, { String key })
     : this.child = child, super(key: key);
 
+  // TODO(jackson): Remove this workaround for limitation of Dart mixins
+  TagNode._withKey(Widget child, String key)
+    : this.child = child, super._withKey(key);
+
   Widget child;
 
+  void walkChildren(WidgetTreeWalker walker) {
+    walker(child);
+  }
+
   void _sync(Widget old, dynamic slot) {
     Widget oldChild = old == null ? null : (old as TagNode).child;
     child = syncChild(child, oldChild, slot);
     assert(child.root != null);
     _root = child.root;
     assert(_root == root); // in case a subclass reintroduces it
   }
 
   void remove() {
     if (child != null)
       removeChild(child);
     super.remove();
   }
 
   void detachRoot() {
     if (child != null)
       child.detachRoot();
   }
 
 }
 
 class ParentDataNode extends TagNode {
   ParentDataNode(Widget child, this.parentData, { String key })
     : super(child, key: key);
   final ParentData parentData;
 }
 
+abstract class _Heir implements Widget {
+  Map<Type, Inherited> _traits;
+  Inherited inheritedOfType(Type type) => _traits[type];
+
+  static _Heir _getHeirAncestor(Widget widget) {
+    Widget ancestor = widget;
+    while (ancestor != null && !(ancestor is _Heir)) {
+      ancestor = ancestor.parent;
+    }
+    return ancestor as _Heir;
+  }
+
+  void _updateTraitsFromParent(Widget parent) {
+    _Heir ancestor = _getHeirAncestor(parent);
+    if (ancestor == null || ancestor._traits == null) return;
+    _updateTraits(ancestor._traits);
+  }
+
+  void _updateTraitsRecursively(Widget widget) {
+    if (widget is _Heir)
+      widget._updateTraits(_traits);
+    else
+      widget.walkChildren(_updateTraitsRecursively);
+  }
+
+  void _updateTraits(Map<Type, Inherited> newTraits) {
+    if (newTraits != _traits) {
+      _traits = newTraits;
+      walkChildren(_updateTraitsRecursively);
+    }
+  }
+}
+
+abstract class Inherited extends TagNode with _Heir {
+  Inherited({ String key, Widget child }) : super._withKey(child, key) {
+    _traits = new Map<Type, Inherited>();
+  }
+
+  void set _traits(Map<Type, Inherited> value) {
+    super._traits = new Map<Type, Inherited>.from(value)
+                                            ..[runtimeType] = this;
+  }
+
+  // TODO(jackson): When Dart supports super in mixins we can move to _Heir
+  void setParent(Widget parent) {
+    _updateTraitsFromParent(parent);
+    super.setParent(parent);
+  }
+}
+
 typedef void GestureEventListener(sky.GestureEvent e);
 typedef void PointerEventListener(sky.PointerEvent e);
 typedef void EventListener(sky.Event e);
 
 class Listener extends TagNode  {
 
   Listener({
     Widget child,
     EventListener onWheel,
     GestureEventListener onGestureFlingCancel,
@@ skipping 71 matching lines @@
 
   void _handleEvent(sky.Event e) {
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
 
 }
 
-
-abstract class Component extends Widget {
+abstract class Component extends Widget with _Heir {
 
   Component({ String key, bool stateful })
       : _stateful = stateful != null ? stateful : false,
         _order = _currentOrder + 1,
-        super(key: key);
+        super._withKey(key);
 
   static Component _currentlyBuilding;
   bool get _isBuilding => _currentlyBuilding == this;
 
   bool _stateful;
   bool _dirty = true;
   bool _disqualifiedFromEverAppearingAgain = false;
 
   Widget _built;
   dynamic _slot; // cached slot from the last time we were synced
 
   void didMount() {
     assert(!_disqualifiedFromEverAppearingAgain);
     super.didMount();
   }
 
+  // TODO(jackson): When Dart supports super in mixins we can move to _Heir
+  void setParent(Widget parent) {
+    _updateTraitsFromParent(parent);
+    super.setParent(parent);
+  }
+
   void remove() {
     assert(_built != null);
     assert(root != null);
     removeChild(_built);
     _built = null;
     super.remove();
   }
 
   void detachRoot() {
     assert(_built != null);
@@ skipping 239 matching lines @@
 }
 
 abstract class OneChildRenderObjectWrapper extends RenderObjectWrapper {
 
   OneChildRenderObjectWrapper({ String key, Widget child })
     : _child = child, super(key: key);
 
   Widget _child;
   Widget get child => _child;
 
+  void walkChildren(WidgetTreeWalker walker) {
+    walker(child);
+  }
+
   void syncRenderObject(RenderObjectWrapper old) {
     super.syncRenderObject(old);
     Widget oldChild = old == null ? null : (old as OneChildRenderObjectWrapper).child;
     _child = syncChild(child, oldChild, null);
   }
 
   void insertChildRoot(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is RenderObjectWithChildMixin);
     assert(slot == null);
     root.child = child.root;
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void detachChildRoot(RenderObjectWrapper child) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(root is RenderObjectWithChildMixin);
     assert(root.child == child.root);
     root.child = null;
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void remove() {
     if (child != null)
       removeChild(child);
     super.remove();
   }
-
 }
 
 abstract class MultiChildRenderObjectWrapper extends RenderObjectWrapper {
 
   // In MultiChildRenderObjectWrapper subclasses, slots are RenderObject nodes
   // to use as the "insert before" sibling in ContainerRenderObjectMixin.add() calls
 
   MultiChildRenderObjectWrapper({ String key, List<Widget> children })
     : this.children = children == null ? const [] : children,
       super(key: key) {
     assert(!_debugHasDuplicateIds());
   }
 
   final List<Widget> children;
 
+  void walkChildren(WidgetTreeWalker walker) {
+    for(Widget child in children)
+      walker(child);
+  }
+
   void insertChildRoot(RenderObjectWrapper child, dynamic slot) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     assert(slot == null || slot is RenderObject);
     assert(root is ContainerRenderObjectMixin);
     root.add(child.root, before: slot);
     assert(root == this.root); // TODO(ianh): Remove this once the analyzer is cleverer
   }
 
   void detachChildRoot(RenderObjectWrapper child) {
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
@@ skipping 286 matching lines @@
     if (root.parent == null) {
       // we haven't attached it yet
       assert(_container.child == null);
       _container.child = root;
     }
     assert(root.parent == _container);
   }
 
   Widget build() => builder();
 }