Various OpenGLUI changes:

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 {
   List _nodes;
   get nodes => _nodes;
   BodyElement() : _nodes = new List();
 }
 
 // The OpenGLUI "equivalent" of Window.
 
 typedef void RequestAnimationFrameCallback(num highResTime);
 
 class Window {
   static int _nextId = 0;
-  Map<int, RequestAnimationFrameCallback> _callbacks;
+  List _callbacks;
+  List _arguments;
 
-  Window._internal() : _callbacks = new Map();
+  Window._internal() : _callbacks = [], _arguments = [];
+
+  int scheduleCallback(callback, [argument]) {

[vsm, 2013/03/27 22:27:06]

Make this private?  It's not a public Window api.

+    _callbacks.add(callback);
+    _arguments.add(argument);
+    return _callbacks.length - 1;
+  }
 
   int requestAnimationFrame(RequestAnimationFrameCallback callback) {
-    _callbacks[_nextId++] = callback;
+    return scheduleCallback(callback,
+        (new DateTime.now()).millisecondsSinceEpoch);
   }
+
   void cancelAnimationFrame(id) {
-    if (_callbacks.containsKey(id)) {
-      _callbacks.remove(id);
-    }
+    _callbacks[id] = null;
+    _arguments[id] = null;
   }
+
   get animationFrame {
     // TODO(gram)
     return null;
   }
 
   void _dispatch() {
-    var when = (new DateTime.now()).millisecondsSinceEpoch;
     // We clear out the callbacks map before calling any callbacks,
     // as they may schedule new callbacks.
     var oldcallbacks = _callbacks;
-    _callbacks = new Map();
-    for (var c in oldcallbacks.values) {
-      c(when);
+    var oldarguments = _arguments;
+    _callbacks = [];
+    _arguments = [];
+    for (var i = 0; i < oldcallbacks.length; i++) {
+      if (oldcallbacks[i] != null) {
+        oldcallbacks[i](oldarguments[i]);
+      }
     }
+    // We could loop around here to handle any callbacks
+    // scheduled in processing the prior ones, but then we
+    // need some other mechanism for trying to get requestAnimationFrame
+    // callbacks at 60fps.
   }
+
+  Map localStorage = {};

[vsm, 2013/03/27 22:27:06]

Should this be persistent somehow?  (Not in this CL, just in general.)

 }
 
 Window window = new Window._internal();
 
 // The OpenGLUI "equivalent" of HtmlDocument.
-class Document {
+class Document extends Node {
   BodyElement _body;
   get body => _body;
   Document._internal() : _body = new BodyElement();
 }
 
 Document document = new Document._internal();
 
 // TODO(gram): make private and call from within library context.
 update_() {
+  log("in 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) {
+    var rtn = false;
     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);
+        rtn = true;
       }
     }
-    return true;
+    return rtn;
   }
 
   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();
     }
@@ skipping 20 matching lines @@
         }
       }
     }
   }
 }
 
 class Event {
   final String type;
   EventTarget target;
   Event(String type) : this.type = type;
+  preventDefault() {}
+  stopPropagation() {}
 }
 
-class KeyEvent extends Event {
+class KeyboardEvent 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) 
+  KeyboardEvent(String type, int keycode, bool alt, bool ctrl, bool shift) 
     : super(type),
       keyCode = keycode,
       altKey = alt,
       ctrlKey = ctrl,
       shiftKey = shift {
   }
 }
 
 class MouseEvent extends Event {
   final int screenX, screenY;
   final int clientX, clientY;
 
   MouseEvent(String type, int x, int y)
     : super(type),
       screenX = x,
       screenY = y,
       clientX = x,
       clientY = y {
   }
 }
 
-
 class _EventStreamSubscription<T extends Event> extends StreamSubscription<T> {
   int _pauseCount = 0;
   EventTarget _target;
   final String _eventType;
   var _onData;
 
   _EventStreamSubscription(this._target, this._eventType, this._onData) {
     _tryResume();
   }
 
@@ skipping 79 matching lines @@
       { void onError(AsyncError error),
       void onDone(),
       bool unsubscribeOnError}) {
 
     return new _EventStreamSubscription<T>(
         this._target, this._eventType, onData);
   }
 }
 
 class Node extends EventTarget {
-  Stream<KeyEvent> get onKeyDown => new _EventStream(this, 'keydown');
-  Stream<KeyEvent> get onKeyUp => new _EventStream(this, 'keyup');
+  Stream<KeyboardEvent> get onKeyDown => new _EventStream(this, 'keydown');
+  Stream<KeyboardEvent> 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 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;
+      return;
     }
   }
