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

sky/framework/README.md

 Sky Framework
 =============
 
 Effen is a functional-reactive framework for Sky which takes inspiration from
 [React](http://facebook.github.io/react/). Effen is comprised of three main
 parts: a virtual-dom and diffing engine, a component mechanism and a very early
 set of widgets for use in creating applications.
 
 The central idea is that you build your UI out of components. Components
 describe what their view should look like given their current configuration &
@@ skipping 15 matching lines @@
   new HelloWorldApp();
 }
 </script>
 ```
 
 ```dart
 // In hello_world.dart
 import 'package:sky/framework/fn.dart';
 
 class HelloWorldApp extends App {
-  Node build() {
+  UINode build() {
     return new Text('Hello, world!');
   }
 }
 ```
 
 An app is comprised of (and is, itself, a) components. A component's main job is
-to implement `Node build()`. The idea here is that the `build` method describes
+to implement `UINode build()`. The idea here is that the `build` method describes
 the DOM of a component at any given point during its lifetime. In this case, our
 `HelloWorldApp`'s `build` method just returns a `Text` node which displays the
 obligatory line of text.
 
 Nodes
 -----
 
-A component's `build` method must return a single `Node` which *may* have
+A component's `build` method must return a single `UINode` which *may* have
 children (and so on, forming a *subtree*). Effen comes with a few built-in nodes
 which mirror the built-in nodes/elements of sky: `Text`, `Anchor` (`<a />`,
 `Image` (`<img />`) and `Container` (`<div />`). `build` can return a tree of
 Nodes comprised of any of these nodes and plus any other imported object which
 extends `Component`.
 
 How to structure you app
 ------------------------
 
 If you're familiar with React, the basic idea is the same: Application data
@@ skipping 77 matching lines @@
 In many cases, nodes don't require a key because there is only one type amongst
 its siblings -- but if there is more one, you must assign each a key. This is
 why most nodes will take `({ Object key })` as an optional constructor
 parameter. In development mode (i.e. when sky is built `Debug`) Effen will throw
 an error if you forget to do this.
 
 Event Handling
 --------------
 
 Events logically fire through the Effen node tree. If want to handle an event as
-it bubbles from the target to the root, create an `EventTarget`. `EventTarget`
+it bubbles from the target to the root, create an `EventListenerNode`. `EventListenerNode`
 has named (typed) parameters for a small set of events that we've hit so far, as
 well as a 'custom' argument which is a `Map<String, sky.EventListener>`. If
 you'd like to add a type argument for an event, just post a patch.
 
 ```dart
 class MyComp extends Component {
   MyComp({
     Object key
   }) : super(key: key);
 
   void _handleTap(sky.GestureEvent e) {
     // do stuff
   }
 
   void _customEventCallback(sky.Event e) {
     // do other stuff
   }
 
-  Node build() {
-    new EventTarget(
+  UINode build() {
+    new EventListenerNode(
       new Container(
         children: // ...
       ),
       onGestureTap: _handleTap,
       custom: {
         'myCustomEvent': _customEventCallback
       }
     );
   }
 
   _handleScroll(sky.Event e) {
     setState(() {
       // update the scroll position
     });
   }
 }
 ```
 
 Styling
 -------
 
 Styling is the part of Effen which is least designed and is likely to change.
-There are two ways to specify styles:
+There are three ways to specify styles:
 
-  * `Style` objects which are interned and can be applied to Elements via the
+  * `Style` objects which are interned and can be applied to WrapperNodes via the
     ``style` constructor parameter. Use `Style` objects for styles which are
     `*not* animated.
 
   * An `inlineStyle` string which can be applied to Elements via the
     `inlineStyle` constructor parameter.  Use `inlineStyle` for styles which
     *are* animated.
   
-If you need to apply a Style to a Component or Node which you didn't construct
+If you need to apply a Style to a Component or UINode which you didn't construct
 (i.e. one that was handed into your constructor), you can wrap it in a
 `StyleNode` which also takes a `Style` constructor in it's `style` constructor
 parameter.
 
 Animation
 ---------
 
 Animation is still an area of exploration. Have a look at
 [AnimatedComponent](components/animated_component.dart) and
 [Drawer](components/drawer.dart) for an example of this this currently works.
 
 Performance
 -----------
 
 It is a design goal that it should be *possible* to arrange that all "build"
 cycles which happen during animations can complete in less than one milliesecond
 on a Nexus 5.