[Effen] add StyleNode

sky/framework/fn.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.
 
 library fn;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:sky' as sky;
 import 'reflect.dart' as reflect;
@@ skipping 34 matching lines @@
       sky.Element styleNode = sky.document.createElement('style');
       styleNode.setChild(new sky.Text(".$className { $styles }"));
       sky.document.appendChild(styleNode);
       return new Style._internal(className);
     });
   }
 
   Style._internal(this._className);
 }
 
+abstract class ContentNode extends Node {
+  Node content;
+
+  ContentNode(Node content) : this.content = content, super(key: content._key);
+
+  void _sync(Node old, sky.ParentNode host, sky.Node insertBefore) {
+    Node oldContent = old == null ? null : (old as ContentNode).content;
+    content = _syncChild(content, oldContent, host, insertBefore);
+    _root = content._root;
+  }
+
+  void _remove() {
+    _removeChild(content);
+    super._remove();
+  }
+}
+
+class StyleNode extends ContentNode {
+  final Style style;
+
+  StyleNode(Node content, this.style): super(content);
+}
+
 void _parentInsertBefore(sky.ParentNode parent,
                          sky.Node node,
                          sky.Node ref) {
   if (ref != null) {
     ref.insertBefore([node]);
   } else {
     parent.appendChild(node);
   }
 }
 
@@ skipping 61 matching lines @@
 
     if (node == oldNode) {
       _trace('_sync(identical) ${node._key}');
       return node; // Nothing to do. Subtrees must be identical.
     }
 
     // TODO(rafaelw): This eagerly removes the old DOM. It may be that a
     // new component was built that could re-use some of it. Consider
     // syncing the new VDOM against the old one.
     if (oldNode != null && node._key != oldNode._key) {
-      _trace('_sync(remove) ${node._key}');
-      oldNode._remove();
+      _removeChild(oldNode);
     }
 
     if (node._willSync(oldNode)) {
       _trace('_sync(statefull) ${node._key}');
       oldNode._sync(node, host, insertBefore);
       node._defunct = true;
       assert(oldNode._root is sky.Node);
       return oldNode;
     }
 
@@ skipping 52 matching lines @@
     _root.remove();
     _nodeMap.remove(_root);
     super._remove();
   }
 }
 
 typedef GestureEventListener(sky.GestureEvent e);
 typedef PointerEventListener(sky.PointerEvent e);
 typedef EventListener(sky.Event e);
 
