Specs: dartification of gestures; move GestureManager from ApplicationDocument to Application; actu…

sky/specs/pointer.md

 Pointer Events
 ==============
 
 Scope
 -----
 
 The following input devices are supported by sky:
  - fingers on multitouch screens
  - mice, including mouse wheels
  - styluses on screens
@@ skipping 326 matching lines @@
 
 
 TODO(ianh): add an API that exposes the currently existing pointers,
 so that you can determine e.g. if you have a mouse.
 
 Here are the class definitions for pointer events:
 
 ```dart
 enum PointerKind { touch, mouse, stylus, invertedStylus }
 
-abstract class PointerEvent extends Event {
-  PointerEvent({ bool bubbles,
-                 this.pointer,
+abstract class PointerEvent<T> extends Event<T> {
+  PointerEvent({ this.pointer,
                  this.kind,
                  this.x, this.y,
                  this.dx: 0.0, this.dy: 0.0,
                  this.buttons: 0,
                  this.down: false,
                  this.primary: false,
                  this.obscured: false,
                  this.pressure, this.minPressure, this.maxPressure,
                  this.distance, this.minDistance, this.maxDistance,
                  this.radiusMajor, this.radiusMinor, this.minRadius, this.maxRadius,
                  this.orientation, this.tilt
-               }): super(bubbles: bubbles);
+               }): super();
 
   final int pointer;
   final PointerKind kind;
   final double x; // logical pixels
   final double y; // logical pixels
   final double dx; // logical pixels
   final double dy; // logical pixels
 
   final int buttons; // bit field
   static const int primaryMouseButton = 0x01;
@@ skipping 28 matching lines @@
   final double orientation; // radians // meaning is different for touch and stylus/invertedStylus
 
   // if kind != stylus or invertedStylus, this is null
   final double tilt; // radians
 }
 
 // the following uses proposed syntax from
 // https://code.google.com/p/dart/issues/detail?id=22274
 // to avoid duplicating that entire constructor up there
 
-class PointerAddedEvent extends Event {
+class PointerAddedEvent extends PointerEvent<Null> {
   PointerAddedEvent = PointerEvent;
+  bool get bubbles => false;
 }
 
-class PointerRemovedEvent extends Event {
+class PointerRemovedEvent extends PointerEvent<Null> {
   PointerRemovedEvent = PointerEvent;
+  bool get bubbles => false;
 }
 
-class PointerDownEvent extends Event {
+class PointerDownEvent extends PointerEvent<List<EventTarget>> {
+  @override void init() { result = new List<EventTarget>(); }
   PointerDownEvent = PointerEvent;
+  bool get bubbles => true;
 }
 
-class PointerUpEvent extends Event {
+class PointerUpEvent extends PointerEvent<Null> {
   PointerUpEvent = PointerEvent;
+  bool get bubbles => false;
 }
 
-class PointerMovedEvent extends Event {
+class PointerMovedEvent extends PointerEvent<Null> {
   PointerMovedEvent = PointerEvent;
+  bool get bubbles => false;
 }
 ```
 
 Wheel events
 ------------
 
 When a wheel input device is turned, a ``WheelEvent`` event that
-bubbles is fired at the application's document, with the following
-fields:
+doesn't bubble is fired at the application's document, with the
+following fields:
 
           wheel: an integer assigned to this wheel by the system. The
                  same wheel on the same system must always be given
                  the same ID. The primary wheel (e.g. the vertical
                  wheel on a mouse) must be given ID 1.
 
           delta: an floating point number representing the fraction of
                  the wheel that was turned, with positive numbers
                  representing a downward movement on vertical wheels,
                  rightward movement on horizontal wheels, and a
                  clockwise movement on wheels with a user-facing side.
 
 Additionally, if the wheel is associated with a pointer (e.g. a mouse
 wheel), the following fields must be present also:
 
         pointer: the integer assigned to the pointer in its
                  ``PointerAddEvent`` event (see above).
 
               x: x-position relative to the top-left corner of the
                  display, in global layout coordinates
 
               y: x-position relative to the top-left corner of the
                  display, in global layout coordinates
 
 Note: The only wheels that are supported are mouse wheels and physical
 dials. Track balls are not reported as mouse wheels.
 
 ```dart
-abstract class WheelEvent extends Event {
+class WheelEvent extends Event {
   PointerEvent({ bool bubbles,
                  this.wheel,
                  this.delta: 0.0,
                  this.pointer,
                  this.x, this.y,
                }): super(bubbles: bubbles);
 
   final int wheel;
   final double delta; // revolutions (or fractions thereof)
   final int pointer;
   final double x; // logical pixels
   final double y; // logical pixels
+
+  bool get bubbles => false;
 }
 ```