[Effen] rename RenderNode and WrapperNode (previously know as Element) to SkyNodeWrapper and SkyEle…

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 162 matching lines @@
   }
 }
 
 class StyleNode extends ContentNode {
   final Style style;
 
   StyleNode(UINode content, this.style): super(content);
 }
 
 /*
- * RenderNodes correspond to a desired state of a sky.Node. They are fully
+ * SkyNodeWrappers correspond to a desired state of a sky.Node. They are fully
  * immutable, with one exception: A UINode which is a Component which lives within
- * an WrapperNode's children list, may be replaced with the "old" instance if it
+ * an SkyElementWrapper's children list, may be replaced with the "old" instance if it
  * has become stateful.
  */
-abstract class RenderNode extends UINode {
+abstract class SkyNodeWrapper extends UINode {
 
-  static final Map<sky.Node, RenderNode> _nodeMap =
-      new HashMap<sky.Node, RenderNode>();
+  static final Map<sky.Node, SkyNodeWrapper> _nodeMap =
+      new HashMap<sky.Node, SkyNodeWrapper>();
 
-  static RenderNode _getMounted(sky.Node node) => _nodeMap[node];
+  static SkyNodeWrapper _getMounted(sky.Node node) => _nodeMap[node];
 
-  RenderNode({ Object key }) : super(key: key);
+  SkyNodeWrapper({ Object key }) : super(key: key);
 
-  RenderNode get _emptyNode;
+  SkyNodeWrapper get _emptyNode;
 
   sky.Node _createNode();
 
   void _sync(UINode old, sky.ParentNode host, sky.Node insertBefore) {
     if (old == null) {
       _root = _createNode();
       _parentInsertBefore(host, _root, insertBefore);
       old = _emptyNode;
     } else {
       _root = old._root;
     }
 
     _nodeMap[_root] = this;
     _syncNode(old);
   }
 
-  void _syncNode(RenderNode old);
+  void _syncNode(SkyNodeWrapper old);
 
   void _remove() {
     assert(_root != null);
     _root.remove();
     _nodeMap.remove(_root);
     super._remove();
   }
 }
 
 typedef GestureEventListener(sky.GestureEvent e);
@@ skipping 79 matching lines @@
        super(content);
 
   void _handleEvent(sky.Event e) {
     sky.EventListener listener = listeners[e.type];
     if (listener != null) {
       listener(e);
     }
   }
 
   static void _dispatchEvent(sky.Event e) {
-    UINode target = RenderNode._getMounted(e.target);
+    UINode target = SkyNodeWrapper._getMounted(e.target);
 
     // TODO(rafaelw): StopPropagation?
     while (target != null) {
       if (target is EventListenerNode) {
         (target as EventListenerNode)._handleEvent(e);
       }
 
       target = target._parent;
     }
   }
 
   static void _ensureDocumentListener(String eventType) {
     if (_registeredEvents.add(eventType)) {
       sky.document.addEventListener(eventType, _dispatchEvent);
     }
   }
 
   void _sync(UINode old, sky.ParentNode host, sky.Node insertBefore) {
     for (var type in listeners.keys) {
       _ensureDocumentListener(type);
     }
 
     super._sync(old, host, insertBefore);
   }
 }
 
