Andreas Hocevar
297 lines
9.0 KiB
JavaScript
297 lines
9.0 KiB
JavaScript
// Copyright 2014 The Closure Library Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS-IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
goog.provide('goog.events.WheelHandlerTest');
|
|
goog.setTestOnly('goog.events.WheelHandlerTest');
|
|
|
|
goog.require('goog.dom');
|
|
goog.require('goog.events');
|
|
goog.require('goog.events.BrowserEvent');
|
|
goog.require('goog.events.WheelEvent');
|
|
goog.require('goog.events.WheelHandler');
|
|
goog.require('goog.string');
|
|
goog.require('goog.testing.PropertyReplacer');
|
|
goog.require('goog.testing.events');
|
|
goog.require('goog.testing.jsunit');
|
|
goog.require('goog.userAgent');
|
|
goog.require('goog.userAgent.product');
|
|
|
|
var log;
|
|
var stubs = new goog.testing.PropertyReplacer();
|
|
|
|
var PREFERRED_TYPE = 'wheel';
|
|
var LEGACY_TYPE = 'mousewheel';
|
|
var GECKO_TYPE = 'DOMMouseScroll';
|
|
|
|
var HORIZONTAL = 'h';
|
|
var VERTICAL = 'v';
|
|
|
|
var DeltaMode = goog.events.WheelEvent.DeltaMode;
|
|
|
|
var mouseWheelEvent;
|
|
var mouseWheelEventRtl;
|
|
var mouseWheelHandler;
|
|
var mouseWheelHandlerRtl;
|
|
|
|
function setUpPage() {
|
|
log = goog.dom.getElement('log');
|
|
}
|
|
|
|
function setUp() {
|
|
stubs.remove(goog, 'userAgent');
|
|
goog.userAgent = {
|
|
product: {
|
|
CHROME: false,
|
|
version: 0,
|
|
isVersion: function(version) {
|
|
return goog.string.compareVersions(this.version, version) >= 0;
|
|
}
|
|
},
|
|
GECKO: false,
|
|
IE: false,
|
|
version: 0,
|
|
isVersionOrHigher: function(version) {
|
|
return goog.string.compareVersions(this.version, version) >= 0;
|
|
}
|
|
};
|
|
}
|
|
|
|
function tearDown() {
|
|
stubs.reset();
|
|
goog.dispose(mouseWheelHandler);
|
|
goog.dispose(mouseWheelHandlerRtl);
|
|
mouseWheelHandlerRtl = null;
|
|
mouseWheelHandler = null;
|
|
mouseWheelEvent = null;
|
|
mouseWheelEventRtl = null;
|
|
}
|
|
|
|
function tearDownPage() {
|
|
// Create interactive demo.
|
|
mouseWheelHandler = new goog.events.WheelHandler(document.body);
|
|
|
|
goog.events.listen(mouseWheelHandler,
|
|
goog.events.WheelEvent.EventType.WHEEL,
|
|
function(e) {
|
|
log.innerHTML += goog.string.subs('<br />(deltaX, deltaY): (%s, %s)',
|
|
e.deltaX, e.deltaY);
|
|
});
|
|
}
|
|
|
|
function testGetDomEventType() {
|
|
// Defaults to legacy non-gecko event.
|
|
assertEquals(LEGACY_TYPE, goog.events.WheelHandler.getDomEventType());
|
|
|
|
// Gecko start to support wheel with version 17.
|
|
goog.userAgent.GECKO = true;
|
|
goog.userAgent.version = 16;
|
|
assertEquals(GECKO_TYPE, goog.events.WheelHandler.getDomEventType());
|
|
goog.userAgent.version = 17;
|
|
assertEquals(PREFERRED_TYPE, goog.events.WheelHandler.getDomEventType());
|
|
goog.userAgent.GECKO = false;
|
|
|
|
// IE started with version 9.
|
|
goog.userAgent.IE = true;
|
|
goog.userAgent.version = 8;
|
|
assertEquals(LEGACY_TYPE, goog.events.WheelHandler.getDomEventType());
|
|
goog.userAgent.version = 9;
|
|
assertEquals(PREFERRED_TYPE, goog.events.WheelHandler.getDomEventType());
|
|
goog.userAgent.IE = false;
|
|
|
|
// Chrome started with version 31.
|
|
goog.userAgent.product.CHROME = true;
|
|
goog.userAgent.product.version = 30;
|
|
assertEquals(LEGACY_TYPE, goog.events.WheelHandler.getDomEventType());
|
|
goog.userAgent.product.version = 31;
|
|
assertEquals(PREFERRED_TYPE, goog.events.WheelHandler.getDomEventType());
|
|
goog.userAgent.product.CHROME = false;
|
|
}
|
|
|
|
function testPreferredStyleWheel() {
|
|
// Enable 'wheel'
|
|
goog.userAgent.IE = true;
|
|
goog.userAgent.version = 9;
|
|
createHandlerAndListen();
|
|
|
|
handleEvent(createFakePreferredEvent(DeltaMode.PIXEL, 10, 20, 30));
|
|
assertWheelEvent(DeltaMode.PIXEL, 10, 20, 30);
|
|
assertPixelDeltas(1);
|
|
|
|
handleEvent(createFakePreferredEvent(DeltaMode.LINE, 10, 20, 30));
|
|
assertWheelEvent(DeltaMode.LINE, 10, 20, 30);
|
|
assertPixelDeltas(15);
|
|
|
|
handleEvent(createFakePreferredEvent(DeltaMode.PAGE, 10, 20, 30));
|
|
assertWheelEvent(DeltaMode.PAGE, 10, 20, 30);
|
|
assertPixelDeltas(30 * 15);
|
|
}
|
|
|
|
function testLegacyStyleWheel() {
|
|
// 'mousewheel' enabled by default
|
|
createHandlerAndListen();
|
|
|
|
// Test one dimensional.
|
|
handleEvent(createFakeLegacyEvent(10));
|
|
assertWheelEvent(DeltaMode.PIXEL, 0, -10, 0);
|
|
assertPixelDeltas(1);
|
|
|
|
// Test two dimensional.
|
|
handleEvent(createFakeLegacyEvent(/* ignored */ 10, 20, 30));
|
|
assertWheelEvent(DeltaMode.PIXEL, -20, -30, 0);
|
|
assertPixelDeltas(1);
|
|
}
|
|
|
|
function testLegacyGeckoStyleWheel() {
|
|
goog.userAgent.GECKO = true;
|
|
createHandlerAndListen();
|
|
|
|
// Test no axis.
|
|
handleEvent(createFakeGeckoEvent(10));
|
|
assertWheelEvent(DeltaMode.LINE, 0, 10, 0);
|
|
assertPixelDeltas(15);
|
|
|
|
// Vertical axis.
|
|
handleEvent(createFakeGeckoEvent(10, VERTICAL));
|
|
assertWheelEvent(DeltaMode.LINE, 0, 10, 0);
|
|
assertPixelDeltas(15);
|
|
|
|
// Horizontal axis.
|
|
handleEvent(createFakeGeckoEvent(10, HORIZONTAL));
|
|
assertWheelEvent(DeltaMode.LINE, 10, 0, 0);
|
|
assertPixelDeltas(15);
|
|
}
|
|
|
|
function testLegacyIeStyleWheel() {
|
|
goog.userAgent.IE = true;
|
|
|
|
createHandlerAndListen();
|
|
|
|
// Non-gecko, non-webkit events get wheelDelta divided by -40 to get detail.
|
|
handleEvent(createFakeLegacyEvent(120));
|
|
assertWheelEvent(DeltaMode.PIXEL, 0, -120, 0);
|
|
|
|
handleEvent(createFakeLegacyEvent(-120));
|
|
assertWheelEvent(DeltaMode.PIXEL, 0, 120, 0);
|
|
|
|
handleEvent(createFakeLegacyEvent(1200));
|
|
assertWheelEvent(DeltaMode.PIXEL, 0, -1200, 0);
|
|
}
|
|
|
|
function testNullBody() {
|
|
goog.userAgent.IE = true;
|
|
var documentObjectWithNoBody = { };
|
|
goog.testing.events.mixinListenable(documentObjectWithNoBody);
|
|
mouseWheelHandler =
|
|
new goog.events.WheelHandler(documentObjectWithNoBody);
|
|
}
|
|
|
|
// Be sure to call this after setting up goog.userAgent mock and not before.
|
|
function createHandlerAndListen() {
|
|
mouseWheelHandler = new goog.events.WheelHandler(
|
|
goog.dom.getElement('foo'));
|
|
|
|
goog.events.listen(mouseWheelHandler,
|
|
goog.events.WheelEvent.EventType.WHEEL,
|
|
function(e) { mouseWheelEvent = e; });
|
|
|
|
mouseWheelHandlerRtl = new goog.events.WheelHandler(
|
|
goog.dom.getElement('fooRtl'));
|
|
|
|
goog.events.listen(mouseWheelHandlerRtl,
|
|
goog.events.WheelEvent.EventType.WHEEL,
|
|
function(e) { mouseWheelEventRtl = e; });
|
|
}
|
|
|
|
function handleEvent(event) {
|
|
mouseWheelHandler.handleEvent(event);
|
|
mouseWheelHandlerRtl.handleEvent(event);
|
|
}
|
|
|
|
function assertWheelEvent(deltaMode, deltaX, deltaY, deltaZ) {
|
|
assertTrue('event should be non-null', !!mouseWheelEvent);
|
|
assertTrue('event should have correct JS type',
|
|
mouseWheelEvent instanceof goog.events.WheelEvent);
|
|
assertEquals('event should have correct deltaMode property',
|
|
deltaMode, mouseWheelEvent.deltaMode);
|
|
assertEquals('event should have correct deltaX property',
|
|
deltaX, mouseWheelEvent.deltaX);
|
|
assertEquals('event should have correct deltaY property',
|
|
deltaY, mouseWheelEvent.deltaY);
|
|
assertEquals('event should have correct deltaZ property',
|
|
deltaZ, mouseWheelEvent.deltaZ);
|
|
|
|
// RTL
|
|
assertTrue('event should be non-null', !!mouseWheelEventRtl);
|
|
assertTrue('event should have correct JS type',
|
|
mouseWheelEventRtl instanceof goog.events.WheelEvent);
|
|
assertEquals('event should have correct deltaMode property',
|
|
deltaMode, mouseWheelEventRtl.deltaMode);
|
|
assertEquals('event should have correct deltaX property',
|
|
-deltaX, mouseWheelEventRtl.deltaX);
|
|
assertEquals('event should have correct deltaY property',
|
|
deltaY, mouseWheelEventRtl.deltaY);
|
|
assertEquals('event should have correct deltaZ property',
|
|
deltaZ, mouseWheelEventRtl.deltaZ);
|
|
|
|
}
|
|
|
|
function assertPixelDeltas(scale) {
|
|
assertEquals(mouseWheelEvent.deltaX * scale, mouseWheelEvent.pixelDeltaX);
|
|
assertEquals(mouseWheelEvent.deltaY * scale, mouseWheelEvent.pixelDeltaY);
|
|
assertEquals(mouseWheelEvent.deltaZ * scale, mouseWheelEvent.pixelDeltaZ);
|
|
|
|
// RTL
|
|
assertEquals(mouseWheelEventRtl.deltaX * scale,
|
|
mouseWheelEventRtl.pixelDeltaX);
|
|
assertEquals(mouseWheelEventRtl.deltaY * scale,
|
|
mouseWheelEventRtl.pixelDeltaY);
|
|
assertEquals(mouseWheelEventRtl.deltaZ * scale,
|
|
mouseWheelEventRtl.pixelDeltaZ);
|
|
}
|
|
|
|
function createFakePreferredEvent(
|
|
opt_deltaMode, opt_deltaX, opt_deltaY, opt_deltaZ) {
|
|
var event = {
|
|
type: PREFERRED_TYPE,
|
|
deltaMode: opt_deltaMode,
|
|
deltaX: opt_deltaX,
|
|
deltaY: opt_deltaY,
|
|
deltaZ: opt_deltaZ
|
|
};
|
|
return new goog.events.BrowserEvent(event);
|
|
}
|
|
|
|
|
|
function createFakeLegacyEvent(
|
|
opt_wheelDelta, opt_wheelDeltaX, opt_wheelDeltaY) {
|
|
var event = {
|
|
type: LEGACY_TYPE,
|
|
wheelDelta: opt_wheelDelta,
|
|
wheelDeltaX: opt_wheelDeltaX,
|
|
wheelDeltaY: opt_wheelDeltaY
|
|
};
|
|
return new goog.events.BrowserEvent(event);
|
|
}
|
|
|
|
function createFakeGeckoEvent(opt_detail, opt_axis) {
|
|
var event = {
|
|
type: GECKO_TYPE,
|
|
detail: opt_detail,
|
|
axis: opt_axis,
|
|
HORIZONTAL_AXIS: HORIZONTAL,
|
|
VERTICAL_AXIS: VERTICAL
|
|
};
|
|
return new goog.events.BrowserEvent(event);
|
|
}
|