Revert revision 33053

third_party/pkg/angular/lib/directive/ng_events.dart

 part of angular.directive;
 
 // NOTE(deboer): onXX functions are now typed as 'var' instead of 'Getter'
 // to work-around https://code.google.com/p/dart/issues/detail?id=13519
 
 /**
  * Allows you to specify custom behavior for DOM UI events such as mouse,
  * keyboard and touch events.
  *
  * The custom behavior is specified via an Angular binding expression specified
  * on the `ng-`*event* directive (e.g. `ng-click`).  This expression is evaluated
  * on the correct `scope` every time the event occurs.  The event is available
  * to the expression as `$event`.
  *
  * This is more secure than inline DOM handlers in HTML that execute arbitrary
  * JavaScript code and have access to globals instead of the scope without the
  * safety constraints of the Angular expression language.
  *
  * Example:
  *
  *     <button ng-click="lastEvent='Click'"
  *             ng-doubleclick="lastEvent='DblClick'">
  *         Button
  *     </button>
  *
  * The full list of supported handlers are:
  *
+ * - [ng-blur]
  * - [ng-abort]
  * - [ng-beforecopy]
  * - [ng-beforecut]
  * - [ng-beforepaste]
  * - [ng-blur]
  * - [ng-change]
  * - [ng-click]
  * - [ng-contextmenu]
  * - [ng-copy]
  * - [ng-cut]
@@ skipping 85 matching lines @@
 @NgDirective(selector: '[ng-submit]',           map: const {'ng-submit':           '&onSubmit'})
 @NgDirective(selector: '[ng-toucheancel]',      map: const {'ng-touchcancel':      '&onTouchCancel'})
 @NgDirective(selector: '[ng-touchend]',         map: const {'ng-touchend':         '&onTouchEnd'})
 @NgDirective(selector: '[ng-touchenter]',       map: const {'ng-touchenter':       '&onTouchEnter'})
 @NgDirective(selector: '[ng-touchleave]',       map: const {'ng-touchleave':       '&onTouchLeave'})
 @NgDirective(selector: '[ng-touchmove]',        map: const {'ng-touchmove':        '&onTouchMove'})
 @NgDirective(selector: '[ng-touchstart]',       map: const {'ng-touchstart':       '&onTouchStart'})
 @NgDirective(selector: '[ng-transitionend]',    map: const {'ng-transitionend':    '&onTransitionEnd'})
 
 class NgEventDirective {
-  // Is it better to use a map of listeners or have 29 properties on this
-  // object?  One would pretty much only assign to one or two of those
-  // properties.  I'm opting for the map since it's less boilerplate code.
-  var listeners = {};
-  final dom.Element element;
-  final Scope scope;
-
-  NgEventDirective(this.element, this.scope);
 
   // NOTE: Do not use the element.on['some_event'].listen(...) syntax.  Doing so
   //     has two downsides:
   //     - it loses the event typing
   //     - some DOM events may have multiple platform-dependent event names
   //       under the covers.  The standard Stream getters you will get the
   //       platform specific event name automatically but you're on your own if
   //       you use the on[] syntax.  This also applies to $dom_addEventListener.
   //     Ref: http://api.dartlang.org/docs/releases/latest/dart_html/Events.html
   initListener(var stream, var handler) {
     int key = stream.hashCode;
     if (!listeners.containsKey(key)) {
       listeners[key] = handler;
-      stream.listen((event) => handler({r"$event": event}));
+      stream.listen((event) => scope.$apply(() {
+        handler({r"$event": event});
+      }));
     }
   }
 
   set onAbort(value)             => initListener(element.onAbort,            value);
   set onBeforeCopy(value)        => initListener(element.onBeforeCopy,       value);
   set onBeforeCut(value)         => initListener(element.onBeforeCut,        value);
   set onBeforePaste(value)       => initListener(element.onBeforePaste,      value);
   set onBlur(value)              => initListener(element.onBlur,             value);
   set onChange(value)            => initListener(element.onChange,           value);
   set onClick(value)             => initListener(element.onClick,            value);
@@ skipping 34 matching lines @@
   set onSelectStart(value)       => initListener(element.onSelectStart,      value);
 //  set onSpeechChange(value)      => initListener(element.onSpeechChange,     value);
   set onSubmit(value)            => initListener(element.onSubmit,           value);
   set onTouchCancel(value)       => initListener(element.onTouchCancel,      value);
   set onTouchEnd(value)          => initListener(element.onTouchEnd,         value);
   set onTouchEnter(value)        => initListener(element.onTouchEnter,       value);
   set onTouchLeave(value)        => initListener(element.onTouchLeave,       value);
   set onTouchMove(value)         => initListener(element.onTouchMove,        value);
   set onTouchStart(value)        => initListener(element.onTouchStart,       value);
   set onTransitionEnd(value)     => initListener(element.onTransitionEnd,    value);
+
+  // Is it better to use a map of listeners or have 29 properties on this
+  // object?  One would pretty much only assign to one or two of those
+  // properties.  I'm opting for the map since it's less boilerplate code.
+  var listeners = {};
+  dom.Element element;
+  Scope scope;
+
+  NgEventDirective(this.element, this.scope);
 }