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/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];
+    }
+  }
+};