-class Text extends RenderNode {
+class Text extends SkyNodeWrapper {
   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) : super(key:'*text*');
 
   static final Text _emptyText = new Text(null);
 
-  RenderNode get _emptyNode => _emptyText;
+  SkyNodeWrapper get _emptyNode => _emptyText;
 
   sky.Node _createNode() {
     return new sky.Text(data);
   }
 
-  void _syncNode(RenderNode old) {
+  void _syncNode(SkyNodeWrapper old) {
     if (old == _emptyText)
       return; // we set inside _createNode();
 
     (_root as sky.Text).data = data;
   }
 }
 
 final List<UINode> _emptyList = new List<UINode>();
 
-abstract class WrapperNode extends RenderNode {
+abstract class SkyElementWrapper extends SkyNodeWrapper {
 
   String get _tagName;
 
   sky.Node _createNode() => sky.document.createElement(_tagName);
 
   final List<UINode> children;
   final Style style;
   final String inlineStyle;
 
   String _class;
 
-  WrapperNode({
+  SkyElementWrapper({
     Object key,
     List<UINode> children,
     this.style,
     this.inlineStyle
   }) : this.children = children == null ? _emptyList : children,
        super(key:key) {
 
     assert(!_debugHasDuplicateIds());
   }
 
@@ skipping 22 matching lines @@
   }
 
   void _ensureClass() {
     if (_class == null) {
       List<Style> styles = new List<Style>();
       if (style != null) {
         styles.add(style);
       }
 
       UINode parent = _parent;
-      while (parent != null && parent is! RenderNode) {
+      while (parent != null && parent is! SkyNodeWrapper) {
         if (parent is StyleNode && (parent as StyleNode).style != null)
           styles.add((parent as StyleNode).style);
 
         parent = parent._parent;
       }
 
       _class = styles.map((s) => s._className).join(' ');
     }
   }
 
-  void _syncNode(RenderNode old) {
-    WrapperNode oldWrapperNode = old as WrapperNode;
+  void _syncNode(SkyNodeWrapper old) {
+    SkyElementWrapper oldSkyElementWrapper = old as SkyElementWrapper;
     sky.Element root = _root as sky.Element;
 
     _ensureClass();
-    if (_class != oldWrapperNode._class && _class != '')
+    if (_class != oldSkyElementWrapper._class && _class != '')
       root.setAttribute('class', _class);
 
-    if (inlineStyle != oldWrapperNode.inlineStyle)
+    if (inlineStyle != oldSkyElementWrapper.inlineStyle)
       root.setAttribute('style', inlineStyle);
 
-    _syncChildren(oldWrapperNode);
+    _syncChildren(oldSkyElementWrapper);
   }
 
-  void _syncChildren(WrapperNode oldWrapperNode) {
+  void _syncChildren(SkyElementWrapper oldSkyElementWrapper) {
     sky.Element root = _root as sky.Element;
     assert(root != null);
 
     var startIndex = 0;
     var endIndex = children.length;
 
-    var oldChildren = oldWrapperNode.children;
+    var oldChildren = oldSkyElementWrapper.children;
     var oldStartIndex = 0;
     var oldEndIndex = oldChildren.length;
 
     sky.Node nextSibling = null;
     UINode currentNode = null;
     UINode oldNode = null;
 
     void sync(int atIndex) {
       children[atIndex] = _syncChild(currentNode, oldNode, _root, nextSibling);
     }
@@ skipping 89 matching lines @@
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       _removeChild(oldNode);
       advanceOldStartIndex();
     }
   }
 }
 
-class Container extends WrapperNode {
+class Container extends SkyElementWrapper {
 
   String get _tagName => 'div';
 
   static final Container _emptyContainer = new Container();
 
-  RenderNode get _emptyNode => _emptyContainer;
+  SkyNodeWrapper get _emptyNode => _emptyContainer;
 
   Container({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle
   }) : super(
     key: key,
     children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 }
 
-class Image extends WrapperNode {
+class Image extends SkyElementWrapper {
 
   String get _tagName => 'img';
 
   static final Image _emptyImage = new Image();
 
-  RenderNode get _emptyNode => _emptyImage;
+  SkyNodeWrapper get _emptyNode => _emptyImage;
 
   final String src;
   final int width;
   final int height;
 
   Image({
     Object key,
     List<UINode> children,
     Style style,
     String inlineStyle,
@@ skipping 17 matching lines @@
       skyImage.src = src;
 
     if (width != oldImage.width)
       skyImage.style['width'] = '${width}px';
 
     if (height != oldImage.height)
       skyImage.style['height'] = '${height}px';
   }
 }
 
-class Anchor extends WrapperNode {
+class Anchor extends SkyElementWrapper {
 
   String get _tagName => 'a';
 
   static final Anchor _emptyAnchor = new Anchor();
 
   UINode get _emptyNode => _emptyAnchor;
 
   final String href;
   final int width;
   final int height;
@@ skipping 240 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);
   }
 }