+  document.dispatchEvent(event);
 }
 
 _dispatchKeyEvent(String type, int keyCode, bool alt, bool ctrl, bool shift) {
-  _dispatchEvent(new KeyEvent(type, keyCode, alt, ctrl, shift));
+  _dispatchEvent(new KeyboardEvent(type, keyCode, alt, ctrl, shift));
 }
 
 _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);
 
 onMouseMove_(int when, double x, double y) =>
     _dispatchMouseEvent('mousemove', x, y);
 
 onMouseUp_(int when, double x, double y) =>
     _dispatchMouseEvent('mouseup', x, y);
 
 class CanvasElement extends Node {
-  int _height;
-  int _width;
-
-  get height => _height;
-  get width => _width;
+  int height;
+  int width;
 
   CanvasRenderingContext2D _context2d;
   WebGLRenderingContext _context3d;
 
   // For use with drawImage, we want to support a src property
   // like ImageElement, which maps to the context handle in native
   // code.
   get src => "context2d://${_context2d.handle}";
 
   CanvasElement({int width, int height})
     : super() {
-    _width = (width == null) ? getDeviceScreenWidth() : width;
-    _height = (height == null) ? getDeviceScreenHeight() : height;
+    this.width = (width == null) ? getDeviceScreenWidth() : width;
+    this.height = (height == null) ? getDeviceScreenHeight() : height;
+    getContext('2d');
   }
 
   CanvasRenderingContext getContext(String contextId) {
     if (contextId == "2d") {
       if (_context2d == null) {
-        _context2d = new CanvasRenderingContext2D(this, _width, _height);
+        _context2d = new CanvasRenderingContext2D(this, width, height);
       }
       return _context2d;
     } else if (contextId == "webgl" || 
                contextId == "experimental-webgl") {
       if (_context3d == null) {
         _context3d = new WebGLRenderingContext(this);
       }
       return _context3d;
     }
   }
+ 
+  String toDataUrl(String type) {
+    // This needs to take the contents of the underlying
+    // canvas painted by the 2d context, give that a unique
+    // URL, and return that. The canvas element should be
+    // reuable afterwards without destroying the previously
+    // rendered data associated with this URL.
+    assert(_context2d != null);
+    var rtn = src;
+    _context2d = null;
+    return rtn;
+  }
 }
 
 class CanvasRenderingContext {
   final CanvasElement canvas;
 
   CanvasRenderingContext(this.canvas);
 }
 
+class AudioElement {
+  double volume;
+  String _src;
+  get src => _src;
+  set src(String v) {
+    _src = v;
+    loadSample(v);
+  }
+
+  AudioElement([this._src]);
+  void play() {
+    playSample(_src);
+  }
+}
+
 // The simplest way to call native code: top-level functions.
 int systemRand() native "SystemRand";
 void systemSrand(int seed) native "SystemSrand";
 void log(String what) native "Log";
 
 int getDeviceScreenWidth() native "GetDeviceScreenWidth";
 int getDeviceScreenHeight() native "GetDeviceScreenHeight";
 
 // EGL functions.
 void glSwapBuffers() native "SwapBuffers";
@@ skipping 282 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";
 
