Adding support for the MouseWheel event in Streams.

sdk/lib/html/dart2js/html_dart2js.dart

 library html;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html_common';
 import 'dart:indexed_db';
 import 'dart:isolate';
 import 'dart:json' as json;
 import 'dart:math';
 import 'dart:svg' as svg;
@@ skipping 7945 matching lines @@
    * [x-tags][] project. Please note: in the future it may be possible to
    * `extend Element` from your class, in which case this field will be
    * deprecated and will simply return this [Element] object.
    *
    * [wc]: http://dvcs.w3.org/hg/webcomponents/raw-file/tip/explainer/index.html
    * [x-tags]: http://x-tags.org/
    */
   @Creates('Null')  // Set from Dart code; does not instantiate a native type.
   var xtag;
 
+  static const EventStreamProvider<WheelEvent> mouseWheelEvent =
+      const _CustomEventStreamProvider<WheelEvent>(
+        Element._determineMouseWheelEventType);
+
+  static String _determineMouseWheelEventType(EventTarget e) {
+    if (JS('bool', '#.onwheel !== undefined', e)) {
+      // W3C spec, and should be IE9+, but IE has a bug exposing onwheel.
+      return 'wheel';
+    } else if (JS('bool', '#.onmousewheel !== undefined', e)) {
+      // Chrome & IE
+      return 'mousewheel';
+    } else {
+      // Firefox
+      return 'DOMMouseScroll';
+    }
+  }
+
   /**
    * Creates a text node and inserts it into the DOM at the specified location.
    *
    * To see the possible values for [where], read the doc for
    * [insertAdjacentHtml].
    *
    * See also:
    *
    * * [insertAdjacentHtml]
    */
@@ skipping 470 matching lines @@
   Stream<MouseEvent> get onMouseDown => mouseDownEvent.forTarget(this);
 
   Stream<MouseEvent> get onMouseMove => mouseMoveEvent.forTarget(this);
 
   Stream<MouseEvent> get onMouseOut => mouseOutEvent.forTarget(this);
 
   Stream<MouseEvent> get onMouseOver => mouseOverEvent.forTarget(this);
 
   Stream<MouseEvent> get onMouseUp => mouseUpEvent.forTarget(this);
 
+  Stream<WheelEvent> get onMouseWheel => mouseWheelEvent.forTarget(this);
+
   Stream<Event> get onPaste => pasteEvent.forTarget(this);
 
   Stream<Event> get onReset => resetEvent.forTarget(this);
 
   Stream<Event> get onScroll => scrollEvent.forTarget(this);
 
   Stream<Event> get onSearch => searchEvent.forTarget(this);
 
   Stream<Event> get onSelect => selectEvent.forTarget(this);
 
