Specs: fix a raft of syntax errors caught by actually running a syntax checker...

sky/specs/gestures.md

 Gestures
 ========
 
 ```dart
 SKY MODULE
 <!-- part of dart:sky -->
 
 <script>
 abstract class GestureEvent extends Event {
   Gesture _gesture;
@@ skipping 94 matching lines @@
     }
     GestureState returnValue = processEvent(event);
     if (returnValue.capture) {
       assert(event is PointerDownEvent);
       if (event is PointerDownEvent)
         event.result.add(this);
     }
     if (returnValue.cancel) {
       assert(returnValue.choose == false);
       if (wasActive)
-        module.application.cancelGesture(this);
+        module.application.gestureManager.cancelGesture(this);
       // if we never became active, then we never called addGesture() below
       _active = false;
     } else if (active == true) {
       if (wasActive == false || event is PointerDownEvent)
-        module.application.addGesture(event, this);
+        module.application.gestureManager.addGesture(event, this);
       if (returnValue.choose == true)
-        module.application.chooseGesture(this);
+        module.application.gestureManager.chooseGesture(this);
     }
     _ready = returnValue.finished;
   }
 }
 
+/*
 ```
 Subclasses should override ``processEvent()``:
  - as the events are received, they get examined to see if they
    fit the pattern for the gesture; if they do, then return an
    object with valid=true; if more events for this gesture could
    still come in, return finished=false.
  - if you returned valid=false finished=false, then the next call
    to this must not return valid=true
  - doing anything with the event or target other than reading
    state is a contract violation
  - you are allowed to call sendEvent() at any time during a
