Remove support for useCapture

src/ol/events.js

@@ -96,8 +96,7 @@ ol.events.ListenerFunctionType;
  *     callOnce: boolean,
  *     listener: ol.events.ListenerFunctionType,
  *     target: (EventTarget|ol.events.EventTarget),
- *     type: (ol.events.EventType|string),
+ *     type: (ol.events.EventType|string)}}
- *     useCapture: boolean}}
  */
 ol.events.ListenerObjType;
 
@@ -127,19 +126,16 @@ ol.events.bindListener_ = function(listenerObj) {
  * @param {!Function} listener The listener function.
  * @param {Object=} opt_this The `this` value inside the listener.
  * @param {boolean=} opt_remove Remove the found listener from the array.
- * @param {boolean=} opt_useCapture The capture flag for the listener.
  * @return {ol.events.ListenerObjType|undefined} The matching listener.
  * @private
  */
 ol.events.findListener_ = function(
-    listenerArray, listener, opt_this, opt_remove, opt_useCapture) {
+    listenerArray, listener, opt_this, opt_remove) {
   var listenerObj;
-  var useCapture = !!opt_useCapture;
   for (var i = 0, ii = listenerArray.length; i < ii; ++i) {
     listenerObj = listenerArray[i];
     if (listenerObj.listener === listener &&
-        listenerObj.bindTo === opt_this &&
+        listenerObj.bindTo === opt_this) {
-        listenerObj.useCapture === useCapture) {
       if (opt_remove) {
         listenerArray.splice(i, 1);
       }
@@ -177,23 +173,17 @@ ol.events.getListeners = function(target, type) {
  * @param {Object=} opt_this Object referenced by the `this` keyword in the
  *     listener. Default is the `target`.
  * @param {boolean=} opt_once If true, add the listener as one-off 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.
  * @return {ol.events.Key} Unique key for the listener.
  */
-ol.events.listen = function(
+ol.events.listen = function(target, type, listener, opt_this, opt_once) {
-    target, type, listener, opt_this, opt_once, opt_useCapture) {
   if (Array.isArray(type)) {
     var keys = [];
     type.forEach(function(t) {
-      keys.push(ol.events.listen(target, t, listener, opt_this, opt_once,
+      keys.push(ol.events.listen(target, t, listener, opt_this, opt_once));
-          opt_useCapture));
     });
     return keys;
   }
 
-  var useCapture = !!opt_useCapture;
   var listenerMap = target[ol.events.LISTENER_MAP_PROP_];
   if (!listenerMap) {
     target[ol.events.LISTENER_MAP_PROP_] = listenerMap = {};
@@ -203,7 +193,7 @@ ol.events.listen = function(
     listenerArray = listenerMap[type] = [];
   }
   var listenerObj = ol.events.findListener_(listenerArray, listener, opt_this,
-      false, useCapture);
+      false);
   if (listenerObj) {
     if (!opt_once) {
       // Turn one-off listener into a permanent one.
@@ -215,11 +205,9 @@ ol.events.listen = function(
       callOnce: !!opt_once,
       listener: listener,
       target: target,
-      type: type,
+      type: type
-      useCapture: useCapture
     });
-    target.addEventListener(type, ol.events.bindListener_(listenerObj),
+    target.addEventListener(type, ol.events.bindListener_(listenerObj));
-        useCapture);
     listenerArray.push(listenerObj);
   }
 
@@ -246,15 +234,11 @@ ol.events.listen = function(
  * @param {ol.events.ListenerFunctionType} listener Listener.
  * @param {Object=} opt_this Object referenced by the `this` keyword in the
  *     listener. Default is the `target`.
- * @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.
  * @return {ol.events.Key} Key for unlistenByKey.
  */
 ol.events.listenOnce = function(
-    target, type, listener, opt_this, opt_useCapture) {
+    target, type, listener, opt_this) {
-  return ol.events.listen(target, type, listener, opt_this, true,
+  return ol.events.listen(target, type, listener, opt_this, true);
-      opt_useCapture);
 };
 
 
@@ -271,15 +255,11 @@ ol.events.listenOnce = function(
  * @param {ol.events.ListenerFunctionType} listener Listener.
  * @param {Object=} opt_this Object referenced by the `this` keyword in the
  *     listener. Default is the `target`.
- * @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.
  */
-ol.events.unlisten = function(
+ol.events.unlisten = function(target, type, listener, opt_this) {
-    target, type, listener, opt_this, opt_useCapture) {
   if (Array.isArray(type)) {
     type.forEach(function(t) {
-      ol.events.unlisten(target, t, listener, opt_this, opt_useCapture);
+      ol.events.unlisten(target, t, listener, opt_this);
     });
     return;
   }
@@ -287,7 +267,7 @@ ol.events.unlisten = function(
   var listenerArray = ol.events.getListeners(target, type);
   if (listenerArray) {
     var listenerObj = ol.events.findListener_(listenerArray, listener,
-        opt_this, false, !!opt_useCapture);
+        opt_this, false);
     if (listenerObj) {
       ol.events.unlistenByKey(listenerObj);
     }
@@ -311,11 +291,10 @@ ol.events.unlistenByKey = function(key) {
   }
 
   if (key && key.target) {
-    key.target.removeEventListener(key.type, key.boundListener, key.useCapture);
+    key.target.removeEventListener(key.type, key.boundListener);
     var listenerArray = ol.events.getListeners(key.target, key.type);
     if (listenerArray) {
-      ol.events.findListener_(listenerArray, key.listener,
+      ol.events.findListener_(listenerArray, key.listener, key.bindTo, true);
-          key.bindTo, true, key.useCapture);
       if (listenerArray.length === 0) {
         var listenerMap = key.target[ol.events.LISTENER_MAP_PROP_];
         delete listenerMap[key.type];

src/ol/events/eventtarget.js

@@ -12,12 +12,7 @@ goog.require('ol.events.Event');
  * There are two important simplifications compared to the specification:
  *
  * 1. The handling of `useCapture` in `addEventListener` and
- *    `removeEventListener`. There is no real capture model. Instead, when
+ *    `removeEventListener`. There is no real capture model.
- *    adding a listener, `useCapture` means that it will be added as first
- *    listener, causing it to be called before other listeners. When removing a
- *    listener, the `useCapture` argument will be ignored, and the listener will
- *    be removed regardless of whether it was added with `useCapture` set to
- *    true or false.
  * 2. The handling of `stopPropagation` and `preventDefault` on `dispatchEvent`.
  *    There is no event target hierarchy. When a listener calls
  *    `stopPropagation` or `preventDefault` on an event object, it means that no
@@ -44,21 +39,15 @@ 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) {
+    type, listener) {
   var listeners = this.listeners_[type];
   if (!listeners) {
     listeners = this.listeners_[type] = [];
   }
   if (listeners.indexOf(listener) === -1) {
-    if (opt_capture) {
+    listeners.unshift(listener);
-      listeners.push(listener);
-    } else {
-      listeners.unshift(listener);
-    }
   }
 };
 
@@ -122,10 +111,8 @@ ol.events.EventTarget.prototype.hasListener = function(opt_type) {
 /**
  * @param {ol.events.EventType|string} type Type.
  * @param {ol.events.ListenerFunctionType} listener Listener.
- * @param {boolean=} opt_capture Ignored. For W3C compatibility only.
  */
-ol.events.EventTarget.prototype.removeEventListener = function(
+ol.events.EventTarget.prototype.removeEventListener = function(type, listener) {
-    type, listener, opt_capture) {
   var listeners = this.listeners_[type];
   if (listeners) {
     var index = listeners.indexOf(listener);

test/spec/ol/events.test.js

@@ -52,8 +52,7 @@ describe('ol.events', function() {
       var listenerObj = {
         type: 'foo',
         target: target,
-        listener: listener,
+        listener: listener
-        useCapture: false
       };
       var listenerArray = [listenerObj];
       var result = ol.events.findListener_(listenerArray, listener);
@@ -105,9 +104,9 @@ describe('ol.events', function() {
     });
     it('only treats listeners as same when all args are equal', function() {
       var listener = function() {};
-      ol.events.listen(target, 'foo', listener, {}, false);
+      ol.events.listen(target, 'foo', listener, {});
-      ol.events.listen(target, 'foo', listener, {}, true);
+      ol.events.listen(target, 'foo', listener, {});
-      ol.events.listen(target, 'foo', listener, undefined, true);
+      ol.events.listen(target, 'foo', listener, undefined);
       expect(add.callCount).to.be(3);
     });
   });
@@ -184,22 +183,23 @@ describe('ol.events', function() {
   });
 
   describe('Compatibility with ol.events.EventTarget', function() {
-    it('works despite different meaning of the useCapture arg', function() {
+    it('does not register duplicated listeners', function() {
       var target = new ol.events.EventTarget();
       var listener = function() {};
-      var key1 = ol.events.listen(target, 'foo', listener, undefined, undefined,
+      var key1 = ol.events.listen(target, 'foo', listener);
-          false);
+      expect(target.getListeners('foo')).to.eql([key1.boundListener]);
+      var key2 = ol.events.listen(target, 'foo', listener);
+      expect(key2.boundListener).to.equal(key1.boundListener);
       expect(target.getListeners('foo')).to.eql([key1.boundListener]);
-      var key2 = ol.events.listen(target, 'foo', listener, undefined, undefined,
-          true);
-      expect(target.getListeners('foo')).to.eql(
-          [key1.boundListener, key2.boundListener]);
     });
-    it('because the created bound listeners are different', function() {
+    it('registers multiple listeners if this object is different', function() {
+      var target = new ol.events.EventTarget();
       var listener = function() {};
-      var key1 = ol.events.listen(target, 'foo', listener, {}, false);
+      var key1 = ol.events.listen(target, 'foo', listener, {});
-      var key2 = ol.events.listen(target, 'foo', listener, {}, true);
+      var key2 = ol.events.listen(target, 'foo', listener, {});
       expect(key1.boundListener).to.not.equal(key2.boundListener);
+      expect(target.getListeners('foo')).to.eql(
+          [key2.boundListener, key1.boundListener]);
     });
   });
 

test/spec/ol/events/eventtarget.test.js

@@ -51,88 +51,62 @@ describe('ol.events.EventTarget', function() {
 
   describe('#addEventListener()', function() {
     it('has listeners for each registered type', function() {
-      eventTarget.addEventListener('foo', spy1, false);
+      eventTarget.addEventListener('foo', spy1);
-      eventTarget.addEventListener('bar', spy2, false);
+      eventTarget.addEventListener('bar', spy2);
       expect(eventTarget.hasListener('foo')).to.be(true);
       expect(eventTarget.hasListener('bar')).to.be(true);
     });
-    it('registers listeners in the order determined by useCapture', function() {
-      eventTarget.addEventListener('foo', spy1, false);
-      eventTarget.addEventListener('foo', spy2, false);
-      eventTarget.addEventListener('foo', spy3, true);
-      expect(eventTarget.getListeners('foo')).to.eql([spy2, spy1, spy3]);
-    });
-    it('does not re-add existing listeners, ignoring useCapture', function() {
-      eventTarget.addEventListener('foo', spy1, false);
-      eventTarget.addEventListener('foo', spy2, false);
-      eventTarget.addEventListener('foo', spy3, true);
-      eventTarget.addEventListener('foo', spy2);
-      eventTarget.addEventListener('foo', spy1, true);
-      eventTarget.addEventListener('foo', spy3, false);
-      expect(eventTarget.getListeners('foo')).to.eql([spy2, spy1, spy3]);
-    });
   });
 
   describe('#removeEventListener()', function() {
     it('keeps the listeners registry clean', function() {
-      eventTarget.addEventListener('foo', spy1, false);
+      eventTarget.addEventListener('foo', spy1);
-      eventTarget.removeEventListener('foo', spy1, false);
+      eventTarget.removeEventListener('foo', spy1);
       expect(eventTarget.hasListener('foo')).to.be(false);
     });
     it('removes added listeners from the listeners registry', function() {
-      eventTarget.addEventListener('foo', spy1, false);
+      eventTarget.addEventListener('foo', spy1);
-      eventTarget.addEventListener('foo', spy2, false);
+      eventTarget.addEventListener('foo', spy2);
       eventTarget.removeEventListener('foo', spy1, false);
       expect(eventTarget.getListeners('foo')).to.have.length(1);
     });
-    it('ignores the useCapture setting when removing listeners', function() {
-      eventTarget.addEventListener('foo', spy1, false);
-      eventTarget.addEventListener('foo', spy2, false);
-      eventTarget.addEventListener('foo', spy3, true);
-      eventTarget.removeEventListener('foo', spy1, true);
-      eventTarget.removeEventListener('foo', spy2);
-      eventTarget.removeEventListener('foo', spy3, false);
-      expect(eventTarget.getListeners('foo')).to.be(undefined);
-    });
   });
 
   describe('#dispatchEvent()', function() {
     it('calls listeners in the correct order', function() {
-      eventTarget.addEventListener('foo', spy1, false);
+      eventTarget.addEventListener('foo', spy1);
-      eventTarget.addEventListener('foo', spy2, false);
+      eventTarget.addEventListener('foo', spy2);
-      eventTarget.addEventListener('foo', spy3, true);
       eventTarget.dispatchEvent('foo');
-      expect(called).to.eql([3, 1, 2]);
+      expect(called).to.eql([1, 2]);
     });
     it('stops propagation when listeners return false', function() {
-      eventTarget.addEventListener('foo', spy1, false);
+      eventTarget.addEventListener('foo', spy1);
       eventTarget.addEventListener('foo', function(evt) {
         spy2();
         return false;
       }, false);
-      eventTarget.addEventListener('foo', spy3, false);
+      eventTarget.addEventListener('foo', spy3);
       eventTarget.dispatchEvent('foo');
       expect(called).to.eql([1, 2]);
     });
     it('stops propagation when listeners call preventDefault()', function() {
-      eventTarget.addEventListener('foo', spy1, false);
       eventTarget.addEventListener('foo', function(evt) {
         spy2();
         evt.preventDefault();
-      }, true);
+      });
-      eventTarget.addEventListener('foo', spy3, false);
+      eventTarget.addEventListener('foo', spy1);
       eventTarget.dispatchEvent('foo');
       expect(called).to.eql([2]);
     });
     it('passes a default ol.events.Event object to listeners', function() {
-      eventTarget.addEventListener('foo', spy1, false);
+      eventTarget.addEventListener('foo', spy1);
       eventTarget.dispatchEvent('foo');
       expect(events[0]).to.be.a(ol.events.Event);
       expect(events[0].type).to.be('foo');
       expect(events[0].target).to.equal(eventTarget);
     });
     it('passes a custom event object with target to listeners', function() {
-      eventTarget.addEventListener('foo', spy1, false);
+      eventTarget.addEventListener('foo', spy1);
       var event = {
         type: 'foo'
       };