[Effen] s/Node/UINode/, s/Element/WrapperNode/, s/EventTarget/EventListenerNode/

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 49 matching lines @@
   if (ref != null) {
     ref.insertBefore([node]);
   } else {
     parent.appendChild(node);
   }
 }
 
 enum _SyncOperation { IDENTICAL, INSERTION, STATEFUL, STATELESS, REMOVAL }
 
 /*
- * All Effen nodes derive from Node. All nodes have a _parent, a _key and
+ * All Effen nodes derive from UINode. All nodes have a _parent, a _key and
  * can be sync'd.
  */
-abstract class Node {
+abstract class UINode {
   String _key;
-  Node _parent;
+  UINode _parent;
   sky.Node _root;
   bool _defunct = false;
   int _nodeDepth;
 
-  Node({ Object key }) {
+  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(Node old) => false;
+  bool _willSync(UINode old) => false;
 
-  void _sync(Node old, sky.ParentNode host, sky.Node insertBefore);
+  void _sync(UINode old, sky.ParentNode host, sky.Node insertBefore);
 
   void _remove() {
     _defunct = true;
     _root = null;
   }
 
   void _ensureDepth() {
     if (_nodeDepth == null) {
       _nodeDepth = 0;
-      Node parent = _parent;
+      UINode parent = _parent;
       while (parent != null) {
         _nodeDepth++;
         parent = parent._parent;
       }
     }
   }
 
   void _trace(String message) {
     if (!_shouldTrace)
       return;
@@ skipping 10 matching lines @@
 
   void _traceSync(_SyncOperation op, String key) {
     if (!_shouldTrace)
       return;
 
     String opString = op.toString().toLowerCase();
     String outString = opString.substring(opString.indexOf('.') + 1);
     _trace('_sync($outString) $key');
   }
 
-  void _removeChild(Node node) {
+  void _removeChild(UINode node) {
     _traceSync(_SyncOperation.REMOVAL, node._key);
     node._remove();
   }
 
   // Returns the child which should be retained as the child of this node.
-  Node _syncChild(Node node, Node oldNode, sky.ParentNode host,
+  UINode _syncChild(UINode node, UINode oldNode, sky.ParentNode host,
       sky.Node insertBefore) {
 
     assert(oldNode == null || node._key == oldNode._key);
 
     if (node == oldNode) {
       _traceSync(_SyncOperation.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
@@ skipping 20 matching lines @@
     }
     node._sync(oldNode, host, insertBefore);
     if (oldNode != null)
       oldNode._defunct = true;
 
     assert(node._root is sky.Node);
     return node;
   }
 }
 
-abstract class ContentNode extends Node {
-  Node content;
+abstract class ContentNode extends UINode {
+  UINode content;
 
-  ContentNode(Node content) : this.content = content, super(key: content._key);
+  ContentNode(UINode 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;
+  void _sync(UINode old, sky.ParentNode host, sky.Node insertBefore) {
+    UINode 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);
+  StyleNode(UINode content, this.style): super(content);
 }
 
 /*
  * RenderNodes correspond to a desired state of a sky.Node. They are fully
- * immutable, with one exception: A Node which is a Component which lives within
- * an Element's children list, may be replaced with the "old" instance if it
+ * 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
  * has become stateful.
  */
-abstract class RenderNode extends Node {
+abstract class RenderNode extends UINode {
 
   static final Map<sky.Node, RenderNode> _nodeMap =
       new HashMap<sky.Node, RenderNode>();
 
   static RenderNode _getMounted(sky.Node node) => _nodeMap[node];
 
   RenderNode({ Object key }) : super(key: key);
 
   RenderNode get _emptyNode;
 
   sky.Node _createNode();
 
-  void _sync(Node old, sky.ParentNode host, sky.Node insertBefore) {
+  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 _remove() {
     assert(_root != null);
     _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 ContentNode  {
+class EventListenerNode 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 28 matching lines @@
     if (onPointerDown != null)
       listeners['pointerdown'] = onPointerDown;
     if (onPointerMove != null)
       listeners['pointermove'] = onPointerMove;
     if (onPointerUp != null)
       listeners['pointerup'] = onPointerUp;
 
     return listeners;
   }
 
-  EventTarget(Node content, {
+  EventListenerNode(UINode content, {
     EventListener onWheel,
     GestureEventListener onGestureFlingCancel,
     GestureEventListener onGestureFlingStart,
     GestureEventListener onGestureScrollStart,
     GestureEventListener onGestureScrollUpdate,
     GestureEventListener onGestureTap,
     GestureEventListener onGestureTapDown,
     PointerEventListener onPointerCancel,
     PointerEventListener onPointerDown,
     PointerEventListener onPointerMove,
@@ skipping 16 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) {
-    Node target = RenderNode._getMounted(e.target);
+    UINode target = RenderNode._getMounted(e.target);
 
     // TODO(rafaelw): StopPropagation?
     while (target != null) {
-      if (target is EventTarget) {
-        (target as EventTarget)._handleEvent(e);
+      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(Node old, sky.ParentNode host, sky.Node insertBefore) {
+  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 {
   final String data;
@@ skipping 13 matching lines @@
   }
 
   void _syncNode(RenderNode old) {
     if (old == _emptyText)
       return; // we set inside _createNode();
 
     (_root as sky.Text).data = data;
   }
 }
 
-final List<Node> _emptyList = new List<Node>();
+final List<UINode> _emptyList = new List<UINode>();
 
-abstract class Element extends RenderNode {
+abstract class WrapperNode extends RenderNode {
 
   String get _tagName;
 
   sky.Node _createNode() => sky.document.createElement(_tagName);
 
-  final List<Node> children;
+  final List<UINode> children;
   final Style style;
   final String inlineStyle;
 
   String _class;
 
-  Element({
+  WrapperNode({
     Object key,
-    List<Node> children,
+    List<UINode> children,
     this.style,
     this.inlineStyle
   }) : this.children = children == null ? _emptyList : children,
        super(key:key) {
 
     if (_isInCheckedMode) {
       _debugReportDuplicateIds();
     }
   }
 
@@ skipping 20 matching lines @@
     }
   }
 
   void _ensureClass() {
     if (_class == null) {
       List<Style> styles = new List<Style>();
       if (style != null) {
         styles.add(style);
       }
 
-      Node parent = _parent;
+      UINode parent = _parent;
       while (parent != null && parent is! RenderNode) {
         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) {
-    Element oldElement = old as Element;
+    WrapperNode oldWrapperNode = old as WrapperNode;
     sky.Element root = _root as sky.Element;
 
     _ensureClass();
-    if (_class != oldElement._class && _class != '')
+    if (_class != oldWrapperNode._class && _class != '')
       root.setAttribute('class', _class);
 
-    if (inlineStyle != oldElement.inlineStyle)
+    if (inlineStyle != oldWrapperNode.inlineStyle)
       root.setAttribute('style', inlineStyle);
 
-    _syncChildren(oldElement);
+    _syncChildren(oldWrapperNode);
   }
 
-  void _syncChildren(Element oldElement) {
+  void _syncChildren(WrapperNode oldWrapperNode) {
     sky.Element root = _root as sky.Element;
     assert(root != null);
 
     var startIndex = 0;
     var endIndex = children.length;
 
-    var oldChildren = oldElement.children;
+    var oldChildren = oldWrapperNode.children;
     var oldStartIndex = 0;
     var oldEndIndex = oldChildren.length;
 
     sky.Node nextSibling = null;
-    Node currentNode = null;
-    Node oldNode = null;
+    UINode currentNode = null;
+    UINode oldNode = null;
 
     void sync(int atIndex) {
       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];
       oldNode = oldChildren[oldEndIndex - 1];
 
       if (currentNode._key != oldNode._key) {
         break;
       }
 
       endIndex--;
       oldEndIndex--;
       sync(endIndex);
       nextSibling = currentNode._root;
     }
 
-    HashMap<String, Node> oldNodeIdMap = null;
+    HashMap<String, UINode> oldNodeIdMap = null;
 
     bool oldNodeReordered(String key) {
       return oldNodeIdMap != null &&
              oldNodeIdMap.containsKey(key) &&
              oldNodeIdMap[key] == null;
     }
 
     void advanceOldStartIndex() {
       oldStartIndex++;
       while (oldStartIndex < oldEndIndex &&
              oldNodeReordered(oldChildren[oldStartIndex]._key)) {
         oldStartIndex++;
       }
     }
 
     void ensureOldIdMap() {
       if (oldNodeIdMap != null)
         return;
 
-      oldNodeIdMap = new HashMap<String, Node>();
+      oldNodeIdMap = new HashMap<String, UINode>();
       for (int i = oldStartIndex; i < oldEndIndex; i++) {
         var node = oldChildren[i];
         if (node is! Text) {
           oldNodeIdMap.putIfAbsent(node._key, () => node);
         }
       }
     }
 
     bool searchForOldNode() {
       if (currentNode is Text)
@@ skipping 41 matching lines @@
     // Removals
     currentNode = null;
     while (oldStartIndex < oldEndIndex) {
       oldNode = oldChildren[oldStartIndex];
       _removeChild(oldNode);
       advanceOldStartIndex();
     }
   }
 }
 
-class Container extends Element {
+class Container extends WrapperNode {
 
   String get _tagName => 'div';
 
   static final Container _emptyContainer = new Container();
 
   RenderNode get _emptyNode => _emptyContainer;
 
   Container({
     Object key,
-    List<Node> children,
+    List<UINode> children,
     Style style,
     String inlineStyle
   }) : super(
     key: key,
     children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 }
 
-class Image extends Element {
+class Image extends WrapperNode {
 
   String get _tagName => 'img';
 
   static final Image _emptyImage = new Image();
 
   RenderNode get _emptyNode => _emptyImage;
 
   final String src;
   final int width;
   final int height;
 
   Image({
     Object key,
-    List<Node> children,
+    List<UINode> children,
     Style style,
     String inlineStyle,
     this.width,
     this.height,
     this.src
   }) : super(
     key: key,
     children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 
-  void _syncNode(Node old) {
+  void _syncNode(UINode old) {
     super._syncNode(old);
 
     Image oldImage = old as Image;
     sky.HTMLImageElement skyImage = _root as sky.HTMLImageElement;
 
     if (src != oldImage.src)
       skyImage.src = src;
 
     if (width != oldImage.width)
       skyImage.style['width'] = '${width}px';
 
     if (height != oldImage.height)
       skyImage.style['height'] = '${height}px';
   }
 }
 
-class Anchor extends Element {
+class Anchor extends WrapperNode {
 
   String get _tagName => 'a';
 
   static final Anchor _emptyAnchor = new Anchor();
 
-  Node get _emptyNode => _emptyAnchor;
+  UINode get _emptyNode => _emptyAnchor;
 
   final String href;
   final int width;
   final int height;
 
   Anchor({
     Object key,
-    List<Node> children,
+    List<UINode> children,
     Style style,
     String inlineStyle,
     this.width,
     this.height,
     this.href
   }) : super(
     key: key,
     children: children,
     style: style,
     inlineStyle: inlineStyle
   );
 
-  void _syncNode(Node old) {
+  void _syncNode(UINode old) {
     super._syncNode(old);
 
     Anchor oldAnchor = old as Anchor;
     sky.HTMLAnchorElement skyAnchor = _root as sky.HTMLAnchorElement;
 
     if (href != oldAnchor.href)
       skyAnchor.href = href;
   }
 }
 
@@ skipping 63 matching lines @@
 void _scheduleComponentForRender(Component c) {
   assert(!_inRenderDirtyComponents);
   _dirtyComponents.add(c);
 
   if (!_buildScheduled) {
     _buildScheduled = true;
     new Future.microtask(_buildDirtyComponents);
   }
 }
 
-abstract class Component extends Node {
+abstract class Component extends UINode {
   bool get _isBuilding => _currentlyBuilding == this;
   bool _dirty = true;
 
   sky.Node get _host => _root.parentNode;
   sky.Node get _insertionPoint => _root == null ? _root : _root.nextSibling;
 
-  Node _built;
+  UINode _built;
   final int _order;
   static int _currentOrder = 0;
   bool _stateful;
   static Component _currentlyBuilding;
   List<Function> _mountCallbacks;
   List<Function> _unmountCallbacks;
 
   void onDidMount(Function fn) {
     if (_mountCallbacks == null)
       _mountCallbacks = new List<Function>();
@@ skipping 33 matching lines @@
 
   void _remove() {
     assert(_built != null);
     assert(_root != null);
     _removeChild(_built);
     _built = null;
     _enqueueDidUnmount(this);
     super._remove();
   }
 
-  bool _willSync(Node old) {
+  bool _willSync(UINode old) {
     Component oldComponent = old as Component;
     if (oldComponent == null || !oldComponent._stateful)
       return false;
 
     // Make |this| the "old" Component
     _stateful = false;
     _built = oldComponent._built;
     assert(_built != null);
 
     // Make |oldComponent| the "new" component
     reflect.copyPublicFields(this, oldComponent);
     oldComponent._built = null;
     oldComponent._dirty = true;
     return true;
   }
 
   /* There are three cases here:
    * 1) Building for the first time:
    *      assert(_built == null && old == null)
    * 2) Re-building (because a dirty flag got set):
    *      assert(_built != null && old == null)
    * 3) Syncing against an old version
    *      assert(_built == null && old != null)
    */
-  void _sync(Node old, sky.ParentNode host, sky.Node insertBefore) {
+  void _sync(UINode old, sky.ParentNode host, sky.Node insertBefore) {
     assert(!_defunct);
     assert(_built == null || old == null);
 
     Component oldComponent = old as Component;
 
     var oldBuilt;
     if (oldComponent == null) {
       oldBuilt = _built;
     } else {
       assert(_built == null);
@@ skipping 31 matching lines @@
   void setState(Function fn()) {
     _stateful = true;
     fn();
     if (_isBuilding || _dirty || _defunct)
       return;
 
     _dirty = true;
     _scheduleComponentForRender(this);
   }
 
-  Node build();
+  UINode build();
 }
 
 abstract class App extends Component {
   sky.Node _host;
 
   App() : super(stateful: true) {
     _host = sky.document.createElement('div');
     sky.document.appendChild(_host);
     _scheduleComponentForRender(this);
   }
 }