+void C2DSetFillGradient(int handle, bool isRadial,

[vsm, 2013/03/27 22:27:06]

Should these C2D functions be private?

+        double x0, double y0, double r0,
+        double x1, double y1, double r1,
+        List<double> positions, List<String> colors)
+    native "C2DSetFillGradient";
+
+void C2DSetStrokeGradient(int handle, bool isRadial,
+        double x0, double y0, double r0,
+        double x1, double y1, double r1,
+        List<double> positions, List<String> colors)
+    native "C2DSetStrokeGradient";
+
+int C2DGetImageWidth(String url)
+    native "C2DGetImageWidth";
+
+int C2DGetImageHeight(String url)
+    native "C2DGetImageHeight";
+
+class CanvasGradient {
+  num _x0, _y0, _r0 = 0, _x1, _y1, _r1 = 0;
+  bool _isRadial;
+  List<double> _colorStopPositions = [];
+  List<String> _colorStopColors = [];
+
+  void addColorStop(num offset, String color) {
+    _colorStopPositions.add(offset.toDouble());
+    _colorStopColors.add(color);
+  }
+
+  CanvasGradient.linear(this._x0, this._y0, this._x1, this._y1)
+      : _isRadial = false;
+  
+  CanvasGradient.radial(this._x0, this._y0, this._r0,
+                        this._x1, this._y1, this._r1)
+      : _isRadial = true;
+
+  void setAsFillStyle(_handle) {
+    C2DSetFillGradient(_handle, _isRadial,
+        _x0.toDouble(), _y0.toDouble(), _r0.toDouble(),
+        _x1.toDouble(), _y1.toDouble(), _r1.toDouble(),
+        _colorStopPositions, _colorStopColors);
+  }
+
+  void setAsStrokeStyle(_handle) {
+    C2DSetStrokeGradient(_handle, _isRadial,
+        _x0.toDouble(), _y0.toDouble(), _r0.toDouble(),
+        _x1.toDouble(), _y1.toDouble(), _r1.toDouble(),
+        _colorStopPositions, _colorStopColors);
+  }
+}
+
 class ImageElement extends Node {
   Stream<Event> get onLoad => new _EventStream(this, 'load');
 
   String _src;
   int _width;
   int _height;
 
   get src => _src;
+
   set src(String v) {
+    log("Set ImageElement src to $v");
     _src = v;
-    var e = new Event('load');
-    e.target = this;
-    dispatchEvent(e);
   }
 
-  get width => _width;
+  // The onLoad handler may be set after the src, so
+  // we hook into that here...
+  void addListener(String eventType, EventListener handler) {
+    super.addListener(eventType, handler);
+    if (eventType == 'load') {
+      var e = new Event('load');
+      e.target = this;
+      window.scheduleCallback(handler, e);
+    }
+  }
+
+  get width => _width == null ? _width = C2DGetImageWidth(_src) : _width;
+  get height => _height == null ? _height = C2DGetImageHeight(_src) : _height;
   set width(int widthp) => _width = widthp;
-
-  get height => _height;
   set height(int heightp) => _height = heightp;
 
   ImageElement({String srcp, int widthp, int heightp})
     : _src = srcp,
       _width = widthp,
       _height = heightp {
+    if (_src != null) {
+      if (_width == null) _width = C2DGetImageWidth(_src);
+      if (_height == null) _height = C2DGetImageHeight(_src);
+    }
   }
 }
 
 class ImageData {
   final Uint8ClampedArray data;
   final int height;
   final int width;
   ImageData(this.height, this.width, this.data);
 }
 
 class TextMetrics {
   final num width;
   TextMetrics(this.width);
 }
 
 void shutdown() {
   CanvasRenderingContext2D.next_handle = 0;
 }
 
