Adding ElementEventStream.capture

tools/dom/src/EventStreamProvider.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 html;
 
 /**
  * Adapter for exposing DOM events as Dart streams.
  */
 class _EventStream<T extends Event> extends Stream<T> {
@@ skipping 22 matching lines @@
 /** A specialized Stream available to [Element]s to enable event delegation. */
 abstract class ElementStream<T extends Event> implements Stream<T> {
   /**
    * Return a stream that only fires when the particular event fires for
    * elements matching the specified CSS selector.
    *
    * This is the Dart equivalent to jQuery's
    * [delegate](http://api.jquery.com/delegate/).
    */
   Stream<T> matches(String selector);
+
+  StreamSubscription<T> capture(void onData(T event));
 }
 
 /**
  * Adapter for exposing DOM Element events as streams, while also allowing
  * event delegation.
  */
 class _ElementEventStreamImpl<T extends Event> extends _EventStream<T>
     implements ElementStream<T> {
   _ElementEventStreamImpl(target, eventType, useCapture) :
       super(target, eventType, useCapture);
 
   Stream<T> matches(String selector) => this.where(
       (event) => event.target.matchesWithAncestors(selector)).map((e) {
         e._selector = selector;
         return e;
       });
+
+  StreamSubscription<T> capture(void onData(T event)) =>
+    new _EventStreamSubscription<T>(
+        this._target, this._eventType, onData, true);
 }
 
 /**
  * Adapter for exposing events on a collection of DOM Elements as streams,
  * while also allowing event delegation.
  */
 class _ElementListEventStreamImpl<T extends Event> extends Stream<T>
     implements ElementStream<T> {
-  final _StreamPool _pool;
-  Stream<T> _stream;
+  final Iterable<Element> _targetList;
+  final bool _useCapture;
+  final String _eventType;
 
-  _ElementListEventStreamImpl(targetList, eventType, useCapture) :
-      _pool = new _StreamPool.broadcast() {
-    for (Element target in targetList) {
-      var stream = new _EventStream(target, eventType, useCapture);
-      _pool.add(stream);
-    }
-    _stream = _pool.stream;
-  }
+  _ElementListEventStreamImpl(
+      this._targetList, this._eventType, this._useCapture);
 
   Stream<T> matches(String selector) => this.where(
       (event) => event.target.matchesWithAncestors(selector)).map((e) {
         e._selector = selector;
         return e;
       });
 
-  // Delegate all regular Stream behavor to our wrapped Stream.
+  // Delegate all regular Stream behavior to a wrapped Stream.
   StreamSubscription<T> listen(void onData(T event),
       { Function onError,
         void onDone(),
-        bool cancelOnError}) =>
-      _stream.listen(onData, onError: onError, onDone: onDone,
+        bool cancelOnError}) {
+    var pool = new _StreamPool.broadcast();
+    for (var target in _targetList) {
+      pool.add(new _EventStream(target, _eventType, _useCapture));
+    }
+    return pool.stream.listen(onData, onError: onError, onDone: onDone,
           cancelOnError: cancelOnError);
+  }
+
+  StreamSubscription<T> capture(void onData(T event)) {
+    var pool = new _StreamPool.broadcast();
+    for (var target in _targetList) {
+      pool.add(new _EventStream(target, _eventType, true));
+    }
+    return pool.stream.listen(onData);
+  }
+
   Stream<T> asBroadcastStream({void onListen(StreamSubscription subscription),
                                void onCancel(StreamSubscription subscription)})
-      => _stream;
+      => this;
   bool get isBroadcast => true;
 }
 
 /**
  * A stream of custom events, which enables the user to "fire" (add) their own
  * custom events to a stream.
  */
 abstract class CustomStream<T extends Event> implements Stream<T> {
   /**
    * Add the following custom event to the stream for dispatching to interested
@@ skipping 277 matching lines @@
 
   ElementStream<T> _forElementList(ElementList e,
       {bool useCapture: false}) {
     return new _ElementListEventStreamImpl(e, _eventTypeGetter(e), useCapture);
   }
 
   String getEventType(EventTarget target) {
     return _eventTypeGetter(target);
   }
 }