@@ skipping 13304 matching lines @@
   EventListenerList get open => this['open'];
 }
 // 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.
 
 
 /// @domName WheelEvent
 class WheelEvent extends MouseEvent native "*WheelEvent" {
 
+  factory WheelEvent(
+      String type,
+      Window view,
+      int wheelDeltaX,
+      int wheelDeltaY,
+      int detail,
+      int screenX,
+      int screenY,
+      int clientX,
+      int clientY,
+      int button,
+      [bool canBubble = true,
+      bool cancelable = true,
+      bool ctrlKey = false,
+      bool altKey = false,
+      bool shiftKey = false,
+      bool metaKey = false,
+      EventTarget relatedTarget = null]) {
+
+    var eventType = 'WheelEvent';
+    if (_Device.isFirefox) {
+      eventType = 'MouseScrollEvents';
+    }
+    final event = document.$dom_createEvent(eventType);
+    if (event._hasInitWheelEvent) {
+      var modifiers = [];
+      if (ctrlKey) {
+        modifiers.push('Control');
+      }
+      if (altKey) {
+        modifiers.push('Alt');
+      }
+      if (shiftKey) {
+        modifiers.push('Shift');
+      }
+      if (metaKey) {
+        modifiers.push('Meta');
+      }
+      var modifiersList = modifiers.join(' ');
+      event._initWheelEvent(
+        type,
+        canBubble,
+        cancelable,
+        view,
+        detail,
+        screenX,
+        screenY,
+        clientX,
+        clientY,
+        button,
+        relatedTarget,
+        modifiersList,
+        wheelDeltaX,
+        wheelDeltaY,
+        0,
+        0);
+    } else if (event._hasInitMouseScrollEvent) {
+      var axis = 0;
+      var detail = 0;
+      if (wheelDeltaX != 0 && wheelDeltaY != 0) {
+        throw UnsupportedError(
+            'Cannot modify wheelDeltaX and wheelDeltaY simultaneously');
+      }
+      if (wheelDeltaY != 0) {
+        detail = wheelDeltaY;
+        axis = JS('int', 'MouseScrollEvent.VERTICAL_AXIS');
+      } else if (wheelDeltaX != 0) {
+        detail = wheelDeltaX;
+        axis = JS('int', 'MouseScrollEvent.HORIZONTAL_AXIS');
+      }
+      event._initMouseScrollEvent(
+        type,
+        canBubble,
+        cancelable,
+        view,
+        detail,
+        screenX,
+        screenY,
+        clientX,
+        clientY,
+        ctrlKey,
+        altKey,
+        shiftKey,
+        metaKey,
+        button,
+        relatedTarget,
+        axis);
+    } else {
+      // Fallthrough for Dartium.
+      event.$dom_initMouseEvent(
+          type,
+          canBubble,
+          cancelable,
+          view,
+          detail,
+          screenX,
+          screenY,
+          clientX,
+          clientY,
+          ctrlKey,
+          altKey,
+          shiftKey,
+          metaKey,
+          button,
+          relatedTarget);
+      event.$dom_initWebKitWheelEvent(
+          wheelDeltaX,
+          (wheelDeltaY / 120).toInt(), // Chrome does an auto-convert to pixels.
+          view,
+          screenX,
+          screenY,
+          clientX,
+          clientY,
+          ctrlKey,
+          altKey,
+          shiftKey,
+          metaKey);
+    }
+
+    return event;
+  }
+
+
   /// @domName WheelEvent.webkitDirectionInvertedFromDevice; @docsEditable true
   final bool webkitDirectionInvertedFromDevice;
 
   /// @domName WheelEvent.initWebKitWheelEvent; @docsEditable true
-  void initWebKitWheelEvent(int wheelDeltaX, int wheelDeltaY, Window view, int screenX, int screenY, int clientX, int clientY, bool ctrlKey, bool altKey, bool shiftKey, bool metaKey) native;
+  @JSName('initWebKitWheelEvent')
+  void $dom_initWebKitWheelEvent(int wheelDeltaX, int wheelDeltaY, Window view, int screenX, int screenY, int clientX, int clientY, bool ctrlKey, bool altKey, bool shiftKey, bool metaKey) native;
 
 
   /** @domName WheelEvent.deltaY */
   num get deltaY {
     if (JS('bool', '#.deltaY !== undefined', this)) {
       // W3C WheelEvent
       return this._deltaY;
     } else if (JS('bool', '#.wheelDelta !== undefined', this)) {
       // Chrome and IE
       return this._wheelDelta;
@@ skipping 24 matching lines @@
       return this._deltaX;
     } else if (JS('bool', '#.wheelDeltaX !== undefined', this)) {
       // Chrome
       return this._wheelDeltaX;
     } else if (JS('bool', '#.detail !== undefined', this)) {
       // Firefox and IE.
       // IE will have detail set but will not set axis.
 
       // Handle DOMMouseScroll case where it uses detail and the axis to
       // differentiate.
-      if (JS('bool', '#.axis !== undefined && #.axis == MouseScrollEvent.HORIZONTAL_AXIS', this, this)) {
+      if (JS('bool', '#.axis !== undefined && '
+        '#.axis == MouseScrollEvent.HORIZONTAL_AXIS', this, this)) {
         var detail = this._detail;
         // Firefox is normally the number of lines to scale (normally 3)
         // so multiply it by 40 to get pixels to move, matching IE & WebKit.
         if (detail < 100) {
           return detail * 40;
         }
         return detail;
       }
       return 0;
     }
     throw new UnsupportedError(
         'deltaX is not supported');
   }
 
   int get deltaMode {
     if (JS('bool', '!!#.deltaMode', this)) {
       // If not available then we're poly-filling and doing pixel scroll.
       return 0;
     }
     return this._deltaMode;
   }
 
   num get _deltaY => JS('num', '#.deltaY', this);
   num get _deltaX => JS('num', '#.deltaX', this);
   num get _wheelDelta => JS('num', '#.wheelDelta', this);
   num get _wheelDeltaX => JS('num', '#.wheelDeltaX', this);
   num get _detail => JS('num', '#.detail', this);
   int get _deltaMode => JS('int', '#.deltaMode', this);
 
+  bool get _hasInitMouseScrollEvent =>
+      JS('bool', '!!(#.initMouseScrollEvent)', this);
+
+  @JSName('initMouseScrollEvent')
+  void _initMouseScrollEvent(
+      String type,
+      bool canBubble,
+      bool cancelable,
+      Window view,
+      int detail,
+      int screenX,
+      int screenY,
+      int clientX,
+      int clientY,
+      bool ctrlKey,
+      bool altKey,
+      bool shiftKey,
+      bool metaKey,
+      int button,
+      EventTarget relatedTarget,
+      int axis) native;
+
+  bool get _hasInitWheelEvent =>
+      JS('bool', '!!(#.initWheelEvent)', this);
+  @JSName('initWheelEvent')
+  void _initWheelEvent(
+      String eventType,
+      bool canBubble,
+      bool cancelable,
+      Window view,
+      int detail,
+      int screenX,
+      int screenY,
+      int clientX,
+      int clientY,
+      int button,
+      EventTarget relatedTarget,
+      String modifiersList,
+      int deltaX,
+      int deltaY,
+      int deltaZ,
+      int deltaMode) native;
+
 }
 // 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.
 
 
 /// @domName Window
 class Window extends EventTarget implements WindowBase native "@*DOMWindow" {
 
   Document get document => JS('Document', '#.document', this);
@@ skipping 3657 matching lines @@
    *     MediaElement.pauseEvent.forTarget(document.body).listen(...);
    *
    * See also:
    *
    * [addEventListener](http://docs.webplatform.org/wiki/dom/methods/addEventListener)
    */
   Stream<T> forTarget(EventTarget e, {bool useCapture: false}) {
     return new _EventStream(e, _eventType, useCapture);
   }
 }
+
+typedef String _EventTypeGetter(EventTarget target);
+
+/**
+ * A factory to expose DOM events as streams, where the DOM event name has to
+ * be determined on the fly (for example, mouse wheel events).
+ */
+class _CustomEventStreamProvider<T extends Event>
+    implements EventStreamProvider<T> {
+
+  final _eventTypeGetter;
+  const _CustomEventStreamProvider(this._eventTypeGetter);
+
+  Stream<T> forTarget(EventTarget e, {bool useCapture: false}) {
+    return new _EventStream(e, _eventTypeGetter(e), useCapture);
+  }
+}
 // 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.
 
 
 /**
  * Works with KeyboardEvent and KeyEvent to determine how to expose information
  * about Key(board)Events. This class functions like an EventListenerList, and
  * provides a consistent interface for the Dart
  * user, despite the fact that a multitude of browsers that have varying
@@ skipping 2532 matching lines @@
       _position = nextPosition;
       return true;
     }
     _current = null;
     _position = _array.length;
     return false;
   }
 
   T get current => _current;
 }