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!
 
+typedef void EventListener(Event event);
+
+class EventTarget {
+  static Map<EventTarget, Map<String, List<EventListener>>>
+      _listeners = new Map();
+
+  static get listeners => _listeners;
+
+  bool dispatchEvent(Event event) {
+    if (!_listeners.containsKey(this)) return false;
+    var listeners = _listeners[this];
+    if (!listeners.containsKey(event.type)) return false;
+    var eventListeners = listeners[event.type];
+    for (var eventListener in eventListeners) {
+      if (eventListener != null) {
+        eventListener(event);
+      }
+    }
+    return true;
+  }
+
+  void addListener(String eventType, EventListener handler) {
+    if (!_listeners.containsKey(this)) {
+      _listeners[this] = new Map();
+    }
+    var listeners = _listeners[this];
+    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] = handler;
+        return;
+      }
+    }
+    event_listeners.add(handler);
+  }
+
+  void removeListener(String eventType, EventListener handler) {
+    if (_listeners.containsKey(this)) {
+      var listeners = _listeners[this];
+      if (listeners.containsKey(eventType)) {
+        var event_listeners = listeners[eventType];
+        for (var i = 0; i < event_listeners.length; i++) {
+          if (event_listeners[i] == handler) {
+            event_listeners[i] = null;
+            break;
+          }
+        }
+      }
+    }
+  }
+}
+
 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 11 matching lines @@
 
   MouseEvent(String type, int x, int y)
     : super(type),
       screenX = x,
       screenY = y,
       clientX = x,
       clientY = y {
   }
 }
 
-typedef void EventListener(Event event);
-
-Map<String,List<Function>> _listeners = new Map();
 
 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();
-      }
-      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);
+      _target.addListener(_eventType, _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;
-          }
-        }
-      }
+      _target.removeListener(_eventType, _onData);
     }
   }
 }
 
 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
+// until we find one that handles the event.
+_dispatchEvent(Event event) {
+  assert(document.body.nodes.length <= 1);
+  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}');
   }
 }