1364 lines
46 KiB
HTML
1364 lines
46 KiB
HTML
<!DOCTYPE HTML>
|
|
<html>
|
|
<head>
|
|
<title>Test for MozMousePixelScroll events</title>
|
|
<script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
|
|
<script type="application/javascript" src="/tests/SimpleTest/EventUtils.js"></script>
|
|
<script type="application/javascript" src="/tests/SimpleTest/paint_listener.js"></script>
|
|
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
|
|
<style>
|
|
.scrollable {
|
|
overflow: auto;
|
|
line-height: 1;
|
|
margin: 15px;
|
|
}
|
|
.scrollable > div {
|
|
width: 1000px;
|
|
height: 1000px;
|
|
font-size: 1000px;
|
|
line-height: 1;
|
|
}
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<p id="display"></p>
|
|
<div id="Scrollable128" class="scrollable" style="font-size: 128px; width: 100px; height: 100px;">
|
|
<div>
|
|
<div id="Scrollable96" class="scrollable" style="font-size: 96px; width: 150px; height: 150px;">
|
|
<div>
|
|
<div id="Scrollable64" class="scrollable" style="font-size: 64px; width: 200px; height: 200px;">
|
|
<div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div id="Scrollable32" class="scrollable" style="font-size: 32px; width: 50px; height: 50px;">
|
|
<div>
|
|
</div>
|
|
</div>
|
|
<div id="content" style="display: none">
|
|
|
|
</div>
|
|
<pre id="test">
|
|
<script type="application/javascript">
|
|
|
|
SimpleTest.waitForExplicitFinish();
|
|
SimpleTest.waitForFocus(startTest, window);
|
|
|
|
var gScrollable128 = document.getElementById("Scrollable128");
|
|
var gScrollable96 = document.getElementById("Scrollable96");
|
|
var gScrollable64 = document.getElementById("Scrollable64");
|
|
var gScrollable32 = document.getElementById("Scrollable32");
|
|
var gRoot = document.documentElement;
|
|
|
|
function* prepareScrollUnits()
|
|
{
|
|
var result = -1;
|
|
function handler(aEvent)
|
|
{
|
|
result = aEvent.detail;
|
|
aEvent.preventDefault();
|
|
setTimeout(runTest, 0);
|
|
}
|
|
window.addEventListener("MozMousePixelScroll", handler, true);
|
|
|
|
yield waitForAllPaints(function () { setTimeout(runTest, 0); });
|
|
|
|
yield synthesizeWheel(gScrollable128, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gScrollable128.wheelLineHeight = result;
|
|
ok(result > 96 && result < 200, "prepareScrollUnits: gScrollable128.wheelLineHeight may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable96, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gScrollable96.wheelLineHeight = result;
|
|
ok(result > 64 && result < gScrollable128.wheelLineHeight, "prepareScrollUnits: gScrollable96.wheelLineHeight may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable64, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gScrollable64.wheelLineHeight = result;
|
|
ok(result > 32 && result < gScrollable96.wheelLineHeight, "prepareScrollUnits: gScrollable64.wheelLineHeight may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable32, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gScrollable32.wheelLineHeight = result;
|
|
ok(result > 16 && result < gScrollable64.wheelLineHeight, "prepareScrollUnits: gScrollable32.wheelLineHeight may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gRoot, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gRoot.wheelLineHeight = result;
|
|
ok(result > 10 && result < gScrollable32.wheelLineHeight, "prepareScrollUnits: gRoot.wheelLineHeight may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable128, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gScrollable128.wheelHorizontalLine = result;
|
|
ok(result > 50 && result < 200, "prepareScrollUnits: gScrollable128.wheelHorizontalLine may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable96, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gScrollable96.wheelHorizontalLine = result;
|
|
ok(result > 30 && result < gScrollable128.wheelHorizontalLine, "prepareScrollUnits: gScrollable96.wheelHorizontalLine may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable64, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gScrollable64.wheelHorizontalLine = result;
|
|
ok(result > 20 && result < gScrollable96.wheelHorizontalLine, "prepareScrollUnits: gScrollable64.wheelHorizontalLine may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable32, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gScrollable32.wheelHorizontalLine = result;
|
|
ok(result > 12 && result < gScrollable64.wheelHorizontalLine, "prepareScrollUnits: gScrollable32.wheelHorizontalLine may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gRoot, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gRoot.wheelHorizontalLine = result;
|
|
ok(result > 5 && result < gScrollable32.wheelHorizontalLine, "prepareScrollUnits: gRoot.wheelHorizontalLine may be illegal value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable128, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gScrollable128.wheelPageHeight = result;
|
|
ok(result >= (100 - gScrollable128.wheelLineHeight * 2) && result <= 100,
|
|
"prepareScrollUnits: gScrollable128.wheelLineHeight is strange value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable96, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gScrollable96.wheelPageHeight = result;
|
|
ok(result >= (150 - gScrollable96.wheelLineHeight * 2) && result <= 150,
|
|
"prepareScrollUnits: gScrollable96.wheelLineHeight is strange value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable64, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gScrollable64.wheelPageHeight = result;
|
|
ok(result >= (200 - gScrollable64.wheelLineHeight * 2) && result <= 200,
|
|
"prepareScrollUnits: gScrollable64.wheelLineHeight is strange value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable32, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gScrollable32.wheelPageHeight = result;
|
|
ok(result >= (50 - gScrollable32.wheelLineHeight * 2) && result <= 50,
|
|
"prepareScrollUnits: gScrollable32.wheelLineHeight is strange value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gRoot, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaY: 1.0, lineOrPageDeltaY: 1 });
|
|
gRoot.wheelPageHeight = result;
|
|
ok(window.innerHeight - result < 100 && window.innerHeight - result > 0,
|
|
"prepareScrollUnits: gRoot.wheelLineHeight is strange value, got " + result);
|
|
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable128, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gScrollable128.wheelPageWidth = result;
|
|
ok(result >= (100 - gScrollable128.wheelLineHeight * 2) && result <= 100,
|
|
"prepareScrollUnits: gScrollable128.wheelPageWidth is strange value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable96, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gScrollable96.wheelPageWidth = result;
|
|
ok(result >= (150 - gScrollable96.wheelLineHeight * 2) && result <= 150,
|
|
"prepareScrollUnits: gScrollable96.wheelPageWidth is strange value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable64, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gScrollable64.wheelPageWidth = result;
|
|
ok(result >= (200 - gScrollable64.wheelLineHeight * 2) && result <= 200,
|
|
"prepareScrollUnits: gScrollable64.wheelPageWidth is strange value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gScrollable32, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gScrollable32.wheelPageWidth = result;
|
|
ok(result >= (50 - gScrollable32.wheelLineHeight * 2) && result <= 50,
|
|
"prepareScrollUnits: gScrollable32.wheelPageWidth is strange value, got " + result);
|
|
|
|
result = -1;
|
|
yield synthesizeWheel(gRoot, 10, 10,
|
|
{ deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, lineOrPageDeltaX: 1 });
|
|
gRoot.wheelPageWidth = result;
|
|
ok(window.innerWidth - result < 100 && window.innerWidth - result > 0,
|
|
"prepareScrollUnits: gRoot.wheelPageWidth is strange value, got " + result);
|
|
|
|
window.removeEventListener("MozMousePixelScroll", handler, true);
|
|
}
|
|
|
|
function* doTests()
|
|
{
|
|
const kTests = [
|
|
// DOM_DELTA_LINE
|
|
{ description: "Should be computed from nearest scrollable element, 128",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable128, y: gScrollable128
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable128, y: gScrollable128
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable96, y: gScrollable96
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable96, y: gScrollable96
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable32, y: gScrollable32
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable32, y: gScrollable32
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gRoot, y: gRoot
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element, even if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gRoot, y: gRoot
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 128",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable128
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable128
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable96
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable96
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable32
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable32
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gRoot
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element, even if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gRoot
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 128",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable128, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable128, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable96, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable96, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable32, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable32, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gRoot, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element, even if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gRoot, y: null
|
|
}
|
|
},
|
|
|
|
// DOM_DELTA_PAGE
|
|
{ description: "Should be computed from nearest scrollable element, 128",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable128, y: gScrollable128
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable128, y: gScrollable128
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable96, y: gScrollable96
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable96, y: gScrollable96
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable32, y: gScrollable32
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable32, y: gScrollable32
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gRoot, y: gRoot
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element, even if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gRoot, y: gRoot
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 128",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable128
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable128
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable96
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable96
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable32
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable32
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gRoot
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element, even if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: null, y: gRoot
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 128",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable128, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
|
|
target: gScrollable128,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable128.scrollLeft = 0;
|
|
gScrollable128.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable128, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable96, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
|
|
target: gScrollable96,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable96, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable32, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
|
|
target: gScrollable32,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable32.scrollLeft = 0;
|
|
gScrollable32.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gScrollable32, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gRoot, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from root element, even if there is no scrollable element, root",
|
|
target: gRoot,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_PAGE,
|
|
deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
},
|
|
cleanup: function () {
|
|
},
|
|
expected: {
|
|
x: gRoot, y: null
|
|
}
|
|
},
|
|
|
|
// Overflow: hidden; boxes shouldn't be ignored.
|
|
{ description: "Should be computed from nearest scrollable element even if it hides overflow content, 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.style.overflow = "hidden";
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
gScrollable64.style.overflow = "auto";
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element even if it hides overflow content (X), 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.style.overflowX = "hidden";
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
gScrollable64.style.overflow = "auto";
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element even if it hides overflow content (Y), 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.style.overflowY = "hidden";
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
gScrollable64.style.overflow = "auto";
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element even if it hides overflow content (X), 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.style.overflowX = "hidden";
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
gScrollable64.style.overflow = "auto";
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element even if it hides overflow content (Y), 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
|
|
prepare: function () {
|
|
gScrollable64.style.overflowY = "hidden";
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
gScrollable64.style.overflow = "auto";
|
|
},
|
|
expected: {
|
|
x: null, y: gScrollable64
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element even if it hides overflow content (X), 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable64.style.overflowX = "hidden";
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
gScrollable64.style.overflow = "auto";
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: null
|
|
}
|
|
},
|
|
{ description: "Should be computed from nearest scrollable element even if it hides overflow content (Y), 64",
|
|
target: gScrollable64,
|
|
event: {
|
|
deltaMode: WheelEvent.DOM_DELTA_LINE,
|
|
deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
|
|
prepare: function () {
|
|
gScrollable64.style.overflowY = "hidden";
|
|
gScrollable96.scrollLeft = 0;
|
|
gScrollable96.scrollTop = 0;
|
|
gScrollable64.scrollLeft = 0;
|
|
gScrollable64.scrollTop = 0;
|
|
},
|
|
cleanup: function () {
|
|
gScrollable64.style.overflow = "auto";
|
|
},
|
|
expected: {
|
|
x: gScrollable64, y: null
|
|
}
|
|
},
|
|
];
|
|
|
|
var currentTest, description, firedX, firedY;
|
|
var expectedHandlerCalls;
|
|
|
|
function handler(aEvent)
|
|
{
|
|
aEvent.preventDefault();
|
|
|
|
if (aEvent.axis != MouseScrollEvent.HORIZONTAL_AXIS &&
|
|
aEvent.axis != MouseScrollEvent.VERTICAL_AXIS) {
|
|
ok(false,
|
|
description + "The event had invalid axis (" + aEvent.axis + ")");
|
|
if (--expectedHandlerCalls == 0) {
|
|
setTimeout(runTest, 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
var isHorizontal = (aEvent.axis == MouseScrollEvent.HORIZONTAL_AXIS);
|
|
if ((isHorizontal && !currentTest.expected.x) ||
|
|
(!isHorizontal && !currentTest.expected.y)) {
|
|
ok(false,
|
|
description + "The event fired unexpectedly (" +
|
|
(isHorizontal ? "Horizontal" : "Vertical") + ")");
|
|
if (--expectedHandlerCalls == 0) {
|
|
setTimeout(runTest, 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (isHorizontal) {
|
|
firedX = true;
|
|
} else {
|
|
firedY = true;
|
|
}
|
|
|
|
var expectedDetail =
|
|
(currentTest.event.deltaMode == WheelEvent.DOM_DELTA_LINE) ?
|
|
(isHorizontal ? currentTest.expected.x.wheelHorizontalLine :
|
|
currentTest.expected.y.wheelLineHeight) :
|
|
(isHorizontal ? currentTest.expected.x.wheelPageWidth :
|
|
currentTest.expected.y.wheelPageHeight);
|
|
is(Math.abs(aEvent.detail), expectedDetail,
|
|
description + ((isHorizontal) ? "horizontal" : "vertical") + " event detail is wrong");
|
|
|
|
if (--expectedHandlerCalls == 0) {
|
|
setTimeout(runTest, 0);
|
|
}
|
|
}
|
|
|
|
window.addEventListener("MozMousePixelScroll", handler, true);
|
|
|
|
for (var i = 0; i < kTests.length; i++) {
|
|
currentTest = kTests[i];
|
|
description = "doTests, " + currentTest.description + " (deltaMode: " +
|
|
(currentTest.event.deltaMode == WheelEvent.DOM_DELTA_LINE ?
|
|
"DOM_DELTA_LINE" : "DOM_DELTA_PAGE") +
|
|
", deltaX: " + currentTest.event.deltaX +
|
|
", deltaY: " + currentTest.event.deltaY + "): ";
|
|
currentTest.prepare();
|
|
firedX = firedY = false;
|
|
expectedHandlerCalls = (currentTest.expected.x ? 1 : 0)
|
|
+ (currentTest.expected.y ? 1 : 0);
|
|
yield synthesizeWheel(currentTest.target, 10, 10, currentTest.event);
|
|
if (currentTest.expected.x) {
|
|
ok(firedX, description + "Horizontal MozMousePixelScroll event wasn't fired");
|
|
}
|
|
if (currentTest.expected.y) {
|
|
ok(firedY, description + "Vertical MozMousePixelScroll event wasn't fired");
|
|
}
|
|
currentTest.cleanup();
|
|
}
|
|
|
|
window.removeEventListener("MozMousePixelScroll", handler, true);
|
|
}
|
|
|
|
function* testBody()
|
|
{
|
|
yield* prepareScrollUnits();
|
|
yield* doTests();
|
|
}
|
|
|
|
var gTestContinuation = null;
|
|
|
|
function runTest()
|
|
{
|
|
if (!gTestContinuation) {
|
|
gTestContinuation = testBody();
|
|
}
|
|
var ret = gTestContinuation.next();
|
|
if (ret.done) {
|
|
SimpleTest.finish();
|
|
}
|
|
}
|
|
|
|
function startTest() {
|
|
SpecialPowers.pushPrefEnv({"set": [["mousewheel.default.delta_multiplier_x", 100],
|
|
["mousewheel.default.delta_multiplier_y", 100],
|
|
["mousewheel.default.delta_multiplier_z", 100],
|
|
["mousewheel.with_alt.delta_multiplier_x", 100],
|
|
["mousewheel.with_alt.delta_multiplier_y", 100],
|
|
["mousewheel.with_alt.delta_multiplier_z", 100],
|
|
["mousewheel.with_control.delta_multiplier_x", 100],
|
|
["mousewheel.with_control.delta_multiplier_y", 100],
|
|
["mousewheel.with_control.delta_multiplier_z", 100],
|
|
["mousewheel.with_meta.delta_multiplier_x", 100],
|
|
["mousewheel.with_meta.delta_multiplier_y", 100],
|
|
["mousewheel.with_meta.delta_multiplier_z", 100],
|
|
["mousewheel.with_shift.delta_multiplier_x", 100],
|
|
["mousewheel.with_shift.delta_multiplier_y", 100],
|
|
["mousewheel.with_shift.delta_multiplier_z", 100],
|
|
["mousewheel.with_win.delta_multiplier_x", 100],
|
|
["mousewheel.with_win.delta_multiplier_y", 100],
|
|
["mousewheel.with_win.delta_multiplier_z", 100],
|
|
// If APZ is enabled we should ensure the preventDefault calls work even
|
|
// if the test is running slowly.
|
|
["apz.content_response_timeout", 2000],
|
|
]}, runTest);
|
|
}
|
|
|
|
</script>
|
|
</pre>
|
|
</body>
|
|
</html>
|