Specs: dartification of dom.md, more work on script.md; this is highly work-in-progress and hasn't …

sky/specs/gestures.md

 Gestures
 ========
 
 ```dart
 SKY MODULE
 <!-- part of sky:core -->
 
 <script>
 abstract class GestureEvent extends Event {
   Gesture _gesture;
   Gesture get gesture => _gesture;
 }
 
 class GestureState {
-  bool cancel = true; // if true, then cancel the gesture at this point
-  bool capture = false; // (for PointerDownEvent) if true, then this pointer is relevant
-  bool choose = false; // if true, the gesture thinks that other gestures should give up
-  bool finished = true; // if true, we're ready for the next gesture to start
+  @nonnull bool cancel = true; // if true, then cancel the gesture at this point
+  @nonnull bool capture = false; // (for PointerDownEvent) if true, then this pointer is relevant
+  @nonnull bool choose = false; // if true, the gesture thinks that other gestures should give up
+  @nonnull bool finished = true; // if true, we're ready for the next gesture to start
   // choose and cancel are mutually exclusive
 }
 
 class BufferedEvent {
   const BufferedEvent(this.event, this.coallesceGroup);
-  final GestureEvent event;
+  final @nonnull GestureEvent event;
   final int coallesceGroup;
 }
 
 abstract class Gesture extends EventTarget {
   Gesture(this.target) : super() {
     target.events.where((event) => event is PointerDownEvent ||
                                    event is PointerMovedEvent ||
                                    event is PointerUpEvent).listen(_handler);
   }
-  final EventTarget target;
+  final @nonnull EventTarget target;
 
   bool _ready = true; // last event, we were finished
   bool get ready => _ready;
   bool _active = false; // we have not yet been canceled since we last started listening to a pointer
   bool get active => _active;
   bool _chosen = false; // we're the only possible gesture at this point
   bool get chosen => _chosen;
 
   // (!ready && !active) means we're discarding events until the user
   // gets to a state where a new gesture can begin
 
   // (active && !chosen) means we're collecting events until no other
   // gesture is valid, or until we take command
 
-  GestureState processEvent(PointerEvent event);
+  @nonnull GestureState processEvent(@nonnull PointerEvent event);
 
-  List<BufferedEvent> _eventBuffer;
+  List<@nonnull BufferedEvent> _eventBuffer;
 
   void choose() {
     // called by GestureManager
     // if you override this, make sure to call superclass choose() first
     assert(_active == true);
     assert(_chosen == false);
     _chosen = true;
     // if there are any buffered events, dispatch them on this
     if ((_eventBuffer != null) && (_eventBuffer.length > 0)) {
       // we make a copy of the event buffer first so that the array isn't mutated out from under us
       // while we are doing this
       var events = _eventBuffer;
       _eventBuffer = null;
-      for (var item in events) {
+      for (var item in events)
         dispatchEvent(item.event);
-      }
     }
   }
 
   void cancel() {
     // called by GestureManager
     // if you override this, make sure to call superclass cancel() last
     _active = false;
     _chosen = false;
     _eventBuffer = null;
   }
 
   // for use by subclasses only
-  void sendEvent(GestureEvent event,
+  void sendEvent(@nonnull GestureEvent event,
                  { int coallesceGroup, // when queuing events, only the last event with each group is kept 
-                   bool prechoose: false // if true, event should just be sent right away, not queued
+                   @nonnull bool prechoose: false // if true, event should just be sent right away, not queued
                  }) {
     assert(_active == true);
     assert(coallesceGroup == null || prechoose == false);
     event._gesture = this;
     if (_chosen || prechoose) {
       dispatchEvent(event);
     } else {
       if (_eventBuffer == null)
         _eventBuffer = new List<BufferedEvent>();
       if (coallesceGroup != null)
         _eventBuffer.removeWhere((candidate) => candidate.coallesceGroup == coallesceGroup);
       _eventBuffer.add(new BufferedEvent(event, coallesceGroup));
     }
   }
 
-  void _handler(event) {
+  void _handler(@nonnull Event event) {
     bool wasActive = _active;
     if (_ready) {
       // reset the state to start a new gesture
       if (_active)
         module.application.gestureManager.cancelGesture(this);
       _active = true;
       _ready = false;
     }
     GestureState returnValue = processEvent(event);
     if (returnValue.capture) {
@@ skipping 47 matching lines @@
 */
 
 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;
-  bool chosen = false;
+  @nonnull List<@nonnull Gesture> gestures;
+  @nonnull bool chosen = false;
 }
 
 class GestureManager {
   GestureManager(this.target) {
     target.events.where((event) => event is PointerDownEvent).listen(_handler);
   }
-  final EventTarget target; // usually the ApplicationDocument object
+  final @nonnull EventTarget target; // usually the ApplicationDocument object
 
-  Map<int, PointerState> _pointers = new SplayTreeMap<int, PointerState>();
+  Map<@nonnull int, @nonnull PointerState> _pointers = new SplayTreeMap<int, PointerState>();
 
-  void addGesture(PointerEvent event, Gesture gesture) {
+  void addGesture(@nonnull PointerEvent event, @nonnull Gesture gesture) {
     assert(gesture.active);
     var pointer = event.pointer;
     if (_pointers.containsKey(pointer)) {
       assert(!_pointers[pointer].gestures.contains(gesture));
       if (_pointers[pointer].chosen)
         cancelGesture(gesture);
       else
         _pointers[pointer].gestures.add(gesture);
     } else {
       PointerState pointerState = new PointerState();
       pointerState.gestures.add(gesture);
       _pointers[pointer] = pointerState;
     }
   }
 
-  void cancelGesture(Gesture gesture) {
+  void cancelGesture(@nonnull Gesture gesture) {
     _pointers.forEach((index, pointerState) => pointerState.gestures.remove(gesture));
     gesture.cancel();
     // get a static copy of the _pointers keys, so we can remove them safely
     var activePointers = new List<int>.from(_pointers.keys);
     // now walk our lists, removing pointers that are obsolete, and choosing
     // gestures from pointers that have only one outstanding gesture
-    for (var index = 0; index < activePointers.length; index += 1) {
-      var pointerState = _pointers[activePointers[index]];
+    for (var pointer in activePointers) {
+      var pointerState = _pointers[pointer];
       if (pointerState.gestures.length == 0) {
-        _pointers.remove(activePointers[index]);
+        _pointers.remove(pointer);
       } else {
         if (pointerState.gestures.length == 1 && pointerState.chosen) {
           pointerState.chosen = true;
           pointerState.gestures[0].choose();
         }
       }
     }
   }
 
-  void chooseGesture(Gesture gesture) {
+  void chooseGesture(@nonnull Gesture gesture) {
     if (!gesture.active)
       // this could happen e.g. if two gestures simultaneously add
       // themselves and chose themselves for the same PointerDownEvent
       return;
-    List<Gesture> losers = new List<Gesture>();
+    @nonnull List<@nonnull Gesture> losers = new List<@nonnull Gesture>();
     _pointers.values
              .where((pointerState) => pointerState.gestures.contains(gesture))
              .forEach((pointerState) {
                losers.addAll(pointerState.gestures.where((candidateLoser) => candidateLoser != gesture));
                pointerState.gestures.clear();
                pointerState.gestures.add(gesture);
                pointerState.chosen = true;
              });
     assert(losers.every((loser) => loser.active));
     losers.forEach((loser) {
       // we check loser.active because losers could contain duplicates
       // and we should only cancel each gesture once
       if (loser.active)
         loser.cancel();
       assert(!loser.active);
     });
     gesture.choose();
   }
 
-  PointerState getActiveGestures(int pointer) {
+  @nonnull PointerState getActiveGestures(@nonnull int pointer) {
     if (_pointers.containsKey(pointer) && _pointers[pointer].gestures.length > 0)
       return new PointerState.clone(_pointers[pointer]);
     return new PointerState();
   }
 
-  void _handler(PointerDownEvent event) {
+  void _handler(@nonnull PointerDownEvent event) {
     var pointer = event.pointer;
     if (_pointers.containsKey(pointer)) {
       var pointerState = _pointers[pointer];
       if ((!pointerState.chosen) && (pointerState.gestures.length == 1)) {
         pointerState.chosen = true;
         pointerState.gestures[0].choose();
       }
     }
   }
 
@@ skipping 166 matching lines @@
   // fling-end: cancel(), or after fling or fling-cancel (prechoose)
 }
 
 class FlingLeftGesture : FlingGesture { }
 class FlingRightGesture : FlingGesture { }
 class FlingUpGesture : FlingGesture { }
 class FlingDownGesture : FlingGesture { }
 
 </script>
 ```