[Effen] remove the last traces of the 'display' property from the effen component library.

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 20 matching lines @@
   bool _defunct = false;
 
   UINode({ Object key }) {
     _key = key == null ? "$runtimeType" : "$runtimeType-$key";
   }
 
   // Subclasses which implements Nodes that become stateful may return true
   // if the |old| node has become stateful and should be retained.
   bool _willSync(UINode old) => false;
 
+  bool get interchangeable => false; // if true, then keys can be duplicated
+
   void _sync(UINode old, RenderCSSContainer host, RenderCSS insertBefore);
 
   void _remove() {
     _defunct = true;
     _root = null;
     handleRemoved();
   }
   void handleRemoved() { }
 
   int _nodeDepth;
@@ skipping 276 matching lines @@
   final List<UINode> children;
   final Style style;
   final String inlineStyle;
 
   SkyElementWrapper({
     Object key,
     List<UINode> children,
     this.style,
     this.inlineStyle
   }) : this.children = children == null ? _emptyList : children,
-       super(key:key) {
+       super(key: key) {
 
     assert(!_debugHasDuplicateIds());
   }
 
   void _remove() {
     assert(children != null);
     for (var child in children) {
       assert(child != null);
       _removeChild(child);
     }
     super._remove();
   }
 
   bool _debugHasDuplicateIds() {
     var idSet = new HashSet<String>();
     for (var child in children) {
       assert(child != null);
-      if (child is Text) {
-        continue; // Text nodes all have the same key and are never reordered.
-      }
+      if (child.interchangeable)
+        continue; // when these nodes are reordered, we just reassign the data
 
       if (!idSet.add(child._key)) {
-        throw '''If multiple (non-Text) nodes of the same type exist as children
+        throw '''If multiple non-interchangeable nodes of the same type exist as children
                 of another node, they must have unique keys.
                 Duplicate: "${child._key}"''';
       }
     }
     return false;
   }
 
   void _syncNode(SkyNodeWrapper old) {
     SkyElementWrapper oldSkyElementWrapper = old as SkyElementWrapper;
 
@@ skipping 78 matching lines @@
       }
     }
 
     void ensureOldIdMap() {
       if (oldNodeIdMap != null)
         return;
 
       oldNodeIdMap = new HashMap<String, UINode>();
       for (int i = oldStartIndex; i < oldEndIndex; i++) {
         var node = oldChildren[i];
-        if (node is! Text) {
+        if (!node.interchangeable)
           oldNodeIdMap.putIfAbsent(node._key, () => node);
-        }
       }
     }
 
     bool searchForOldNode() {
-      if (currentNode is Text)
-        return false; // Never re-order Text nodes.
+      if (currentNode.interchangeable)
+        return false; // never re-order these nodes
 
       ensureOldIdMap();
       oldNode = oldNodeIdMap[currentNode._key];
       if (oldNode == null)
         return false;
 
-      oldNodeIdMap[currentNode._key] = null; // mark it reordered.
+      oldNodeIdMap[currentNode._key] = null; // mark it reordered
       assert(_root is RenderCSSContainer);
       assert(oldNode._root is RenderCSSContainer);
       oldSkyElementWrapper._root.remove(oldNode._root);
       _root.add(oldNode._root, before: nextSibling);
       return true;
     }
 
     // Scan forwards, this time we may re-order;
     nextSibling = _root.firstChild;
     while (startIndex < endIndex && oldStartIndex < oldEndIndex) {
@@ skipping 28 matching lines @@
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       _removeChild(oldNode);
       advanceOldStartIndex();
     }
   }
 }
 
 class Container extends SkyElementWrapper {
 
-  RenderCSS _createNode() => new RenderCSSContainer(this);
+  RenderCSSContainer _root;
+  RenderCSSContainer _createNode() => new RenderCSSContainer(this);
 
   static final Container _emptyContainer = new Container();
 
   SkyNodeWrapper get _emptyNode => _emptyContainer;
 
   Container({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle
   }) : super(
     key: key,
     children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 }
 
+class Paragraph extends SkyElementWrapper {
+
+  RenderCSSParagraph _root;
+  RenderCSSParagraph _createNode() => new RenderCSSParagraph(this);
+
+  static final Paragraph _emptyContainer = new Paragraph();
+
+  SkyNodeWrapper get _emptyNode => _emptyContainer;
+
+  Paragraph({
+    Object key,
+    List<UINode> children,
+    Style style,
+    String inlineStyle
+  }) : super(
+    key: key,
+    children: children,
+    style: style,
+    inlineStyle: inlineStyle
+  );
+}
+
 class FlexContainer extends SkyElementWrapper {
 
   RenderCSSFlex _root;
   RenderCSSFlex _createNode() => new RenderCSSFlex(this, this.direction);
 
   static final FlexContainer _emptyContainer = new FlexContainer();
     // direction doesn't matter if it's empty
 
   SkyNodeWrapper get _emptyNode => _emptyContainer;
 
@@ skipping 11 matching lines @@
     style: style,
     inlineStyle: inlineStyle
   );
 
   void _syncNode(UINode old) {
     super._syncNode(old);
     _root.direction = direction;
   }
 }
 
-class Text extends SkyElementWrapper {
+class TextFragment extends SkyElementWrapper {
 
-  RenderCSSText _root;
-  RenderCSSText _createNode() => new RenderCSSText(this, this.data);
+  RenderCSSInline _root;
+  RenderCSSInline _createNode() => new RenderCSSInline(this, this.data);
 
-  static final Text _emptyText = new Text('');
+  static final TextFragment _emptyText = new TextFragment('');
 
   SkyNodeWrapper get _emptyNode => _emptyText;
 
   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.
-  Text(this.data, {
+  TextFragment(this.data, {
+    Object key,
     Style style,
     String inlineStyle
   }) : super(
-    key: '*text*',
+    key: key,
     style: style,
     inlineStyle: inlineStyle
   );
 
   void _syncNode(UINode old) {
     super._syncNode(old);
     _root.data = data;
   }
 }
 
 class Image extends SkyElementWrapper {
 
   RenderCSSImage _root;
   RenderCSSImage _createNode() => new RenderCSSImage(this, this.src, this.width, this.height);
 
   static final Image _emptyImage = new Image();
 
   SkyNodeWrapper get _emptyNode => _emptyImage;
 
   final String src;
   final int width;
   final int height;
 
   Image({
     Object key,
-    List<UINode> children,
     Style style,
     String inlineStyle,
     this.width,
     this.height,
     this.src
   }) : super(
     key: key,
-    children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 
   void _syncNode(UINode old) {
     super._syncNode(old);
     _root.configure(this.src, this.width, this.height);
   }
 }
 
@@ skipping 93 matching lines @@
     if (_unmountCallbacks == null)
       _unmountCallbacks = new List<Function>();
 
     _unmountCallbacks.add(fn);
   }
 
 
   Component({ Object key, bool stateful })
       : _stateful = stateful != null ? stateful : false,
         _order = _currentOrder + 1,
-        super(key:key);
+        super(key: key);
 
   Component.fromArgs(Object key, bool stateful)
       : this(key: key, stateful: stateful);
 
   void _didMount() {
     if (_mountCallbacks != null)
       _mountCallbacks.forEach((fn) => fn());
   }
 
   void _didUnmount() {
@@ skipping 103 matching lines @@
   }
 
   void _buildIfDirty() {
     if (!_dirty || _defunct)
       return;
 
     _trace('$_key rebuilding...');
     _sync(null, _host, _root);
   }
 }
+
+class Text extends Component {
+  Text(this.data) : super(key: '*text*');
+  final String data;
+  bool get interchangeable => true;
+  UINode build() => new Paragraph(children: [new TextFragment(data)]);
+}