-   processEventInternal() call, or after a call to
-   processEventInternal(), assuming that the last such call returned
-   valid=true, until the next call to processEventInternal() or
-   cancel().
+   processEvent() call, or after a call to processEvent(), assuming
+   that the last such call returned valid=true, until the next call to
+   processEvent() or cancel().
  - set forceChoose=true on the return value if you are confident
    that this is the gesture the user meant, even if it's possible
    that another gesture is still claiming it's valid (e.g. a long
    press might forceChoose to override a scroll, if the user
    hasn't moved for a while)
  - if you send events, you can set prechoose=true to send the
    event even before the gesture has been chosen
  - if you send prechoose events, make sure to send corresponding
    "cancel" events if cancel() is called
 
 ```dart
+*/
 
 class PointerState {
   PointerState({this.gestures, this.chosen}) {
     if (gestures == null)
       gestures = new List<Gesture>();
   }
   factory PointerState.clone(PointerState source) {
     return new PointerState(gestures: source.gestures, chosen: source.chosen);
   }
   List<Gesture> gestures;
@@ skipping 80 matching lines @@
     if (_pointers.containsKey(pointer)) {
       var pointerState = _pointers[pointer];
       if ((!pointerState.chosen) && (pointerState.gestures.length == 1)) {
         pointerState.chosen = true;
         pointerState.gestures[0].choose();
       }
     }
   }
 
 }
+/*
 </script>
 ```
 
 Gestures defined in the framework
 ---------------------------------
 
 ```dart
 SKY MODULE
 <!-- not in dart:sky -->
 <!-- note: this hasn't been dartified yet -->
 
 <script>
+*/
 class TapGesture extends Gesture {
+  TapGesture = Gesture;
 
   // internal state:
   //   Integer numButtons = 0;
   //   Boolean primaryDown = false;
 
-  virtual GestureState processEvent(Event event);
+  GestureState processEvent(Event event);
   // - let returnValue = { finished = false }
   // - if the event is a pointer-down:
   //    - increment this.numButtons
   //    - set returnValue.capture = true
   // - otherwise if it is a pointer-up:
   //    - assert: this.numButtons > 0
   //    - decrement this.numButtons
   //    - if numButtons == 0:
   //       - set returnValue.finished = true
   // - if this.ready == false and this.active == false:
@@ skipping 44 matching lines @@
   //       - set returnValue.cancel = false
   //       - return returnValue
   //    - otherwise:
   //       - // this is the 'up' of some bogus secondary press
   //         // ignore it, but continue listening for our primary up if necessary
   //       - if this.primaryDown == true and this.active == true:
   //          - set returnValue.cancel = false
   //       - return returnValue
 }
 
-class LongPressGesture : Gesture {
-  GestureState processEvent(EventTarget target, Event event);  
+class LongPressGesture extends Gesture {
+  LongPressGesture = Gesture;
+
+  GestureState processEvent(PointerEvent event);
   // long-tap-start: sent when the primary pointer goes down
   // long-tap-cancel: sent when cancel()ed or finger goes out of bounding box
   // long-tap: sent when the primary pointer is released
 }
 
-class DoubleTapGesture : Gesture {
-  GestureState processEvent(EventTarget target, Event event);  
+class DoubleTapGesture extends Gesture {
+  DoubleTapGesture = Gesture;
+
+  GestureState processEvent(PointerEvent event);
   // double-tap-start: sent when the primary pointer goes down the first time
   // double-tap-cancel: sent when cancel()ed or finger goes out of bounding box, or it times out
   // double-tap: sent when the primary pointer is released the second time within the timeout
 }
 
 
-abstract class ScrollGesture : Gesture {
-  GestureState processEvent(EventTarget target, Event event);  
+abstract class ScrollGesture extends Gesture {
+  ScrollGesture = Gesture;
+
+  GestureState processEvent(PointerEvent event);
   // this fires the following events (inertia is a boolean, delta is a float):
   //   scroll-start, with field inertia=false, delta=0; prechoose=true
   //   scroll, with fields inertia (is this a simulated scroll from inertia or a real scroll?), delta (number of pixels to scroll); prechoose=true
   //   scroll-end, with field inertia (same), delta=0; prechoose=true
   // scroll-start is fired right away
   // scroll is sent whenever the primary pointer moves while down
   // scroll is also sent after the pointer goes back up, based on inertia
   // scroll-end is sent after the pointer goes back up once the scroll reaches delta=0
   // scroll-end is also sent when the gesture is canceled or reset
   // processEvent() returns:
   //  - cancel=false pretty much always so long as there's a primary touch (e.g. not for a right-click)
   //  - chose=true when you travel a certain distance
   //  - finished=true when the primary pointer goes up
 }
 
-class HorizontalScrollGesture : ScrollGesture { }
+class HorizontalScrollGesture extends ScrollGesture {
   // a ScrollGesture giving x-axis scrolling
+  HorizontalScrollGesture = ScrollGesture;
+}
 
-class VerticalScrollGesture : ScrollGesture { }
+class VerticalScrollGesture extends ScrollGesture {
   // a ScrollGesture giving y-axis scrolling
+  VerticalScrollGesture = ScrollGesture;
+}
 
 
-class PanGesture : Gesture {
+class PanGesture extends Gesture {
+  PanGesture = Gesture;
   // similar to ScrollGesture, but with two axes
   // pan-start, pan, pan-end
   // events have inertia (boolean), dx (float), dy (float)
 }
 
 
-abstract class ZoomGesture : Gesture {
-  GestureState processEvent(EventTarget target, Event event);  
+abstract class ZoomGesture extends Gesture {
+  ZoomGesture = Gesture;
+
+  GestureState processEvent(PointerEvent event);
   // zoom-start: sent when we could start zooming (e.g. for pinch-zoom, when two fingers hit the glass) (prechoose)
   // zoom-end: sent when cancel()ed after zoom-start, or when the fingers are lifted (prechoose)
   // zoom, with a 'scale' attribute, whose value is a multiple of the scale factor at zoom-start
   // e.g. if the user zooms to 2x, you'd get a bunch of 'zoom' events like scale=1.0, scale=1.17, ... scale=1.91, scale=2.0
 }
 
-class PinchZoomGesture : ZoomGesture {
+class PinchZoomGesture extends ZoomGesture {
+  PinchZoomGesture = ZoomGesture;
   // a ZoomGesture for two-finger-pinch gesture
   // zoom is prechoose
 }
 
-class DoubleTapZoomGesture : ZoomGesture {
+class DoubleTapZoomGesture extends ZoomGesture {
+  DoubleTapZoomGesture = ZoomGesture;
   // a ZoomGesture for the double-tap-slide gesture
   // when the slide starts, forceChoose
 }
 
 
-class PanAndZoomGesture : Gesture {
-  GestureState processEvent(EventTarget target, Event event);  
+class PanAndZoomGesture extends Gesture {
+  PanAndZoomGesture = Gesture;
+
+  GestureState processEvent(PointerEvent event);
   // manipulate-start (prechoose)
   // manipulate: (prechoose)
   //    panX, panY: pixels
   //    scaleX, scaleY: a multiplier of the scale at manipulate-start
   //    rotation: turns
   // manipulate-end (prechoose)
 }
 
 
-abstract class FlingGesture : Gesture {
-  GestureState processEvent(EventTarget target, Event event);  
+abstract class FlingGesture extends Gesture {
+  FlingGesture = Gesture;
+
+  GestureState processEvent(PointerEvent event);
   // fling-start: when the gesture begins (prechoose)
   // fling-move: while the user is directly dragging the element (has delta attribute with the distance from fling-start) (prechoose)
   // fling: the user has released the pointer and the decision is it was in fact flung
   // fling-cancel: cancel(), or the user has released the pointer and the decision is it was not flung (prechoose)
   // fling-end: cancel(), or after fling or fling-cancel (prechoose)
 }
 
-class FlingLeftGesture : FlingGesture { }
-class FlingRightGesture : FlingGesture { }
-class FlingUpGesture : FlingGesture { }
-class FlingDownGesture : FlingGesture { }
-
+class FlingLeftGesture extends FlingGesture {
+  FlingLeftGesture = FlingGesture;
+}
+class FlingRightGesture extends FlingGesture {
+  FlingRightGesture = FlingGesture;
+}
+class FlingUpGesture extends FlingGesture {
+  FlingUpGesture = FlingGesture;
+}
+class FlingDownGesture extends FlingGesture {
+  FlingDownGesture = FlingGesture;
+}
 </script>
 ```