Replace goog.events.Event/EventTarget system with our own

This also removes goog.events.listen, goog.events.unlisten,
goog.events.unlistenByKey and goog.events.BrowserEvent.

src/ol/collection.js

@@ -7,7 +7,7 @@ goog.provide('ol.Collection');
 goog.provide('ol.CollectionEvent');
 goog.provide('ol.CollectionEventType');
 
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.Object');
 
 
@@ -36,7 +36,7 @@ ol.CollectionEventType = {
  * type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.CollectionEvent}
  * @param {ol.CollectionEventType} type Type.
  * @param {*=} opt_element Element.
@@ -54,7 +54,7 @@ ol.CollectionEvent = function(type, opt_element, opt_target) {
   this.element = opt_element;
 
 };
-goog.inherits(ol.CollectionEvent, goog.events.Event);
+goog.inherits(ol.CollectionEvent, ol.events.Event);
 
 
 /**

src/ol/control/attributioncontrol.js

@@ -5,8 +5,8 @@ goog.provide('ol.control.Attribution');
 goog.require('goog.asserts');
 goog.require('goog.dom');
 goog.require('goog.dom.classlist');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('goog.style');
 goog.require('ol');
@@ -95,7 +95,7 @@ ol.control.Attribution = function(opt_options) {
     'title': tipLabel
   }, activeLabel);
 
-  goog.events.listen(button, goog.events.EventType.CLICK,
+  ol.events.listen(button, ol.events.EventType.CLICK,
       this.handleClick_, false, this);
 
   var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' +
@@ -328,7 +328,7 @@ ol.control.Attribution.prototype.insertLogos_ = function(frameState) {
 
 
 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
  * @private
  */
 ol.control.Attribution.prototype.handleClick_ = function(event) {

src/ol/control/control.js

@@ -1,7 +1,7 @@
 goog.provide('ol.control.Control');
 
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol');
 goog.require('ol.MapEventType');
 goog.require('ol.Object');
@@ -108,7 +108,7 @@ ol.control.Control.prototype.setMap = function(map) {
     goog.dom.removeNode(this.element);
   }
   if (this.listenerKeys.length > 0) {
-    this.listenerKeys.forEach(goog.events.unlistenByKey);
+    this.listenerKeys.forEach(/** @type {Function} */ (ol.events.unlistenByKey));
     this.listenerKeys.length = 0;
   }
   this.map_ = map;
@@ -117,7 +117,7 @@ ol.control.Control.prototype.setMap = function(map) {
         this.target_ : map.getOverlayContainerStopEvent();
     target.appendChild(this.element);
     if (this.render !== ol.nullFunction) {
-      this.listenerKeys.push(goog.events.listen(map,
+      this.listenerKeys.push(ol.events.listen(map,
           ol.MapEventType.POSTRENDER, this.render, false, this));
     }
     map.render();

src/ol/control/fullscreencontrol.js

@@ -5,8 +5,8 @@ goog.require('goog.dom');
 goog.require('goog.dom.classlist');
 goog.require('goog.dom.fullscreen');
 goog.require('goog.dom.fullscreen.EventType');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol');
 goog.require('ol.control.Control');
 goog.require('ol.css');
@@ -64,10 +64,10 @@ ol.control.FullScreen = function(opt_options) {
     'title': tipLabel
   }, this.labelNode_);
 
-  goog.events.listen(button, goog.events.EventType.CLICK,
+  ol.events.listen(button, ol.events.EventType.CLICK,
       this.handleClick_, false, this);
 
-  goog.events.listen(goog.global.document,
+  ol.events.listen(goog.global.document,
       goog.dom.fullscreen.EventType.CHANGE,
       this.handleFullScreenChange_, false, this);
 
@@ -98,7 +98,7 @@ goog.inherits(ol.control.FullScreen, ol.control.Control);
 
 
 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
  * @private
  */
 ol.control.FullScreen.prototype.handleClick_ = function(event) {

src/ol/control/mousepositioncontrol.js

@@ -3,8 +3,8 @@
 goog.provide('ol.control.MousePosition');
 
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.CoordinateFormatType');
 goog.require('ol.Object');
 goog.require('ol.Pixel');
@@ -53,7 +53,7 @@ ol.control.MousePosition = function(opt_options) {
     target: options.target
   });
 
-  goog.events.listen(this,
+  ol.events.listen(this,
       ol.Object.getChangeEventType(ol.control.MousePositionProperty.PROJECTION),
       this.handleProjectionChanged_, false, this);
 
@@ -154,18 +154,18 @@ ol.control.MousePosition.prototype.getProjection = function() {
 
 
 /**
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} browserEvent Browser event.
  * @protected
  */
 ol.control.MousePosition.prototype.handleMouseMove = function(browserEvent) {
   var map = this.getMap();
-  this.lastMouseMovePixel_ = map.getEventPixel(browserEvent.getBrowserEvent());
+  this.lastMouseMovePixel_ = map.getEventPixel(browserEvent);
   this.updateHTML_(this.lastMouseMovePixel_);
 };
 
 
 /**
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} browserEvent Browser event.
  * @protected
  */
 ol.control.MousePosition.prototype.handleMouseOut = function(browserEvent) {
@@ -183,9 +183,9 @@ ol.control.MousePosition.prototype.setMap = function(map) {
   if (map) {
     var viewport = map.getViewport();
     this.listenerKeys.push(
-        goog.events.listen(viewport, goog.events.EventType.MOUSEMOVE,
+        ol.events.listen(viewport, ol.events.EventType.MOUSEMOVE,
             this.handleMouseMove, false, this),
-        goog.events.listen(viewport, goog.events.EventType.MOUSEOUT,
+        ol.events.listen(viewport, ol.events.EventType.MOUSEOUT,
             this.handleMouseOut, false, this)
     );
   }

src/ol/control/overviewmapcontrol.js

@@ -3,8 +3,8 @@ goog.provide('ol.control.OverviewMap');
 goog.require('goog.asserts');
 goog.require('goog.dom');
 goog.require('goog.dom.classlist');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.math.Size');
 goog.require('goog.style');
 goog.require('ol');
@@ -83,7 +83,7 @@ ol.control.OverviewMap = function(opt_options) {
     'title': tipLabel
   }, activeLabel);
 
-  goog.events.listen(button, goog.events.EventType.CLICK,
+  ol.events.listen(button, ol.events.EventType.CLICK,
       this.handleClick_, false, this);
 
   var ovmapDiv = goog.dom.createDom('DIV', 'ol-overviewmap-map');
@@ -159,7 +159,7 @@ ol.control.OverviewMap.prototype.setMap = function(map) {
   goog.base(this, 'setMap', map);
 
   if (map) {
-    this.listenerKeys.push(goog.events.listen(
+    this.listenerKeys.push(ol.events.listen(
         map, ol.ObjectEventType.PROPERTYCHANGE,
         this.handleMapPropertyChange_, false, this));
 
@@ -203,7 +203,7 @@ ol.control.OverviewMap.prototype.handleMapPropertyChange_ = function(event) {
  * @private
  */
 ol.control.OverviewMap.prototype.bindView_ = function(view) {
-  goog.events.listen(view,
+  ol.events.listen(view,
       ol.Object.getChangeEventType(ol.ViewProperty.ROTATION),
       this.handleRotationChanged_, false, this);
 };
@@ -215,7 +215,7 @@ ol.control.OverviewMap.prototype.bindView_ = function(view) {
  * @private
  */
 ol.control.OverviewMap.prototype.unbindView_ = function(view) {
-  goog.events.unlisten(view,
+  ol.events.unlisten(view,
       ol.Object.getChangeEventType(ol.ViewProperty.ROTATION),
       this.handleRotationChanged_, false, this);
 };
@@ -432,7 +432,7 @@ ol.control.OverviewMap.prototype.calculateCoordinateRotate_ = function(
 
 
 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
  * @private
  */
 ol.control.OverviewMap.prototype.handleClick_ = function(event) {
@@ -459,7 +459,7 @@ ol.control.OverviewMap.prototype.handleToggle_ = function() {
   if (!this.collapsed_ && !ovmap.isRendered()) {
     ovmap.updateSize();
     this.resetExtent_();
-    goog.events.listenOnce(ovmap, ol.MapEventType.POSTRENDER,
+    ol.events.listenOnce(ovmap, ol.MapEventType.POSTRENDER,
         function(event) {
           this.updateBox_();
         },

src/ol/control/rotatecontrol.js

@@ -2,8 +2,8 @@ goog.provide('ol.control.Rotate');
 
 goog.require('goog.dom');
 goog.require('goog.dom.classlist');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol');
 goog.require('ol.animation');
 goog.require('ol.control.Control');
@@ -53,7 +53,7 @@ ol.control.Rotate = function(opt_options) {
     'title': tipLabel
   }, this.label_);
 
-  goog.events.listen(button, goog.events.EventType.CLICK,
+  ol.events.listen(button, ol.events.EventType.CLICK,
       ol.control.Rotate.prototype.handleClick_, false, this);
 
   var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' +
@@ -97,7 +97,7 @@ goog.inherits(ol.control.Rotate, ol.control.Control);
 
 
 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
  * @private
  */
 ol.control.Rotate.prototype.handleClick_ = function(event) {

src/ol/control/scalelinecontrol.js

@@ -4,7 +4,7 @@ goog.provide('ol.control.ScaleLineUnits');
 
 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.style');
 goog.require('ol');
 goog.require('ol.Object');
@@ -109,7 +109,7 @@ ol.control.ScaleLine = function(opt_options) {
     target: options.target
   });
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.control.ScaleLineProperty.UNITS),
       this.handleUnitsChanged_, false, this);
 

src/ol/control/zoomcontrol.js

@@ -1,8 +1,8 @@
 goog.provide('ol.control.Zoom');
 
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.animation');
 goog.require('ol.control.Control');
 goog.require('ol.css');
@@ -42,8 +42,8 @@ ol.control.Zoom = function(opt_options) {
     'title': zoomInTipLabel
   }, zoomInLabel);
 
-  goog.events.listen(inElement,
+  ol.events.listen(inElement,
-      goog.events.EventType.CLICK, goog.partial(
+      ol.events.EventType.CLICK, goog.partial(
           ol.control.Zoom.prototype.handleClick_, delta), false, this);
 
   var outElement = goog.dom.createDom('BUTTON', {
@@ -52,8 +52,8 @@ ol.control.Zoom = function(opt_options) {
     'title': zoomOutTipLabel
   }, zoomOutLabel);
 
-  goog.events.listen(outElement,
+  ol.events.listen(outElement,
-      goog.events.EventType.CLICK, goog.partial(
+      ol.events.EventType.CLICK, goog.partial(
           ol.control.Zoom.prototype.handleClick_, -delta), false, this);
 
   var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' +
@@ -78,7 +78,7 @@ goog.inherits(ol.control.Zoom, ol.control.Control);
 
 /**
  * @param {number} delta Zoom delta.
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
  * @private
  */
 ol.control.Zoom.prototype.handleClick_ = function(delta, event) {

src/ol/control/zoomslidercontrol.js

@@ -4,9 +4,9 @@ goog.provide('ol.control.ZoomSlider');
 
 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.fx.DragEvent');
 goog.require('goog.fx.Dragger');
 goog.require('goog.fx.Dragger.EventType');
@@ -92,17 +92,17 @@ ol.control.ZoomSlider = function(opt_options) {
   this.dragger_ = new goog.fx.Dragger(thumbElement);
   this.registerDisposable(this.dragger_);
 
-  goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.START,
+  ol.events.listen(this.dragger_, goog.fx.Dragger.EventType.START,
       this.handleDraggerStart_, false, this);
-  goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.DRAG,
+  ol.events.listen(this.dragger_, goog.fx.Dragger.EventType.DRAG,
       this.handleDraggerDrag_, false, this);
-  goog.events.listen(this.dragger_, goog.fx.Dragger.EventType.END,
+  ol.events.listen(this.dragger_, goog.fx.Dragger.EventType.END,
       this.handleDraggerEnd_, false, this);
 
-  goog.events.listen(containerElement, goog.events.EventType.CLICK,
+  ol.events.listen(containerElement, ol.events.EventType.CLICK,
       this.handleContainerClick_, false, this);
-  goog.events.listen(thumbElement, goog.events.EventType.CLICK,
+  ol.events.listen(thumbElement, ol.events.EventType.CLICK,
-      goog.events.Event.stopPropagation);
+      ol.events.Event.stopPropagation);
 
   var render = options.render ? options.render : ol.control.ZoomSlider.render;
 
@@ -196,7 +196,7 @@ ol.control.ZoomSlider.render = function(mapEvent) {
 
 
 /**
- * @param {goog.events.BrowserEvent} browserEvent The browser event to handle.
+ * @param {Event} browserEvent The browser event to handle.
  * @private
  */
 ol.control.ZoomSlider.prototype.handleContainerClick_ = function(browserEvent) {

src/ol/control/zoomtoextentcontrol.js

@@ -2,8 +2,8 @@ goog.provide('ol.control.ZoomToExtent');
 
 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.control.Control');
 goog.require('ol.css');
 
@@ -38,7 +38,7 @@ ol.control.ZoomToExtent = function(opt_options) {
     'title': tipLabel
   }, label);
 
-  goog.events.listen(button, goog.events.EventType.CLICK,
+  ol.events.listen(button, ol.events.EventType.CLICK,
       this.handleClick_, false, this);
 
   var cssClasses = className + ' ' + ol.css.CLASS_UNSELECTABLE + ' ' +
@@ -54,7 +54,7 @@ goog.inherits(ol.control.ZoomToExtent, ol.control.Control);
 
 
 /**
- * @param {goog.events.BrowserEvent} event The event to handle
+ * @param {Event} event The event to handle
  * @private
  */
 ol.control.ZoomToExtent.prototype.handleClick_ = function(event) {

src/ol/deviceorientation.js

@@ -1,7 +1,7 @@
 goog.provide('ol.DeviceOrientation');
 goog.provide('ol.DeviceOrientationProperty');
 
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol');
 goog.require('ol.Object');
 goog.require('ol.has');
@@ -83,11 +83,11 @@ ol.DeviceOrientation = function(opt_options) {
 
   /**
    * @private
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    */
   this.listenerKey_ = null;
 
-  goog.events.listen(this,
+  ol.events.listen(this,
       ol.Object.getChangeEventType(ol.DeviceOrientationProperty.TRACKING),
       this.handleTrackingChanged_, false, this);
 
@@ -108,11 +108,11 @@ ol.DeviceOrientation.prototype.disposeInternal = function() {
 
 /**
  * @private
- * @param {goog.events.BrowserEvent} browserEvent Event.
+ * @param {Event} browserEvent Event.
  */
 ol.DeviceOrientation.prototype.orientationChange_ = function(browserEvent) {
   var event = /** @type {DeviceOrientationEvent} */
-      (browserEvent.getBrowserEvent());
+      (browserEvent);
   if (event.alpha !== null) {
     var alpha = ol.math.toRadians(event.alpha);
     this.set(ol.DeviceOrientationProperty.ALPHA, alpha);
@@ -208,10 +208,10 @@ ol.DeviceOrientation.prototype.handleTrackingChanged_ = function() {
   if (ol.has.DEVICE_ORIENTATION) {
     var tracking = this.getTracking();
     if (tracking && !this.listenerKey_) {
-      this.listenerKey_ = goog.events.listen(goog.global, 'deviceorientation',
+      this.listenerKey_ = ol.events.listen(goog.global, 'deviceorientation',
           this.orientationChange_, false, this);
-    } else if (!tracking && this.listenerKey_) {
+    } else if (!tracking && this.listenerKey_ !== null) {
-      goog.events.unlistenByKey(this.listenerKey_);
+      ol.events.unlistenByKey(this.listenerKey_);
       this.listenerKey_ = null;
     }
   }

src/ol/events.js

@@ -0,0 +1,243 @@
+goog.provide('ol.events');
+goog.provide('ol.events.EventType');
+
+
+/**
+ * @enum {string}
+ */
+ol.events.EventType = {
+  /**
+   * Generic change event.
+   * @event ol.events.Event#change
+   * @api
+   */
+  CHANGE: 'change',
+  CLICK: 'click',
+  DBLCLICK: 'dblclick',
+  ERROR: 'error',
+  LOAD: 'load',
+  MOUSEDOWN: 'mousedown',
+  MOUSEMOVE: 'mousemove',
+  MOUSEOUT: 'mouseout',
+  MSPOINTERDOWN: 'mspointerdown',
+  RESIZE: 'resize',
+  TOUCHSTART: 'touchstart'
+};
+
+/**
+ * Key to use with {@link ol.Observable#unByKey}.
+ *
+ * @typedef {string|Array.<string>}
+ * @api
+ */
+ol.events.Key;
+
+
+/**
+ * @typedef {{listener: ol.events.ListenerFunctionType,
+ *     target: (EventTarget|ol.events.EventTarget),
+ *     thisArg: (Object|undefined),
+ *     type: (ol.events.EventType|Array.<ol.events.EventType>),
+ *     useCapture: boolean}}
+ */
+ol.events.ListenerData;
+
+
+/**
+ * Listener function. This function is called with an event object as argument.
+ * When the function returns `false`, event propagation will stop.
+ *
+ * @typedef {function(ol.events.Event)|function(ol.events.Event): boolean}
+ * @api
+ */
+ol.events.ListenerFunctionType;
+
+
+/**
+ * @private
+ * @type {Object.<ol.events.Key, ol.events.ListenerData>}
+ */
+ol.events.listenersByKey_ = {};
+
+
+/**
+ * @private
+ * @param {EventTarget|ol.events.EventTarget|
+ *     {removeEventListener: function(string, Function, boolean=)}} target Event target.
+ * @param {ol.events.EventType|string|Array.<(ol.events.EventType|string)>} type
+ *     Event type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {boolean=} opt_useCapture Use capture. For listeners on an
+ *     {@link ol.events.EventTarget}, `true` simply means that the listener will
+ *     be called before already registered listeners. Default is false.
+ * @param {Object=} opt_this Object referenced by the `this` keyword in the
+ *     listener. Default is the `target`.
+ * @return {ol.events.ListenerFunctionType} Listener that unregisters itself.
+ */
+ol.events.createListenOnce_ = function(target, type, listener, opt_useCapture, opt_this) {
+  var count = Array.isArray(type) ? type.length : 1;
+  var key = ol.events.getKey.apply(undefined, arguments);
+  return function listenOnce(evt) {
+    listener.call(opt_this || this, evt);
+    target.removeEventListener(evt.type, listenOnce, opt_useCapture);
+    --count;
+    if (count === 0) {
+      delete ol.events.listenersByKey_[key];
+    }
+  }
+};
+
+
+/**
+ * @param {EventTarget|ol.events.EventTarget} target Event target.
+ * @param {ol.events.EventType|string|Array.<(ol.events.EventType|string)>} type
+ *     Event type.
+ * @param {Event|ol.events.Event} event Event to dispatch on the `target`.
+ */
+ol.events.fireListeners = function(target, type, event) {
+  event.type = type;
+  target.dispatchEvent(event);
+};
+
+
+/**
+ * @param {EventTarget|ol.events.EventTarget} target Event target.
+ * @param {ol.events.EventType|string|Array.<(ol.events.EventType|string)>} type
+ *     Event type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {boolean=} opt_useCapture Use capture. For listeners on an
+ *     {@link ol.events.EventTarget}, `true` simply means that the listener will
+ *     be called before already registered listeners. Default is false.
+ * @param {Object=} opt_this Object referenced by the `this` keyword in the
+ *     listener. Default is the `target`.
+ * @return {!ol.events.Key} Key for unlistenByKey.
+ */
+ol.events.getKey = function(target, type, listener, opt_useCapture, opt_this) {
+  return [
+    goog.getUid(target), type.toString(),goog.getUid(listener),
+    Number(!!opt_useCapture), (opt_this ? goog.getUid(opt_this) : '')
+  ].toString();
+};
+
+
+/**
+ * @param {ol.events.EventTarget} target Target.
+ * @param {ol.events.EventType|string} type Type.
+ * @return {Array.<ol.events.ListenerFunctionType>} Listeners.
+ */
+ol.events.getListeners = function(target, type) {
+  return target.getListeners(type);
+};
+
+
+/**
+ * @param {EventTarget|ol.events.EventTarget|
+ *     {addEventListener: function(string, Function, boolean=)}} target Event target.
+ * @param {ol.events.EventType|string|Array.<(ol.events.EventType|string)>} type
+ *     Event type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {boolean=} opt_useCapture Use capture. For listeners on an
+ *     {@link ol.events.EventTarget}, `true` simply means that the listener will
+ *     be called before already registered listeners. Default is false.
+ * @param {Object=} opt_this Object referenced by the `this` keyword in the
+ *     listener. Default is the `target`.
+ * @return {ol.events.Key} Key for unlistenByKey.
+ */
+ol.events.listen = function(target, type, listener, opt_useCapture, opt_this) {
+  var targetListener = opt_this ? listener.bind(opt_this) : listener;
+  //TODO remove:
+  targetListener.handler = opt_this;
+  var types = Array.isArray(type) ? type : [type];
+  var key = ol.events.getKey.apply(undefined, arguments);
+  if (!ol.events.listenersByKey_[key]) {
+    for (var i = 0, ii = types.length; i < ii; ++i) {
+      target.addEventListener(types[i], targetListener, opt_useCapture);
+    }
+    ol.events.listenersByKey_[key] = /** @type {ol.events.ListenerData} */ ({
+      listener: targetListener,
+      target: target,
+      thisArg: opt_this,
+      type: type,
+      useCapture: opt_useCapture
+    });
+  }
+  return key;
+};
+
+
+/**
+ * @param {EventTarget|ol.events.EventTarget|
+ *     {addEventListener: function(string, Function, boolean=),
+ *     removeEventListener: function(string, Function, boolean=)}} target Event target.
+ * @param {ol.events.EventType|string|Array.<(ol.events.EventType|string)>} type
+ *     Event type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {boolean=} opt_useCapture Use capture. For listeners on an
+ *     {@link ol.events.EventTarget}, `true` simply means that the listener will
+ *     be called before already registered listeners. Default is false.
+ * @param {Object=} opt_this Object referenced by the `this` keyword in the
+ *     listener. Default is the `target`.
+ * @return {ol.events.Key} Key for unlistenByKey.
+ */
+ol.events.listenOnce = function(target, type, listener, opt_useCapture, opt_this) {
+  var key = ol.events.getKey.apply(undefined, arguments);
+  if (!ol.events.listenersByKey_[key]) {
+    var targetListener = ol.events.createListenOnce_(target, type, listener,
+        opt_useCapture, opt_this);
+    var onceKey = ol.events.listen(target, type, targetListener, opt_useCapture);
+    ol.events.listenersByKey_[key] = ol.events.listenersByKey_[onceKey];
+    delete ol.events.listenersByKey_[onceKey];
+  }
+  return key;
+};
+
+
+/**
+ * @param {EventTarget|ol.events.EventTarget|{removeEventListener: function(string, Function, boolean=)}} target
+ *     Event target.
+ * @param {ol.events.EventType|string|Array.<(ol.events.EventType|string)>} type
+ *     Event type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {boolean=} opt_useCapture Use capture. For listeners on an
+ *     {@link ol.events.EventTarget}, `true` simply means that the listener will
+ *     be called before already registered listeners. Default is false.
+ * @param {Object=} opt_this Object referenced by the `this` keyword in the
+ *     listener. Default is the `target`.
+ * @return {ol.events.Key} Key that the listener was referenced with.
+ */
+ol.events.unlisten = function(target, type, listener, opt_useCapture, opt_this) {
+  var key = ol.events.getKey.apply(undefined, arguments);
+  ol.events.unlistenByKey(key);
+  return key;
+};
+
+
+/**
+ * @param {ol.events.Key} key Key or keys.
+ */
+ol.events.unlistenByKey = function(key) {
+  var listenerData = ol.events.listenersByKey_[key];
+  if (listenerData) {
+    var type = listenerData.type;
+    var types = Array.isArray(type) ? type : [type];
+    for (var i = 0, ii = types.length; i < ii; ++i) {
+      listenerData.target.removeEventListener(types[i],
+          listenerData.listener, listenerData.useCapture);
+    }
+    delete ol.events.listenersByKey_[key];
+  }
+};
+
+
+/**
+ * @param {EventTarget|ol.events.EventTarget} target Target.
+ */
+ol.events.unlistenAll = function(target) {
+  var listenerData;
+  for (var key in ol.events.listenersByKey_) {
+    listenerData = ol.events.listenersByKey_[key];
+    if (listenerData.target === target || listenerData.thisArg === target) {
+      ol.events.unlistenByKey(key);
+    }
+  }
+};

src/ol/events/condition.js

@@ -26,10 +26,10 @@ ol.events.ConditionType;
  * @api stable
  */
 ol.events.condition.altKeyOnly = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var browserEvent = mapBrowserEvent.originalEvent;
   return (
       browserEvent.altKey &&
-      !browserEvent.platformModifierKey &&
+      !(browserEvent.metaKey || browserEvent.ctrlKey) &&
       !browserEvent.shiftKey);
 };
 
@@ -43,10 +43,10 @@ ol.events.condition.altKeyOnly = function(mapBrowserEvent) {
  * @api stable
  */
 ol.events.condition.altShiftKeysOnly = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var browserEvent = mapBrowserEvent.originalEvent;
   return (
       browserEvent.altKey &&
-      !browserEvent.platformModifierKey &&
+      !(browserEvent.metaKey || browserEvent.ctrlKey) &&
       browserEvent.shiftKey);
 };
 
@@ -74,6 +74,22 @@ ol.events.condition.click = function(mapBrowserEvent) {
 };
 
 
+/**
+ * Return `true` if the event has an "action"-producing mouse button.
+ *
+ * By definition, this includes left-click on windows/linux, and left-click
+ * without the ctrl key on Macs.
+ *
+ * @param {ol.MapBrowserEvent} mapBrowserEvent Map browser event.
+ * @return {boolean} The result.
+ */
+ol.events.condition.mouseActionButton = function(mapBrowserEvent) {
+  var browserEvent = mapBrowserEvent.originalEvent;
+  return browserEvent.button == 0 &&
+      !(goog.userAgent.WEBKIT && goog.userAgent.MAC && browserEvent.ctrlKey);
+};
+
+
 /**
  * Return always false.
  *
@@ -131,10 +147,10 @@ ol.events.condition.doubleClick = function(mapBrowserEvent) {
  * @api stable
  */
 ol.events.condition.noModifierKeys = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var browserEvent = mapBrowserEvent.originalEvent;
   return (
       !browserEvent.altKey &&
-      !browserEvent.platformModifierKey &&
+      !(browserEvent.metaKey || browserEvent.ctrlKey) &&
       !browserEvent.shiftKey);
 };
 
@@ -149,10 +165,10 @@ ol.events.condition.noModifierKeys = function(mapBrowserEvent) {
  * @api stable
  */
 ol.events.condition.platformModifierKeyOnly = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var browserEvent = mapBrowserEvent.originalEvent;
   return (
       !browserEvent.altKey &&
-      browserEvent.platformModifierKey &&
+      (goog.userAgent.MAC ? browserEvent.metaKey : browserEvent.ctrlKey) &&
       !browserEvent.shiftKey);
 };
 
@@ -166,10 +182,10 @@ ol.events.condition.platformModifierKeyOnly = function(mapBrowserEvent) {
  * @api stable
  */
 ol.events.condition.shiftKeyOnly = function(mapBrowserEvent) {
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var browserEvent = mapBrowserEvent.originalEvent;
   return (
       !browserEvent.altKey &&
-      !browserEvent.platformModifierKey &&
+      !(browserEvent.metaKey || browserEvent.ctrlKey) &&
       browserEvent.shiftKey);
 };
 
@@ -183,7 +199,7 @@ ol.events.condition.shiftKeyOnly = function(mapBrowserEvent) {
  * @api
  */
 ol.events.condition.targetNotEditable = function(mapBrowserEvent) {
-  var target = mapBrowserEvent.browserEvent.target;
+  var target = mapBrowserEvent.originalEvent.target;
   goog.asserts.assertInstanceof(target, Element,
       'target should be an Element');
   var tagName = target.tagName;

src/ol/events/event.js

@@ -0,0 +1,51 @@
+goog.provide('ol.events.Event');
+
+
+/**
+ * @constructor
+ * @param {ol.events.EventType|string} type Type.
+ * @param {Object=} opt_target Target.
+ */
+ol.events.Event = function(type, opt_target) {
+
+  /**
+   * @type {boolean}
+   */
+  this.propagationStopped;
+
+  /**
+   * @type {string}
+   */
+  this.type = type;
+
+  /**
+   * @type {Object|undefined}
+   */
+  this.target = opt_target;
+
+};
+
+
+/**
+ * Stop event propagation
+ */
+ol.events.Event.prototype.preventDefault =
+ol.events.Event.prototype.stopPropagation = function() {
+  this.propagationStopped = true;
+};
+
+
+/**
+ * @param {Event|ol.events.Event} evt Event
+ */
+ol.events.Event.stopPropagation = function(evt) {
+  evt.stopPropagation();
+};
+
+
+/**
+ * @param {Event|ol.events.Event} evt Event
+ */
+ol.events.Event.preventDefault = function(evt) {
+  evt.preventDefault();
+};

src/ol/events/eventtarget.js

@@ -0,0 +1,113 @@
+goog.provide('ol.events.EventTarget');
+
+goog.require('goog.Disposable');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+
+/**
+ * @constructor
+ * @extends {goog.Disposable}
+ */
+ol.events.EventTarget = function() {
+
+  goog.base(this);
+
+  /**
+   * @private
+   * @type {!Object.<string, Array.<ol.events.ListenerFunctionType>>}
+   */
+  this.listeners_ = {};
+
+};
+goog.inherits(ol.events.EventTarget, goog.Disposable);
+
+
+/**
+ * @param {ol.events.EventType|string} type Type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {boolean=} opt_capture Call listener before already registered
+ *     listeners. Default is false.
+ */
+ol.events.EventTarget.prototype.addEventListener = function(type, listener, opt_capture) {
+  var listeners = this.listeners_[type];
+  if (!listeners) {
+    listeners = this.listeners_[type] = [];
+  }
+  if (listeners.indexOf(listener) === -1) {
+    if (opt_capture) {
+      listeners.push(listener);
+    } else {
+      listeners.unshift(listener);
+    }
+  }
+};
+
+
+/**
+ * @param {{type: (ol.events.EventType|string),
+ *     target: (EventTarget|ol.events.EventTarget|undefined)}|ol.events.Event|
+ *     ol.events.EventType|string} event Event or event type.
+ * @return {boolean|undefined} `false` if anyone called preventDefault on the
+ *     event object or if any of the listeners returned false.
+ */
+ol.events.EventTarget.prototype.dispatchEvent = function(event) {
+  var evt = goog.isString(event) ? new ol.events.Event(event) : event;
+  var type = evt.type;
+  evt.target = this;
+  var listeners = this.listeners_[type];
+  if (listeners) {
+    for (var i = listeners.length - 1; i >= 0; --i) {
+      if (listeners[i].call(this, evt) === false || evt.propagationStopped) {
+        return false;
+      }
+    }
+  }
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.events.EventTarget.prototype.disposeInternal = function() {
+  ol.events.unlistenAll(this);
+  goog.base(this, 'disposeInternal');
+};
+
+
+/**
+ * @param {ol.events.EventType|string} type Type.
+ * @return {Array.<ol.events.ListenerFunctionType>} Listeners.
+ */
+ol.events.EventTarget.prototype.getListeners = function(type) {
+  return this.listeners_[type];
+};
+
+
+/**
+ * @param {(ol.events.EventType|string)=} opt_type Type. If not provided,
+ *     `true` will be returned if this EventTarget has any listeners.
+ * @return {boolean} Has listeners.
+ */
+ol.events.EventTarget.prototype.hasListener = function(opt_type) {
+  return opt_type ?
+      opt_type in this.listeners_ :
+      Object.keys(this.listeners_).length > 0;
+};
+
+
+/**
+ * @param {ol.events.EventType|string} type Type.
+ * @param {ol.events.ListenerFunctionType} listener Listener.
+ * @param {boolean=} opt_capture Call listener before already registered
+ *     listeners. Default is false.
+ */
+ol.events.EventTarget.prototype.removeEventListener = function(type, listener, opt_capture) {
+  var listeners = this.listeners_[type];
+  if (listeners) {
+    var index = listeners.indexOf(listener);
+    listeners.splice(index, 1);
+    if (listeners.length === 0) {
+      delete this.listeners_[type];
+    }
+  }
+};

src/ol/feature.js

@@ -2,8 +2,8 @@ goog.provide('ol.Feature');
 goog.provide('ol.FeatureStyleFunction');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol');
 goog.require('ol.Object');
 goog.require('ol.geom.Geometry');
@@ -87,11 +87,11 @@ ol.Feature = function(opt_geometryOrProperties) {
 
   /**
    * @private
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    */
   this.geometryChangeKey_ = null;
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(this.geometryName_),
       this.handleGeometryChanged_, false, this);
 
@@ -209,13 +209,13 @@ ol.Feature.prototype.handleGeometryChange_ = function() {
  */
 ol.Feature.prototype.handleGeometryChanged_ = function() {
   if (this.geometryChangeKey_) {
-    goog.events.unlistenByKey(this.geometryChangeKey_);
+    ol.events.unlistenByKey(this.geometryChangeKey_);
     this.geometryChangeKey_ = null;
   }
   var geometry = this.getGeometry();
   if (geometry) {
-    this.geometryChangeKey_ = goog.events.listen(geometry,
+    this.geometryChangeKey_ = ol.events.listen(geometry,
-        goog.events.EventType.CHANGE, this.handleGeometryChange_, false, this);
+        ol.events.EventType.CHANGE, this.handleGeometryChange_, false, this);
   }
   this.changed();
 };
@@ -273,11 +273,11 @@ ol.Feature.prototype.setId = function(id) {
  * @api stable
  */
 ol.Feature.prototype.setGeometryName = function(name) {
-  goog.events.unlisten(
+  ol.events.unlisten(
       this, ol.Object.getChangeEventType(this.geometryName_),
       this.handleGeometryChanged_, false, this);
   this.geometryName_ = name;
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(this.geometryName_),
       this.handleGeometryChanged_, false, this);
   this.handleGeometryChanged_();

src/ol/featureloader.js

@@ -3,7 +3,7 @@ goog.provide('ol.FeatureUrlFunction');
 goog.provide('ol.featureloader');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.net.EventType');
 goog.require('goog.net.XhrIo');
 goog.require('goog.net.XhrIo.ResponseType');
@@ -72,7 +72,7 @@ ol.featureloader.loadFeaturesXhr = function(url, format, success, failure) {
             format.getType() == ol.format.FormatType.ARRAY_BUFFER ?
                 goog.net.XhrIo.ResponseType.ARRAY_BUFFER :
                 goog.net.XhrIo.ResponseType.TEXT);
-        goog.events.listen(xhrIo, goog.net.EventType.COMPLETE,
+        ol.events.listen(xhrIo, goog.net.EventType.COMPLETE,
             /**
              * @param {Event} event Event.
              * @private

src/ol/geolocation.js

@@ -3,8 +3,8 @@
 goog.provide('ol.Geolocation');
 goog.provide('ol.GeolocationProperty');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.Coordinate');
 goog.require('ol.Object');
 goog.require('ol.geom.Geometry');
@@ -83,10 +83,10 @@ ol.Geolocation = function(opt_options) {
    */
   this.watchId_ = undefined;
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.GeolocationProperty.PROJECTION),
       this.handleProjectionChanged_, false, this);
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.GeolocationProperty.TRACKING),
       this.handleTrackingChanged_, false, this);
 
@@ -189,9 +189,9 @@ ol.Geolocation.prototype.positionChange_ = function(position) {
  * @param {GeolocationPositionError} error error object.
  */
 ol.Geolocation.prototype.positionError_ = function(error) {
-  error.type = goog.events.EventType.ERROR;
+  error.type = ol.events.EventType.ERROR;
   this.setTracking(false);
-  this.dispatchEvent(error);
+  this.dispatchEvent(/** @type {{type: string}} */ (error));
 };
 
 

src/ol/geom/geometrycollection.js

@@ -1,7 +1,7 @@
 goog.provide('ol.geom.GeometryCollection');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.extent');
 goog.require('ol.geom.Geometry');
@@ -56,8 +56,8 @@ ol.geom.GeometryCollection.prototype.unlistenGeometriesChange_ = function() {
     return;
   }
   for (i = 0, ii = this.geometries_.length; i < ii; ++i) {
-    goog.events.unlisten(
+    ol.events.unlisten(
-        this.geometries_[i], goog.events.EventType.CHANGE,
+        this.geometries_[i], ol.events.EventType.CHANGE,
         this.changed, false, this);
   }
 };
@@ -72,8 +72,8 @@ ol.geom.GeometryCollection.prototype.listenGeometriesChange_ = function() {
     return;
   }
   for (i = 0, ii = this.geometries_.length; i < ii; ++i) {
-    goog.events.listen(
+    ol.events.listen(
-        this.geometries_[i], goog.events.EventType.CHANGE,
+        this.geometries_[i], ol.events.EventType.CHANGE,
         this.changed, false, this);
   }
 };

src/ol/image.js

@@ -1,8 +1,8 @@
 goog.provide('ol.Image');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.ImageBase');
 goog.require('ol.ImageState');
@@ -49,7 +49,7 @@ ol.Image = function(extent, resolution, pixelRatio, attributions, src,
 
   /**
    * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
    */
   this.imageListenerKeys_ = null;
 
@@ -131,9 +131,9 @@ ol.Image.prototype.load = function() {
     goog.asserts.assert(!this.imageListenerKeys_,
         'this.imageListenerKeys_ should be null');
     this.imageListenerKeys_ = [
-      goog.events.listenOnce(this.image_, goog.events.EventType.ERROR,
+      ol.events.listenOnce(this.image_, ol.events.EventType.ERROR,
           this.handleImageError_, false, this),
-      goog.events.listenOnce(this.image_, goog.events.EventType.LOAD,
+      ol.events.listenOnce(this.image_, ol.events.EventType.LOAD,
           this.handleImageLoad_, false, this)
     ];
     this.imageLoadFunction_(this, this.src_);
@@ -157,6 +157,6 @@ ol.Image.prototype.setImage = function(image) {
 ol.Image.prototype.unlistenImage_ = function() {
   goog.asserts.assert(this.imageListenerKeys_,
       'this.imageListenerKeys_ should not be null');
-  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(ol.events.unlistenByKey);
   this.imageListenerKeys_ = null;
 };

src/ol/imagebase.js

@@ -2,8 +2,8 @@ goog.provide('ol.ImageBase');
 goog.provide('ol.ImageState');
 
 goog.require('goog.asserts');
-goog.require('goog.events.EventTarget');
+goog.require('ol.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.Attribution');
 goog.require('ol.Extent');
 
@@ -21,7 +21,7 @@ ol.ImageState = {
 
 /**
  * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
  * @param {ol.Extent} extent Extent.
  * @param {number|undefined} resolution Resolution.
  * @param {number} pixelRatio Pixel ratio.
@@ -63,14 +63,14 @@ ol.ImageBase = function(extent, resolution, pixelRatio, state, attributions) {
   this.state = state;
 
 };
-goog.inherits(ol.ImageBase, goog.events.EventTarget);
+goog.inherits(ol.ImageBase, ol.events.EventTarget);
 
 
 /**
  * @protected
  */
 ol.ImageBase.prototype.changed = function() {
-  this.dispatchEvent(goog.events.EventType.CHANGE);
+  this.dispatchEvent(ol.events.EventType.CHANGE);
 };
 
 

src/ol/imagetile.js

@@ -1,8 +1,8 @@
 goog.provide('ol.ImageTile');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.Tile');
 goog.require('ol.TileCoord');
@@ -48,7 +48,7 @@ ol.ImageTile = function(tileCoord, state, src, crossOrigin, tileLoadFunction) {
 
   /**
    * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
    */
   this.imageListenerKeys_ = null;
 
@@ -146,9 +146,9 @@ ol.ImageTile.prototype.load = function() {
     goog.asserts.assert(!this.imageListenerKeys_,
         'this.imageListenerKeys_ should be null');
     this.imageListenerKeys_ = [
-      goog.events.listenOnce(this.image_, goog.events.EventType.ERROR,
+      ol.events.listenOnce(this.image_, ol.events.EventType.ERROR,
           this.handleImageError_, false, this),
-      goog.events.listenOnce(this.image_, goog.events.EventType.LOAD,
+      ol.events.listenOnce(this.image_, ol.events.EventType.LOAD,
           this.handleImageLoad_, false, this)
     ];
     this.tileLoadFunction_(this, this.src_);
@@ -164,6 +164,6 @@ ol.ImageTile.prototype.load = function() {
 ol.ImageTile.prototype.unlistenImage_ = function() {
   goog.asserts.assert(this.imageListenerKeys_,
       'this.imageListenerKeys_ should not be null');
-  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(ol.events.unlistenByKey);
   this.imageListenerKeys_ = null;
 };

src/ol/interaction/doubleclickzoominteraction.js

@@ -49,7 +49,7 @@ goog.inherits(ol.interaction.DoubleClickZoom, ol.interaction.Interaction);
  */
 ol.interaction.DoubleClickZoom.handleEvent = function(mapBrowserEvent) {
   var stopEvent = false;
-  var browserEvent = mapBrowserEvent.browserEvent;
+  var browserEvent = mapBrowserEvent.originalEvent;
   if (mapBrowserEvent.type == ol.MapBrowserEvent.EventType.DBLCLICK) {
     var map = mapBrowserEvent.map;
     var anchor = mapBrowserEvent.coordinate;

src/ol/interaction/draganddropinteraction.js

@@ -4,8 +4,8 @@ goog.provide('ol.interaction.DragAndDrop');
 goog.provide('ol.interaction.DragAndDropEvent');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('goog.events.FileDropHandler');
 goog.require('goog.events.FileDropHandler.EventType');
 goog.require('goog.fs.FileReader');
@@ -54,7 +54,7 @@ ol.interaction.DragAndDrop = function(opt_options) {
 
   /**
    * @private
-   * @type {goog.events.Key|undefined}
+   * @type {ol.events.Key|undefined}
    */
   this.dropListenKey_ = undefined;
 
@@ -67,18 +67,18 @@ goog.inherits(ol.interaction.DragAndDrop, ol.interaction.Interaction);
  */
 ol.interaction.DragAndDrop.prototype.disposeInternal = function() {
   if (this.dropListenKey_) {
-    goog.events.unlistenByKey(this.dropListenKey_);
+    ol.events.unlistenByKey(this.dropListenKey_);
   }
   goog.base(this, 'disposeInternal');
 };
 
 
 /**
- * @param {goog.events.BrowserEvent} event Event.
+ * @param {Event} event Event.
  * @private
  */
 ol.interaction.DragAndDrop.prototype.handleDrop_ = function(event) {
-  var files = event.getBrowserEvent().dataTransfer.files;
+  var files = event.dataTransfer.files;
   var i, ii, file;
   for (i = 0, ii = files.length; i < ii; ++i) {
     file = files[i];
@@ -150,7 +150,7 @@ ol.interaction.DragAndDrop.handleEvent = goog.functions.TRUE;
  */
 ol.interaction.DragAndDrop.prototype.setMap = function(map) {
   if (this.dropListenKey_) {
-    goog.events.unlistenByKey(this.dropListenKey_);
+    ol.events.unlistenByKey(this.dropListenKey_);
     this.dropListenKey_ = undefined;
   }
   if (this.fileDropHandler_) {
@@ -162,7 +162,7 @@ ol.interaction.DragAndDrop.prototype.setMap = function(map) {
   goog.base(this, 'setMap', map);
   if (map) {
     this.fileDropHandler_ = new goog.events.FileDropHandler(map.getViewport());
-    this.dropListenKey_ = goog.events.listen(
+    this.dropListenKey_ = ol.events.listen(
         this.fileDropHandler_, goog.events.FileDropHandler.EventType.DROP,
         this.handleDrop_, false, this);
   }
@@ -203,7 +203,7 @@ ol.interaction.DragAndDropEventType = {
  * of this type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.interaction.DragAndDropEvent}
  * @param {ol.interaction.DragAndDropEventType} type Type.
  * @param {Object} target Target.
@@ -237,4 +237,4 @@ ol.interaction.DragAndDropEvent = function(type, target, file, opt_features, opt
   this.projection = opt_projection;
 
 };
-goog.inherits(ol.interaction.DragAndDropEvent, goog.events.Event);
+goog.inherits(ol.interaction.DragAndDropEvent, ol.events.Event);

src/ol/interaction/dragboxinteraction.js

@@ -2,7 +2,7 @@
 goog.provide('ol.DragBoxEvent');
 goog.provide('ol.interaction.DragBox');
 
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol');
 goog.require('ol.events.ConditionType');
 goog.require('ol.events.condition');
@@ -54,7 +54,7 @@ ol.DragBoxEventType = {
  * @param {string} type The event type.
  * @param {ol.Coordinate} coordinate The event coordinate.
  * @param {ol.MapBrowserEvent} mapBrowserEvent Originating event.
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @constructor
  * @implements {oli.DragBoxEvent}
  */
@@ -77,7 +77,7 @@ ol.DragBoxEvent = function(type, coordinate, mapBrowserEvent) {
   this.mapBrowserEvent = mapBrowserEvent;
 
 };
-goog.inherits(ol.DragBoxEvent, goog.events.Event);
+goog.inherits(ol.DragBoxEvent, ol.events.Event);
 
 
 /**
@@ -234,8 +234,8 @@ ol.interaction.DragBox.handleDownEvent_ = function(mapBrowserEvent) {
     return false;
   }
 
-  var browserEvent = mapBrowserEvent.browserEvent;
+  if (ol.events.condition.mouseActionButton(mapBrowserEvent) &&
-  if (browserEvent.isMouseActionButton() && this.condition_(mapBrowserEvent)) {
+      this.condition_(mapBrowserEvent)) {
     this.startPixel_ = mapBrowserEvent.pixel;
     this.box_.setMap(mapBrowserEvent.map);
     this.box_.setPixels(this.startPixel_, this.startPixel_);

src/ol/interaction/dragrotateinteraction.js

@@ -112,8 +112,8 @@ ol.interaction.DragRotate.handleDownEvent_ = function(mapBrowserEvent) {
     return false;
   }
 
-  var browserEvent = mapBrowserEvent.browserEvent;
+  if (ol.events.condition.mouseActionButton(mapBrowserEvent) &&
-  if (browserEvent.isMouseActionButton() && this.condition_(mapBrowserEvent)) {
+      this.condition_(mapBrowserEvent)) {
     var map = mapBrowserEvent.map;
     map.getView().setHint(ol.ViewHint.INTERACTING, 1);
     map.render();

src/ol/interaction/drawinteraction.js

@@ -5,8 +5,8 @@ goog.provide('ol.interaction.DrawGeometryFunctionType');
 goog.provide('ol.interaction.DrawMode');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.Collection');
 goog.require('ol.Coordinate');
 goog.require('ol.Feature');
@@ -55,7 +55,7 @@ ol.interaction.DrawEventType = {
  * this type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.DrawEvent}
  * @param {ol.interaction.DrawEventType} type Type.
  * @param {ol.Feature} feature The feature drawn.
@@ -72,7 +72,7 @@ ol.interaction.DrawEvent = function(type, feature) {
   this.feature = feature;
 
 };
-goog.inherits(ol.interaction.DrawEvent, goog.events.Event);
+goog.inherits(ol.interaction.DrawEvent, ol.events.Event);
 
 
 /**
@@ -300,7 +300,7 @@ ol.interaction.Draw = function(options) {
   this.freehandCondition_ = options.freehandCondition ?
       options.freehandCondition : ol.events.condition.shiftKeyOnly;
 
-  goog.events.listen(this,
+  ol.events.listen(this,
       ol.Object.getChangeEventType(ol.interaction.InteractionProperty.ACTIVE),
       this.updateState_, false, this);
 

src/ol/interaction/keyboardpaninteraction.js

@@ -74,8 +74,8 @@ goog.inherits(ol.interaction.KeyboardPan, ol.interaction.Interaction);
 ol.interaction.KeyboardPan.handleEvent = function(mapBrowserEvent) {
   var stopEvent = false;
   if (mapBrowserEvent.type == goog.events.KeyHandler.EventType.KEY) {
-    var keyEvent = /** @type {goog.events.KeyEvent} */
+    var keyEvent = /** @type {Event} */
-        (mapBrowserEvent.browserEvent);
+        (mapBrowserEvent.originalEvent);
     var keyCode = keyEvent.keyCode;
     if (this.condition_(mapBrowserEvent) &&
         (keyCode == goog.events.KeyCodes.DOWN ||

src/ol/interaction/keyboardzoominteraction.js

@@ -67,8 +67,8 @@ goog.inherits(ol.interaction.KeyboardZoom, ol.interaction.Interaction);
 ol.interaction.KeyboardZoom.handleEvent = function(mapBrowserEvent) {
   var stopEvent = false;
   if (mapBrowserEvent.type == goog.events.KeyHandler.EventType.KEY) {
-    var keyEvent = /** @type {goog.events.KeyEvent} */
+    var keyEvent = /** @type {Event} */
-        (mapBrowserEvent.browserEvent);
+        (mapBrowserEvent.originalEvent);
     var charCode = keyEvent.charCode;
     if (this.condition_(mapBrowserEvent) &&
         (charCode == '+'.charCodeAt(0) || charCode == '-'.charCodeAt(0))) {

src/ol/interaction/modifyinteraction.js

@@ -2,9 +2,9 @@ goog.provide('ol.interaction.Modify');
 goog.provide('ol.interaction.ModifyEvent');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.functions');
 goog.require('ol');
 goog.require('ol.Collection');
@@ -55,7 +55,7 @@ ol.ModifyEventType = {
  * this type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.ModifyEvent}
  * @param {ol.ModifyEventType} type Type.
  * @param {ol.Collection.<ol.Feature>} features The features modified.
@@ -80,7 +80,7 @@ ol.interaction.ModifyEvent = function(type, features, mapBrowserPointerEvent) {
    */
   this.mapBrowserPointerEvent = mapBrowserPointerEvent;
 };
-goog.inherits(ol.interaction.ModifyEvent, goog.events.Event);
+goog.inherits(ol.interaction.ModifyEvent, ol.events.Event);
 
 
 /**
@@ -229,9 +229,9 @@ ol.interaction.Modify = function(options) {
   this.features_ = options.features;
 
   this.features_.forEach(this.addFeature_, this);
-  goog.events.listen(this.features_, ol.CollectionEventType.ADD,
+  ol.events.listen(this.features_, ol.CollectionEventType.ADD,
       this.handleFeatureAdd_, false, this);
-  goog.events.listen(this.features_, ol.CollectionEventType.REMOVE,
+  ol.events.listen(this.features_, ol.CollectionEventType.REMOVE,
       this.handleFeatureRemove_, false, this);
 
 };
@@ -251,7 +251,7 @@ ol.interaction.Modify.prototype.addFeature_ = function(feature) {
   if (map) {
     this.handlePointerAtPixel_(this.lastPixel_, map);
   }
-  goog.events.listen(feature, goog.events.EventType.CHANGE,
+  ol.events.listen(feature, ol.events.EventType.CHANGE,
       this.handleFeatureChange_, false, this);
 };
 
@@ -281,7 +281,7 @@ ol.interaction.Modify.prototype.removeFeature_ = function(feature) {
     this.overlay_.getSource().removeFeature(this.vertexFeature_);
     this.vertexFeature_ = null;
   }
-  goog.events.unlisten(feature, goog.events.EventType.CHANGE,
+  ol.events.unlisten(feature, ol.events.EventType.CHANGE,
       this.handleFeatureChange_, false, this);
 };
 
@@ -330,7 +330,7 @@ ol.interaction.Modify.prototype.handleFeatureAdd_ = function(evt) {
 
 
 /**
- * @param {goog.events.Event} evt Event.
+ * @param {ol.events.Event} evt Event.
  * @private
  */
 ol.interaction.Modify.prototype.handleFeatureChange_ = function(evt) {

src/ol/interaction/mousewheelzoominteraction.js

@@ -79,7 +79,7 @@ ol.interaction.MouseWheelZoom.handleEvent = function(mapBrowserEvent) {
   if (mapBrowserEvent.type ==
       goog.events.MouseWheelHandler.EventType.MOUSEWHEEL) {
     var map = mapBrowserEvent.map;
-    var mouseWheelEvent = mapBrowserEvent.browserEvent;
+    var mouseWheelEvent = mapBrowserEvent.originalEvent;
     goog.asserts.assertInstanceof(mouseWheelEvent, goog.events.MouseWheelEvent,
         'mouseWheelEvent should be of type MouseWheelEvent');
 

src/ol/interaction/selectinteraction.js

@@ -4,8 +4,8 @@ goog.provide('ol.interaction.SelectEventType');
 goog.provide('ol.interaction.SelectFilterFunction');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('goog.functions');
 goog.require('goog.object');
 goog.require('ol.CollectionEventType');
@@ -53,7 +53,7 @@ ol.interaction.SelectFilterFunction;
  * @param {ol.MapBrowserEvent} mapBrowserEvent Associated
  *     {@link ol.MapBrowserEvent}.
  * @implements {oli.SelectEvent}
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @constructor
  */
 ol.interaction.SelectEvent = function(type, selected, deselected, mapBrowserEvent) {
@@ -80,7 +80,7 @@ ol.interaction.SelectEvent = function(type, selected, deselected, mapBrowserEven
    */
   this.mapBrowserEvent = mapBrowserEvent;
 };
-goog.inherits(ol.interaction.SelectEvent, goog.events.Event);
+goog.inherits(ol.interaction.SelectEvent, ol.events.Event);
 
 
 /**
@@ -208,9 +208,9 @@ ol.interaction.Select = function(opt_options) {
   this.featureLayerAssociation_ = {};
 
   var features = this.featureOverlay_.getSource().getFeaturesCollection();
-  goog.events.listen(features, ol.CollectionEventType.ADD,
+  ol.events.listen(features, ol.CollectionEventType.ADD,
       this.addFeature_, false, this);
-  goog.events.listen(features, ol.CollectionEventType.REMOVE,
+  ol.events.listen(features, ol.CollectionEventType.REMOVE,
       this.removeFeature_, false, this);
 
 };

src/ol/interaction/snapinteraction.js

@@ -2,8 +2,8 @@ goog.provide('ol.interaction.Snap');
 goog.provide('ol.interaction.SnapProperty');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Collection');
@@ -68,19 +68,19 @@ ol.interaction.Snap = function(opt_options) {
   this.features_ = options.features ? options.features : null;
 
   /**
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
    * @private
    */
   this.featuresListenerKeys_ = [];
 
   /**
-   * @type {Object.<number, goog.events.Key>}
+   * @type {Object.<number, ol.events.Key>}
    * @private
    */
   this.geometryChangeListenerKeys_ = {};
 
   /**
-   * @type {Object.<number, goog.events.Key>}
+   * @type {Object.<number, ol.events.Key>}
    * @private
    */
   this.geometryModifyListenerKeys_ = {};
@@ -169,7 +169,7 @@ ol.interaction.Snap.prototype.addFeature = function(feature, opt_listen) {
 
     if (listen) {
       this.geometryModifyListenerKeys_[feature_uid] = geometry.on(
-          goog.events.EventType.CHANGE,
+          ol.events.EventType.CHANGE,
           this.handleGeometryModify_.bind(this, feature),
           this);
       this.geometryChangeListenerKeys_[feature_uid] = feature.on(
@@ -249,11 +249,11 @@ ol.interaction.Snap.prototype.handleFeatureRemove_ = function(evt) {
 
 
 /**
- * @param {goog.events.Event} evt Event.
+ * @param {ol.events.Event} evt Event.
  * @private
  */
 ol.interaction.Snap.prototype.handleGeometryChange_ = function(evt) {
-  var feature = evt.currentTarget;
+  var feature = evt.target;
   goog.asserts.assertInstanceof(feature, ol.Feature);
   this.removeFeature(feature, true);
   this.addFeature(feature, true);
@@ -262,7 +262,7 @@ ol.interaction.Snap.prototype.handleGeometryChange_ = function(evt) {
 
 /**
  * @param {ol.Feature} feature Feature which geometry was modified.
- * @param {goog.events.Event} evt Event.
+ * @param {ol.events.Event} evt Event.
  * @private
  */
 ol.interaction.Snap.prototype.handleGeometryModify_ = function(feature, evt) {

src/ol/interaction/translateinteraction.js

@@ -1,8 +1,8 @@
 goog.provide('ol.interaction.Translate');
 goog.provide('ol.interaction.TranslateEvent');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.array');
 goog.require('ol.interaction.Pointer');
 
@@ -38,7 +38,7 @@ ol.interaction.TranslateEventType = {
  * this type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.interaction.TranslateEvent}
  * @param {ol.interaction.TranslateEventType} type Type.
  * @param {ol.Collection.<ol.Feature>} features The features translated.
@@ -63,7 +63,7 @@ ol.interaction.TranslateEvent = function(type, features, coordinate) {
    */
   this.coordinate = coordinate;
 };
-goog.inherits(ol.interaction.TranslateEvent, goog.events.Event);
+goog.inherits(ol.interaction.TranslateEvent, ol.events.Event);
 
 
 /**

src/ol/layer/heatmaplayer.js

@@ -1,7 +1,7 @@
 goog.provide('ol.layer.Heatmap');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Object');
@@ -72,7 +72,7 @@ ol.layer.Heatmap = function(opt_options) {
    */
   this.styleCache_ = null;
 
-  goog.events.listen(this,
+  ol.events.listen(this,
       ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.GRADIENT),
       this.handleGradientChanged_, false, this);
 
@@ -83,7 +83,7 @@ ol.layer.Heatmap = function(opt_options) {
 
   this.setRadius(options.radius !== undefined ? options.radius : 8);
 
-  goog.events.listen(this, [
+  ol.events.listen(this, [
     ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.BLUR),
     ol.Object.getChangeEventType(ol.layer.HeatmapLayerProperty.RADIUS)
   ], this.handleStyleChanged_, false, this);
@@ -129,7 +129,7 @@ ol.layer.Heatmap = function(opt_options) {
   // The render order is not relevant for a heatmap representation.
   this.setRenderOrder(null);
 
-  goog.events.listen(this, ol.render.EventType.RENDER,
+  ol.events.listen(this, ol.render.EventType.RENDER,
       this.handleRender_, false, this);
 
 };

src/ol/layer/layer.js

@@ -1,7 +1,7 @@
 goog.provide('ol.layer.Layer');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Object');
@@ -41,19 +41,19 @@ ol.layer.Layer = function(options) {
 
   /**
    * @private
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    */
   this.mapPrecomposeKey_ = null;
 
   /**
    * @private
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    */
   this.mapRenderKey_ = null;
 
   /**
    * @private
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    */
   this.sourceChangeKey_ = null;
 
@@ -61,7 +61,7 @@ ol.layer.Layer = function(options) {
     this.setMap(options.map);
   }
 
-  goog.events.listen(this,
+  ol.events.listen(this,
       ol.Object.getChangeEventType(ol.layer.LayerProperty.SOURCE),
       this.handleSourcePropertyChange_, false, this);
 
@@ -139,13 +139,13 @@ ol.layer.Layer.prototype.handleSourceChange_ = function() {
  */
 ol.layer.Layer.prototype.handleSourcePropertyChange_ = function() {
   if (this.sourceChangeKey_) {
-    goog.events.unlistenByKey(this.sourceChangeKey_);
+    ol.events.unlistenByKey(this.sourceChangeKey_);
     this.sourceChangeKey_ = null;
   }
   var source = this.getSource();
   if (source) {
-    this.sourceChangeKey_ = goog.events.listen(source,
+    this.sourceChangeKey_ = ol.events.listen(source,
-        goog.events.EventType.CHANGE, this.handleSourceChange_, false, this);
+        ol.events.EventType.CHANGE, this.handleSourceChange_, false, this);
   }
   this.changed();
 };
@@ -164,15 +164,15 @@ ol.layer.Layer.prototype.handleSourcePropertyChange_ = function() {
  * @api
  */
 ol.layer.Layer.prototype.setMap = function(map) {
-  goog.events.unlistenByKey(this.mapPrecomposeKey_);
+  ol.events.unlistenByKey(this.mapPrecomposeKey_);
   this.mapPrecomposeKey_ = null;
   if (!map) {
     this.changed();
   }
-  goog.events.unlistenByKey(this.mapRenderKey_);
+  ol.events.unlistenByKey(this.mapRenderKey_);
   this.mapRenderKey_ = null;
   if (map) {
-    this.mapPrecomposeKey_ = goog.events.listen(
+    this.mapPrecomposeKey_ = ol.events.listen(
         map, ol.render.EventType.PRECOMPOSE, function(evt) {
           var layerState = this.getLayerState();
           layerState.managed = false;
@@ -180,8 +180,8 @@ ol.layer.Layer.prototype.setMap = function(map) {
           evt.frameState.layerStatesArray.push(layerState);
           evt.frameState.layerStates[goog.getUid(this)] = layerState;
         }, false, this);
-    this.mapRenderKey_ = goog.events.listen(
+    this.mapRenderKey_ = ol.events.listen(
-        this, goog.events.EventType.CHANGE, map.render, false, map);
+        this, ol.events.EventType.CHANGE, map.render, false, map);
     this.changed();
   }
 };

src/ol/layer/layergroup.js

@@ -1,8 +1,8 @@
 goog.provide('ol.layer.Group');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.Collection');
 goog.require('ol.CollectionEvent');
@@ -46,17 +46,17 @@ ol.layer.Group = function(opt_options) {
 
   /**
    * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
    */
   this.layersListenerKeys_ = [];
 
   /**
    * @private
-   * @type {Object.<string, Array.<goog.events.Key>>}
+   * @type {Object.<string, Array.<ol.events.Key>>}
    */
   this.listenerKeys_ = {};
 
-  goog.events.listen(this,
+  ol.events.listen(this,
       ol.Object.getChangeEventType(ol.layer.GroupProperty.LAYERS),
       this.handleLayersChanged_, false, this);
 
@@ -89,22 +89,22 @@ ol.layer.Group.prototype.handleLayerChange_ = function() {
 
 
 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
  * @private
  */
 ol.layer.Group.prototype.handleLayersChanged_ = function(event) {
-  this.layersListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.layersListenerKeys_.forEach(ol.events.unlistenByKey);
   this.layersListenerKeys_.length = 0;
 
   var layers = this.getLayers();
   this.layersListenerKeys_.push(
-      goog.events.listen(layers, ol.CollectionEventType.ADD,
+      ol.events.listen(layers, ol.CollectionEventType.ADD,
           this.handleLayersAdd_, false, this),
-      goog.events.listen(layers, ol.CollectionEventType.REMOVE,
+      ol.events.listen(layers, ol.CollectionEventType.REMOVE,
           this.handleLayersRemove_, false, this));
 
   goog.object.forEach(this.listenerKeys_, function(keys) {
-    keys.forEach(goog.events.unlistenByKey);
+    keys.forEach(ol.events.unlistenByKey);
   });
   goog.object.clear(this.listenerKeys_);
 
@@ -113,9 +113,9 @@ ol.layer.Group.prototype.handleLayersChanged_ = function(event) {
   for (i = 0, ii = layersArray.length; i < ii; i++) {
     layer = layersArray[i];
     this.listenerKeys_[goog.getUid(layer).toString()] = [
-      goog.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE,
+      ol.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE,
           this.handleLayerChange_, false, this),
-      goog.events.listen(layer, goog.events.EventType.CHANGE,
+      ol.events.listen(layer, ol.events.EventType.CHANGE,
           this.handleLayerChange_, false, this)
     ];
   }
@@ -134,9 +134,9 @@ ol.layer.Group.prototype.handleLayersAdd_ = function(collectionEvent) {
   goog.asserts.assert(!(key in this.listenerKeys_),
       'listeners already registered');
   this.listenerKeys_[key] = [
-    goog.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE,
+    ol.events.listen(layer, ol.ObjectEventType.PROPERTYCHANGE,
         this.handleLayerChange_, false, this),
-    goog.events.listen(layer, goog.events.EventType.CHANGE,
+    ol.events.listen(layer, ol.events.EventType.CHANGE,
         this.handleLayerChange_, false, this)
   ];
   this.changed();
@@ -151,7 +151,7 @@ ol.layer.Group.prototype.handleLayersRemove_ = function(collectionEvent) {
   var layer = /** @type {ol.layer.Base} */ (collectionEvent.element);
   var key = goog.getUid(layer).toString();
   goog.asserts.assert(key in this.listenerKeys_, 'no listeners to unregister');
-  this.listenerKeys_[key].forEach(goog.events.unlistenByKey);
+  this.listenerKeys_[key].forEach(ol.events.unlistenByKey);
   delete this.listenerKeys_[key];
   this.changed();
 };

src/ol/map.js

@@ -12,10 +12,9 @@ goog.require('goog.debug.Console');
 goog.require('goog.dom');
 goog.require('goog.dom.ViewportSizeMonitor');
 goog.require('goog.dom.classlist');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.BrowserEvent');
+goog.require('ol.events.Event');
-goog.require('goog.events.Event');
+goog.require('ol.events.EventType');
-goog.require('goog.events.EventType');
 goog.require('goog.events.KeyHandler');
 goog.require('goog.events.KeyHandler.EventType');
 goog.require('goog.events.MouseWheelHandler');
@@ -46,6 +45,9 @@ goog.require('ol.View');
 goog.require('ol.ViewHint');
 goog.require('ol.array');
 goog.require('ol.control');
+goog.require('ol.events');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventType');
 goog.require('ol.extent');
 goog.require('ol.has');
 goog.require('ol.interaction');
@@ -244,13 +246,13 @@ ol.Map = function(options) {
 
   /**
    * @private
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    */
   this.viewPropertyListenerKey_ = null;
 
   /**
    * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
    */
   this.layerGroupPropertyListenerKeys_ = null;
 
@@ -285,19 +287,19 @@ ol.Map = function(options) {
    */
   this.overlayContainerStopEvent_ = document.createElement('DIV');
   this.overlayContainerStopEvent_.className = 'ol-overlaycontainer-stopevent';
-  goog.events.listen(this.overlayContainerStopEvent_, [
+  ol.events.listen(this.overlayContainerStopEvent_, [
-    goog.events.EventType.CLICK,
+    ol.events.EventType.CLICK,
-    goog.events.EventType.DBLCLICK,
+    ol.events.EventType.DBLCLICK,
-    goog.events.EventType.MOUSEDOWN,
+    ol.events.EventType.MOUSEDOWN,
-    goog.events.EventType.TOUCHSTART,
+    ol.events.EventType.TOUCHSTART,
-    goog.events.EventType.MSPOINTERDOWN,
+    ol.events.EventType.MSPOINTERDOWN,
     ol.MapBrowserEvent.EventType.POINTERDOWN,
     goog.userAgent.GECKO ? 'DOMMouseScroll' : 'mousewheel'
-  ], goog.events.Event.stopPropagation);
+  ], ol.events.Event.stopPropagation);
   this.viewport_.appendChild(this.overlayContainerStopEvent_);
 
   var mapBrowserEventHandler = new ol.MapBrowserEventHandler(this);
-  goog.events.listen(mapBrowserEventHandler,
+  ol.events.listen(mapBrowserEventHandler,
       goog.object.getValues(ol.MapBrowserEvent.EventType),
       this.handleMapBrowserEvent, false, this);
   this.registerDisposable(mapBrowserEventHandler);
@@ -313,12 +315,12 @@ ol.Map = function(options) {
    * @type {goog.events.KeyHandler}
    */
   this.keyHandler_ = new goog.events.KeyHandler();
-  goog.events.listen(this.keyHandler_, goog.events.KeyHandler.EventType.KEY,
+  ol.events.listen(this.keyHandler_, goog.events.KeyHandler.EventType.KEY,
       this.handleBrowserEvent, false, this);
   this.registerDisposable(this.keyHandler_);
 
   var mouseWheelHandler = new goog.events.MouseWheelHandler(this.viewport_);
-  goog.events.listen(mouseWheelHandler,
+  ol.events.listen(mouseWheelHandler,
       goog.events.MouseWheelHandler.EventType.MOUSEWHEEL,
       this.handleBrowserEvent, false, this);
   this.registerDisposable(mouseWheelHandler);
@@ -364,7 +366,7 @@ ol.Map = function(options) {
   this.registerDisposable(this.viewportSizeMonitor_);
 
   /**
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    * @private
    */
   this.viewportResizeListenerKey_ = null;
@@ -402,14 +404,14 @@ ol.Map = function(options) {
    */
   this.skippedFeatureUids_ = {};
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.MapProperty.LAYERGROUP),
       this.handleLayerGroupChanged_, false, this);
-  goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.VIEW),
+  ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.VIEW),
       this.handleViewChanged_, false, this);
-  goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.SIZE),
+  ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.SIZE),
       this.handleSizeChanged_, false, this);
-  goog.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.TARGET),
+  ol.events.listen(this, ol.Object.getChangeEventType(ol.MapProperty.TARGET),
       this.handleTargetChanged_, false, this);
 
   // setProperties will trigger the rendering of the map if the map
@@ -425,7 +427,7 @@ ol.Map = function(options) {
         control.setMap(this);
       }, this);
 
-  goog.events.listen(this.controls_, ol.CollectionEventType.ADD,
+  ol.events.listen(this.controls_, ol.CollectionEventType.ADD,
       /**
        * @param {ol.CollectionEvent} event Collection event.
        */
@@ -433,7 +435,7 @@ ol.Map = function(options) {
         event.element.setMap(this);
       }, false, this);
 
-  goog.events.listen(this.controls_, ol.CollectionEventType.REMOVE,
+  ol.events.listen(this.controls_, ol.CollectionEventType.REMOVE,
       /**
        * @param {ol.CollectionEvent} event Collection event.
        */
@@ -450,7 +452,7 @@ ol.Map = function(options) {
         interaction.setMap(this);
       }, this);
 
-  goog.events.listen(this.interactions_, ol.CollectionEventType.ADD,
+  ol.events.listen(this.interactions_, ol.CollectionEventType.ADD,
       /**
        * @param {ol.CollectionEvent} event Collection event.
        */
@@ -458,7 +460,7 @@ ol.Map = function(options) {
         event.element.setMap(this);
       }, false, this);
 
-  goog.events.listen(this.interactions_, ol.CollectionEventType.REMOVE,
+  ol.events.listen(this.interactions_, ol.CollectionEventType.REMOVE,
       /**
        * @param {ol.CollectionEvent} event Collection event.
        */
@@ -468,7 +470,7 @@ ol.Map = function(options) {
 
   this.overlays_.forEach(this.addOverlayInternal_, this);
 
-  goog.events.listen(this.overlays_, ol.CollectionEventType.ADD,
+  ol.events.listen(this.overlays_, ol.CollectionEventType.ADD,
       /**
        * @param {ol.CollectionEvent} event Collection event.
        */
@@ -476,7 +478,7 @@ ol.Map = function(options) {
         this.addOverlayInternal_(/** @type {ol.Overlay} */ (event.element));
       }, false, this);
 
-  goog.events.listen(this.overlays_, ol.CollectionEventType.REMOVE,
+  ol.events.listen(this.overlays_, ol.CollectionEventType.REMOVE,
       /**
        * @param {ol.CollectionEvent} event Collection event.
        */
@@ -949,7 +951,7 @@ ol.Map.prototype.getTilePriority = function(tile, tileSourceKey, tileCenter, til
 
 
 /**
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} browserEvent Browser event.
  * @param {string=} opt_type Type.
  */
 ol.Map.prototype.handleBrowserEvent = function(browserEvent, opt_type) {
@@ -1064,7 +1066,7 @@ ol.Map.prototype.handleTargetChanged_ = function() {
   if (!targetElement) {
     goog.dom.removeNode(this.viewport_);
     if (this.viewportResizeListenerKey_) {
-      goog.events.unlistenByKey(this.viewportResizeListenerKey_);
+      ol.events.unlistenByKey(this.viewportResizeListenerKey_);
       this.viewportResizeListenerKey_ = null;
     }
   } else {
@@ -1075,8 +1077,8 @@ ol.Map.prototype.handleTargetChanged_ = function() {
     this.keyHandler_.attach(keyboardEventTarget);
 
     if (!this.viewportResizeListenerKey_) {
-      this.viewportResizeListenerKey_ = goog.events.listen(
+      this.viewportResizeListenerKey_ = ol.events.listen(
-          this.viewportSizeMonitor_, goog.events.EventType.RESIZE,
+          this.viewportSizeMonitor_, ol.events.EventType.RESIZE,
           this.updateSize, false, this);
     }
   }
@@ -1108,12 +1110,12 @@ ol.Map.prototype.handleViewPropertyChanged_ = function() {
  */
 ol.Map.prototype.handleViewChanged_ = function() {
   if (this.viewPropertyListenerKey_) {
-    goog.events.unlistenByKey(this.viewPropertyListenerKey_);
+    ol.events.unlistenByKey(this.viewPropertyListenerKey_);
     this.viewPropertyListenerKey_ = null;
   }
   var view = this.getView();
   if (view) {
-    this.viewPropertyListenerKey_ = goog.events.listen(
+    this.viewPropertyListenerKey_ = ol.events.listen(
         view, ol.ObjectEventType.PROPERTYCHANGE,
         this.handleViewPropertyChanged_, false, this);
   }
@@ -1122,11 +1124,11 @@ ol.Map.prototype.handleViewChanged_ = function() {
 
 
 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
  * @private
  */
 ol.Map.prototype.handleLayerGroupMemberChanged_ = function(event) {
-  goog.asserts.assertInstanceof(event, goog.events.Event,
+  goog.asserts.assertInstanceof(event, ol.events.Event,
       'event should be an Event');
   this.render();
 };
@@ -1148,17 +1150,17 @@ ol.Map.prototype.handleLayerGroupPropertyChanged_ = function(event) {
  */
 ol.Map.prototype.handleLayerGroupChanged_ = function() {
   if (this.layerGroupPropertyListenerKeys_) {
-    this.layerGroupPropertyListenerKeys_.forEach(goog.events.unlistenByKey);
+    this.layerGroupPropertyListenerKeys_.forEach(ol.events.unlistenByKey);
     this.layerGroupPropertyListenerKeys_ = null;
   }
   var layerGroup = this.getLayerGroup();
   if (layerGroup) {
     this.layerGroupPropertyListenerKeys_ = [
-      goog.events.listen(
+      ol.events.listen(
           layerGroup, ol.ObjectEventType.PROPERTYCHANGE,
           this.handleLayerGroupPropertyChanged_, false, this),
-      goog.events.listen(
+      ol.events.listen(
-          layerGroup, goog.events.EventType.CHANGE,
+          layerGroup, ol.events.EventType.CHANGE,
           this.handleLayerGroupMemberChanged_, false, this)
     ];
   }

src/ol/mapbrowserevent.js

@@ -4,10 +4,9 @@ goog.provide('ol.MapBrowserEventHandler');
 goog.provide('ol.MapBrowserPointerEvent');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.BrowserEvent');
+goog.require('ol.events.EventTarget');
-goog.require('goog.events.EventTarget');
+goog.require('ol.events.EventType');
-goog.require('goog.events.EventType');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Coordinate');
@@ -27,7 +26,7 @@ goog.require('ol.pointer.PointerEventHandler');
  * @implements {oli.MapBrowserEvent}
  * @param {string} type Event type.
  * @param {ol.Map} map Map.
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} browserEvent Browser event.
  * @param {boolean=} opt_dragging Is the map currently being dragged?
  * @param {?olx.FrameState=} opt_frameState Frame state.
  */
@@ -36,19 +35,13 @@ ol.MapBrowserEvent = function(type, map, browserEvent, opt_dragging,
 
   goog.base(this, type, map, opt_frameState);
 
-  /**
-   * @const
-   * @type {goog.events.BrowserEvent}
-   */
-  this.browserEvent = browserEvent;
-
   /**
    * The original browser event.
    * @const
    * @type {Event}
    * @api stable
    */
-  this.originalEvent = browserEvent.getBrowserEvent();
+  this.originalEvent = browserEvent;
 
   /**
    * The pixel of the original browser event.
@@ -85,7 +78,7 @@ goog.inherits(ol.MapBrowserEvent, ol.MapEvent);
  */
 ol.MapBrowserEvent.prototype.preventDefault = function() {
   goog.base(this, 'preventDefault');
-  this.browserEvent.preventDefault();
+  this.originalEvent.preventDefault();
 };
 
 
@@ -97,7 +90,7 @@ ol.MapBrowserEvent.prototype.preventDefault = function() {
  */
 ol.MapBrowserEvent.prototype.stopPropagation = function() {
   goog.base(this, 'stopPropagation');
-  this.browserEvent.stopPropagation();
+  this.originalEvent.stopPropagation();
 };
 
 
@@ -113,7 +106,7 @@ ol.MapBrowserEvent.prototype.stopPropagation = function() {
 ol.MapBrowserPointerEvent = function(type, map, pointerEvent, opt_dragging,
     opt_frameState) {
 
-  goog.base(this, type, map, pointerEvent.browserEvent, opt_dragging,
+  goog.base(this, type, map, pointerEvent.originalEvent, opt_dragging,
       opt_frameState);
 
   /**
@@ -129,7 +122,7 @@ goog.inherits(ol.MapBrowserPointerEvent, ol.MapBrowserEvent);
 /**
  * @param {ol.Map} map The map with the viewport to listen to events on.
  * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
  */
 ol.MapBrowserEventHandler = function(map) {
 
@@ -155,13 +148,13 @@ ol.MapBrowserEventHandler = function(map) {
   this.dragging_ = false;
 
   /**
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
    * @private
    */
   this.dragListenerKeys_ = null;
 
   /**
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    * @private
    */
   this.pointerdownListenerKey_ = null;
@@ -206,16 +199,16 @@ ol.MapBrowserEventHandler = function(map) {
    */
   this.documentPointerEventHandler_ = null;
 
-  this.pointerdownListenerKey_ = goog.events.listen(this.pointerEventHandler_,
+  this.pointerdownListenerKey_ = ol.events.listen(this.pointerEventHandler_,
       ol.pointer.EventType.POINTERDOWN,
       this.handlePointerDown_, false, this);
 
-  this.relayedListenerKey_ = goog.events.listen(this.pointerEventHandler_,
+  this.relayedListenerKey_ = ol.events.listen(this.pointerEventHandler_,
       ol.pointer.EventType.POINTERMOVE,
       this.relayEvent_, false, this);
 
 };
-goog.inherits(ol.MapBrowserEventHandler, goog.events.EventTarget);
+goog.inherits(ol.MapBrowserEventHandler, ol.events.EventTarget);
 
 
 /**
@@ -287,7 +280,7 @@ ol.MapBrowserEventHandler.prototype.handlePointerUp_ = function(pointerEvent) {
   goog.asserts.assert(this.activePointers_ >= 0,
       'this.activePointers_ should be equal to or larger than 0');
   if (this.activePointers_ === 0) {
-    this.dragListenerKeys_.forEach(goog.events.unlistenByKey);
+    this.dragListenerKeys_.forEach(ol.events.unlistenByKey);
     this.dragListenerKeys_ = null;
     this.dragging_ = false;
     this.down_ = null;
@@ -328,10 +321,10 @@ ol.MapBrowserEventHandler.prototype.handlePointerDown_ = function(pointerEvent)
         new ol.pointer.PointerEventHandler(document);
 
     this.dragListenerKeys_ = [
-      goog.events.listen(this.documentPointerEventHandler_,
+      ol.events.listen(this.documentPointerEventHandler_,
           ol.MapBrowserEvent.EventType.POINTERMOVE,
           this.handlePointerMove_, false, this),
-      goog.events.listen(this.documentPointerEventHandler_,
+      ol.events.listen(this.documentPointerEventHandler_,
           ol.MapBrowserEvent.EventType.POINTERUP,
           this.handlePointerUp_, false, this),
       /* Note that the listener for `pointercancel is set up on
@@ -347,7 +340,7 @@ ol.MapBrowserEventHandler.prototype.handlePointerDown_ = function(pointerEvent)
        * only receive a `touchcancel` from `pointerEventHandler_`, because it is
        * only registered there.
        */
-      goog.events.listen(this.pointerEventHandler_,
+      ol.events.listen(this.pointerEventHandler_,
           ol.MapBrowserEvent.EventType.POINTERCANCEL,
           this.handlePointerUp_, false, this)
     ];
@@ -410,15 +403,15 @@ ol.MapBrowserEventHandler.prototype.isMoving_ = function(pointerEvent) {
  */
 ol.MapBrowserEventHandler.prototype.disposeInternal = function() {
   if (this.relayedListenerKey_) {
-    goog.events.unlistenByKey(this.relayedListenerKey_);
+    ol.events.unlistenByKey(this.relayedListenerKey_);
     this.relayedListenerKey_ = null;
   }
   if (this.pointerdownListenerKey_) {
-    goog.events.unlistenByKey(this.pointerdownListenerKey_);
+    ol.events.unlistenByKey(this.pointerdownListenerKey_);
     this.pointerdownListenerKey_ = null;
   }
   if (this.dragListenerKeys_) {
-    this.dragListenerKeys_.forEach(goog.events.unlistenByKey);
+    this.dragListenerKeys_.forEach(ol.events.unlistenByKey);
     this.dragListenerKeys_ = null;
   }
   if (this.documentPointerEventHandler_) {
@@ -452,14 +445,14 @@ ol.MapBrowserEvent.EventType = {
    * @event ol.MapBrowserEvent#click
    * @api stable
    */
-  CLICK: goog.events.EventType.CLICK,
+  CLICK: ol.events.EventType.CLICK,
 
   /**
    * A true double click, with no dragging.
    * @event ol.MapBrowserEvent#dblclick
    * @api stable
    */
-  DBLCLICK: goog.events.EventType.DBLCLICK,
+  DBLCLICK: ol.events.EventType.DBLCLICK,
 
   /**
    * Triggered when a pointer is dragged.

src/ol/mapevent.js

@@ -1,7 +1,7 @@
 goog.provide('ol.MapEvent');
 goog.provide('ol.MapEventType');
 
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 
 
 /**
@@ -32,7 +32,7 @@ ol.MapEventType = {
  * See {@link ol.Map} for which events trigger a map event.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.MapEvent}
  * @param {string} type Event type.
  * @param {ol.Map} map Map.
@@ -57,4 +57,4 @@ ol.MapEvent = function(type, map, opt_frameState) {
   this.frameState = opt_frameState !== undefined ? opt_frameState : null;
 
 };
-goog.inherits(ol.MapEvent, goog.events.Event);
+goog.inherits(ol.MapEvent, ol.events.Event);

src/ol/object.js

@@ -2,8 +2,8 @@ goog.provide('ol.Object');
 goog.provide('ol.ObjectEvent');
 goog.provide('ol.ObjectEventType');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.Observable');
 
 
@@ -27,7 +27,7 @@ ol.ObjectEventType = {
  * @param {string} type The event type.
  * @param {string} key The property name.
  * @param {*} oldValue The old value for `key`.
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.ObjectEvent}
  * @constructor
  */
@@ -50,7 +50,7 @@ ol.ObjectEvent = function(type, key, oldValue) {
   this.oldValue = oldValue;
 
 };
-goog.inherits(ol.ObjectEvent, goog.events.Event);
+goog.inherits(ol.ObjectEvent, ol.events.Event);
 
 
 /**

src/ol/observable.js

@@ -1,8 +1,8 @@
 goog.provide('ol.Observable');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventTarget');
+goog.require('ol.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 
 
 /**
@@ -14,7 +14,7 @@ goog.require('goog.events.EventType');
  * {@link ol.Observable#changed}.
  *
  * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
  * @fires change
  * @struct
  * @api stable
@@ -30,16 +30,16 @@ ol.Observable = function() {
   this.revision_ = 0;
 
 };
-goog.inherits(ol.Observable, goog.events.EventTarget);
+goog.inherits(ol.Observable, ol.events.EventTarget);
 
 
 /**
  * Removes an event listener using the key returned by `on()` or `once()`.
- * @param {goog.events.Key} key The key returned by `on()` or `once()`.
+ * @param {ol.events.Key} key The key returned by `on()` or `once()`.
  * @api stable
  */
 ol.Observable.unByKey = function(key) {
-  goog.events.unlistenByKey(key);
+  ol.events.unlistenByKey(key);
 };
 
 
@@ -49,7 +49,7 @@ ol.Observable.unByKey = function(key) {
  */
 ol.Observable.prototype.changed = function() {
   ++this.revision_;
-  this.dispatchEvent(goog.events.EventType.CHANGE);
+  this.dispatchEvent(ol.events.EventType.CHANGE);
 };
 
 
@@ -65,7 +65,9 @@ ol.Observable.prototype.changed = function() {
  * of this type. The event parameter can either be a string or an
  * Object with a `type` property.
  *
- * @param {goog.events.EventLike} event Event object.
+ * @param {{type: (ol.events.EventType|string),
+ *     target: (EventTarget|ol.events.EventTarget|undefined)}|ol.events.Event|
+ *     ol.events.EventType|string} event Event object.
  * @function
  * @api
  */
@@ -88,11 +90,11 @@ ol.Observable.prototype.getRevision = function() {
  * @param {string|Array.<string>} type The event type or array of event types.
  * @param {function(?): ?} listener The listener function.
  * @param {Object=} opt_this The object to use as `this` in `listener`.
- * @return {goog.events.Key} Unique key for the listener.
+ * @return {ol.events.Key} Unique key for the listener.
  * @api stable
  */
 ol.Observable.prototype.on = function(type, listener, opt_this) {
-  return goog.events.listen(this, type, listener, false, opt_this);
+  return ol.events.listen(this, type, listener, false, opt_this);
 };
 
 
@@ -101,11 +103,11 @@ ol.Observable.prototype.on = function(type, listener, opt_this) {
  * @param {string|Array.<string>} type The event type or array of event types.
  * @param {function(?): ?} listener The listener function.
  * @param {Object=} opt_this The object to use as `this` in `listener`.
- * @return {goog.events.Key} Unique key for the listener.
+ * @return {ol.events.Key} Unique key for the listener.
  * @api stable
  */
 ol.Observable.prototype.once = function(type, listener, opt_this) {
-  return goog.events.listenOnce(this, type, listener, false, opt_this);
+  return ol.events.listenOnce(this, type, listener, false, opt_this);
 };
 
 
@@ -118,7 +120,7 @@ ol.Observable.prototype.once = function(type, listener, opt_this) {
  * @api stable
  */
 ol.Observable.prototype.un = function(type, listener, opt_this) {
-  goog.events.unlisten(this, type, listener, false, opt_this);
+  ol.events.unlisten(this, type, listener, false, opt_this);
 };
 
 
@@ -126,7 +128,7 @@ ol.Observable.prototype.un = function(type, listener, opt_this) {
  * Removes an event listener using the key returned by `on()` or `once()`.
  * Note that using the {@link ol.Observable.unByKey} static function is to
  * be preferred.
- * @param {goog.events.Key} key The key returned by `on()` or `once()`.
+ * @param {ol.events.Key} key The key returned by `on()` or `once()`.
  * @function
  * @api stable
  */

src/ol/overlay.js

@@ -4,7 +4,7 @@ goog.provide('ol.OverlayProperty');
 
 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.style');
 goog.require('ol.Coordinate');
 goog.require('ol.Map');
@@ -137,27 +137,27 @@ ol.Overlay = function(options) {
 
   /**
    * @private
-   * @type {goog.events.Key}
+   * @type {ol.events.Key}
    */
   this.mapPostrenderListenerKey_ = null;
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.OverlayProperty.ELEMENT),
       this.handleElementChanged, false, this);
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.OverlayProperty.MAP),
       this.handleMapChanged, false, this);
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.OverlayProperty.OFFSET),
       this.handleOffsetChanged, false, this);
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.OverlayProperty.POSITION),
       this.handlePositionChanged, false, this);
 
-  goog.events.listen(
+  ol.events.listen(
       this, ol.Object.getChangeEventType(ol.OverlayProperty.POSITIONING),
       this.handlePositioningChanged, false, this);
 
@@ -269,12 +269,12 @@ ol.Overlay.prototype.handleElementChanged = function() {
 ol.Overlay.prototype.handleMapChanged = function() {
   if (this.mapPostrenderListenerKey_) {
     goog.dom.removeNode(this.element_);
-    goog.events.unlistenByKey(this.mapPostrenderListenerKey_);
+    ol.events.unlistenByKey(this.mapPostrenderListenerKey_);
     this.mapPostrenderListenerKey_ = null;
   }
   var map = this.getMap();
   if (map) {
-    this.mapPostrenderListenerKey_ = goog.events.listen(map,
+    this.mapPostrenderListenerKey_ = ol.events.listen(map,
         ol.MapEventType.POSTRENDER, this.render, false, this);
     this.updatePixelPosition();
     var container = this.stopEvent_ ?

src/ol/pointer/eventsource.js

@@ -1,11 +1,9 @@
 goog.provide('ol.pointer.EventSource');
 
-goog.require('goog.events.BrowserEvent');
-
 
 /**
  * @param {ol.pointer.PointerEventHandler} dispatcher Event handler.
- * @param {!Object.<string, function(goog.events.BrowserEvent)>} mapping Event
+ * @param {!Object.<string, function(Event)>} mapping Event
  *     mapping.
  * @constructor
  */
@@ -18,7 +16,7 @@ ol.pointer.EventSource = function(dispatcher, mapping) {
   /**
    * @private
    * @const
-   * @type {!Object.<string, function(goog.events.BrowserEvent)>}
+   * @type {!Object.<string, function(Event)>}
    */
   this.mapping_ = mapping;
 };
@@ -36,7 +34,7 @@ ol.pointer.EventSource.prototype.getEvents = function() {
 /**
  * Returns a mapping between the supported event types and
  * the handlers that should handle an event.
- * @return {Object.<string, function(goog.events.BrowserEvent)>}
+ * @return {Object.<string, function(Event)>}
  *         Event/Handler mapping
  */
 ol.pointer.EventSource.prototype.getMapping = function() {
@@ -47,7 +45,7 @@ ol.pointer.EventSource.prototype.getMapping = function() {
 /**
  * Returns the handler that should handle a given event type.
  * @param {string} eventType The event type.
- * @return {function(goog.events.BrowserEvent)} Handler
+ * @return {function(Event)} Handler
  */
 ol.pointer.EventSource.prototype.getHandlerForEvent = function(eventType) {
   return this.mapping_[eventType];

src/ol/pointer/mousesource.js

@@ -50,7 +50,7 @@ ol.pointer.MouseSource = function(dispatcher) {
 
   /**
    * @const
-   * @type {!Object.<string, goog.events.BrowserEvent|Object>}
+   * @type {!Object.<string, Event|Object>}
    */
   this.pointerMap = dispatcher.pointerMap;
 
@@ -107,7 +107,7 @@ ol.pointer.MouseSource.DEDUP_DIST = 25;
  * or detect that the positions are invalid.
  *
  * @private
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  * @return {boolean} True, if the event was generated by a touch.
  */
 ol.pointer.MouseSource.prototype.isEventSimulatedFromTouch_ = function(inEvent) {
@@ -129,12 +129,12 @@ ol.pointer.MouseSource.prototype.isEventSimulatedFromTouch_ = function(inEvent)
  * Creates a copy of the original event that will be used
  * for the fake pointer event.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  * @param {ol.pointer.PointerEventHandler} dispatcher Event handler.
  * @return {Object} The copied event.
  */
 ol.pointer.MouseSource.prepareEvent = function(inEvent, dispatcher) {
-  var e = dispatcher.cloneEvent(inEvent, inEvent.getBrowserEvent());
+  var e = dispatcher.cloneEvent(inEvent, inEvent);
 
   // forward mouse preventDefault
   var pd = e.preventDefault;
@@ -154,7 +154,7 @@ ol.pointer.MouseSource.prepareEvent = function(inEvent, dispatcher) {
 /**
  * Handler for `mousedown`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MouseSource.prototype.mousedown = function(inEvent) {
   if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -173,7 +173,7 @@ ol.pointer.MouseSource.prototype.mousedown = function(inEvent) {
 /**
  * Handler for `mousemove`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MouseSource.prototype.mousemove = function(inEvent) {
   if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -186,7 +186,7 @@ ol.pointer.MouseSource.prototype.mousemove = function(inEvent) {
 /**
  * Handler for `mouseup`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MouseSource.prototype.mouseup = function(inEvent) {
   if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -204,7 +204,7 @@ ol.pointer.MouseSource.prototype.mouseup = function(inEvent) {
 /**
  * Handler for `mouseover`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MouseSource.prototype.mouseover = function(inEvent) {
   if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -217,7 +217,7 @@ ol.pointer.MouseSource.prototype.mouseover = function(inEvent) {
 /**
  * Handler for `mouseout`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MouseSource.prototype.mouseout = function(inEvent) {
   if (!this.isEventSimulatedFromTouch_(inEvent)) {
@@ -230,7 +230,7 @@ ol.pointer.MouseSource.prototype.mouseout = function(inEvent) {
 /**
  * Dispatches a `pointercancel` event.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MouseSource.prototype.cancel = function(inEvent) {
   var e = ol.pointer.MouseSource.prepareEvent(inEvent, this.dispatcher);

src/ol/pointer/mssource.js

@@ -53,7 +53,7 @@ ol.pointer.MsSource = function(dispatcher) {
 
   /**
    * @const
-   * @type {!Object.<string, goog.events.BrowserEvent|Object>}
+   * @type {!Object.<string, Event|Object>}
    */
   this.pointerMap = dispatcher.pointerMap;
 
@@ -77,14 +77,14 @@ goog.inherits(ol.pointer.MsSource, ol.pointer.EventSource);
  * for the fake pointer event.
  *
  * @private
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  * @return {Object} The copied event.
  */
 ol.pointer.MsSource.prototype.prepareEvent_ = function(inEvent) {
   var e = inEvent;
-  if (goog.isNumber(inEvent.getBrowserEvent().pointerType)) {
+  if (goog.isNumber(inEvent.pointerType)) {
-    e = this.dispatcher.cloneEvent(inEvent, inEvent.getBrowserEvent());
+    e = this.dispatcher.cloneEvent(inEvent, inEvent);
-    e.pointerType = this.POINTER_TYPES[inEvent.getBrowserEvent().pointerType];
+    e.pointerType = this.POINTER_TYPES[inEvent.pointerType];
   }
 
   return e;
@@ -103,10 +103,10 @@ ol.pointer.MsSource.prototype.cleanup = function(pointerId) {
 /**
  * Handler for `msPointerDown`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MsSource.prototype.msPointerDown = function(inEvent) {
-  this.pointerMap[inEvent.getBrowserEvent().pointerId.toString()] = inEvent;
+  this.pointerMap[inEvent.pointerId.toString()] = inEvent;
   var e = this.prepareEvent_(inEvent);
   this.dispatcher.down(e, inEvent);
 };
@@ -115,7 +115,7 @@ ol.pointer.MsSource.prototype.msPointerDown = function(inEvent) {
 /**
  * Handler for `msPointerMove`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MsSource.prototype.msPointerMove = function(inEvent) {
   var e = this.prepareEvent_(inEvent);
@@ -126,19 +126,19 @@ ol.pointer.MsSource.prototype.msPointerMove = function(inEvent) {
 /**
  * Handler for `msPointerUp`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MsSource.prototype.msPointerUp = function(inEvent) {
   var e = this.prepareEvent_(inEvent);
   this.dispatcher.up(e, inEvent);
-  this.cleanup(inEvent.getBrowserEvent().pointerId);
+  this.cleanup(inEvent.pointerId);
 };
 
 
 /**
  * Handler for `msPointerOut`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MsSource.prototype.msPointerOut = function(inEvent) {
   var e = this.prepareEvent_(inEvent);
@@ -149,7 +149,7 @@ ol.pointer.MsSource.prototype.msPointerOut = function(inEvent) {
 /**
  * Handler for `msPointerOver`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MsSource.prototype.msPointerOver = function(inEvent) {
   var e = this.prepareEvent_(inEvent);
@@ -160,23 +160,23 @@ ol.pointer.MsSource.prototype.msPointerOver = function(inEvent) {
 /**
  * Handler for `msPointerCancel`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MsSource.prototype.msPointerCancel = function(inEvent) {
   var e = this.prepareEvent_(inEvent);
   this.dispatcher.cancel(e, inEvent);
-  this.cleanup(inEvent.getBrowserEvent().pointerId);
+  this.cleanup(inEvent.pointerId);
 };
 
 
 /**
  * Handler for `msLostPointerCapture`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MsSource.prototype.msLostPointerCapture = function(inEvent) {
   var e = this.dispatcher.makeEvent('lostpointercapture',
-      inEvent.getBrowserEvent(), inEvent);
+      inEvent, inEvent);
   this.dispatcher.dispatchEvent(e);
 };
 
@@ -184,10 +184,10 @@ ol.pointer.MsSource.prototype.msLostPointerCapture = function(inEvent) {
 /**
  * Handler for `msGotPointerCapture`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.MsSource.prototype.msGotPointerCapture = function(inEvent) {
   var e = this.dispatcher.makeEvent('gotpointercapture',
-      inEvent.getBrowserEvent(), inEvent);
+      inEvent, inEvent);
   this.dispatcher.dispatchEvent(e);
 };

src/ol/pointer/nativesource.js

@@ -57,7 +57,7 @@ goog.inherits(ol.pointer.NativeSource, ol.pointer.EventSource);
 /**
  * Handler for `pointerdown`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.NativeSource.prototype.pointerDown = function(inEvent) {
   this.dispatcher.fireNativeEvent(inEvent);
@@ -67,7 +67,7 @@ ol.pointer.NativeSource.prototype.pointerDown = function(inEvent) {
 /**
  * Handler for `pointermove`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.NativeSource.prototype.pointerMove = function(inEvent) {
   this.dispatcher.fireNativeEvent(inEvent);
@@ -77,7 +77,7 @@ ol.pointer.NativeSource.prototype.pointerMove = function(inEvent) {
 /**
  * Handler for `pointerup`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.NativeSource.prototype.pointerUp = function(inEvent) {
   this.dispatcher.fireNativeEvent(inEvent);
@@ -87,7 +87,7 @@ ol.pointer.NativeSource.prototype.pointerUp = function(inEvent) {
 /**
  * Handler for `pointerout`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.NativeSource.prototype.pointerOut = function(inEvent) {
   this.dispatcher.fireNativeEvent(inEvent);
@@ -97,7 +97,7 @@ ol.pointer.NativeSource.prototype.pointerOut = function(inEvent) {
 /**
  * Handler for `pointerover`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.NativeSource.prototype.pointerOver = function(inEvent) {
   this.dispatcher.fireNativeEvent(inEvent);
@@ -107,7 +107,7 @@ ol.pointer.NativeSource.prototype.pointerOver = function(inEvent) {
 /**
  * Handler for `pointercancel`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.NativeSource.prototype.pointerCancel = function(inEvent) {
   this.dispatcher.fireNativeEvent(inEvent);
@@ -117,7 +117,7 @@ ol.pointer.NativeSource.prototype.pointerCancel = function(inEvent) {
 /**
  * Handler for `lostpointercapture`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.NativeSource.prototype.lostPointerCapture = function(inEvent) {
   this.dispatcher.fireNativeEvent(inEvent);
@@ -127,7 +127,7 @@ ol.pointer.NativeSource.prototype.lostPointerCapture = function(inEvent) {
 /**
  * Handler for `gotpointercapture`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.NativeSource.prototype.gotPointerCapture = function(inEvent) {
   this.dispatcher.fireNativeEvent(inEvent);

src/ol/pointer/pointerevent.js

@@ -31,8 +31,8 @@
 goog.provide('ol.pointer.PointerEvent');
 
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 
 
 /**
@@ -42,9 +42,9 @@ goog.require('goog.events.Event');
  * touch events and even native pointer events.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @param {string} type The type of the event to create.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  * @param {Object.<string, ?>=} opt_eventDict An optional dictionary of
  *    initial event properties.
  */
@@ -53,9 +53,9 @@ ol.pointer.PointerEvent = function(type, browserEvent, opt_eventDict) {
 
   /**
    * @const
-   * @type {goog.events.BrowserEvent}
+   * @type {Event}
    */
-  this.browserEvent = browserEvent;
+  this.originalEvent = browserEvent;
 
   var eventDict = opt_eventDict ? opt_eventDict : {};
 
@@ -192,7 +192,7 @@ ol.pointer.PointerEvent = function(type, browserEvent, opt_eventDict) {
     };
   }
 };
-goog.inherits(ol.pointer.PointerEvent, goog.events.Event);
+goog.inherits(ol.pointer.PointerEvent, ol.events.Event);
 
 
 /**

src/ol/pointer/pointereventhandler.js

@@ -31,9 +31,8 @@
 goog.provide('ol.pointer.PointerEventHandler');
 
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.BrowserEvent');
+goog.require('ol.events.EventTarget');
-goog.require('goog.events.EventTarget');
 
 goog.require('ol.has');
 goog.require('ol.pointer.MouseSource');
@@ -45,7 +44,7 @@ goog.require('ol.pointer.TouchSource');
 
 /**
  * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
  * @param {Element|HTMLDocument} element Viewport element.
  */
 ol.pointer.PointerEventHandler = function(element) {
@@ -60,12 +59,12 @@ ol.pointer.PointerEventHandler = function(element) {
 
   /**
    * @const
-   * @type {!Object.<string, goog.events.BrowserEvent|Object>}
+   * @type {!Object.<string, Event|Object>}
    */
   this.pointerMap = {};
 
   /**
-   * @type {Object.<string, function(goog.events.BrowserEvent)>}
+   * @type {Object.<string, function(Event)>}
    * @private
    */
   this.eventMap_ = {};
@@ -78,7 +77,7 @@ ol.pointer.PointerEventHandler = function(element) {
 
   this.registerSources();
 };
-goog.inherits(ol.pointer.PointerEventHandler, goog.events.EventTarget);
+goog.inherits(ol.pointer.PointerEventHandler, ol.events.EventTarget);
 
 
 /**
@@ -159,7 +158,7 @@ ol.pointer.PointerEventHandler.prototype.unregister_ = function() {
 /**
  * Calls the right handler for a new event.
  * @private
- * @param {goog.events.BrowserEvent} inEvent Browser event.
+ * @param {Event} inEvent Browser event.
  */
 ol.pointer.PointerEventHandler.prototype.eventHandler_ = function(inEvent) {
   var type = inEvent.type;
@@ -177,7 +176,7 @@ ol.pointer.PointerEventHandler.prototype.eventHandler_ = function(inEvent) {
  */
 ol.pointer.PointerEventHandler.prototype.addEvents_ = function(events) {
   events.forEach(function(eventName) {
-    goog.events.listen(this.element_, eventName,
+    ol.events.listen(this.element_, eventName,
         this.eventHandler_, false, this);
   }, this);
 };
@@ -190,7 +189,7 @@ ol.pointer.PointerEventHandler.prototype.addEvents_ = function(events) {
  */
 ol.pointer.PointerEventHandler.prototype.removeEvents_ = function(events) {
   events.forEach(function(e) {
-    goog.events.unlisten(this.element_, e,
+    ol.events.unlisten(this.element_, e,
         this.eventHandler_, false, this);
   }, this);
 };
@@ -199,7 +198,7 @@ ol.pointer.PointerEventHandler.prototype.removeEvents_ = function(events) {
 /**
  * Returns a snapshot of inEvent, with writable properties.
  *
- * @param {goog.events.BrowserEvent} browserEvent Browser event.
+ * @param {Event} browserEvent Browser event.
  * @param {Event|Touch} inEvent An event that contains
  *    properties to copy.
  * @return {Object} An object containing shallow copies of
@@ -225,7 +224,7 @@ ol.pointer.PointerEventHandler.prototype.cloneEvent = function(browserEvent, inE
 /**
  * Triggers a 'pointerdown' event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.down = function(pointerEventData, browserEvent) {
   this.fireEvent(ol.pointer.EventType.POINTERDOWN,
@@ -236,7 +235,7 @@ ol.pointer.PointerEventHandler.prototype.down = function(pointerEventData, brows
 /**
  * Triggers a 'pointermove' event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.move = function(pointerEventData, browserEvent) {
   this.fireEvent(ol.pointer.EventType.POINTERMOVE,
@@ -247,7 +246,7 @@ ol.pointer.PointerEventHandler.prototype.move = function(pointerEventData, brows
 /**
  * Triggers a 'pointerup' event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.up = function(pointerEventData, browserEvent) {
   this.fireEvent(ol.pointer.EventType.POINTERUP,
@@ -258,7 +257,7 @@ ol.pointer.PointerEventHandler.prototype.up = function(pointerEventData, browser
 /**
  * Triggers a 'pointerenter' event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.enter = function(pointerEventData, browserEvent) {
   pointerEventData.bubbles = false;
@@ -270,7 +269,7 @@ ol.pointer.PointerEventHandler.prototype.enter = function(pointerEventData, brow
 /**
  * Triggers a 'pointerleave' event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.leave = function(pointerEventData, browserEvent) {
   pointerEventData.bubbles = false;
@@ -282,7 +281,7 @@ ol.pointer.PointerEventHandler.prototype.leave = function(pointerEventData, brow
 /**
  * Triggers a 'pointerover' event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.over = function(pointerEventData, browserEvent) {
   pointerEventData.bubbles = true;
@@ -294,7 +293,7 @@ ol.pointer.PointerEventHandler.prototype.over = function(pointerEventData, brows
 /**
  * Triggers a 'pointerout' event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.out = function(pointerEventData, browserEvent) {
   pointerEventData.bubbles = true;
@@ -306,7 +305,7 @@ ol.pointer.PointerEventHandler.prototype.out = function(pointerEventData, browse
 /**
  * Triggers a 'pointercancel' event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.cancel = function(pointerEventData, browserEvent) {
   this.fireEvent(ol.pointer.EventType.POINTERCANCEL,
@@ -317,7 +316,7 @@ ol.pointer.PointerEventHandler.prototype.cancel = function(pointerEventData, bro
 /**
  * Triggers a combination of 'pointerout' and 'pointerleave' events.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.leaveOut = function(pointerEventData, browserEvent) {
   this.out(pointerEventData, browserEvent);
@@ -332,7 +331,7 @@ ol.pointer.PointerEventHandler.prototype.leaveOut = function(pointerEventData, b
 /**
  * Triggers a combination of 'pointerover' and 'pointerevents' events.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.enterOver = function(pointerEventData, browserEvent) {
   this.over(pointerEventData, browserEvent);
@@ -366,7 +365,7 @@ ol.pointer.PointerEventHandler.prototype.contains_ = function(container, contain
  *
  * @param {string} inType A string representing the type of event to create.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  * @return {ol.pointer.PointerEvent} A PointerEvent of type `inType`.
  */
 ol.pointer.PointerEventHandler.prototype.makeEvent = function(inType, pointerEventData, browserEvent) {
@@ -378,7 +377,7 @@ ol.pointer.PointerEventHandler.prototype.makeEvent = function(inType, pointerEve
  * Make and dispatch an event in one call.
  * @param {string} inType A string representing the type of event.
  * @param {Object} pointerEventData Pointer event data.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  */
 ol.pointer.PointerEventHandler.prototype.fireEvent = function(inType, pointerEventData, browserEvent) {
   var e = this.makeEvent(inType, pointerEventData, browserEvent);
@@ -389,10 +388,10 @@ ol.pointer.PointerEventHandler.prototype.fireEvent = function(inType, pointerEve
 /**
  * Creates a pointer event from a native pointer event
  * and dispatches this event.
- * @param {goog.events.BrowserEvent} nativeEvent A platform event with a target.
+ * @param {Event} nativeEvent A platform event with a target.
  */
 ol.pointer.PointerEventHandler.prototype.fireNativeEvent = function(nativeEvent) {
-  var e = this.makeEvent(nativeEvent.type, nativeEvent.getBrowserEvent(),
+  var e = this.makeEvent(nativeEvent.type, nativeEvent,
       nativeEvent);
   this.dispatchEvent(e);
 };
@@ -402,7 +401,7 @@ ol.pointer.PointerEventHandler.prototype.fireNativeEvent = function(nativeEvent)
  * Wrap a native mouse event into a pointer event.
  * This proxy method is required for the legacy IE support.
  * @param {string} eventType The pointer event type.
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  * @return {ol.pointer.PointerEvent} The wrapped event.
  */
 ol.pointer.PointerEventHandler.prototype.wrapMouseEvent = function(eventType, browserEvent) {

src/ol/pointer/touchsource.js

@@ -54,7 +54,7 @@ ol.pointer.TouchSource = function(dispatcher, mouseSource) {
 
   /**
    * @const
-   * @type {!Object.<string, goog.events.BrowserEvent|Object>}
+   * @type {!Object.<string, Event|Object>}
    */
   this.pointerMap = dispatcher.pointerMap;
 
@@ -176,7 +176,7 @@ ol.pointer.TouchSource.prototype.cancelResetClickCount_ = function() {
 
 /**
  * @private
- * @param {goog.events.BrowserEvent} browserEvent Browser event
+ * @param {Event} browserEvent Browser event
  * @param {Touch} inTouch Touch event
  * @return {Object} A pointer object.
  */
@@ -212,12 +212,12 @@ ol.pointer.TouchSource.prototype.touchToPointer_ = function(browserEvent, inTouc
 
 /**
  * @private
- * @param {goog.events.BrowserEvent} inEvent Touch event
+ * @param {Event} inEvent Touch event
- * @param {function(goog.events.BrowserEvent, Object)} inFunction In function.
+ * @param {function(Event, Object)} inFunction In function.
  */
 ol.pointer.TouchSource.prototype.processTouches_ = function(inEvent, inFunction) {
   var touches = Array.prototype.slice.call(
-      inEvent.getBrowserEvent().changedTouches);
+      inEvent.changedTouches);
   var count = touches.length;
   function preventDefault() {
     inEvent.preventDefault();
@@ -260,10 +260,10 @@ ol.pointer.TouchSource.prototype.findTouch_ = function(touchList, searchId) {
  * this "abandoned" touch
  *
  * @private
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.TouchSource.prototype.vacuumTouches_ = function(inEvent) {
-  var touchList = inEvent.getBrowserEvent().touches;
+  var touchList = inEvent.touches;
   // pointerMap.getCount() should be < touchList.length here,
   // as the touchstart has not been processed yet.
   var keys = Object.keys(this.pointerMap);
@@ -293,11 +293,11 @@ ol.pointer.TouchSource.prototype.vacuumTouches_ = function(inEvent) {
  * Handler for `touchstart`, triggers `pointerover`,
  * `pointerenter` and `pointerdown` events.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.TouchSource.prototype.touchstart = function(inEvent) {
   this.vacuumTouches_(inEvent);
-  this.setPrimaryTouch_(inEvent.getBrowserEvent().changedTouches[0]);
+  this.setPrimaryTouch_(inEvent.changedTouches[0]);
   this.dedupSynthMouse_(inEvent);
   this.clickCount_++;
   this.processTouches_(inEvent, this.overDown_);
@@ -306,7 +306,7 @@ ol.pointer.TouchSource.prototype.touchstart = function(inEvent) {
 
 /**
  * @private
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  * @param {Object} inPointer The in pointer object.
  */
 ol.pointer.TouchSource.prototype.overDown_ = function(browserEvent, inPointer) {
@@ -324,7 +324,7 @@ ol.pointer.TouchSource.prototype.overDown_ = function(browserEvent, inPointer) {
 /**
  * Handler for `touchmove`.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.TouchSource.prototype.touchmove = function(inEvent) {
   inEvent.preventDefault();
@@ -334,7 +334,7 @@ ol.pointer.TouchSource.prototype.touchmove = function(inEvent) {
 
 /**
  * @private
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  * @param {Object} inPointer The in pointer.
  */
 ol.pointer.TouchSource.prototype.moveOverOut_ = function(browserEvent, inPointer) {
@@ -371,7 +371,7 @@ ol.pointer.TouchSource.prototype.moveOverOut_ = function(browserEvent, inPointer
  * Handler for `touchend`, triggers `pointerup`,
  * `pointerout` and `pointerleave` events.
  *
- * @param {goog.events.BrowserEvent} inEvent The event.
+ * @param {Event} inEvent The event.
  */
 ol.pointer.TouchSource.prototype.touchend = function(inEvent) {
   this.dedupSynthMouse_(inEvent);
@@ -381,7 +381,7 @@ ol.pointer.TouchSource.prototype.touchend = function(inEvent) {
 
 /**
  * @private
- * @param {goog.events.BrowserEvent} browserEvent An event.
+ * @param {Event} browserEvent An event.
  * @param {Object} inPointer The inPointer object.
  */
 ol.pointer.TouchSource.prototype.upOut_ = function(browserEvent, inPointer) {
@@ -396,7 +396,7 @@ ol.pointer.TouchSource.prototype.upOut_ = function(browserEvent, inPointer) {
  * Handler for `touchcancel`, triggers `pointercancel`,
  * `pointerout` and `pointerleave` events.
  *
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.TouchSource.prototype.touchcancel = function(inEvent) {
   this.processTouches_(inEvent, this.cancelOut_);
@@ -405,7 +405,7 @@ ol.pointer.TouchSource.prototype.touchcancel = function(inEvent) {
 
 /**
  * @private
- * @param {goog.events.BrowserEvent} browserEvent The event.
+ * @param {Event} browserEvent The event.
  * @param {Object} inPointer The in pointer.
  */
 ol.pointer.TouchSource.prototype.cancelOut_ = function(browserEvent, inPointer) {
@@ -430,11 +430,11 @@ ol.pointer.TouchSource.prototype.cleanUpPointer_ = function(inPointer) {
  * Prevent synth mouse events from creating pointer events.
  *
  * @private
- * @param {goog.events.BrowserEvent} inEvent The in event.
+ * @param {Event} inEvent The in event.
  */
 ol.pointer.TouchSource.prototype.dedupSynthMouse_ = function(inEvent) {
   var lts = this.mouseSource.lastTouches;
-  var t = inEvent.getBrowserEvent().changedTouches[0];
+  var t = inEvent.changedTouches[0];
   // only the primary finger will synth mouse events
   if (this.isPrimaryTouch_(t)) {
     // remember x/y of last touch

src/ol/render/renderevent.js

@@ -1,7 +1,7 @@
 goog.provide('ol.render.Event');
 goog.provide('ol.render.EventType');
 
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.render.VectorContext');
 
 
@@ -29,7 +29,7 @@ ol.render.EventType = {
 
 /**
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.render.Event}
  * @param {ol.render.EventType} type Type.
  * @param {Object=} opt_target Target.
@@ -75,4 +75,4 @@ ol.render.Event = function(
   this.glContext = opt_glContext;
 
 };
-goog.inherits(ol.render.Event, goog.events.Event);
+goog.inherits(ol.render.Event, ol.events.Event);

src/ol/render/vector.js

@@ -69,7 +69,7 @@ ol.renderer.vector.renderCircleGeometry_ = function(replayGroup, geometry, style
  * @param {ol.Feature|ol.render.Feature} feature Feature.
  * @param {ol.style.Style} style Style.
  * @param {number} squaredTolerance Squared tolerance.
- * @param {function(this: T, goog.events.Event)} listener Listener function.
+ * @param {function(this: T, ol.events.Event)} listener Listener function.
  * @param {T} thisArg Value to use as `this` when executing `listener`.
  * @return {boolean} `true` if style is loading.
  * @template T

src/ol/renderer/canvas/canvasvectorlayerrenderer.js

@@ -1,7 +1,7 @@
 goog.provide('ol.renderer.canvas.VectorLayer');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.ViewHint');
 goog.require('ol.dom');
 goog.require('ol.extent');
@@ -181,7 +181,7 @@ ol.renderer.canvas.VectorLayer.prototype.forEachFeatureAtCoordinate = function(c
 
 /**
  * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
  * @private
  */
 ol.renderer.canvas.VectorLayer.prototype.handleStyleImageChange_ = function(event) {

src/ol/renderer/canvas/canvasvectortilelayerrenderer.js

@@ -1,7 +1,7 @@
 goog.provide('ol.renderer.canvas.VectorTileLayer');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.vec.Mat4');
 goog.require('ol.Feature');
 goog.require('ol.TileRange');
@@ -364,7 +364,7 @@ ol.renderer.canvas.VectorTileLayer.prototype.forEachFeatureAtCoordinate = functi
 
 /**
  * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
  * @private
  */
 ol.renderer.canvas.VectorTileLayer.prototype.handleStyleImageChange_ = function(event) {

src/ol/renderer/dom/dommaprenderer.js

@@ -2,9 +2,9 @@ goog.provide('ol.renderer.dom.Map');
 
 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.style');
 goog.require('goog.vec.Mat4');
 goog.require('ol');
@@ -68,8 +68,8 @@ ol.renderer.dom.Map = function(container, map) {
   style.height = '100%';
 
   // prevent the img context menu on mobile devices
-  goog.events.listen(this.layersPane_, goog.events.EventType.TOUCHSTART,
+  ol.events.listen(this.layersPane_, ol.events.EventType.TOUCHSTART,
-      goog.events.Event.preventDefault);
+      ol.events.Event.preventDefault);
 
   goog.dom.insertChildAt(container, this.layersPane_, 0);
 

src/ol/renderer/dom/domvectorlayerrenderer.js

@@ -1,7 +1,7 @@
 goog.provide('ol.renderer.dom.VectorLayer');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.vec.Mat4');
 goog.require('ol.ViewHint');
 goog.require('ol.dom');
@@ -202,7 +202,7 @@ ol.renderer.dom.VectorLayer.prototype.forEachFeatureAtCoordinate = function(coor
 
 /**
  * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
  * @private
  */
 ol.renderer.dom.VectorLayer.prototype.handleStyleImageChange_ = function(event) {

src/ol/renderer/layerrenderer.js

@@ -1,8 +1,8 @@
 goog.provide('ol.renderer.Layer');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.functions');
 goog.require('ol');
 goog.require('ol.ImageState');
@@ -121,7 +121,7 @@ ol.renderer.Layer.prototype.getLayer = function() {
 
 /**
  * Handle changes in image state.
- * @param {goog.events.Event} event Image change event.
+ * @param {ol.events.Event} event Image change event.
  * @private
  */
 ol.renderer.Layer.prototype.handleImageChange_ = function(event) {
@@ -149,7 +149,7 @@ ol.renderer.Layer.prototype.loadImage = function(image) {
     goog.asserts.assert(imageState == ol.ImageState.IDLE ||
         imageState == ol.ImageState.LOADING,
         'imageState is "idle" or "loading"');
-    goog.events.listen(image, goog.events.EventType.CHANGE,
+    ol.events.listen(image, ol.events.EventType.CHANGE,
         this.handleImageChange_, false, this);
   }
   if (imageState == ol.ImageState.IDLE) {

src/ol/renderer/maprenderer.js

@@ -4,8 +4,8 @@ goog.provide('ol.renderer.Map');
 goog.require('goog.Disposable');
 goog.require('goog.asserts');
 goog.require('goog.dispose');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.functions');
 goog.require('goog.object');
 goog.require('goog.vec.Mat4');
@@ -55,7 +55,7 @@ ol.renderer.Map = function(container, map) {
 
   /**
    * @private
-   * @type {Object.<string, goog.events.Key>}
+   * @type {Object.<string, ol.events.Key>}
    */
   this.layerRendererListeners_ = {};
 
@@ -255,8 +255,8 @@ ol.renderer.Map.prototype.getLayerRenderer = function(layer) {
   } else {
     var layerRenderer = this.createLayerRenderer(layer);
     this.layerRenderers_[layerKey] = layerRenderer;
-    this.layerRendererListeners_[layerKey] = goog.events.listen(layerRenderer,
+    this.layerRendererListeners_[layerKey] = ol.events.listen(layerRenderer,
-        goog.events.EventType.CHANGE, this.handleLayerRendererChange_,
+        ol.events.EventType.CHANGE, this.handleLayerRendererChange_,
         false, this);
 
     return layerRenderer;
@@ -321,7 +321,7 @@ ol.renderer.Map.prototype.removeLayerRendererByKey_ = function(layerKey) {
 
   goog.asserts.assert(layerKey in this.layerRendererListeners_,
       'given layerKey (%s) exists in layerRendererListeners', layerKey);
-  goog.events.unlistenByKey(this.layerRendererListeners_[layerKey]);
+  ol.events.unlistenByKey(this.layerRendererListeners_[layerKey]);
   delete this.layerRendererListeners_[layerKey];
 
   return layerRenderer;

src/ol/renderer/webgl/webglmaprenderer.js

@@ -4,8 +4,8 @@ goog.provide('ol.renderer.webgl.Map');
 
 goog.require('goog.asserts');
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('goog.log');
 goog.require('goog.log.Logger');
 goog.require('goog.object');
@@ -106,9 +106,9 @@ ol.renderer.webgl.Map = function(container, map) {
    */
   this.context_ = new ol.webgl.Context(this.canvas_, this.gl_);
 
-  goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST,
+  ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST,
       this.handleWebGLContextLost, false, this);
-  goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED,
+  ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED,
       this.handleWebGLContextRestored, false, this);
 
   /**
@@ -377,7 +377,7 @@ ol.renderer.webgl.Map.prototype.getType = function() {
 
 
 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
  * @protected
  */
 ol.renderer.webgl.Map.prototype.handleWebGLContextLost = function(event) {

src/ol/renderer/webgl/webglvectorlayerrenderer.js

@@ -1,7 +1,7 @@
 goog.provide('ol.renderer.webgl.VectorLayer');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.ViewHint');
 goog.require('ol.extent');
 goog.require('ol.layer.Vector');
@@ -169,7 +169,7 @@ ol.renderer.webgl.VectorLayer.prototype.forEachLayerAtPixel = function(pixel, fr
 
 /**
  * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
  * @private
  */
 ol.renderer.webgl.VectorLayer.prototype.handleStyleImageChange_ = function(event) {

src/ol/reproj/image.js

@@ -2,8 +2,8 @@ goog.provide('ol.reproj.Image');
 goog.provide('ol.reproj.ImageFunctionType');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.ImageBase');
 goog.require('ol.ImageState');
 goog.require('ol.extent');
@@ -102,7 +102,7 @@ ol.reproj.Image = function(sourceProj, targetProj,
 
   /**
    * @private
-   * @type {goog.events.Key}
+   * @type {ol.events.Key|null}
    */
   this.sourceListenerKey_ = null;
 
@@ -183,8 +183,8 @@ ol.reproj.Image.prototype.load = function() {
         sourceState == ol.ImageState.ERROR) {
       this.reproject_();
     } else {
-      this.sourceListenerKey_ = this.sourceImage_.listen(
+      this.sourceListenerKey_ = ol.events.listen(this.sourceImage_,
-          goog.events.EventType.CHANGE, function(e) {
+          ol.events.EventType.CHANGE, function(e) {
             var sourceState = this.sourceImage_.getState();
             if (sourceState == ol.ImageState.LOADED ||
                 sourceState == ol.ImageState.ERROR) {
@@ -204,6 +204,6 @@ ol.reproj.Image.prototype.load = function() {
 ol.reproj.Image.prototype.unlistenSource_ = function() {
   goog.asserts.assert(this.sourceListenerKey_,
       'this.sourceListenerKey_ should not be null');
-  goog.events.unlistenByKey(this.sourceListenerKey_);
+  ol.events.unlistenByKey(this.sourceListenerKey_);
   this.sourceListenerKey_ = null;
 };

src/ol/reproj/tile.js

@@ -2,8 +2,8 @@ goog.provide('ol.reproj.Tile');
 goog.provide('ol.reproj.TileFunctionType');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.math');
 goog.require('goog.object');
 goog.require('ol.Tile');
@@ -97,7 +97,7 @@ ol.reproj.Tile = function(sourceProj, sourceTileGrid,
 
   /**
    * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
    */
   this.sourcesListenerKeys_ = null;
 
@@ -297,13 +297,13 @@ ol.reproj.Tile.prototype.load = function() {
         leftToLoad++;
 
         var sourceListenKey;
-        sourceListenKey = tile.listen(goog.events.EventType.CHANGE,
+        sourceListenKey = ol.events.listen(tile, ol.events.EventType.CHANGE,
             function(e) {
               var state = tile.getState();
               if (state == ol.TileState.LOADED ||
                   state == ol.TileState.ERROR ||
                   state == ol.TileState.EMPTY) {
-                goog.events.unlistenByKey(sourceListenKey);
+                ol.events.unlistenByKey(sourceListenKey);
                 leftToLoad--;
                 goog.asserts.assert(leftToLoad >= 0,
                     'leftToLoad should not be negative');
@@ -337,6 +337,6 @@ ol.reproj.Tile.prototype.load = function() {
 ol.reproj.Tile.prototype.unlistenSources_ = function() {
   goog.asserts.assert(this.sourcesListenerKeys_,
       'this.sourcesListenerKeys_ should not be null');
-  this.sourcesListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.sourcesListenerKeys_.forEach(ol.events.unlistenByKey);
   this.sourcesListenerKeys_ = null;
 };

src/ol/source/clustersource.js

@@ -4,7 +4,7 @@
 goog.provide('ol.source.Cluster');
 
 goog.require('goog.asserts');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.Feature');
 goog.require('ol.coordinate');
@@ -55,7 +55,7 @@ ol.source.Cluster = function(options) {
    */
   this.source_ = options.source;
 
-  this.source_.on(goog.events.EventType.CHANGE,
+  this.source_.on(ol.events.EventType.CHANGE,
       ol.source.Cluster.prototype.onSourceChange_, this);
 };
 goog.inherits(ol.source.Cluster, ol.source.Vector);

src/ol/source/imagemapguidesource.js

@@ -1,7 +1,7 @@
 goog.provide('ol.source.ImageMapGuide');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('goog.uri.utils');
 goog.require('ol.Image');
@@ -143,7 +143,7 @@ ol.source.ImageMapGuide.prototype.getImageInternal = function(extent, resolution
     image = new ol.Image(extent, resolution, pixelRatio,
         this.getAttributions(), imageUrl, this.crossOrigin_,
         this.imageLoadFunction_);
-    goog.events.listen(image, goog.events.EventType.CHANGE,
+    ol.events.listen(image, ol.events.EventType.CHANGE,
         this.handleImageChange, false, this);
   } else {
     image = null;

src/ol/source/imagesource.js

@@ -2,7 +2,7 @@ goog.provide('ol.source.Image');
 goog.provide('ol.source.ImageEvent');
 
 goog.require('goog.asserts');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol.Attribution');
 goog.require('ol.ImageState');
 goog.require('ol.array');
@@ -153,7 +153,7 @@ ol.source.Image.prototype.getImageInternal = goog.abstractMethod;
 
 /**
  * Handle image change events.
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
  * @protected
  */
 ol.source.Image.prototype.handleImageChange = function(event) {
@@ -197,7 +197,7 @@ ol.source.Image.defaultImageLoadFunction = function(image, src) {
  * type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.source.ImageEvent}
  * @param {string} type Type.
  * @param {ol.Image} image The image.
@@ -214,7 +214,7 @@ ol.source.ImageEvent = function(type, image) {
   this.image = image;
 
 };
-goog.inherits(ol.source.ImageEvent, goog.events.Event);
+goog.inherits(ol.source.ImageEvent, ol.events.Event);
 
 
 /**

src/ol/source/imagestaticsource.js

@@ -1,7 +1,7 @@
 goog.provide('ol.source.ImageStatic');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.Image');
 goog.require('ol.ImageLoadFunctionType');
 goog.require('ol.ImageState');
@@ -52,7 +52,7 @@ ol.source.ImageStatic = function(options) {
    */
   this.imageSize_ = options.imageSize ? options.imageSize : null;
 
-  goog.events.listen(this.image_, goog.events.EventType.CHANGE,
+  ol.events.listen(this.image_, ol.events.EventType.CHANGE,
       this.handleImageChange, false, this);
 
 };

src/ol/source/imagevectorsource.js

@@ -1,8 +1,8 @@
 goog.provide('ol.source.ImageVector');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.vec.Mat4');
 goog.require('ol.dom');
 goog.require('ol.extent');
@@ -89,7 +89,7 @@ ol.source.ImageVector = function(options) {
 
   this.setStyle(options.style);
 
-  goog.events.listen(this.source_, goog.events.EventType.CHANGE,
+  ol.events.listen(this.source_, ol.events.EventType.CHANGE,
       this.handleSourceChange_, undefined, this);
 
 };
@@ -226,7 +226,7 @@ ol.source.ImageVector.prototype.getTransform_ = function(center, resolution, pix
 
 /**
  * Handle changes in image style state.
- * @param {goog.events.Event} event Image style change event.
+ * @param {ol.events.Event} event Image style change event.
  * @private
  */
 ol.source.ImageVector.prototype.handleImageChange_ = function(event) {

src/ol/source/imagewmssource.js

@@ -3,8 +3,8 @@
 goog.provide('ol.source.ImageWMS');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('goog.string');
 goog.require('goog.uri.utils');
@@ -241,7 +241,7 @@ ol.source.ImageWMS.prototype.getImageInternal = function(extent, resolution, pix
 
   this.renderedRevision_ = this.getRevision();
 
-  goog.events.listen(this.image_, goog.events.EventType.CHANGE,
+  ol.events.listen(this.image_, ol.events.EventType.CHANGE,
       this.handleImageChange, false, this);
 
   return this.image_;

src/ol/source/rastersource.js

@@ -3,9 +3,9 @@ goog.provide('ol.source.RasterEvent');
 goog.provide('ol.source.RasterEventType');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('goog.vec.Mat4');
 goog.require('ol.ImageCanvas');
@@ -62,7 +62,7 @@ ol.source.Raster = function(options) {
   this.renderers_ = ol.source.Raster.createRenderers_(options.sources);
 
   for (var r = 0, rr = this.renderers_.length; r < rr; ++r) {
-    goog.events.listen(this.renderers_[r], goog.events.EventType.CHANGE,
+    ol.events.listen(this.renderers_[r], ol.events.EventType.CHANGE,
         this.changed, false, this);
   }
 
@@ -474,7 +474,7 @@ ol.source.Raster.RenderedState;
  * type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.source.RasterEvent}
  * @param {string} type Type.
  * @param {olx.FrameState} frameState The frame state.
@@ -506,7 +506,7 @@ ol.source.RasterEvent = function(type, frameState, data) {
   this.data = data;
 
 };
-goog.inherits(ol.source.RasterEvent, goog.events.Event);
+goog.inherits(ol.source.RasterEvent, ol.events.Event);
 
 
 /**

src/ol/source/tileimagesource.js

@@ -1,8 +1,8 @@
 goog.provide('ol.source.TileImage');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.ImageTile');
 goog.require('ol.TileCache');
@@ -197,7 +197,7 @@ ol.source.TileImage.prototype.createTile_ = function(z, x, y, pixelRatio, projec
       this.crossOrigin,
       this.tileLoadFunction);
   tile.key = key;
-  goog.events.listen(tile, goog.events.EventType.CHANGE,
+  ol.events.listen(tile, ol.events.EventType.CHANGE,
       this.handleTileChange, false, this);
   return tile;
 };

src/ol/source/tilejsonsource.js

@@ -8,7 +8,7 @@ goog.provide('ol.source.TileJSON');
 goog.provide('ol.tilejson');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.net.CorsXmlHttpFactory');
 goog.require('goog.net.EventType');
 goog.require('goog.net.Jsonp');
@@ -49,7 +49,7 @@ ol.source.TileJSON = function(options) {
         this.handleTileJSONError.bind(this));
   } else {
     var xhr = new goog.net.XhrIo(new goog.net.CorsXmlHttpFactory());
-    goog.events.listen(xhr, goog.net.EventType.COMPLETE, function(e) {
+    ol.events.listen(xhr, goog.net.EventType.COMPLETE, function(e) {
       if (xhr.isSuccess()) {
         var response = /** @type {TileJSON} */(xhr.getResponseJson());
         this.handleTileJSONResponse(response);

src/ol/source/tilesource.js

@@ -3,7 +3,7 @@ goog.provide('ol.source.TileEvent');
 goog.provide('ol.source.TileOptions');
 
 goog.require('goog.asserts');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
 goog.require('ol');
 goog.require('ol.Attribution');
 goog.require('ol.Extent');
@@ -305,7 +305,7 @@ ol.source.Tile.prototype.useTile = ol.nullFunction;
  * type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.source.TileEvent}
  * @param {string} type Type.
  * @param {ol.Tile} tile The tile.
@@ -322,7 +322,7 @@ ol.source.TileEvent = function(type, tile) {
   this.tile = tile;
 
 };
-goog.inherits(ol.source.TileEvent, goog.events.Event);
+goog.inherits(ol.source.TileEvent, ol.events.Event);
 
 
 /**

src/ol/source/tileutfgridsource.js

@@ -2,13 +2,15 @@ goog.provide('ol.source.TileUTFGrid');
 
 goog.require('goog.asserts');
 goog.require('goog.async.nextTick');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.net.Jsonp');
 goog.require('ol.Attribution');
 goog.require('ol.Tile');
 goog.require('ol.TileState');
 goog.require('ol.TileUrlFunction');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.extent');
 goog.require('ol.proj');
 goog.require('ol.source.State');
@@ -307,7 +309,7 @@ ol.source.TileUTFGridTile_.prototype.getData = function(coordinate) {
  */
 ol.source.TileUTFGridTile_.prototype.forDataAtCoordinate = function(coordinate, callback, opt_this, opt_request) {
   if (this.state == ol.TileState.IDLE && opt_request === true) {
-    goog.events.listenOnce(this, goog.events.EventType.CHANGE, function(e) {
+    ol.events.listenOnce(this, ol.events.EventType.CHANGE, function(e) {
       callback.call(opt_this, this.getData(coordinate));
     }, false, this);
     this.loadInternal_();

src/ol/source/urltilesource.js

@@ -1,6 +1,6 @@
 goog.provide('ol.source.UrlTile');
 
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.TileLoadFunctionType');
 goog.require('ol.TileState');
 goog.require('ol.TileUrlFunction');
@@ -126,7 +126,7 @@ ol.source.UrlTile.prototype.getUrls = function() {
 
 /**
  * Handle tile change events.
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
  * @protected
  */
 ol.source.UrlTile.prototype.handleTileChange = function(event) {

src/ol/source/vectorsource.js

@@ -6,9 +6,9 @@ goog.provide('ol.source.VectorEvent');
 goog.provide('ol.source.VectorEventType');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.Event');
+goog.require('ol.events.Event');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol');
 goog.require('ol.Collection');
@@ -146,7 +146,7 @@ ol.source.Vector = function(opt_options) {
 
   /**
    * @private
-   * @type {Object.<string, Array.<goog.events.Key>>}
+   * @type {Object.<string, Array.<ol.events.Key>>}
    */
   this.featureChangeKeys_ = {};
 
@@ -228,10 +228,10 @@ ol.source.Vector.prototype.setupChangeEvents_ = function(featureKey, feature) {
   goog.asserts.assert(!(featureKey in this.featureChangeKeys_),
       'key (%s) not yet registered in featureChangeKey', featureKey);
   this.featureChangeKeys_[featureKey] = [
-    goog.events.listen(feature,
+    ol.events.listen(feature,
-        goog.events.EventType.CHANGE,
+        ol.events.EventType.CHANGE,
         this.handleFeatureChange_, false, this),
-    goog.events.listen(feature,
+    ol.events.listen(feature,
         ol.ObjectEventType.PROPERTYCHANGE,
         this.handleFeatureChange_, false, this)
   ];
@@ -327,7 +327,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
   goog.asserts.assert(!this.featuresCollection_,
       'bindFeaturesCollection can only be called once');
   var modifyingCollection = false;
-  goog.events.listen(this, ol.source.VectorEventType.ADDFEATURE,
+  ol.events.listen(this, ol.source.VectorEventType.ADDFEATURE,
       function(evt) {
         if (!modifyingCollection) {
           modifyingCollection = true;
@@ -335,7 +335,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
           modifyingCollection = false;
         }
       });
-  goog.events.listen(this, ol.source.VectorEventType.REMOVEFEATURE,
+  ol.events.listen(this, ol.source.VectorEventType.REMOVEFEATURE,
       function(evt) {
         if (!modifyingCollection) {
           modifyingCollection = true;
@@ -343,7 +343,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
           modifyingCollection = false;
         }
       });
-  goog.events.listen(collection, ol.CollectionEventType.ADD,
+  ol.events.listen(collection, ol.CollectionEventType.ADD,
       function(evt) {
         if (!modifyingCollection) {
           var feature = evt.element;
@@ -353,7 +353,7 @@ ol.source.Vector.prototype.bindFeaturesCollection_ = function(collection) {
           modifyingCollection = false;
         }
       }, false, this);
-  goog.events.listen(collection, ol.CollectionEventType.REMOVE,
+  ol.events.listen(collection, ol.CollectionEventType.REMOVE,
       function(evt) {
         if (!modifyingCollection) {
           var feature = evt.element;
@@ -376,7 +376,7 @@ ol.source.Vector.prototype.clear = function(opt_fast) {
   if (opt_fast) {
     for (var featureId in this.featureChangeKeys_) {
       var keys = this.featureChangeKeys_[featureId];
-      keys.forEach(goog.events.unlistenByKey);
+      keys.forEach(ol.events.unlistenByKey);
     }
     if (!this.featuresCollection_) {
       this.featureChangeKeys_ = {};
@@ -680,7 +680,7 @@ ol.source.Vector.prototype.getFeatureById = function(id) {
 
 
 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
  * @private
  */
 ol.source.Vector.prototype.handleFeatureChange_ = function(event) {
@@ -816,7 +816,7 @@ ol.source.Vector.prototype.removeFeatureInternal = function(feature) {
   var featureKey = goog.getUid(feature).toString();
   goog.asserts.assert(featureKey in this.featureChangeKeys_,
       'featureKey exists in featureChangeKeys');
-  this.featureChangeKeys_[featureKey].forEach(goog.events.unlistenByKey);
+  this.featureChangeKeys_[featureKey].forEach(ol.events.unlistenByKey);
   delete this.featureChangeKeys_[featureKey];
   var id = feature.getId();
   if (id !== undefined) {
@@ -855,7 +855,7 @@ ol.source.Vector.prototype.removeFromIdIndex_ = function(feature) {
  * type.
  *
  * @constructor
- * @extends {goog.events.Event}
+ * @extends {ol.events.Event}
  * @implements {oli.source.VectorEvent}
  * @param {string} type Type.
  * @param {ol.Feature=} opt_feature Feature.
@@ -872,4 +872,4 @@ ol.source.VectorEvent = function(type, opt_feature) {
   this.feature = opt_feature;
 
 };
-goog.inherits(ol.source.VectorEvent, goog.events.Event);
+goog.inherits(ol.source.VectorEvent, ol.events.Event);

src/ol/source/vectortilesource.js

@@ -1,9 +1,11 @@
 goog.provide('ol.source.VectorTile');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.TileState');
 goog.require('ol.VectorTile');
+goog.require('ol.events');
+goog.require('ol.events.EventType');
 goog.require('ol.featureloader');
 goog.require('ol.source.UrlTile');
 
@@ -79,7 +81,7 @@ ol.source.VectorTile.prototype.getTile = function(z, x, y, pixelRatio, projectio
         tileUrl !== undefined ? ol.TileState.IDLE : ol.TileState.EMPTY,
         tileUrl !== undefined ? tileUrl : '',
         this.format_, this.tileLoadFunction);
-    goog.events.listen(tile, goog.events.EventType.CHANGE,
+    ol.events.listen(tile, ol.events.EventType.CHANGE,
         this.handleTileChange, false, this);
 
     this.tileCache.set(tileCoordKey, tile);

src/ol/style/iconstyle.js

@@ -4,9 +4,9 @@ goog.provide('ol.style.IconImageCache');
 goog.provide('ol.style.IconOrigin');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventTarget');
+goog.require('ol.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.color');
 goog.require('ol.dom');
 goog.require('ol.style.Image');
@@ -345,7 +345,7 @@ ol.style.Icon.prototype.getSize = function() {
  * @inheritDoc
  */
 ol.style.Icon.prototype.listenImageChange = function(listener, thisArg) {
-  return goog.events.listen(this.iconImage_, goog.events.EventType.CHANGE,
+  return ol.events.listen(this.iconImage_, ol.events.EventType.CHANGE,
       listener, false, thisArg);
 };
 
@@ -366,7 +366,7 @@ ol.style.Icon.prototype.load = function() {
  * @inheritDoc
  */
 ol.style.Icon.prototype.unlistenImageChange = function(listener, thisArg) {
-  goog.events.unlisten(this.iconImage_, goog.events.EventType.CHANGE,
+  ol.events.unlisten(this.iconImage_, ol.events.EventType.CHANGE,
       listener, false, thisArg);
 };
 
@@ -379,7 +379,7 @@ ol.style.Icon.prototype.unlistenImageChange = function(listener, thisArg) {
  * @param {?string} crossOrigin Cross origin.
  * @param {ol.style.ImageState} imageState Image state.
  * @param {ol.Color} color Color.
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
  * @private
  */
 ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState,
@@ -419,7 +419,7 @@ ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState,
 
   /**
    * @private
-   * @type {Array.<goog.events.Key>}
+   * @type {Array.<ol.events.Key>}
    */
   this.imageListenerKeys_ = null;
 
@@ -451,7 +451,7 @@ ol.style.IconImage_ = function(image, src, size, crossOrigin, imageState,
   }
 
 };
-goog.inherits(ol.style.IconImage_, goog.events.EventTarget);
+goog.inherits(ol.style.IconImage_, ol.events.EventTarget);
 
 
 /**
@@ -494,7 +494,7 @@ ol.style.IconImage_.prototype.determineTainting_ = function() {
  * @private
  */
 ol.style.IconImage_.prototype.dispatchChangeEvent_ = function() {
-  this.dispatchEvent(goog.events.EventType.CHANGE);
+  this.dispatchEvent(ol.events.EventType.CHANGE);
 };
 
 
@@ -585,9 +585,9 @@ ol.style.IconImage_.prototype.load = function() {
         'no listener keys existing');
     this.imageState_ = ol.style.ImageState.LOADING;
     this.imageListenerKeys_ = [
-      goog.events.listenOnce(this.image_, goog.events.EventType.ERROR,
+      ol.events.listenOnce(this.image_, ol.events.EventType.ERROR,
           this.handleImageError_, false, this),
-      goog.events.listenOnce(this.image_, goog.events.EventType.LOAD,
+      ol.events.listenOnce(this.image_, ol.events.EventType.LOAD,
           this.handleImageLoad_, false, this)
     ];
     try {
@@ -639,7 +639,7 @@ ol.style.IconImage_.prototype.replaceColor_ = function() {
 ol.style.IconImage_.prototype.unlistenImage_ = function() {
   goog.asserts.assert(this.imageListenerKeys_,
       'we must have listeners registered');
-  this.imageListenerKeys_.forEach(goog.events.unlistenByKey);
+  this.imageListenerKeys_.forEach(ol.events.unlistenByKey);
   this.imageListenerKeys_ = null;
 };
 
@@ -703,7 +703,7 @@ ol.style.IconImageCache.prototype.expire = function() {
     var key, iconImage;
     for (key in this.cache_) {
       iconImage = this.cache_[key];
-      if ((i++ & 3) === 0 && !goog.events.hasListener(iconImage)) {
+      if ((i++ & 3) === 0 && !iconImage.hasListener()) {
         delete this.cache_[key];
         --this.cacheSize_;
       }

src/ol/style/imagestyle.js

@@ -231,9 +231,9 @@ ol.style.Image.prototype.setSnapToPixel = function(snapToPixel) {
 
 
 /**
- * @param {function(this: T, goog.events.Event)} listener Listener function.
+ * @param {function(this: T, ol.events.Event)} listener Listener function.
  * @param {T} thisArg Value to use as `this` when executing `listener`.
- * @return {goog.events.Key|undefined} Listener key.
+ * @return {ol.events.Key|undefined} Listener key.
  * @template T
  */
 ol.style.Image.prototype.listenImageChange = goog.abstractMethod;
@@ -246,7 +246,7 @@ ol.style.Image.prototype.load = goog.abstractMethod;
 
 
 /**
- * @param {function(this: T, goog.events.Event)} listener Listener function.
+ * @param {function(this: T, ol.events.Event)} listener Listener function.
  * @param {T} thisArg Value to use as `this` when executing `listener`.
  * @template T
  */

src/ol/tile.js

@@ -1,9 +1,9 @@
 goog.provide('ol.Tile');
 goog.provide('ol.TileState');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventTarget');
+goog.require('ol.events.EventTarget');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.TileCoord');
 
 
@@ -24,7 +24,7 @@ ol.TileState = {
  * Base class for tiles.
  *
  * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
  * @param {ol.TileCoord} tileCoord Tile coordinate.
  * @param {ol.TileState} state State.
  */
@@ -60,14 +60,14 @@ ol.Tile = function(tileCoord, state) {
   this.key = '';
 
 };
-goog.inherits(ol.Tile, goog.events.EventTarget);
+goog.inherits(ol.Tile, ol.events.EventTarget);
 
 
 /**
  * @protected
  */
 ol.Tile.prototype.changed = function() {
-  this.dispatchEvent(goog.events.EventType.CHANGE);
+  this.dispatchEvent(ol.events.EventType.CHANGE);
 };
 
 

src/ol/tilequeue.js

@@ -1,8 +1,8 @@
 goog.provide('ol.TilePriorityFunction');
 goog.provide('ol.TileQueue');
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.Coordinate');
 goog.require('ol.TileState');
 goog.require('ol.structs.PriorityQueue');
@@ -71,7 +71,7 @@ ol.TileQueue.prototype.enqueue = function(element) {
   var added = goog.base(this, 'enqueue', element);
   if (added) {
     var tile = element[0];
-    goog.events.listen(tile, goog.events.EventType.CHANGE,
+    ol.events.listen(tile, ol.events.EventType.CHANGE,
         this.handleTileChange, false, this);
   }
   return added;
@@ -87,7 +87,7 @@ ol.TileQueue.prototype.getTilesLoading = function() {
 
 
 /**
- * @param {goog.events.Event} event Event.
+ * @param {ol.events.Event} event Event.
  * @protected
  */
 ol.TileQueue.prototype.handleTileChange = function(event) {
@@ -95,7 +95,7 @@ ol.TileQueue.prototype.handleTileChange = function(event) {
   var state = tile.getState();
   if (state === ol.TileState.LOADED || state === ol.TileState.ERROR ||
       state === ol.TileState.EMPTY) {
-    goog.events.unlisten(tile, goog.events.EventType.CHANGE,
+    ol.events.unlisten(tile, ol.events.EventType.CHANGE,
         this.handleTileChange, false, this);
     var tileKey = tile.getKey();
     if (tileKey in this.tilesLoadingKeys_) {

src/ol/webgl/context.js

@@ -1,7 +1,7 @@
 goog.provide('ol.webgl.Context');
 
 goog.require('goog.asserts');
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.log');
 goog.require('goog.object');
 goog.require('ol');
@@ -22,7 +22,7 @@ ol.webgl.BufferCacheEntry;
  * A WebGL context for accessing low-level WebGL capabilities.
  *
  * @constructor
- * @extends {goog.events.EventTarget}
+ * @extends {ol.events.EventTarget}
  * @param {HTMLCanvasElement} canvas Canvas.
  * @param {WebGLRenderingContext} gl GL.
  */
@@ -95,9 +95,9 @@ ol.webgl.Context = function(canvas, gl) {
         'Failed to get extension "OES_element_index_uint"');
   }
 
-  goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST,
+  ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.LOST,
       this.handleWebGLContextLost, false, this);
-  goog.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED,
+  ol.events.listen(this.canvas_, ol.webgl.WebGLContextEventType.RESTORED,
       this.handleWebGLContextRestored, false, this);
 
 };

test/index.html

@@ -38,15 +38,15 @@
      * that we don't have other global leaks, we preemptively set the property
      * so Mocha can compare the global before and after our tests.
      *
-     * In addition, calling goog.events.listen on the global object (as done
+     * In addition, calling ol.events.listen on the global object (as done
      * in deviceorientation.js) creates a second leak by setting
-     * goog.events.LISTENER_MAP_PROP_ on the global object.
+     * ol.events.listenER_MAP_PROP_ on the global object.
      *
      * We preemptively set both of these properties so Mocha can compare the
-     * global before and after tests.  The call to goog.events.listen also
+     * global before and after tests.  The call to ol.events.listen also
      * calls goog.getUid.
      */
-    goog.events.listen(this, 'test', function() {});
+    ol.events.listen(this, 'test', function() {});
 
     var runner = mocha.run();
     if (window.console && console.log) {

test/spec/ol/collection.test.js

@@ -114,7 +114,7 @@ describe('ol.collection', function() {
     it('fires a remove event', function() {
       var collection = new ol.Collection([0, 1, 2]);
       var cb = sinon.spy();
-      goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb);
+      ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb);
       expect(collection.remove(1)).to.eql(1);
       expect(cb).to.be.called();
       expect(cb.lastCall.args[0].element).to.eql(1);
@@ -137,10 +137,10 @@ describe('ol.collection', function() {
     it('does dispatch events', function() {
       var collection = new ol.Collection(['a', 'b']);
       var added, removed;
-      goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
+      ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
         added = e.element;
       });
-      goog.events.listen(
+      ol.events.listen(
           collection, ol.CollectionEventType.REMOVE, function(e) {
             removed = e.element;
           });
@@ -154,7 +154,7 @@ describe('ol.collection', function() {
     it('does dispatch events', function() {
       var collection = new ol.Collection(['a']);
       var removed;
-      goog.events.listen(
+      ol.events.listen(
           collection, ol.CollectionEventType.REMOVE, function(e) {
             removed = e.element;
           });
@@ -167,7 +167,7 @@ describe('ol.collection', function() {
     it('does dispatch events', function() {
       var collection = new ol.Collection([0, 2]);
       var added;
-      goog.events.listen(
+      ol.events.listen(
           collection, ol.CollectionEventType.ADD, function(e) {
             added = e.element;
           });
@@ -179,7 +179,7 @@ describe('ol.collection', function() {
   describe('setAt beyond end', function() {
     it('triggers events properly', function() {
       var added = [];
-      goog.events.listen(
+      ol.events.listen(
           collection, ol.CollectionEventType.ADD, function(e) {
             added.push(e.element);
           });
@@ -200,7 +200,7 @@ describe('ol.collection', function() {
     beforeEach(function() {
       collection = new ol.Collection([0, 1, 2]);
       cb = sinon.spy();
-      goog.events.listen(collection, 'change:length', cb);
+      ol.events.listen(collection, 'change:length', cb);
     });
 
     describe('insertAt', function() {
@@ -229,7 +229,7 @@ describe('ol.collection', function() {
     it('triggers add when pushing', function() {
       var collection = new ol.Collection();
       var elem;
-      goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
+      ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
         elem = e.element;
       });
       collection.push(1);
@@ -246,8 +246,8 @@ describe('ol.collection', function() {
     });
     describe('setAt', function() {
       it('triggers remove', function() {
-        goog.events.listen(collection, ol.CollectionEventType.ADD, cb1);
+        ol.events.listen(collection, ol.CollectionEventType.ADD, cb1);
-        goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb2);
+        ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb2);
         collection.setAt(0, 2);
         expect(cb2.lastCall.args[0].element).to.eql(1);
         expect(cb1.lastCall.args[0].element).to.eql(2);
@@ -255,7 +255,7 @@ describe('ol.collection', function() {
     });
     describe('pop', function() {
       it('triggers remove', function() {
-        goog.events.listen(collection, ol.CollectionEventType.REMOVE, cb1);
+        ol.events.listen(collection, ol.CollectionEventType.REMOVE, cb1);
         collection.pop();
         expect(cb1.lastCall.args[0].element).to.eql(1);
       });
@@ -273,7 +273,7 @@ describe('ol.collection', function() {
     it('fires events', function() {
       var collection = new ol.Collection();
       var elems = [];
-      goog.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
+      ol.events.listen(collection, ol.CollectionEventType.ADD, function(e) {
         elems.push(e.element);
       });
       collection.extend([1, 2]);
@@ -284,6 +284,6 @@ describe('ol.collection', function() {
 });
 
 
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.Collection');
 goog.require('ol.CollectionEventType');

test/spec/ol/feature.test.js

@@ -462,7 +462,7 @@ describe('ol.Feature.createStyleFunction()', function() {
 });
 
 
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('goog.object');
 goog.require('ol.Feature');
 goog.require('ol.geom.Point');

test/spec/ol/featureloader.test.js

@@ -69,7 +69,7 @@ describe('ol.featureloader', function() {
       var url = 'spec/ol/data/point.json';
       var format = new ol.format.GeoJSON();
       loader = ol.featureloader.tile(url, format);
-      goog.events.listen(tile, 'change', function(e) {
+      ol.events.listen(tile, 'change', function(e) {
         expect(tile.getFeatures().length).to.be.greaterThan(0);
         done();
       });
@@ -81,7 +81,7 @@ describe('ol.featureloader', function() {
           var url = 'spec/ol/data/14-8938-5680.vector.pbf';
           var format = new ol.format.MVT();
           loader = ol.featureloader.tile(url, format);
-          goog.events.listen(tile, 'change', function(e) {
+          ol.events.listen(tile, 'change', function(e) {
             expect(tile.getFeatures().length).to.be.greaterThan(0);
             expect(tile.getProjection().getUnits()).to.be('tile-pixels');
             done();
@@ -93,7 +93,7 @@ describe('ol.featureloader', function() {
 
 });
 
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.VectorTile');
 goog.require('ol.featureloader');
 goog.require('ol.format.GeoJSON');

test/spec/ol/interaction/drawinteraction.test.js

@@ -51,11 +51,11 @@ describe('ol.interaction.Draw', function() {
     var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false;
     var event = new ol.MapBrowserPointerEvent(type, map,
         new ol.pointer.PointerEvent(type,
-            new goog.events.BrowserEvent({
+            {
               clientX: position.x + x + width / 2,
               clientY: position.y + y + height / 2,
               shiftKey: shiftKey
-            })));
+            }));
     map.handleMapBrowserEvent(event);
   }
 
@@ -163,8 +163,8 @@ describe('ol.interaction.Draw', function() {
     it('triggers draw events', function() {
       var ds = sinon.spy();
       var de = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
       simulateEvent('pointermove', 10, 20);
       simulateEvent('pointerdown', 10, 20);
       simulateEvent('pointerup', 10, 20);
@@ -180,7 +180,7 @@ describe('ol.interaction.Draw', function() {
         end: 0,
         addfeature: 0
       };
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND,
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND,
           function() {
             expect(receivedEvents.end).to.be(0);
             expect(receivedEvents.addfeature).to.be(0);
@@ -309,8 +309,8 @@ describe('ol.interaction.Draw', function() {
     it('triggers draw events', function() {
       var ds = sinon.spy();
       var de = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
 
       // first point
       simulateEvent('pointermove', 10, 20);
@@ -467,8 +467,8 @@ describe('ol.interaction.Draw', function() {
     it('triggers draw events', function() {
       var ds = sinon.spy();
       var de = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
 
       // first point
       simulateEvent('pointermove', 10, 20);
@@ -607,8 +607,8 @@ describe('ol.interaction.Draw', function() {
     it('triggers draw events', function() {
       var ds = sinon.spy();
       var de = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, ds);
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWEND, de);
 
       // first point
       simulateEvent('pointermove', 10, 20);
@@ -805,7 +805,7 @@ describe('ol.interaction.Draw', function() {
 
     it('dispatches a drawstart event', function() {
       var spy = sinon.spy();
-      goog.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, spy);
+      ol.events.listen(draw, ol.interaction.DrawEventType.DRAWSTART, spy);
       draw.extend(feature);
       expect(spy.callCount).to.be(1);
     });
@@ -814,8 +814,7 @@ describe('ol.interaction.Draw', function() {
 });
 
 goog.require('goog.dispose');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.BrowserEvent');
 goog.require('goog.style');
 goog.require('ol.Feature');
 goog.require('ol.Map');

test/spec/ol/interaction/interaction.test.js

@@ -11,7 +11,7 @@ describe('ol.interaction.Interaction', function() {
 
     it('creates a new interaction', function() {
       expect(interaction).to.be.a(ol.interaction.Interaction);
-      expect(interaction).to.be.a(goog.events.EventTarget);
+      expect(interaction).to.be.a(ol.events.EventTarget);
     });
 
     it('creates an active interaction', function() {
@@ -55,6 +55,6 @@ describe('ol.interaction.Interaction', function() {
 
 });
 
-goog.require('goog.events.EventTarget');
+goog.require('ol.events.EventTarget');
 goog.require('ol.Map');
 goog.require('ol.interaction.Interaction');

test/spec/ol/interaction/modifyinteraction.test.js

@@ -68,13 +68,13 @@ describe('ol.interaction.Modify', function() {
     var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false;
     var event = new ol.MapBrowserPointerEvent(type, map,
         new ol.pointer.PointerEvent(type,
-            new goog.events.BrowserEvent({
+            {
               type: type,
               button: button,
               clientX: position.x + x + width / 2,
               clientY: position.y + y + height / 2,
               shiftKey: shiftKey
-            })));
+            }));
     event.pointerEvent.pointerId = 1;
     map.handleMapBrowserEvent(event);
   }
@@ -327,8 +327,8 @@ describe('ol.interaction.Modify', function() {
 
     beforeEach(function() {
       getListeners = function(feature, modify) {
-        var listeners = goog.events.getListeners(
+        var listeners = ol.events.getListeners(
-            feature, goog.events.EventType.CHANGE, false);
+            feature, ol.events.EventType.CHANGE);
         return listeners.filter(function(listener) {
           return listener.handler == modify;
         });
@@ -377,9 +377,8 @@ describe('ol.interaction.Modify', function() {
 });
 
 goog.require('goog.dispose');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
-goog.require('goog.events.BrowserEvent');
 goog.require('goog.style');
 goog.require('ol.Collection');
 goog.require('ol.Feature');

test/spec/ol/interaction/selectinteraction.test.js

@@ -82,11 +82,11 @@ describe('ol.interaction.Select', function() {
     var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false;
     var event = new ol.MapBrowserPointerEvent(type, map,
         new ol.pointer.PointerEvent(type,
-            new goog.events.BrowserEvent({
+            {
               clientX: position.x + x + width / 2,
               clientY: position.y + y + height / 2,
               shiftKey: shiftKey
-            })));
+            }));
     map.handleMapBrowserEvent(event);
   }
 
@@ -333,8 +333,6 @@ describe('ol.interaction.Select', function() {
 });
 
 goog.require('goog.dispose');
-goog.require('goog.events');
-goog.require('goog.events.BrowserEvent');
 goog.require('goog.style');
 goog.require('ol.Collection');
 goog.require('ol.Feature');

test/spec/ol/interaction/translateinteraction.test.js

@@ -56,12 +56,11 @@ describe('ol.interaction.Translate', function() {
     var position = goog.style.getClientPosition(viewport);
     var shiftKey = opt_shiftKey !== undefined ? opt_shiftKey : false;
     var event = new ol.MapBrowserPointerEvent(type, map,
-        new ol.pointer.PointerEvent(type,
+        new ol.pointer.PointerEvent(type, {
-        new goog.events.BrowserEvent({
           clientX: position.x + x + width / 2,
           clientY: position.y + y + height / 2,
           shiftKey: shiftKey
-        })));
+        }));
     map.handleMapBrowserEvent(event);
   }
 
@@ -110,8 +109,6 @@ describe('ol.interaction.Translate', function() {
 });
 
 goog.require('goog.dispose');
-goog.require('goog.events');
-goog.require('goog.events.BrowserEvent');
 goog.require('goog.style');
 goog.require('ol.Collection');
 goog.require('ol.Feature');

test/spec/ol/layer/layergroup.test.js

@@ -68,14 +68,14 @@ describe('ol.layer.Group', function() {
     });
 
     it('is dispatched by the group when layer opacity changes', function() {
-      group.on(goog.events.EventType.CHANGE, listener);
+      group.on(ol.events.EventType.CHANGE, listener);
 
       layer.setOpacity(0.5);
       expect(listener.calledOnce).to.be(true);
     });
 
     it('is dispatched by the group when layer visibility changes', function() {
-      group.on(goog.events.EventType.CHANGE, listener);
+      group.on(ol.events.EventType.CHANGE, listener);
 
       layer.setVisible(false);
       expect(listener.callCount).to.be(1);
@@ -286,14 +286,14 @@ describe('ol.layer.Group', function() {
 
       var listeners = layerGroup.listenerKeys_[goog.getUid(layer)];
       expect(listeners.length).to.eql(2);
-      expect(listeners[0]).to.be.a(goog.events.Listener);
+      expect(typeof listeners[0]).to.be('string');
-      expect(listeners[1]).to.be.a(goog.events.Listener);
+      expect(typeof listeners[1]).to.be('string');
 
       // remove the layer from the group
       layers.pop();
       expect(goog.object.getCount(layerGroup.listenerKeys_)).to.eql(0);
-      expect(listeners[0].removed).to.eql(true);
+      expect(ol.events.listenersByKey_[listeners[0]]).to.be(undefined);
-      expect(listeners[1].removed).to.eql(true);
+      expect(ol.events.listenersByKey_[listeners[1]]).to.be(undefined);
     });
 
   });
@@ -491,8 +491,8 @@ describe('ol.layer.Group', function() {
 
 goog.require('goog.array');
 goog.require('goog.dispose');
-goog.require('goog.events.EventType');
+goog.require('ol.events');
-goog.require('goog.events.Listener');
+goog.require('ol.events.EventType');
 goog.require('goog.object');
 goog.require('ol.ObjectEventType');
 goog.require('ol.extent');

test/spec/ol/map.test.js

@@ -212,7 +212,7 @@ describe('ol.Map', function() {
         target: document.createElement('div')
       });
       var viewportResizeListeners = map.viewportSizeMonitor_.getListeners(
-          goog.events.EventType.RESIZE, false);
+          ol.events.EventType.RESIZE, false);
       expect(viewportResizeListeners).to.have.length(1);
     });
 
@@ -220,7 +220,7 @@ describe('ol.Map', function() {
       it('unregisters the viewport resize listener', function() {
         map.setTarget(null);
         var viewportResizeListeners = map.viewportSizeMonitor_.getListeners(
-            goog.events.EventType.RESIZE, false);
+            ol.events.EventType.RESIZE, false);
         expect(viewportResizeListeners).to.have.length(0);
       });
     });
@@ -230,7 +230,7 @@ describe('ol.Map', function() {
         map.setTarget(null);
         map.setTarget(document.createElement('div'));
         var viewportResizeListeners = map.viewportSizeMonitor_.getListeners(
-            goog.events.EventType.RESIZE, false);
+            ol.events.EventType.RESIZE, false);
         expect(viewportResizeListeners).to.have.length(1);
       });
     });
@@ -316,15 +316,15 @@ describe('ol.Map', function() {
           target: target
         });
 
-        var browserEvent = new goog.events.BrowserEvent({
+        var browserEvent = {
           type: 'touchend',
           target: target,
           changedTouches: [{
             clientX: 100,
             clientY: 200
           }]
-        });
+        };
-        var position = map.getEventPixel(browserEvent.getBrowserEvent());
+        var position = map.getEventPixel(browserEvent);
         // 80 = clientX - target.style.left
         expect(position[0]).to.eql(80);
         // 190 = clientY - target.style.top
@@ -401,8 +401,7 @@ describe('ol.Map', function() {
 
 goog.require('goog.dispose');
 goog.require('goog.dom');
-goog.require('goog.events.BrowserEvent');
+goog.require('ol.events.EventType');
-goog.require('goog.events.EventType');
 goog.require('ol.Map');
 goog.require('ol.MapEvent');
 goog.require('ol.Overlay');

test/spec/ol/mapbrowserevent.test.js

@@ -17,13 +17,13 @@ describe('ol.MapBrowserEventHandler', function() {
       }));
 
       clickSpy = sinon.spy();
-      goog.events.listen(handler, 'click', clickSpy);
+      ol.events.listen(handler, 'click', clickSpy);
 
       singleclickSpy = sinon.spy();
-      goog.events.listen(handler, 'singleclick', singleclickSpy);
+      ol.events.listen(handler, 'singleclick', singleclickSpy);
 
       dblclickSpy = sinon.spy();
-      goog.events.listen(handler, 'dblclick', dblclickSpy);
+      ol.events.listen(handler, 'dblclick', dblclickSpy);
 
     });
 
@@ -32,24 +32,22 @@ describe('ol.MapBrowserEventHandler', function() {
     });
 
     it('emulates click', function() {
-      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown',
+      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', {
-          new goog.events.BrowserEvent({
+        type: 'mousedown',
-            type: 'mousedown',
+        target: target,
-            target: target,
+        clientX: 0,
-            clientX: 0,
+        clientY: 0
-            clientY: 0
+      }));
-          })));
       expect(clickSpy.called).to.be.ok();
     });
 
     it('emulates singleclick', function() {
-      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown',
+      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', {
-          new goog.events.BrowserEvent({
+        type: 'mousedown',
-            type: 'mousedown',
+        target: target,
-            target: target,
+        clientX: 0,
-            clientX: 0,
+        clientY: 0
-            clientY: 0
+      }));
-          })));
       expect(singleclickSpy.called).to.not.be.ok();
       expect(dblclickSpy.called).to.not.be.ok();
 
@@ -57,35 +55,32 @@ describe('ol.MapBrowserEventHandler', function() {
       expect(singleclickSpy.calledOnce).to.be.ok();
       expect(dblclickSpy.called).to.not.be.ok();
 
-      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown',
+      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', {
-          new goog.events.BrowserEvent({
+        type: 'mousedown',
-            type: 'mousedown',
+        target: target,
-            target: target,
+        clientX: 0,
-            clientX: 0,
+        clientY: 0
-            clientY: 0
+      }));
-          })));
       expect(singleclickSpy.calledOnce).to.be.ok();
       expect(dblclickSpy.called).to.not.be.ok();
     });
 
     it('emulates dblclick', function() {
-      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown',
+      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', {
-          new goog.events.BrowserEvent({
+        type: 'mousedown',
-            type: 'mousedown',
+        target: target,
-            target: target,
+        clientX: 0,
-            clientX: 0,
+        clientY: 0
-            clientY: 0
+      }));
-          })));
       expect(singleclickSpy.called).to.not.be.ok();
       expect(dblclickSpy.called).to.not.be.ok();
 
-      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown',
+      handler.emulateClick_(new ol.pointer.PointerEvent('pointerdown', {
-          new goog.events.BrowserEvent({
+        type: 'mousedown',
-            type: 'mousedown',
+        target: target,
-            target: target,
+        clientX: 0,
-            clientX: 0,
+        clientY: 0
-            clientY: 0
+      }));
-          })));
       expect(singleclickSpy.called).to.not.be.ok();
       expect(dblclickSpy.calledOnce).to.be.ok();
 
@@ -108,8 +103,7 @@ describe('ol.MapBrowserEventHandler', function() {
     });
 
     it('is an event after handlePointerDown_ has been called', function() {
-      var event = new ol.pointer.PointerEvent('pointerdown',
+      var event = new ol.pointer.PointerEvent('pointerdown', {});
-          new goog.events.BrowserEvent({}));
       handler.handlePointerDown_(event);
       expect(handler.down_).to.be(event);
     });
@@ -118,8 +112,7 @@ describe('ol.MapBrowserEventHandler', function() {
 });
 
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.BrowserEvent');
 goog.require('ol.Map');
 goog.require('ol.MapBrowserEventHandler');
 goog.require('ol.pointer.PointerEvent');

test/spec/ol/object.test.js

@@ -113,10 +113,10 @@ describe('ol.Object', function() {
 
     beforeEach(function() {
       listener1 = sinon.spy();
-      goog.events.listen(o, 'change:k', listener1);
+      ol.events.listen(o, 'change:k', listener1);
 
       listener2 = sinon.spy();
-      goog.events.listen(o, ol.ObjectEventType.PROPERTYCHANGE, listener2);
+      ol.events.listen(o, ol.ObjectEventType.PROPERTYCHANGE, listener2);
     });
 
     it('dispatches events', function() {
@@ -146,10 +146,10 @@ describe('ol.Object', function() {
 
     beforeEach(function() {
       listener1 = sinon.spy();
-      goog.events.listen(o, 'change:k', listener1);
+      ol.events.listen(o, 'change:k', listener1);
 
       listener2 = sinon.spy();
-      goog.events.listen(o, ol.ObjectEventType.PROPERTYCHANGE, listener2);
+      ol.events.listen(o, ol.ObjectEventType.PROPERTYCHANGE, listener2);
     });
 
     it('dispatches events to object', function() {
@@ -222,9 +222,9 @@ describe('ol.Object', function() {
 
     beforeEach(function() {
       listener1 = sinon.spy();
-      goog.events.listen(o, 'change:k', listener1);
+      ol.events.listen(o, 'change:k', listener1);
       listener2 = sinon.spy();
-      goog.events.listen(o, 'change:K', listener2);
+      ol.events.listen(o, 'change:K', listener2);
     });
 
     it('dispatches the expected event', function() {
@@ -239,6 +239,6 @@ describe('ol.Object', function() {
 });
 
 
-goog.require('goog.events');
+goog.require('ol.events');
 goog.require('ol.Object');
 goog.require('ol.ObjectEventType');

test/spec/ol/observable.test.js

@@ -7,7 +7,7 @@ describe('ol.Observable', function() {
     it('creates a new observable', function() {
       var observable = new ol.Observable();
       expect(observable).to.be.a(ol.Observable);
-      expect(observable).to.be.a(goog.events.EventTarget);
+      expect(observable).to.be.a(ol.events.EventTarget);
     });
 
   });
@@ -51,7 +51,7 @@ describe('ol.Observable', function() {
     it('returns a listener key', function() {
       var key = observable.on('foo', listener);
 
-      expect(key).to.be.a(goog.events.Listener);
+      expect(typeof key).to.be('string');
     });
 
   });
@@ -101,7 +101,7 @@ describe('ol.Observable', function() {
     it('returns a listener key', function() {
       var key = observable.once('foo', listener);
 
-      expect(key).to.be.a(goog.events.Listener);
+      expect(typeof key).to.be('string');
     });
 
   });
@@ -167,6 +167,5 @@ describe('ol.Observable', function() {
 });
 
 
-goog.require('goog.events.EventTarget');
+goog.require('ol.events.EventTarget');
-goog.require('goog.events.Listener');
 goog.require('ol.Observable');

test/spec/ol/pointer/mousesource.test.js

@@ -8,7 +8,7 @@ describe('ol.pointer.MouseSource', function() {
 
   beforeEach(function() {
     clock = sinon.useFakeTimers();
-    target = goog.dom.createElement('DIV');
+    target = new ol.events.EventTarget();
 
     // make sure that a mouse and touch event source is used
     ol.has.POINTER = false;
@@ -26,7 +26,7 @@ describe('ol.pointer.MouseSource', function() {
 
   describe('simulated mouse events', function() {
     it('prevents simulated mouse events', function() {
-      goog.events.listen(handler, 'pointerdown', eventSpy);
+      ol.events.listen(handler, 'pointerdown', eventSpy);
 
       // simulates that a mouse event is triggered from a touch
       simulateTouchEvent('touchstart', 10, 20);
@@ -37,7 +37,7 @@ describe('ol.pointer.MouseSource', function() {
     });
 
     it('dispatches real mouse events', function() {
-      goog.events.listen(handler, 'pointerdown', eventSpy);
+      ol.events.listen(handler, 'pointerdown', eventSpy);
 
       // the two events are at different positions
       simulateTouchEvent('touchstart', 10, 20);
@@ -50,7 +50,7 @@ describe('ol.pointer.MouseSource', function() {
       // set the timeout to a lower value, to speed up the tests
       ol.pointer.TouchSource.DEDUP_TIMEOUT = 100;
 
-      goog.events.listen(handler, 'pointerdown', eventSpy);
+      ol.events.listen(handler, 'pointerdown', eventSpy);
 
       // first simulate a touch event, then a mouse event
       // at the same position after a timeout
@@ -70,28 +70,28 @@ describe('ol.pointer.MouseSource', function() {
       target: target
     }];
 
-    var event = new goog.events.BrowserEvent({
+    var event = {
       type: type,
       touches: touches,
       changedTouches: touches
-    });
+    };
-    goog.events.fireListeners(target, type, false, event);
+    ol.events.fireListeners(target, type, event);
   }
 
   function simulateEvent(type, x, y) {
-    var event = new goog.events.BrowserEvent({
+    var event = {
       type: type,
       clientX: x,
       clientY: y,
       target: target
-    });
+    };
-    goog.events.fireListeners(target, type, false, event);
+    ol.events.fireListeners(target, type, event);
   }
 });
 
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.BrowserEvent');
+goog.require('ol.events.EventTarget');
 goog.require('ol.has');
 goog.require('ol.pointer.MouseSource');
 goog.require('ol.pointer.PointerEvent');

test/spec/ol/pointer/pointereventhandler.test.js

@@ -6,7 +6,7 @@ describe('ol.pointer.PointerEventHandler', function() {
   var eventSpy;
 
   beforeEach(function() {
-    target = goog.dom.createElement('DIV');
+    target = new ol.events.EventTarget();
 
     // make sure that a mouse event source is used
     ol.has.POINTER = false;
@@ -29,18 +29,18 @@ describe('ol.pointer.PointerEventHandler', function() {
   });
 
   function simulateEvent(type, x, y) {
-    var event = new goog.events.BrowserEvent({
+    var event = {
       type: type,
       clientX: x,
       clientY: y,
       target: target
-    });
+    };
-    goog.events.fireListeners(target, type, false, event);
+    ol.events.fireListeners(target, type, event);
   }
 
   describe('pointer down', function() {
     it('fires pointerdown events', function() {
-      goog.events.listen(handler, 'pointerdown', eventSpy);
+      ol.events.listen(handler, 'pointerdown', eventSpy);
       simulateEvent('mousedown', 0, 0);
       expect(eventSpy.calledOnce).to.be.ok();
 
@@ -54,7 +54,7 @@ describe('ol.pointer.PointerEventHandler', function() {
 
   describe('pointer up', function() {
     it('fires pointerup events', function() {
-      goog.events.listen(handler, 'pointerup', eventSpy);
+      ol.events.listen(handler, 'pointerup', eventSpy);
       simulateEvent('mousedown', 0, 0);
       simulateEvent('mouseup', 0, 0);
       expect(eventSpy.calledOnce).to.be.ok();
@@ -63,7 +63,7 @@ describe('ol.pointer.PointerEventHandler', function() {
 
   describe('pointer move', function() {
     it('fires pointermove events', function() {
-      goog.events.listen(handler, 'pointermove', eventSpy);
+      ol.events.listen(handler, 'pointermove', eventSpy);
       simulateEvent('mousemove', 0, 0);
       expect(eventSpy.calledOnce).to.be.ok();
     });
@@ -74,8 +74,8 @@ describe('ol.pointer.PointerEventHandler', function() {
       var enterEventSpy = sinon.spy();
       var overEventSpy = sinon.spy();
 
-      goog.events.listen(handler, 'pointerenter', enterEventSpy);
+      ol.events.listen(handler, 'pointerenter', enterEventSpy);
-      goog.events.listen(handler, 'pointerover', overEventSpy);
+      ol.events.listen(handler, 'pointerover', overEventSpy);
 
       simulateEvent('mouseover', 0, 0);
 
@@ -89,8 +89,8 @@ describe('ol.pointer.PointerEventHandler', function() {
       var leaveEventSpy = sinon.spy();
       var outEventSpy = sinon.spy();
 
-      goog.events.listen(handler, 'pointerleave', leaveEventSpy);
+      ol.events.listen(handler, 'pointerleave', leaveEventSpy);
-      goog.events.listen(handler, 'pointerout', outEventSpy);
+      ol.events.listen(handler, 'pointerout', outEventSpy);
 
       simulateEvent('mouseout', 0, 0);
 
@@ -107,7 +107,7 @@ describe('ol.pointer.PointerEventHandler', function() {
         clientX: 1,
         clientY: 2
       };
-      var browserEvent = new goog.events.BrowserEvent(event);
+      var browserEvent = event;
 
       var eventClone = handler.cloneEvent(browserEvent, event);
 
@@ -136,7 +136,7 @@ describe('ol.pointer.PointerEventHandler', function() {
         clientX: 1,
         clientY: 2
       };
-      var browserEvent = new goog.events.BrowserEvent(event);
+      var browserEvent = event;
 
       var eventClone = handler.cloneEvent(browserEvent, event);
       var pointerEvent = handler.makeEvent('pointerdown',
@@ -161,8 +161,8 @@ describe('ol.pointer.PointerEventHandler', function() {
 });
 
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.BrowserEvent');
+goog.require('ol.events.EventTarget');
 goog.require('ol.has');
 goog.require('ol.pointer.MouseSource');
 goog.require('ol.pointer.PointerEvent');

test/spec/ol/pointer/touchsource.test.js

@@ -8,7 +8,7 @@ describe('ol.pointer.TouchSource', function() {
   var eventSpy;
 
   beforeEach(function() {
-    target = goog.dom.createElement('DIV');
+    target = new ol.events.EventTarget();
 
     // make sure that a mouse and touch event source is used
     ol.has.POINTER = false;
@@ -25,7 +25,7 @@ describe('ol.pointer.TouchSource', function() {
 
   describe('pointer event creation', function() {
     it('generates pointer events for each touch contact', function() {
-      goog.events.listen(handler, 'pointerdown', eventSpy);
+      ol.events.listen(handler, 'pointerdown', eventSpy);
 
       simulateTouchEvent('touchstart', [
         {identifier: 3, clientX: 10, clientY: 11},
@@ -52,7 +52,7 @@ describe('ol.pointer.TouchSource', function() {
     });
 
     it('creates the right pointer events', function() {
-      goog.events.listen(handler, 'pointerdown', eventSpy);
+      ol.events.listen(handler, 'pointerdown', eventSpy);
 
       // first touch
       simulateTouchEvent('touchstart', [
@@ -71,7 +71,7 @@ describe('ol.pointer.TouchSource', function() {
 
       // first touch moves
       var moveEventSpy = sinon.spy();
-      goog.events.listen(handler, 'pointermove', moveEventSpy);
+      ol.events.listen(handler, 'pointermove', moveEventSpy);
 
       simulateTouchEvent('touchmove', [
         {identifier: 3, clientX: 15, clientY: 16}
@@ -81,7 +81,7 @@ describe('ol.pointer.TouchSource', function() {
 
       // and then both touches go up
       var upEventSpy = sinon.spy();
-      goog.events.listen(handler, 'pointerup', upEventSpy);
+      ol.events.listen(handler, 'pointerup', upEventSpy);
 
       simulateTouchEvent('touchend', [
         {identifier: 3, clientX: 15, clientY: 16},
@@ -93,7 +93,7 @@ describe('ol.pointer.TouchSource', function() {
     });
 
     it('handles flawed touches', function() {
-      goog.events.listen(handler, 'pointerdown', eventSpy);
+      ol.events.listen(handler, 'pointerdown', eventSpy);
 
       // first touch
       simulateTouchEvent('touchstart', [
@@ -104,7 +104,7 @@ describe('ol.pointer.TouchSource', function() {
 
       // second touch, but the first touch has disappeared
       var cancelEventSpy = sinon.spy();
-      goog.events.listen(handler, 'pointercancel', cancelEventSpy);
+      ol.events.listen(handler, 'pointercancel', cancelEventSpy);
       simulateTouchEvent('touchstart', [
         {identifier: 4, clientX: 30, clientY: 45}
       ], [{identifier: 4}]
@@ -120,18 +120,19 @@ describe('ol.pointer.TouchSource', function() {
   function simulateTouchEvent(type, changedTouches, touches) {
     touches = touches !== undefined ? touches : changedTouches;
 
-    var event = new goog.events.BrowserEvent({
+    var event = new ol.events.Event(type);
-      type: type,
+    goog.object.extend(event, {
       touches: touches,
       changedTouches: changedTouches
     });
-    goog.events.fireListeners(target, type, false, event);
+    ol.events.fireListeners(target, type, event);
   }
 });
 
 goog.require('goog.dom');
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.BrowserEvent');
+goog.require('ol.events.Event');
+goog.require('ol.events.EventTarget');
 goog.require('ol.has');
 goog.require('ol.pointer.PointerEvent');
 goog.require('ol.pointer.PointerEventHandler');

test/spec/ol/render/vector.test.js

@@ -39,8 +39,8 @@ describe('ol.renderer.vector', function() {
             style, squaredTolerance, listener, listenerThis);
 
         expect(iconStyleLoadSpy.calledOnce).to.be.ok();
-        listeners = goog.events.getListeners(
+        listeners = ol.events.getListeners(
-            iconStyle.iconImage_, goog.events.EventType.CHANGE, false);
+            iconStyle.iconImage_, ol.events.EventType.CHANGE);
         expect(listeners.length).to.eql(1);
 
         // call #2
@@ -48,8 +48,8 @@ describe('ol.renderer.vector', function() {
             style, squaredTolerance, listener, listenerThis);
 
         expect(iconStyleLoadSpy.calledOnce).to.be.ok();
-        listeners = goog.events.getListeners(
+        listeners = ol.events.getListeners(
-            iconStyle.iconImage_, goog.events.EventType.CHANGE, false);
+            iconStyle.iconImage_, ol.events.EventType.CHANGE);
         expect(listeners.length).to.eql(1);
       });
 
@@ -155,8 +155,8 @@ describe('ol.renderer.vector', function() {
   });
 });
 
-goog.require('goog.events');
+goog.require('ol.events');
-goog.require('goog.events.EventType');
+goog.require('ol.events.EventType');
 goog.require('ol.geom.LineString');
 goog.require('ol.geom.Point');
 goog.require('ol.geom.Polygon');