-class EventTarget extends Node  {
-  Node content;
+class EventTarget extends ContentNode  {
   final Map<String, sky.EventListener> listeners;
 
   static final Set<String> _registeredEvents = new HashSet<String>();
 
   static Map<String, sky.EventListener> _createListeners({
     EventListener onWheel,
     GestureEventListener onGestureFlingCancel,
     GestureEventListener onGestureFlingStart,
     GestureEventListener onGestureScrollStart,
     GestureEventListener onGestureScrollUpdate,
@@ skipping 41 matching lines @@
     GestureEventListener onGestureFlingStart,
     GestureEventListener onGestureScrollStart,
     GestureEventListener onGestureScrollUpdate,
     GestureEventListener onGestureTap,
     GestureEventListener onGestureTapDown,
     PointerEventListener onPointerCancel,
     PointerEventListener onPointerDown,
     PointerEventListener onPointerMove,
     PointerEventListener onPointerUp,
     Map<String, sky.EventListener> custom
-  }) : this.content = content,
-       listeners = _createListeners(
+  }) : listeners = _createListeners(
          onWheel: onWheel,
          onGestureFlingCancel: onGestureFlingCancel,
          onGestureFlingStart: onGestureFlingStart,
          onGestureScrollUpdate: onGestureScrollUpdate,
          onGestureScrollStart: onGestureScrollStart,
          onGestureTap: onGestureTap,
          onGestureTapDown: onGestureTapDown,
          onPointerCancel: onPointerCancel,
          onPointerDown: onPointerDown,
          onPointerMove: onPointerMove,
          onPointerUp: onPointerUp,
          custom: custom
        ),
-       super(key: content._key);
+       super(content);
 
   void _handleEvent(sky.Event e) {
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
 
   static void _dispatchEvent(sky.Event e) {
     Node target = RenderNode._getMounted(e.target);
@@ skipping 12 matching lines @@
     if (_registeredEvents.add(eventType)) {
       sky.document.addEventListener(eventType, _dispatchEvent);
     }
   }
 
   void _sync(Node old, sky.ParentNode host, sky.Node insertBefore) {
     for (var type in listeners.keys) {
       _ensureDocumentListener(type);
     }
 
-    Node oldContent = old == null ? null : (old as EventTarget).content;
-    content = _syncChild(content, oldContent , host, insertBefore);
-    _root = content._root;
-  }
-
-  void _remove() {
-    _removeChild(content);
-    super._remove();
+    super._sync(old, host, insertBefore);
   }
 }
 
 class Text extends RenderNode {
   final String data;
 
   // Text nodes are special cases of having non-unique keys (which don't need
   // to be assigned as part of the API). Since they are unique in not having
   // children, there's little point to reordering, so we always just re-assign
   // the data.
@@ skipping 16 matching lines @@
 }
 
 final List<Node> _emptyList = new List<Node>();
 
 abstract class Element extends RenderNode {
 
   String get _tagName;
 
   sky.Node _createNode() => sky.document.createElement(_tagName);
 
+  final List<Node> children;
+  final Style style;
   final String inlineStyle;
 
-  final List<Node> _children;
-  final String _class;
+  String _class;
 
   Element({
     Object key,
     List<Node> children,
-    Style style,
+    this.style,
     this.inlineStyle
-  }) : _class = style == null ? '' : style._className,
-       _children = children == null ? _emptyList : children,
+  }) : this.children = children == null ? _emptyList : children,
        super(key:key) {
 
     if (_isInCheckedMode) {
       _debugReportDuplicateIds();
     }
   }
 
   void _remove() {
     super._remove();
-    if (_children != null) {
-      for (var child in _children) {
+    if (children != null) {
+      for (var child in children) {
         _removeChild(child);
       }
     }
   }
 
   void _debugReportDuplicateIds() {
     var idSet = new HashSet<String>();
-    for (var child in _children) {
+    for (var child in children) {
       if (child is Text) {
         continue; // Text nodes all have the same key and are never reordered.
       }
 
       if (!idSet.add(child._key)) {
         throw '''If multiple (non-Text) nodes of the same type exist as children
                  of another node, they must have unique keys.''';
       }
     }
   }
 
+  void _ensureClass() {
+    if (_class == null) {
+      List<Style> styles = new List<Style>();
+      if (style != null) {
+        styles.add(style);
+      }
+
+      Node parent = _parent;
+      while (parent != null && parent is! RenderNode) {
+        if (parent is StyleNode)
+          styles.add((parent as StyleNode).style);
+
+        parent = parent._parent;
+      }
+
+      _class = styles.map((s) => s._className).join(' ');
+    }
+  }
+
   void _syncNode(RenderNode old) {
     Element oldElement = old as Element;
     sky.Element root = _root as sky.Element;
 
+    _ensureClass();
     if (_class != oldElement._class)
       root.setAttribute('class', _class);
 
     if (inlineStyle != oldElement.inlineStyle)
       root.setAttribute('style', inlineStyle);
 
     _syncChildren(oldElement);
   }
 
   void _syncChildren(Element oldElement) {
     sky.Element root = _root as sky.Element;
     assert(root != null);
 
     var startIndex = 0;
-    var endIndex = _children.length;
+    var endIndex = children.length;
 
-    var oldChildren = oldElement._children;
+    var oldChildren = oldElement.children;
     var oldStartIndex = 0;
     var oldEndIndex = oldChildren.length;
 
     sky.Node nextSibling = null;
     Node currentNode = null;
     Node oldNode = null;
 
     void sync(int atIndex) {
-      _children[atIndex] = _syncChild(currentNode, oldNode, _root, nextSibling);
+      children[atIndex] = _syncChild(currentNode, oldNode, _root, nextSibling);
     }
 
     // Scan backwards from end of list while nodes can be directly synced
     // without reordering.
     while (endIndex > startIndex && oldEndIndex > oldStartIndex) {
-      currentNode = _children[endIndex - 1];
+      currentNode = children[endIndex - 1];
       oldNode = oldChildren[oldEndIndex - 1];
 
       if (currentNode._key != oldNode._key) {
         break;
       }
 
       endIndex--;
       oldEndIndex--;
       sync(endIndex);
       nextSibling = currentNode._root;
@@ skipping 38 matching lines @@
         return false;
 
       oldNodeIdMap[currentNode._key] = null; // mark it reordered.
       _parentInsertBefore(root, oldNode._root, nextSibling);
       return true;
     }
 
     // Scan forwards, this time we may re-order;
     nextSibling = root.firstChild;
     while (startIndex < endIndex && oldStartIndex < oldEndIndex) {
-      currentNode = _children[startIndex];
+      currentNode = children[startIndex];
       oldNode = oldChildren[oldStartIndex];
 
       if (currentNode._key == oldNode._key) {
         assert(currentNode.runtimeType == oldNode.runtimeType);
         nextSibling = nextSibling.nextSibling;
         sync(startIndex);
         startIndex++;
         advanceOldStartIndex();
         continue;
       }
 
       oldNode = null;
       searchForOldNode();
       sync(startIndex);
       startIndex++;
     }
 
     // New insertions
     oldNode = null;
     while (startIndex < endIndex) {
-      currentNode = _children[startIndex];
+      currentNode = children[startIndex];
       sync(startIndex);
       startIndex++;
     }
 
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       _removeChild(oldNode);
       advanceOldStartIndex();
@@ skipping 298 matching lines @@
 
 abstract class App extends Component {
   sky.Node _host;
 
   App() : super(stateful: true) {
     _host = sky.document.createElement('div');
     sky.document.appendChild(_host);
     _scheduleComponentForRender(this);
   }
 }