"Reverting 28321"

tools/dom/src/KeyboardEventStream.dart

 // Copyright (c) 2012, 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;
 
 /**
  * Internal class that does the actual calculations to determine keyCode and
  * charCode for keydown, keypress, and keyup events for all browsers.
  */
 class _KeyboardEventHandler extends EventStreamProvider<KeyEvent> {
   // This code inspired by Closure's KeyHandling library.
   // http://closure-library.googlecode.com/svn/docs/closure_goog_events_keyhandler.js.source.html
 
   /**
    * The set of keys that have been pressed down without seeing their
    * corresponding keyup event.
    */
   final List<KeyboardEvent> _keyDownList = <KeyboardEvent>[];
 
   /** The type of KeyEvent we are tracking (keyup, keydown, keypress). */
   final String _type;
 
   /** The element we are watching for events to happen on. */
   final EventTarget _target;
 
   // The distance to shift from upper case alphabet Roman letters to lower case.
   static final int _ROMAN_ALPHABET_OFFSET = "a".codeUnits[0] - "A".codeUnits[0];
 
-  /** Custom Stream (Controller) to produce KeyEvents for the stream. */
-  _CustomKeyEventStreamImpl _stream;
+  /** Controller to produce KeyEvents for the stream. */
+  final StreamController _controller = new StreamController(sync: true);
 
   static const _EVENT_TYPE = 'KeyEvent';
 
   /**
    * An enumeration of key identifiers currently part of the W3C draft for DOM3
    * and their mappings to keyCodes.
    * http://www.w3.org/TR/DOM-Level-3-Events/keyset.html#KeySet-Set
    */
   static const Map<String, int> _keyIdentifier = const {
     'Up': KeyCode.UP,
@@ skipping 15 matching lines @@
     'F12': KeyCode.F12,
     'U+007F': KeyCode.DELETE,
     'Home': KeyCode.HOME,
     'End': KeyCode.END,
     'PageUp': KeyCode.PAGE_UP,
     'PageDown': KeyCode.PAGE_DOWN,
     'Insert': KeyCode.INSERT
   };
 
   /** Return a stream for KeyEvents for the specified target. */
-  // Note: this actually functions like a factory constructor.
-  CustomStream<KeyEvent> forTarget(EventTarget e, {bool useCapture: false}) {
-    var handler = new _KeyboardEventHandler.initializeAllEventListeners(
-        _type, e);
-    return handler._stream;
+  Stream<KeyEvent> forTarget(EventTarget e, {bool useCapture: false}) {
+    return new _KeyboardEventHandler.initializeAllEventListeners(
+        _type, e).stream;
+  }
+
+  /**
+   * Accessor to the stream associated with a particular KeyboardEvent
+   * EventTarget.
+   *
+   * [forTarget] must be called to initialize this stream to listen to a
+   * particular EventTarget.
+   */
+  Stream<KeyEvent> get stream {
+    if(_target != null) {
+      return _controller.stream;
+    } else {
+      throw new StateError("Not initialized. Call forTarget to access a stream "
+          "initialized with a particular EventTarget.");
+    }
   }
 
   /**
    * General constructor, performs basic initialization for our improved
    * KeyboardEvent controller.
    */
-  _KeyboardEventHandler(this._type): super(_EVENT_TYPE),
-      _stream = new _CustomKeyEventStreamImpl('event');
+  _KeyboardEventHandler(this._type) :
+    _target = null, super(_EVENT_TYPE) {
+  }
 
   /**
    * Hook up all event listeners under the covers so we can estimate keycodes
    * and charcodes when they are not provided.
    */
   _KeyboardEventHandler.initializeAllEventListeners(this._type, this._target) :
-      super(_EVENT_TYPE) {
+    super(_EVENT_TYPE) {
     Element.keyDownEvent.forTarget(_target, useCapture: true).listen(
         processKeyDown);
     Element.keyPressEvent.forTarget(_target, useCapture: true).listen(
         processKeyPress);
     Element.keyUpEvent.forTarget(_target, useCapture: true).listen(
         processKeyUp);
-    _stream = new _CustomKeyEventStreamImpl(_type);
+  }
+
+  /**
+   * Notify all callback listeners that a KeyEvent of the relevant type has
+   * occurred.
+   */
+  bool _dispatch(KeyEvent event) {
+    if (event.type == _type)
+      _controller.add(event);
   }
 
   /** Determine if caps lock is one of the currently depressed keys. */
   bool get _capsLockOn =>
       _keyDownList.any((var element) => element.keyCode == KeyCode.CAPS_LOCK);
 
   /**
    * Given the previously recorded keydown key codes, see if we can determine
    * the keycode of this keypress [event]. (Generally browsers only provide
    * charCode information for keypress events, but with a little
@@ skipping 170 matching lines @@
     // before we've caught a key-up event.  If the last-key was one of these
     // we reset the state.
     if (_keyDownList.length > 0 &&
         (_keyDownList.last.keyCode == KeyCode.CTRL && !e.ctrlKey ||
          _keyDownList.last.keyCode == KeyCode.ALT && !e.altKey ||
          Device.userAgent.contains('Mac') &&
          _keyDownList.last.keyCode == KeyCode.META && !e.metaKey)) {
       _keyDownList.clear();
     }
 
-    var event = new KeyEvent.wrap(e);
+    var event = new KeyEvent(e);
     event._shadowKeyCode = _normalizeKeyCodes(event);
     // Technically a "keydown" event doesn't have a charCode. This is
     // calculated nonetheless to provide us with more information in giving
     // as much information as possible on keypress about keycode and also
     // charCode.
     event._shadowCharCode = _findCharCodeKeyDown(event);
     if (_keyDownList.length > 0 && event.keyCode != _keyDownList.last.keyCode &&
         !_firesKeyPressEvent(event)) {
       // Some browsers have quirks not firing keypress events where all other
       // browsers do. This makes them more consistent.
       processKeyPress(e);
     }
     _keyDownList.add(event);
-    _stream.add(event);
+    _dispatch(event);
   }
 
   /** Handle keypress events. */
   void processKeyPress(KeyboardEvent event) {
-    var e = new KeyEvent.wrap(event);
+    var e = new KeyEvent(event);
     // IE reports the character code in the keyCode field for keypress events.
     // There are two exceptions however, Enter and Escape.
     if (Device.isIE) {
       if (e.keyCode == KeyCode.ENTER || e.keyCode == KeyCode.ESC) {
         e._shadowCharCode = 0;
       } else {
         e._shadowCharCode = e.keyCode;
       }
     } else if (Device.isOpera) {
       // Opera reports the character code in the keyCode field.
       e._shadowCharCode = KeyCode.isCharacterKey(e.keyCode) ? e.keyCode : 0;
     }
     // Now we guestimate about what the keycode is that was actually
     // pressed, given previous keydown information.
     e._shadowKeyCode = _determineKeyCodeForKeypress(e);
 
     // Correct the key value for certain browser-specific quirks.
     if (e._shadowKeyIdentifier != null &&
         _keyIdentifier.containsKey(e._shadowKeyIdentifier)) {
       // This is needed for Safari Windows because it currently doesn't give a
       // keyCode/which for non printable keys.
       e._shadowKeyCode = _keyIdentifier[e._shadowKeyIdentifier];
     }
     e._shadowAltKey = _keyDownList.any((var element) => element.altKey);
-    _stream.add(e);
+    _dispatch(e);
   }
 
   /** Handle keyup events. */
   void processKeyUp(KeyboardEvent event) {
-    var e = new KeyEvent.wrap(event);
+    var e = new KeyEvent(event);
     KeyboardEvent toRemove = null;
     for (var key in _keyDownList) {
       if (key.keyCode == e.keyCode) {
         toRemove = key;
       }
     }
     if (toRemove != null) {
       _keyDownList.removeWhere((element) => element == toRemove);
     } else if (_keyDownList.length > 0) {
       // This happens when we've reached some international keyboard case we
       // haven't accounted for or we haven't correctly eliminated all browser
       // inconsistencies. Filing bugs on when this is reached is welcome!
       _keyDownList.removeLast();
     }
-    _stream.add(e);
+    _dispatch(e);
   }
 }
 
 
 /**
  * Records KeyboardEvents that occur on a particular element, and provides a
  * stream of outgoing KeyEvents with cross-browser consistent keyCode and
  * charCode values despite the fact that a multitude of browsers that have
  * varying keyboard default behavior.
  *
  * Example usage:
  *
  *     KeyboardEventStream.onKeyDown(document.body).listen(
  *         keydownHandlerTest);
  *
  * This class is very much a work in progress, and we'd love to get information
  * on how we can make this class work with as many international keyboards as
  * possible. Bugs welcome!
  */
 class KeyboardEventStream {
 
   /** Named constructor to produce a stream for onKeyPress events. */
-  static CustomStream<KeyEvent> onKeyPress(EventTarget target) =>
+  static Stream<KeyEvent> onKeyPress(EventTarget target) =>
       new _KeyboardEventHandler('keypress').forTarget(target);
 
   /** Named constructor to produce a stream for onKeyUp events. */
-  static CustomStream<KeyEvent> onKeyUp(EventTarget target) =>
+  static Stream<KeyEvent> onKeyUp(EventTarget target) =>
       new _KeyboardEventHandler('keyup').forTarget(target);
 
   /** Named constructor to produce a stream for onKeyDown events. */
-  static CustomStream<KeyEvent> onKeyDown(EventTarget target) =>
-      new _KeyboardEventHandler('keydown').forTarget(target);
+  static Stream<KeyEvent> onKeyDown(EventTarget target) =>
+    new _KeyboardEventHandler('keydown').forTarget(target);
 }