ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove support for useCapture

Browse Source
This commit is contained in:
Tim Schaub
2016-02-02 08:29:11 -07:00
committed by Andreas Hocevar
parent 80df1f5ae8
commit c62e76ab67
4 changed files with 49 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
src/ol/events.js
View File

@@ -96,8 +96,7 @@ ol.events.ListenerFunctionType;
* callOnce: boolean,
* listener: ol.events.ListenerFunctionType,
* target: (EventTarget|ol.events.EventTarget),
* type: (ol.events.EventType|string),
* useCapture: boolean}}
* type: (ol.events.EventType|string)}}
*/
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.useCapture === useCapture) {
listenerObj.bindTo === opt_this) {
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(
target, type, listener, opt_this, opt_once, opt_useCapture) {
ol.events.listen = function(target, type, listener, opt_this, opt_once) {
if (Array.isArray(type)) {
var keys = [];
type.forEach(function(t) {
keys.push(ol.events.listen(target, t, listener, opt_this, opt_once,
opt_useCapture));
keys.push(ol.events.listen(target, t, listener, opt_this, opt_once));
});
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,
useCapture: useCapture
type: type
});
target.addEventListener(type, ol.events.bindListener_(listenerObj),
useCapture);
target.addEventListener(type, ol.events.bindListener_(listenerObj));
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) {
return ol.events.listen(target, type, listener, opt_this, true,
opt_useCapture);
target, type, listener, opt_this) {
return ol.events.listen(target, type, listener, opt_this, true);
};
@@ -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(
target, type, listener, opt_this, opt_useCapture) {
ol.events.unlisten = function(target, type, listener, opt_this) {
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,
key.bindTo, true, key.useCapture);
ol.events.findListener_(listenerArray, key.listener, key.bindTo, true);
if (listenerArray.length === 0) {
var listenerMap = key.target[ol.events.LISTENER_MAP_PROP_];
delete listenerMap[key.type];

21
src/ol/events/eventtarget.js
View File

@@ -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
* 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.
* `removeEventListener`. There is no real capture model.
* 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.push(listener);
} else {
listeners.unshift(listener);
}
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(
type, listener, opt_capture) {
ol.events.EventTarget.prototype.removeEventListener = function(type, listener) {
var listeners = this.listeners_[type];
if (listeners) {
var index = listeners.indexOf(listener);

30
test/spec/ol/events.test.js
View File

@@ -52,8 +52,7 @@ describe('ol.events', function() {
var listenerObj = {
type: 'foo',
target: target,
listener: listener,
useCapture: false
listener: listener
};
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, {}, true);
ol.events.listen(target, 'foo', listener, undefined, true);
ol.events.listen(target, 'foo', listener, {});
ol.events.listen(target, 'foo', listener, {});
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,
false);
var key1 = ol.events.listen(target, 'foo', listener);
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 key2 = ol.events.listen(target, 'foo', listener, {}, true);
var key1 = ol.events.listen(target, 'foo', listener, {});
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]);
});
});

56
test/spec/ol/events/eventtarget.test.js
View File

@@ -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('bar', spy2, false);
eventTarget.addEventListener('foo', spy1);
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.removeEventListener('foo', spy1, false);
eventTarget.addEventListener('foo', spy1);
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', spy2, false);
eventTarget.addEventListener('foo', spy1);
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', spy2, false);
eventTarget.addEventListener('foo', spy3, true);
eventTarget.addEventListener('foo', spy1);
eventTarget.addEventListener('foo', spy2);
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'
};