[mdv] implement Node.createBinding and Node.createBindings

pkg/mdv/lib/src/input_bindings.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of mdv;
 
-abstract class _InputBinding {
-  // InputElement or SelectElement
-  final element;
-  PathObserver binding;
-  StreamSubscription _pathSub;
+abstract class _InputBinding extends NodeBinding {
   StreamSubscription _eventSub;
 
-  _InputBinding(this.element, model, String path) {
-    binding = new PathObserver(model, path);
-    _pathSub = binding.bindSync(valueChanged);
-    _eventSub = _getStreamForInputType(element).listen(updateBinding);
+  _InputBinding(node, name, model, path): super(node, name, model, path) {
+    _eventSub = _getStreamForInputType(node).listen(nodeValueChanged);
   }
 
-  void valueChanged(newValue);
+  void boundValueChanged(newValue);
 
-  void updateBinding(e);
+  void nodeValueChanged(e);
 
-  void unbind() {
-    binding = null;
-    _pathSub.cancel();
+  void close() {
+    if (closed) return;
     _eventSub.cancel();
+    super.close();
   }
 
   static EventStreamProvider<Event> _checkboxEventType = () {
     // Attempt to feature-detect which event (change or click) is fired first
     // for checkboxes.
     var div = new DivElement();
     var checkbox = div.append(new InputElement());
     checkbox.type = 'checkbox';
     var fired = [];
     checkbox.onClick.listen((e) {
@@ skipping 16 matching lines @@
       case 'select-multiple':
       case 'select-one':
         return element.onChange;
       default:
         return element.onInput;
     }
   }
 }
 
 class _ValueBinding extends _InputBinding {
-  _ValueBinding(element, model, path) : super(element, model, path);
+  _ValueBinding(node, model, path) : super(node, 'value', model, path);
 
-  void valueChanged(value) {
-    // Note: element can be an InputElement or TextAreaElement.
-    element.value = value == null ? '' : '$value';
+  get node => super.node;

[Siggi Cherem (dart-lang), 2013/07/25 16:24:12]

remove this getter or the 'as dynamic' below?

+
+  void boundValueChanged(newValue) {
+    // Note: node can be an InputElement or TextAreaElement. Both have "value".
+    (node as dynamic).value = sanitizeBoundValue(newValue);
   }
 
-  void updateBinding(e) {
-    binding.value = element.value;
+  void nodeValueChanged(e) {
+    value = (node as dynamic).value;
   }
 }
 
 class _CheckedBinding extends _InputBinding {
-  _CheckedBinding(element, model, path) : super(element, model, path);
+  _CheckedBinding(node, model, path) : super(node, 'checked', model, path);
 
-  InputElement get element => super.element;
+  InputElement get node => super.node;
 
-  void valueChanged(value) {
-    element.checked = _toBoolean(value);
+  void boundValueChanged(newValue) {
+    node.checked = _toBoolean(newValue);
   }
 
-  void updateBinding(e) {
-    binding.value = element.checked;
+  void nodeValueChanged(e) {
+    value = node.checked;
 
     // Only the radio button that is getting checked gets an event. We
     // therefore find all the associated radio buttons and update their
     // CheckedBinding manually.
-    if (element is InputElement && element.type == 'radio') {
-      for (var r in _getAssociatedRadioButtons(element)) {
-        var checkedBinding = _mdv(r)._checkedBinding;
+    if (node is InputElement && node.type == 'radio') {
+      for (var r in _getAssociatedRadioButtons(node)) {
+        var checkedBinding = r.bindings['checked'];
         if (checkedBinding != null) {
           // Set the value directly to avoid an infinite call stack.
-          checkedBinding.binding.value = false;
+          checkedBinding.value = false;
         }
       }
     }
   }
 
   // |element| is assumed to be an HTMLInputElement with |type| == 'radio'.
   // Returns an array containing all radio buttons other than |element| that
   // have the same |name|, either in the form that |element| belongs to or,
   // if no form, in the document tree to which |element| belongs.
   //
@@ skipping 21 matching lines @@
   static bool _isNodeInDocument(Node node) {
     // On non-IE this works:
     // return node.document.contains(node);
     var document = node.document;
     if (node == document || node.parentNode == document) return true;
     return document.documentElement.contains(node);
   }
 }
 
 class _SelectedIndexBinding extends _InputBinding {
-  _SelectedIndexBinding(element, model, path) : super(element, model, path);
+  _SelectedIndexBinding(node, model, path)
+      : super(node, 'selectedIndex', model, path);
 
-  SelectElement get element => super.element;
+  SelectElement get node => super.node;
 
-  void valueChanged(value) {
+  void boundValueChanged(value) {
     var newValue = _toInt(value);
-    if (newValue <= element.length) {
-      element.selectedIndex = newValue;
+    if (newValue <= node.length) {
+      node.selectedIndex = newValue;
       return;
     }
 
     // The binding may wish to bind to an <option> which has not yet been
     // produced by a child <template>. Furthermore, we may need to wait for
     // <optgroup> iterating and then for <option>.
     //
     // Unlike the JavaScript MDV, we don't have a special "Object.observe" event
     // loop to schedule on. (See the the "ensureScheduled" function:
     // https://github.com/Polymer/mdv/commit/9a51ad7ed74a292bf71662cea28acbd151ff65c8)
     //
     // Instead we use runAsync. Each <template repeat> needs a delay of 2:
     //   * once to happen after the child _TemplateIterator is created
     //   * once to be after _TemplateIterator.inputs CompoundBinding resolve
     // And then we need to do this delay sequence twice:
     //   * once for OPTGROUP
     //   * once for OPTION.
     // The resulting 2 * 2 is our maxRetries.
     var maxRetries = 4;
     delaySetSelectedIndex() {
-      if (newValue > element.length && --maxRetries >= 0) {
+      if (newValue > node.length && --maxRetries >= 0) {
         runAsync(delaySetSelectedIndex);
       } else {
-        element.selectedIndex = newValue;
+        node.selectedIndex = newValue;
       }
     }
 
     runAsync(delaySetSelectedIndex);
   }
 
-  void updateBinding(e) {
-    binding.value = element.selectedIndex;
+  void nodeValueChanged(e) {
+    value = node.selectedIndex;
   }
 
   // TODO(jmesserly,sigmund): I wonder how many bindings typically convert from
   // one type to another (e.g. value-as-number) and whether it is useful to
   // have something like a int/num binding converter (either as a base class or
   // a wrapper).
   static int _toInt(value) {
     if (value is String) return int.parse(value, onError: (_) => null);
     return value is int ? value : null;
   }
 }