Change ImageElement to use onLoad.listen instead of on.load and

runtime/embedders/openglui/common/gl.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.
 
 library android_extension;
 import 'dart:async';
 
 // A VERY simplified DOM.
 
 class BodyElement {
@@ skipping 49 matching lines @@
 Document document = new Document._internal();
 
 // TODO(gram): make private and call from within library context.
 update_() {
   window._dispatch();
 }
 
 // Event handling. This is very kludgy for now, especially the
 // bare-bones Stream stuff!
 
+class EventTarget extends Object {

[vsm, 2013/03/08 17:49:35]

Nit: Don't need "extends Object".

[gram, 2013/03/11 21:25:08]

Done.

+  bool dispatchEvent(Event event) {
+    if (!_listeners.containsKey(this)) return false;
+    var listeners = _listeners[this];
+    if (!listeners.containsKey(event.type)) return false;
+    var event_listeners = listeners[event.type];

[vsm, 2013/03/08 17:49:35]

event_listeners -> eventListeners per style guide

+    for (var i = 0; i < event_listeners.length; i++) {

[vsm, 2013/03/08 17:49:35]

Just iterate directly:
for (var eventListener in eventListeners) { ... }

[gram, 2013/03/11 21:25:08]

Will do, but is there a perf implication? I know that in many languages this
creates an Iterator object that is much more costly than just using an int
index.

The other reason I did this is that we can have null entries in the list; I
don't expect that should be a problem but wanted to be cautious.

+      if (event_listeners[i] != null) {
+        event_listeners[i](event);
+      }
+    }
+    return true;
+  }
+}
+
 class Event {
   final String type;
+  EventTarget target;
   Event(String type) : this.type = type;
 }
 
 class KeyEvent extends Event {
   final bool altKey;
   final bool ctrlKey;
   final bool shiftKey;
   final int keyCode;
 
   KeyEvent(String type, int keycode, bool alt, bool ctrl, bool shift) 
@@ skipping 13 matching lines @@
     : super(type),
       screenX = x,
       screenY = y,
       clientX = x,
       clientY = y {
   }
 }
 
 typedef void EventListener(Event event);
 
-Map<String,List<Function>> _listeners = new Map();
+Map<EventTarget, Map<String, List<Function>>> _listeners = new Map();

[vsm, 2013/03/08 17:49:35]

Function -> EventListener ?

This might also be cleaner if you just have a Map<String, List<EventListener>>
defined in EventTarget instead of a global map.

[gram, 2013/03/11 21:25:08]

Done.

 
 class _EventStreamSubscription<T extends Event> extends StreamSubscription<T> {
   int _pauseCount = 0;
-  Object _target;
+  EventTarget _target;
   final String _eventType;
   var _onData;
 
   _EventStreamSubscription(this._target, this._eventType, this._onData) {
     _tryResume();
   }
 
   void cancel() {
     if (_canceled) {
       throw new StateError("Subscription has been canceled.");
@@ skipping 44 matching lines @@
     }
     if (!_paused) {
       throw new StateError("Subscription is not paused.");
     }
     --_pauseCount;
     _tryResume();
   }
 
   void _tryResume() {
     if (_onData != null && !_paused) {
-      if (!_listeners.containsKey(_eventType)) {
-        _listeners[_eventType] = new List();
+      if (!_listeners.containsKey(_target)) {
+        _listeners[_target] = new Map();
       }
-      var event_listeners = _listeners[_eventType];
+      var listeners = _listeners[_target];
+      if (!listeners.containsKey(_eventType)) {
+        listeners[_eventType] = new List();
+      }
+      var event_listeners = listeners[_eventType];
       for (var i = 0; i < event_listeners.length; i++) {
         if (event_listeners[i] == null) {
           event_listeners[i] = _onData;
           return;
         }
       }
       event_listeners.add(_onData);
     }
   }
 
   void _unlisten() {
     if (_onData != null) {
-      if (!_listeners.containsKey(_eventType)) {
-        var event_listeners = _listeners[_eventType];
-        for (var i = 0; i < event_listeners.length; i++) {
-          if (event_listeners[i] == _onData) {
-            event_listeners[i] = null;
-            break;
+      if (_listeners.containsKey(_target)) {
+        var listeners = _listeners[_target];
+        if (listeners.containsKey(_eventType)) {
+          var event_listeners = listeners[_eventType];
+          for (var i = 0; i < event_listeners.length; i++) {
+            if (event_listeners[i] == _onData) {
+              event_listeners[i] = null;
+              break;
+            }
           }
         }
       }
     }
   }
 }
 
 class _EventStream<T extends Event> extends Stream<T> {
   final Object _target;
   final String _eventType;
 
   _EventStream(this._target, this._eventType);
 
   // DOM events are inherently multi-subscribers.
   Stream<T> asBroadcastStream() => this;
   bool get isBroadcast => true;
 
   StreamSubscription<T> listen(void onData(T event),
       { void onError(AsyncError error),
       void onDone(),
       bool unsubscribeOnError}) {
 
     return new _EventStreamSubscription<T>(
         this._target, this._eventType, onData);
   }
 }
 
-class Node {
+class Node extends EventTarget {
   Stream<KeyEvent> get onKeyDown => new _EventStream(this, 'keydown');
   Stream<KeyEvent> get onKeyUp => new _EventStream(this, 'keyup');
   Stream<MouseEvent> get onMouseDown => new _EventStream(this, 'mousedown');
   Stream<MouseEvent> get onMouseMove => new _EventStream(this, 'mousemove');
   Stream<MouseEvent> get onMouseUp => new _EventStream(this, 'mouseup');
 }
 
 // TODO(gram): If we support more than one on-screen canvas, we will
-// need to filter dispatched events by the target Node.
-_dispatchEvent(String event_type, Event e) {
-  if (!_listeners.containsKey(event_type)) return;
-  var event_listeners = _listeners[event_type];
-  for (var i = 0; i < event_listeners.length; i++) {
-    if (event_listeners[i] != null) {
-      event_listeners[i](e);
+// need to filter dispatched mouse and key events by the target Node
+// with more granularity; right now we just iterate through DOM nodes which should

[vsm, 2013/03/08 17:49:35]

line len

[gram, 2013/03/11 21:25:08]

Done.

+// just be the one canvas.

[vsm, 2013/03/08 17:49:35]

Should the code assert that there is just one canvas?

[gram, 2013/03/11 21:25:08]

Done.

+_dispatchEvent(Event event) {
+  for (var target in document.body.nodes) {
+    event.target = target;
+    if (target.dispatchEvent(event)) {
+      break;
     }
   }
 }
 
-_dispatchKeyEvent(String type, int keyCode, bool alt, bool ctrl, bool shift) =>
-    _dispatchEvent(type, new KeyEvent(type, keyCode, alt, ctrl, shift));
+_dispatchKeyEvent(String type, int keyCode, bool alt, bool ctrl, bool shift) {
+  _dispatchEvent(new KeyEvent(type, keyCode, alt, ctrl, shift));
+}
 
-_dispatchMouseEvent(String type, double x, double y) =>
-    _dispatchEvent(type, new MouseEvent(type, x.toInt(), y.toInt()));
+_dispatchMouseEvent(String type, double x, double y) {
+  _dispatchEvent(new MouseEvent(type, x.toInt(), y.toInt()));
+}
 
 // These next few are called by vmglue.cc.
 onKeyDown_(int when, int keyCode, bool alt, bool ctrl, bool shift, int repeat)
     =>  _dispatchKeyEvent('keydown', keyCode, alt, ctrl, shift);
 
 onKeyUp_(int when, int keyCode, bool alt, bool ctrl, bool shift, int repeat) =>
     _dispatchKeyEvent('keyup', keyCode, alt, ctrl, shift);
 
 onMouseDown_(int when, double x, double y) =>
     _dispatchMouseEvent('mousedown', x, y);
@@ skipping 342 matching lines @@
     native "C2DStrokeText";
 void C2DTransform(int handle, double m11, double m12,
                   double m21, double m22, double dx, double dy)
     native "C2DTransform";
 void C2DTranslate(int handle, double x, double y)
     native "C2DTranslate";
 
 void C2DCreateNativeContext(int handle, int width, int height)
     native "C2DCreateNativeContext";
 
-class ElementEvents {
-  final List load;
-  ElementEvents()
-    : load =new List() {
-  }
-}
+class ImageElement extends Node {
+  Stream<Event> get onLoad => new _EventStream(this, 'load');
 
-class ImageElement {
-  ElementEvents on;
   String _src;
   int _width;
   int _height;
 
   get src => _src;
   set src(String v) {
     _src = v;
-    for (var e in on.load) {
-      e(this);
-    }
+    var e = new Event('load');
+    e.target = this;
+    dispatchEvent(e);
   }
 
   get width => _width;
   set width(int widthp) => _width = widthp;
 
   get height => _height;
   set height(int heightp) => _height = heightp;
 
   ImageElement({String srcp, int widthp, int heightp})
-    : on = new ElementEvents(),
-      _src = srcp,
+    : _src = srcp,
       _width = widthp,
       _height = heightp {
   }
 }
 
 class ImageData {
   final Uint8ClampedArray data;
   final int height;
   final int width;
   ImageData(this.height, this.width, this.data);
@@ skipping 345 matching lines @@
                             num dirtyWidth, num dirtyHeight]) {
     throw new Exception('Unimplemented webkitGetImageDataHD');
   }
 
   // TODO(vsm): Kill.
   noSuchMethod(invocation) {
       throw new Exception('Unimplemented/unknown ${invocation.memberName}');
   }
 }