+class Rect {
+  final num top, left, width, height;
+  const Rect(this.left, this.top, this.width, this.height);
+}
+
 class CanvasRenderingContext2D extends CanvasRenderingContext {
   // TODO(gram): We need to support multiple contexts, for cached content
   // prerendered to an offscreen buffer. For this we will use handles, with
   // handle 0 being the physical display.
   static int next_handle = 0;
   int _handle = 0;
   get handle => _handle;
 
   int _width, _height;
   set width(int w) { _width = C2DSetWidth(_handle, w); }
@@ skipping 10 matching lines @@
   double _alpha = 1.0;
   set globalAlpha(num a) {
     _alpha = C2DSetGlobalAlpha(_handle, a.toDouble());
   }
   get globalAlpha => _alpha;
 
   // TODO(gram): make sure we support compound assignments like:
   // fillStyle = strokeStyle = "red"
   var _fillStyle = "#000";
   set fillStyle(fs) {
-    C2DSetFillStyle(_handle, _fillStyle = fs);
+    _fillStyle = fs;
+    // TODO(gram): Support for CanvasPattern.
+    if (fs is CanvasGradient) {
+      fs.setAsFillStyle(_handle);
+    } else {
+      C2DSetFillStyle(_handle, fs);
+    }
   }
   get fillStyle => _fillStyle;
 
   String _font = "10px sans-serif";
   set font(String f) { _font = C2DSetFont(_handle, f); }
   get font => _font;
 
   String _globalCompositeOperation = "source-over";
   set globalCompositeOperation(String o) =>
       C2DSetGlobalCompositeOperation(_handle, _globalCompositeOperation = o);
@@ skipping 50 matching lines @@
   num _shadowOffsetY;
   get shadowOffsetY => _shadowOffsetY;
   set shadowOffsetY(num offset) {
     _shadowOffsetY = offset;
     C2DSetShadowOffsetY(_handle, offset.toDouble());
   }
 
   var _strokeStyle = "#000";
   get strokeStyle => _strokeStyle;
   set strokeStyle(ss) {
-    C2DSetStrokeStyle(_handle, _strokeStyle = ss);
+    _strokeStyle = ss;
+    // TODO(gram): Support for CanvasPattern.
+    if (ss is CanvasGradient) {
+      ss.setAsStrokeStyle(_handle);
+    } else {
+      C2DSetStrokeStyle(_handle, ss);
+    }
   }
 
   String _textAlign = "start";
   get textAlign => _textAlign;
   set textAlign(String a) { _textAlign = C2DSetTextAlign(_handle, a); }
 
   String _textBaseline = "alphabetic";
   get textBaseline => _textBaseline;
   set textBaseline(String b) { _textBaseline = C2DSetTextBaseline(_handle, b); }
 
@@ skipping 52 matching lines @@
 
   ImageData createImageData(var imagedata_OR_sw, [num sh = null]) {
     if (sh == null) {
       throw new Exception('Unimplemented createImageData(imagedata)');
     } else {
       return C2DCreateImageDataFromDimensions(_handle, imagedata_OR_sw, sh);
     }
   }
 
   CanvasGradient createLinearGradient(num x0, num y0, num x1, num y1) {
-    throw new Exception('Unimplemented createLinearGradient');
+    return new CanvasGradient.linear(x0, y0, x1, y1);
   }
 
   CanvasPattern createPattern(canvas_OR_image, String repetitionType) {
     throw new Exception('Unimplemented createPattern');
   }
 
-  CanvasGradient createRadialGradient(num x0, num y0, num x1, num y1, num r1) {
-    throw new Exception('Unimplemented createRadialGradient');
+  CanvasGradient createRadialGradient(num x0, num y0, num r0,
+                                      num x1, num y1, num r1) {
+    return new CanvasGradient.radial(x0, y0, r0, x1, y1, r1);
   }
 
   void drawImage(element, num x1, num y1,
                 [num w1, num h1, num x2, num y2, num w2, num h2]) {
+    if (element == null || element.src == null || element.src.length == 0) {
+      throw "drawImage called with no valid src";
+    } else {
+      log("drawImage ${element.src}");
+    }
     var w = (element.width == null) ? 0 : element.width;
     var h = (element.height == null) ?  0 : element.height;
     if (!?w1) { // drawImage(element, dx, dy)
       C2DDrawImage(_handle, element.src, 0, 0, false, w, h,
                    x1.toInt(), y1.toInt(), false, 0, 0);
     } else if (!?x2) {  // drawImage(element, dx, dy, dw, dh)
       C2DDrawImage(_handle, element.src, 0, 0, false, w, h,
                    x1.toInt(), y1.toInt(), true, w1.toInt(), h1.toInt());
     } else {  // drawImage(image, sx, sy, sw, sh, dx, dy, dw, dh)
       C2DDrawImage(_handle, element.src, 
                    x1.toInt(), y1.toInt(), true, w1.toInt(), h1.toInt(),
                    x2.toInt(), y2.toInt(), true, w2.toInt(), h2.toInt());
     }
   }
 
+  void drawImageAtScale(element, Rect dest, {Rect sourceRect}) {
+    if (sourceRect == null) {
+      drawImage(element, dest.left, dest.top, dest.width, dest.height);
+    } else {
+      drawImage(element,
+         sourceRect.left, sourceRect.top, sourceRect.width, sourceRect.height,
+         dest.left, dest.top, dest.width, dest.height);
+    }
+  }
+
   void fill() => C2DFill(_handle);
 
   void fillRect(num x, num y, num w, num h) =>
     C2DFillRect(_handle, x.toDouble(), y.toDouble(),
                          w.toDouble(), h.toDouble());
 
   void fillText(String text, num x, num y, [num maxWidth = -1]) =>
       C2DFillText(_handle, text, x.toDouble(), y.toDouble(),
                                  maxWidth.toDouble());
 
@@ skipping 122 matching lines @@
                             num dirtyWidth, num dirtyHeight]) {
     throw new Exception('Unimplemented webkitGetImageDataHD');
   }
 
   // TODO(vsm): Kill.
   noSuchMethod(invocation) {
       throw new Exception('Unimplemented/unknown ${invocation.memberName}');
   }
 }
 
+int loadSample(String s) native "LoadSample";

[vsm, 2013/03/27 22:27:06]

Make these private?

+int playSample(String s) native "PlaySample";