mirror of
https://github.com/openseadragon/openseadragon.git
synced 2024-11-22 13:16:10 +03:00
1648 lines
58 KiB
JavaScript
1648 lines
58 KiB
JavaScript
/* global QUnit, $, TouchUtil, Util, testLog */
|
|
|
|
(function () {
|
|
var viewer;
|
|
|
|
QUnit.module("Events", {
|
|
beforeEach: function () {
|
|
$('<div id="eventsexample"></div>').appendTo("#qunit-fixture");
|
|
|
|
testLog.reset();
|
|
|
|
viewer = OpenSeadragon({
|
|
id: "eventsexample",
|
|
prefixUrl: "/build/openseadragon/images/",
|
|
springStiffness: 100, // Faster animation = faster tests
|
|
});
|
|
},
|
|
afterEach: function () {
|
|
if (viewer && viewer.close) {
|
|
viewer.close();
|
|
}
|
|
|
|
viewer = null;
|
|
},
|
|
});
|
|
|
|
// ----------
|
|
QUnit.test("MouseTracker: mouse gestures", function (assert) {
|
|
var done = assert.async();
|
|
var $canvas = $(viewer.element)
|
|
.find(".openseadragon-canvas")
|
|
.not(".navigator .openseadragon-canvas"),
|
|
simEvent = {},
|
|
offset = $canvas.offset(),
|
|
tracker = viewer.innerTracker,
|
|
origEnterHandler,
|
|
origLeaveHandler,
|
|
origPressHandler,
|
|
origReleaseHandler,
|
|
origNonPrimaryPressHandler,
|
|
origNonPrimaryReleaseHandler,
|
|
origMoveHandler,
|
|
origClickHandler,
|
|
origDblClickHandler,
|
|
origDragHandler,
|
|
origDragEndHandler,
|
|
enterCount,
|
|
leaveCount,
|
|
pressCount,
|
|
releaseCount,
|
|
rightPressCount,
|
|
rightReleaseCount,
|
|
middlePressCount,
|
|
middleReleaseCount,
|
|
moveCount,
|
|
clickCount,
|
|
dblClickCount,
|
|
dragCount,
|
|
dragEndCount,
|
|
insideElementPressed,
|
|
insideElementReleased,
|
|
quickClick,
|
|
speed,
|
|
direction;
|
|
|
|
var hookViewerHandlers = function () {
|
|
origEnterHandler = tracker.enterHandler;
|
|
tracker.enterHandler = function (event) {
|
|
enterCount++;
|
|
if (origEnterHandler) {
|
|
return origEnterHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origLeaveHandler = tracker.leaveHandler;
|
|
tracker.leaveHandler = function (event) {
|
|
leaveCount++;
|
|
if (origLeaveHandler) {
|
|
return origLeaveHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origPressHandler = tracker.pressHandler;
|
|
tracker.pressHandler = function (event) {
|
|
pressCount++;
|
|
if (origPressHandler) {
|
|
return origPressHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origReleaseHandler = tracker.releaseHandler;
|
|
tracker.releaseHandler = function (event) {
|
|
releaseCount++;
|
|
insideElementPressed = event.insideElementPressed;
|
|
insideElementReleased = event.insideElementReleased;
|
|
if (origReleaseHandler) {
|
|
return origReleaseHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origNonPrimaryPressHandler = tracker.nonPrimaryPressHandler;
|
|
tracker.nonPrimaryPressHandler = function (event) {
|
|
if (event.button === 0) {
|
|
pressCount++;
|
|
} else if (event.button === 1) {
|
|
middlePressCount++;
|
|
} else if (event.button === 2) {
|
|
rightPressCount++;
|
|
}
|
|
if (origNonPrimaryPressHandler) {
|
|
return origNonPrimaryPressHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origNonPrimaryReleaseHandler = tracker.nonPrimaryReleaseHandler;
|
|
tracker.nonPrimaryReleaseHandler = function (event) {
|
|
if (event.button === 0) {
|
|
releaseCount++;
|
|
} else if (event.button === 1) {
|
|
middleReleaseCount++;
|
|
} else if (event.button === 2) {
|
|
rightReleaseCount++;
|
|
}
|
|
if (origNonPrimaryReleaseHandler) {
|
|
return origNonPrimaryReleaseHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origMoveHandler = tracker.moveHandler;
|
|
tracker.moveHandler = function (event) {
|
|
moveCount++;
|
|
if (origMoveHandler) {
|
|
return origMoveHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origClickHandler = tracker.clickHandler;
|
|
tracker.clickHandler = function (event) {
|
|
clickCount++;
|
|
quickClick = event.quick;
|
|
if (origClickHandler) {
|
|
return origClickHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origDblClickHandler = tracker.dblClickHandler;
|
|
tracker.dblClickHandler = function (event) {
|
|
dblClickCount++;
|
|
if (origDblClickHandler) {
|
|
return origDblClickHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origDragHandler = tracker.dragHandler;
|
|
tracker.dragHandler = function (event) {
|
|
dragCount++;
|
|
if (origDragHandler) {
|
|
return origDragHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
origDragEndHandler = tracker.dragEndHandler;
|
|
tracker.dragEndHandler = function (event) {
|
|
dragEndCount++;
|
|
speed = event.speed;
|
|
direction = event.direction;
|
|
if (origDragEndHandler) {
|
|
return origDragEndHandler(event);
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
};
|
|
|
|
var unhookViewerHandlers = function () {
|
|
tracker.enterHandler = origEnterHandler;
|
|
tracker.leaveHandler = origLeaveHandler;
|
|
tracker.pressHandler = origPressHandler;
|
|
tracker.releaseHandler = origReleaseHandler;
|
|
tracker.moveHandler = origMoveHandler;
|
|
tracker.clickHandler = origClickHandler;
|
|
tracker.dblClickHandler = origDblClickHandler;
|
|
tracker.dragHandler = origDragHandler;
|
|
tracker.dragEndHandler = origDragEndHandler;
|
|
};
|
|
|
|
var simulateEnter = function (x, y) {
|
|
simEvent.clientX = offset.left + x;
|
|
simEvent.clientY = offset.top + y;
|
|
$canvas.simulate("mouseenter", simEvent);
|
|
};
|
|
|
|
var simulateLeave = function (x, y) {
|
|
simEvent.clientX = offset.left + x;
|
|
simEvent.clientY = offset.top + y;
|
|
simEvent.relatedTarget = document.body;
|
|
$canvas.simulate("mouseleave", simEvent);
|
|
};
|
|
|
|
//var simulateLeaveFrame = function (x, y) {
|
|
// simEvent.clientX = offset.left + x;
|
|
// simEvent.clientY = offset.top + y;
|
|
// simEvent.relatedTarget = document.getElementsByTagName("html")[0];
|
|
// $canvas.simulate( 'mouseleave', simEvent );
|
|
//};
|
|
|
|
var simulateDown = function (x, y) {
|
|
simEvent.button = 0;
|
|
simEvent.clientX = offset.left + x;
|
|
simEvent.clientY = offset.top + y;
|
|
$canvas.simulate("mousedown", simEvent);
|
|
};
|
|
|
|
var simulateUp = function (x, y) {
|
|
simEvent.button = 0;
|
|
simEvent.clientX = offset.left + x;
|
|
simEvent.clientY = offset.top + y;
|
|
$canvas.simulate("mouseup", simEvent);
|
|
};
|
|
|
|
var simulateNonPrimaryDown = function (x, y, button) {
|
|
simEvent.button = button;
|
|
simEvent.clientX = offset.left + x;
|
|
simEvent.clientY = offset.top + y;
|
|
$canvas.simulate("mousedown", simEvent);
|
|
};
|
|
|
|
var simulateNonPrimaryUp = function (x, y, button) {
|
|
simEvent.button = button;
|
|
simEvent.clientX = offset.left + x;
|
|
simEvent.clientY = offset.top + y;
|
|
$canvas.simulate("mouseup", simEvent);
|
|
};
|
|
|
|
var simulateMove = function (dX, dY, count) {
|
|
var i;
|
|
for (i = 0; i < count; i++) {
|
|
simEvent.clientX += dX;
|
|
simEvent.clientY += dY;
|
|
$canvas.simulate("mousemove", simEvent);
|
|
}
|
|
};
|
|
|
|
var resetForAssessment = function () {
|
|
simEvent = {
|
|
button: 0,
|
|
clientX: offset.left,
|
|
clientY: offset.top,
|
|
};
|
|
enterCount = 0;
|
|
leaveCount = 0;
|
|
pressCount = 0;
|
|
releaseCount = 0;
|
|
rightPressCount = 0;
|
|
rightReleaseCount = 0;
|
|
middlePressCount = 0;
|
|
middleReleaseCount = 0;
|
|
moveCount = 0;
|
|
clickCount = 0;
|
|
dblClickCount = 0;
|
|
dragCount = 0;
|
|
dragEndCount = 0;
|
|
insideElementPressed = false;
|
|
insideElementReleased = false;
|
|
quickClick = false;
|
|
speed = 0;
|
|
direction = 2 * Math.PI;
|
|
};
|
|
|
|
var assessGestureExpectations = function (expected) {
|
|
var pointersList = tracker.getActivePointersListByType("mouse");
|
|
if ("enterCount" in expected) {
|
|
assert.equal(
|
|
enterCount,
|
|
expected.enterCount,
|
|
expected.description +
|
|
"enterHandler event count matches expected (" +
|
|
expected.enterCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("leaveCount" in expected) {
|
|
assert.equal(
|
|
leaveCount,
|
|
expected.leaveCount,
|
|
expected.description +
|
|
"leaveHandler event count matches expected (" +
|
|
expected.leaveCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("pressCount" in expected) {
|
|
assert.equal(
|
|
pressCount,
|
|
expected.pressCount,
|
|
expected.description +
|
|
"pressHandler event count matches expected (" +
|
|
expected.pressCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("releaseCount" in expected) {
|
|
assert.equal(
|
|
releaseCount,
|
|
expected.releaseCount,
|
|
expected.description +
|
|
"releaseHandler event count matches expected (" +
|
|
expected.releaseCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("rightPressCount" in expected) {
|
|
assert.equal(
|
|
rightPressCount,
|
|
expected.rightPressCount,
|
|
expected.description +
|
|
"nonPrimaryPressHandler event count (secondary/right button) matches expected (" +
|
|
expected.rightPressCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("rightReleaseCount" in expected) {
|
|
assert.equal(
|
|
rightReleaseCount,
|
|
expected.rightReleaseCount,
|
|
expected.description +
|
|
"nonPrimaryReleaseHandler event count (secondary/right button) matches expected (" +
|
|
expected.rightReleaseCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("middlePressCount" in expected) {
|
|
assert.equal(
|
|
middlePressCount,
|
|
expected.middlePressCount,
|
|
expected.description +
|
|
"nonPrimaryPressHandler event count (aux/middle button) matches expected (" +
|
|
expected.middlePressCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("middleReleaseCount" in expected) {
|
|
assert.equal(
|
|
middleReleaseCount,
|
|
expected.middleReleaseCount,
|
|
expected.description +
|
|
"nonPrimaryReleaseHandler event count (aux/middle button) matches expected (" +
|
|
expected.middleReleaseCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("moveCount" in expected) {
|
|
assert.equal(
|
|
moveCount,
|
|
expected.moveCount,
|
|
expected.description +
|
|
"moveHandler event count matches expected (" +
|
|
expected.moveCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("clickCount" in expected) {
|
|
assert.equal(
|
|
clickCount,
|
|
expected.clickCount,
|
|
expected.description +
|
|
"clickHandler event count matches expected (" +
|
|
expected.clickCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("dblClickCount" in expected) {
|
|
assert.equal(
|
|
dblClickCount,
|
|
expected.dblClickCount,
|
|
expected.description +
|
|
"dblClickHandler event count matches expected (" +
|
|
expected.dblClickCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("dragCount" in expected) {
|
|
assert.equal(
|
|
dragCount,
|
|
expected.dragCount,
|
|
expected.description +
|
|
"dragHandler event count matches expected (" +
|
|
expected.dragCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("dragEndCount" in expected) {
|
|
assert.equal(
|
|
dragEndCount,
|
|
expected.dragEndCount,
|
|
expected.description +
|
|
"dragEndHandler event count matches expected (" +
|
|
expected.dragEndCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("insideElementPressed" in expected) {
|
|
assert.equal(
|
|
insideElementPressed,
|
|
expected.insideElementPressed,
|
|
expected.description +
|
|
"releaseHandler event.insideElementPressed matches expected (" +
|
|
expected.insideElementPressed +
|
|
")"
|
|
);
|
|
}
|
|
if ("insideElementReleased" in expected) {
|
|
assert.equal(
|
|
insideElementReleased,
|
|
expected.insideElementReleased,
|
|
expected.description +
|
|
"releaseHandler event.insideElementReleased matches expected (" +
|
|
expected.insideElementReleased +
|
|
")"
|
|
);
|
|
}
|
|
if ("contacts" in expected) {
|
|
assert.equal(
|
|
pointersList.contacts,
|
|
expected.contacts,
|
|
expected.description +
|
|
"Remaining pointer contact count matches expected (" +
|
|
expected.contacts +
|
|
")"
|
|
);
|
|
}
|
|
if ("trackedPointers" in expected) {
|
|
assert.equal(
|
|
pointersList.getLength(),
|
|
expected.trackedPointers,
|
|
expected.description +
|
|
"Remaining tracked pointer count matches expected (" +
|
|
expected.trackedPointers +
|
|
")"
|
|
);
|
|
}
|
|
if ("quickClick" in expected) {
|
|
assert.equal(
|
|
quickClick,
|
|
expected.quickClick,
|
|
expected.description +
|
|
"clickHandler event.quick matches expected (" +
|
|
expected.quickClick +
|
|
")"
|
|
);
|
|
}
|
|
if ("speed" in expected) {
|
|
Util.assessNumericValue(
|
|
expected.speed,
|
|
speed,
|
|
1.0,
|
|
expected.description + "Drag speed "
|
|
);
|
|
}
|
|
if ("direction" in expected) {
|
|
Util.assessNumericValue(
|
|
expected.direction,
|
|
direction,
|
|
0.2,
|
|
expected.description + "Drag direction "
|
|
);
|
|
}
|
|
};
|
|
|
|
var onOpen = function (event) {
|
|
viewer.removeHandler("open", onOpen);
|
|
|
|
hookViewerHandlers();
|
|
|
|
// enter-move-release (release in tracked element, press in unknown element)
|
|
// (Note we also test to see if the pointer is still being tracked by not simulating a leave event until after assessment)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateMove(1, 1, 10);
|
|
simulateMove(-1, -1, 10);
|
|
simulateUp(0, 0);
|
|
assessGestureExpectations({
|
|
description:
|
|
"enter-move-release (release in tracked element, press in unknown element): ",
|
|
enterCount: 1,
|
|
leaveCount: 0,
|
|
pressCount: 0,
|
|
releaseCount: 1,
|
|
rightPressCount: 0,
|
|
rightReleaseCount: 0,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 20,
|
|
clickCount: 0,
|
|
dblClickCount: 0,
|
|
dragCount: 0,
|
|
dragEndCount: 0,
|
|
insideElementPressed: false,
|
|
insideElementReleased: true,
|
|
contacts: 0,
|
|
trackedPointers: 1,
|
|
//quickClick: false
|
|
});
|
|
simulateLeave(-1, -1); // flush tracked pointer
|
|
|
|
// enter-move-leave (fly-over)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateMove(1, 1, 10);
|
|
simulateMove(-1, -1, 10);
|
|
simulateLeave(-1, -1);
|
|
assessGestureExpectations({
|
|
description: "enter-move-leave (fly-over): ",
|
|
enterCount: 1,
|
|
leaveCount: 1,
|
|
pressCount: 0,
|
|
releaseCount: 0,
|
|
rightPressCount: 0,
|
|
rightReleaseCount: 0,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 20,
|
|
clickCount: 0,
|
|
dblClickCount: 0,
|
|
dragCount: 0,
|
|
dragEndCount: 0,
|
|
//insideElementPressed: false,
|
|
//insideElementReleased: false,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
//quickClick: false
|
|
});
|
|
|
|
// move-leave (fly-over, no enter event)
|
|
resetForAssessment();
|
|
simulateMove(1, 1, 10);
|
|
simulateMove(-1, -1, 10);
|
|
simulateLeave(-1, -1);
|
|
assessGestureExpectations({
|
|
description: "move-leave (fly-over, no enter event): ",
|
|
enterCount: 0,
|
|
leaveCount: 1,
|
|
pressCount: 0,
|
|
releaseCount: 0,
|
|
rightPressCount: 0,
|
|
rightReleaseCount: 0,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 20,
|
|
clickCount: 0,
|
|
dblClickCount: 0,
|
|
dragCount: 0,
|
|
dragEndCount: 0,
|
|
//insideElementPressed: false,
|
|
//insideElementReleased: false,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
//quickClick: false
|
|
});
|
|
|
|
// enter-press-release-press-release-leave (primary/left double click)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateDown(0, 0);
|
|
simulateUp(0, 0);
|
|
simulateDown(0, 0);
|
|
simulateUp(0, 0);
|
|
simulateLeave(-1, -1);
|
|
assessGestureExpectations({
|
|
description:
|
|
"enter-press-release-press-release-leave (primary/left double click): ",
|
|
enterCount: 1,
|
|
leaveCount: 1,
|
|
pressCount: 2,
|
|
releaseCount: 2,
|
|
rightPressCount: 0,
|
|
rightReleaseCount: 0,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 0,
|
|
clickCount: 2,
|
|
dblClickCount: 1,
|
|
dragCount: 0,
|
|
dragEndCount: 2, // v2.5.0+ drag-end event now fired even if pointer didn't move (#1459)
|
|
insideElementPressed: true,
|
|
insideElementReleased: true,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
//quickClick: true
|
|
});
|
|
|
|
// enter-press-release-leave (primary/left click)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateDown(0, 0);
|
|
simulateUp(0, 0);
|
|
simulateLeave(-1, -1);
|
|
assessGestureExpectations({
|
|
description:
|
|
"enter-press-release-leave (primary/left click): ",
|
|
enterCount: 1,
|
|
leaveCount: 1,
|
|
pressCount: 1,
|
|
releaseCount: 1,
|
|
rightPressCount: 0,
|
|
rightReleaseCount: 0,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 0,
|
|
clickCount: 1,
|
|
dblClickCount: 0,
|
|
dragCount: 0,
|
|
dragEndCount: 1, // v2.5.0+ drag-end event now fired even if pointer didn't move (#1459)
|
|
insideElementPressed: true,
|
|
insideElementReleased: true,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
quickClick: true,
|
|
});
|
|
|
|
// enter-nonprimarypress-nonprimaryrelease-leave (secondary/right click)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateNonPrimaryDown(0, 0, 2);
|
|
simulateNonPrimaryUp(0, 0, 2);
|
|
simulateLeave(-1, -1);
|
|
assessGestureExpectations({
|
|
description:
|
|
"enter-nonprimarypress-nonprimaryrelease-leave (secondary/right click): ",
|
|
enterCount: 1,
|
|
leaveCount: 1,
|
|
pressCount: 0,
|
|
releaseCount: 0,
|
|
rightPressCount: 1,
|
|
rightReleaseCount: 1,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 0,
|
|
clickCount: 0,
|
|
dblClickCount: 0,
|
|
dragCount: 0,
|
|
dragEndCount: 0,
|
|
//insideElementPressed: true,
|
|
//insideElementReleased: true,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
//quickClick: true
|
|
});
|
|
|
|
// enter-nonprimarypress-nonprimaryrelease-leave (aux/middle click)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateNonPrimaryDown(0, 0, 1);
|
|
simulateNonPrimaryUp(0, 0, 1);
|
|
simulateLeave(-1, -1);
|
|
assessGestureExpectations({
|
|
description:
|
|
"enter-nonprimarypress-nonprimaryrelease-leave (aux/middle click): ",
|
|
enterCount: 1,
|
|
leaveCount: 1,
|
|
pressCount: 0,
|
|
releaseCount: 0,
|
|
rightPressCount: 0,
|
|
rightReleaseCount: 0,
|
|
middlePressCount: 1,
|
|
middleReleaseCount: 1,
|
|
moveCount: 0,
|
|
clickCount: 0,
|
|
dblClickCount: 0,
|
|
dragCount: 0,
|
|
dragEndCount: 0,
|
|
//insideElementPressed: true,
|
|
//insideElementReleased: true,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
//quickClick: true
|
|
});
|
|
|
|
// enter-nonprimarypress-move-nonprimaryrelease-move-leave (secondary/right button drag, release in tracked element)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateNonPrimaryDown(0, 0, 2);
|
|
simulateMove(1, 1, 100);
|
|
simulateNonPrimaryUp(10, 10, 2);
|
|
simulateMove(-1, -1, 100);
|
|
simulateLeave(-1, -1);
|
|
assessGestureExpectations({
|
|
description:
|
|
"enter-nonprimarypress-move-nonprimaryrelease-move-leave (secondary/right button drag, release in tracked element): ",
|
|
enterCount: 1,
|
|
leaveCount: 1,
|
|
pressCount: 0,
|
|
releaseCount: 0,
|
|
rightPressCount: 1,
|
|
rightReleaseCount: 1,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 200,
|
|
clickCount: 0,
|
|
dblClickCount: 0,
|
|
dragCount: 0,
|
|
dragEndCount: 0,
|
|
//insideElementPressed: true,
|
|
//insideElementReleased: true,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
//quickClick: false
|
|
});
|
|
|
|
// enter-press-move-release-move-leave (drag, release in tracked element)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateDown(0, 0);
|
|
simulateMove(1, 1, 100);
|
|
simulateUp(10, 10);
|
|
simulateMove(-1, -1, 100);
|
|
simulateLeave(-1, -1);
|
|
assessGestureExpectations({
|
|
description:
|
|
"enter-press-move-release-move-leave (drag, release in tracked element): ",
|
|
enterCount: 1,
|
|
leaveCount: 1,
|
|
pressCount: 1,
|
|
releaseCount: 1,
|
|
rightPressCount: 0,
|
|
rightReleaseCount: 0,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 200,
|
|
clickCount: 1,
|
|
dblClickCount: 0,
|
|
dragCount: 100,
|
|
dragEndCount: 1,
|
|
insideElementPressed: true,
|
|
insideElementReleased: true,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
quickClick: false,
|
|
});
|
|
|
|
// enter-press-move-leave-move-release (drag, release outside tracked element)
|
|
resetForAssessment();
|
|
simulateEnter(0, 0);
|
|
simulateDown(0, 0);
|
|
simulateMove(1, 1, 5);
|
|
simulateMove(-1, -1, 5);
|
|
simulateLeave(-1, -1);
|
|
simulateMove(-1, -1, 5);
|
|
simulateUp(-5, -5);
|
|
assessGestureExpectations({
|
|
description:
|
|
"enter-press-move-leave-move-release (drag, release outside tracked element): ",
|
|
enterCount: 1,
|
|
leaveCount: 1,
|
|
pressCount: 1,
|
|
releaseCount: 1,
|
|
rightPressCount: 0,
|
|
rightReleaseCount: 0,
|
|
middlePressCount: 0,
|
|
middleReleaseCount: 0,
|
|
moveCount: 15,
|
|
clickCount: 0,
|
|
dblClickCount: 0,
|
|
dragCount: 15,
|
|
dragEndCount: 1,
|
|
insideElementPressed: true,
|
|
insideElementReleased: false,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
quickClick: false,
|
|
});
|
|
|
|
//// enter-press-move-leave-move-release-outside (drag, release outside iframe)
|
|
//resetForAssessment();
|
|
//simulateEnter(0, 0);
|
|
//simulateDown(0, 0);
|
|
//simulateMove(1, 1, 5);
|
|
//simulateMove(-1, -1, 5);
|
|
//simulateLeaveFrame(-1, -1);
|
|
//// you don't actually receive the mouseup if you mouseup outside of the document
|
|
//assessGestureExpectations({
|
|
// description: 'enter-press-move-leave-move-release-outside (drag, release outside iframe): ',
|
|
// enterCount: 1,
|
|
// leaveCount: 1,
|
|
// pressCount: 1,
|
|
// releaseCount: 1,
|
|
// rightPressCount: 0,
|
|
// rightReleaseCount: 0,
|
|
// middlePressCount: 0,
|
|
// middleReleaseCount: 0,
|
|
// moveCount: 10,
|
|
// clickCount: 0,
|
|
// dblClickCount: 0,
|
|
// dragCount: 10,
|
|
// dragEndCount: 1,
|
|
// insideElementPressed: true,
|
|
// insideElementReleased: false,
|
|
// contacts: 0,
|
|
// trackedPointers: 0,
|
|
// quickClick: false
|
|
//});
|
|
|
|
unhookViewerHandlers();
|
|
|
|
viewer.close();
|
|
done();
|
|
};
|
|
|
|
viewer.addHandler("open", onOpen);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
});
|
|
|
|
// ----------
|
|
if ("TouchEvent" in window) {
|
|
QUnit.test("MouseTracker: touch events", function (assert) {
|
|
var done = assert.async();
|
|
var tracker = viewer.innerTracker,
|
|
touches;
|
|
|
|
var reset = function () {
|
|
touches = [];
|
|
TouchUtil.reset();
|
|
};
|
|
|
|
var assessTouchExpectations = function (expected) {
|
|
var pointersList = tracker.getActivePointersListByType("touch");
|
|
if ("captureCount" in expected) {
|
|
assert.equal(
|
|
pointersList.captureCount,
|
|
expected.captureCount,
|
|
expected.description +
|
|
"Pointer capture count matches expected (" +
|
|
expected.captureCount +
|
|
")"
|
|
);
|
|
}
|
|
if ("contacts" in expected) {
|
|
assert.equal(
|
|
pointersList.contacts,
|
|
expected.contacts,
|
|
expected.description +
|
|
"Pointer contact count matches expected (" +
|
|
expected.contacts +
|
|
")"
|
|
);
|
|
}
|
|
if ("trackedPointers" in expected) {
|
|
assert.equal(
|
|
pointersList.getLength(),
|
|
expected.trackedPointers,
|
|
expected.description +
|
|
"Tracked pointer count matches expected (" +
|
|
expected.trackedPointers +
|
|
")"
|
|
);
|
|
}
|
|
};
|
|
|
|
var onOpen = function (event) {
|
|
viewer.removeHandler("open", onOpen);
|
|
|
|
TouchUtil.initTracker(tracker);
|
|
|
|
// start-end-end (multi-touch start event)
|
|
reset();
|
|
touches = TouchUtil.start([0, 0], [20, 20]);
|
|
assessTouchExpectations({
|
|
description:
|
|
"start-end-end (multi-touch start event) [capture]: ",
|
|
captureCount: 2,
|
|
contacts: 2,
|
|
trackedPointers: 2,
|
|
});
|
|
TouchUtil.end(touches[1]);
|
|
TouchUtil.end(touches[0]);
|
|
assessTouchExpectations({
|
|
description:
|
|
"start-end-end (multi-touch start event) [release]: ",
|
|
captureCount: 0,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
});
|
|
|
|
// start-start-end (multi-touch end event)
|
|
reset();
|
|
touches.push(TouchUtil.start([0, 0]));
|
|
touches.push(TouchUtil.start([20, 20]));
|
|
assessTouchExpectations({
|
|
description:
|
|
"start-start-end (multi-touch end event) [capture]: ",
|
|
captureCount: 2,
|
|
contacts: 2,
|
|
trackedPointers: 2,
|
|
});
|
|
TouchUtil.end(touches);
|
|
assessTouchExpectations({
|
|
description:
|
|
"start-start-end (multi-touch end event) [release]: ",
|
|
captureCount: 0,
|
|
contacts: 0,
|
|
trackedPointers: 0,
|
|
});
|
|
|
|
TouchUtil.resetTracker(tracker);
|
|
viewer.close();
|
|
done();
|
|
};
|
|
|
|
viewer.addHandler("open", onOpen);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
});
|
|
}
|
|
|
|
// ----------
|
|
QUnit.test("Viewer: preventDefaultAction", function (assert) {
|
|
var done = assert.async();
|
|
var $canvas = $(viewer.element)
|
|
.find(".openseadragon-canvas")
|
|
.not(".navigator .openseadragon-canvas");
|
|
//var tracker = viewer.innerTracker;
|
|
var epsilon = 0.0000001;
|
|
|
|
function simulateClickAndDrag() {
|
|
$canvas.simulate("focus");
|
|
// Drag to pan
|
|
Util.simulateViewerClickWithDrag({
|
|
viewer: viewer,
|
|
widthFactor: 0.25,
|
|
heightFactor: 0.25,
|
|
dragCount: 10,
|
|
dragDx: 1,
|
|
dragDy: 1,
|
|
});
|
|
// Click to zoom
|
|
Util.simulateViewerClickWithDrag({
|
|
viewer: viewer,
|
|
widthFactor: 0.25,
|
|
heightFactor: 0.25,
|
|
dragCount: 0,
|
|
dragDx: 0,
|
|
dragDy: 0,
|
|
});
|
|
$canvas.simulate("blur");
|
|
}
|
|
|
|
var onOpen = function () {
|
|
viewer.removeHandler("open", onOpen);
|
|
|
|
// Hook viewer events to set preventDefaultAction
|
|
var onCanvasClick = function (event) {
|
|
event.preventDefaultAction = true;
|
|
};
|
|
var onCanvasDrag = function (event) {
|
|
event.preventDefaultAction = true;
|
|
};
|
|
|
|
viewer.addHandler("canvas-click", onCanvasClick);
|
|
viewer.addHandler("canvas-drag", onCanvasDrag);
|
|
|
|
var originalZoom = viewer.viewport.getZoom();
|
|
var originalBounds = viewer.viewport.getBounds();
|
|
|
|
simulateClickAndDrag();
|
|
|
|
var zoom = viewer.viewport.getZoom();
|
|
var bounds = viewer.viewport.getBounds();
|
|
Util.assessNumericValue(
|
|
assert,
|
|
zoom,
|
|
originalZoom,
|
|
epsilon,
|
|
"Zoom should be prevented"
|
|
);
|
|
Util.assertRectangleEquals(
|
|
assert,
|
|
bounds,
|
|
originalBounds,
|
|
epsilon,
|
|
"Pan should be prevented"
|
|
);
|
|
|
|
viewer.removeHandler("canvas-click", onCanvasClick);
|
|
viewer.removeHandler("canvas-drag", onCanvasDrag);
|
|
|
|
simulateClickAndDrag();
|
|
|
|
zoom = viewer.viewport.getZoom();
|
|
bounds = viewer.viewport.getBounds();
|
|
Util.assessNumericValue(
|
|
assert,
|
|
zoom,
|
|
0.002,
|
|
epsilon,
|
|
"Zoom should not be prevented"
|
|
);
|
|
Util.assertRectangleEquals(
|
|
assert,
|
|
new OpenSeadragon.Rect(-249.5, -0.25, 500, 0.5),
|
|
bounds,
|
|
epsilon,
|
|
"Pan should not be prevented"
|
|
);
|
|
|
|
viewer.close();
|
|
done();
|
|
};
|
|
|
|
viewer.addHandler("open", onOpen);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
});
|
|
|
|
// ----------
|
|
QUnit.test(
|
|
"Viewer: preventDefaultAction in dblClickHandler",
|
|
function (assert) {
|
|
var done = assert.async();
|
|
var tracker = viewer.innerTracker;
|
|
var epsilon = 0.0000001;
|
|
|
|
function simulateDblTap() {
|
|
var touches = [];
|
|
TouchUtil.reset();
|
|
|
|
touches.push(TouchUtil.start([0, 0]));
|
|
TouchUtil.end(touches[0]);
|
|
touches.push(TouchUtil.start([0, 0]));
|
|
TouchUtil.end(touches[1]);
|
|
}
|
|
|
|
var onOpen = function () {
|
|
viewer.removeHandler("open", onOpen);
|
|
|
|
var originalZoom = viewer.viewport.getZoom();
|
|
|
|
var onCanvasDblClick = function (event) {
|
|
event.preventDefaultAction = true;
|
|
};
|
|
|
|
viewer.addHandler("canvas-double-click", onCanvasDblClick);
|
|
|
|
TouchUtil.initTracker(tracker);
|
|
simulateDblTap();
|
|
|
|
var zoom = viewer.viewport.getZoom();
|
|
Util.assessNumericValue(
|
|
assert,
|
|
originalZoom,
|
|
zoom,
|
|
epsilon,
|
|
"Zoom on double tap should be prevented"
|
|
);
|
|
|
|
// Reset event handler to original
|
|
viewer.removeHandler("canvas-double-click", onCanvasDblClick);
|
|
|
|
simulateDblTap();
|
|
originalZoom *= viewer.zoomPerClick;
|
|
|
|
zoom = viewer.viewport.getZoom();
|
|
Util.assessNumericValue(
|
|
assert,
|
|
originalZoom,
|
|
zoom,
|
|
epsilon,
|
|
"Zoom on double tap should not be prevented"
|
|
);
|
|
|
|
TouchUtil.resetTracker(tracker);
|
|
viewer.close();
|
|
done();
|
|
};
|
|
|
|
viewer.addHandler("open", onOpen);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
}
|
|
);
|
|
|
|
// ----------
|
|
QUnit.test(
|
|
"EventSource/MouseTracker/Viewer: event.originalEvent event.userData canvas-drag canvas-drag-end canvas-release canvas-click",
|
|
function (assert) {
|
|
var done = assert.async();
|
|
var $canvas = $(viewer.element)
|
|
.find(".openseadragon-canvas")
|
|
.not(".navigator .openseadragon-canvas"),
|
|
mouseTracker = null,
|
|
userData = { item1: "Test user data", item2: Math.random() },
|
|
originalUserData = {
|
|
item1: userData.item1,
|
|
item2: userData.item2,
|
|
},
|
|
dragCount = 10,
|
|
dragsHandledEventSource = 0,
|
|
dragEndsHandledEventSource = 0,
|
|
releasesHandledEventSource = 0,
|
|
clicksHandledEventSource = 0,
|
|
eventsHandledMouseTracker = 0,
|
|
eventSourcePassedMouseTracker = 0,
|
|
originalEventsPassedMouseTracker = 0,
|
|
eventsHandledViewer = 0,
|
|
originalEventsPassedViewer = 0,
|
|
dragEndsExpected = 1,
|
|
releasesExpected = 1;
|
|
|
|
var onOpen = function () {
|
|
viewer.removeHandler("open", onOpen);
|
|
|
|
viewer.addHandler("canvas-drag", onEventSourceDrag);
|
|
viewer.addHandler("canvas-drag-end", onEventSourceDragEnd);
|
|
viewer.addHandler("canvas-release", onEventSourceRelease);
|
|
viewer.addHandler("canvas-click", onEventSourceClick);
|
|
|
|
mouseTracker = new OpenSeadragon.MouseTracker({
|
|
element: $canvas[0],
|
|
userData: userData,
|
|
clickTimeThreshold:
|
|
OpenSeadragon.DEFAULT_SETTINGS.clickTimeThreshold,
|
|
clickDistThreshold:
|
|
OpenSeadragon.DEFAULT_SETTINGS.clickDistThreshold,
|
|
dblClickTimeThreshold:
|
|
OpenSeadragon.DEFAULT_SETTINGS.dblClickTimeThreshold,
|
|
dblClickDistThreshold:
|
|
OpenSeadragon.DEFAULT_SETTINGS.dblClickDistThreshold,
|
|
focusHandler: onMouseTrackerFocus,
|
|
blurHandler: onMouseTrackerBlur,
|
|
enterHandler: onMouseTrackerEnter,
|
|
pressHandler: onMouseTrackerPress,
|
|
moveHandler: onMouseTrackerMove,
|
|
dragHandler: onMouseTrackerDrag,
|
|
dragEndHandler: onMouseTrackerDragEnd,
|
|
releaseHandler: onMouseTrackerRelease,
|
|
clickHandler: onMouseTrackerClick,
|
|
leaveHandler: onMouseTrackerLeave,
|
|
});
|
|
|
|
var event = {
|
|
clientX: 1,
|
|
clientY: 1,
|
|
};
|
|
|
|
$canvas.simulate("focus", event);
|
|
Util.simulateViewerClickWithDrag({
|
|
viewer: viewer,
|
|
widthFactor: 0.25,
|
|
heightFactor: 0.25,
|
|
dragCount: dragCount,
|
|
dragDx: 1,
|
|
dragDy: 1,
|
|
});
|
|
$canvas.simulate("blur", event);
|
|
};
|
|
|
|
var checkOriginalEventReceivedViewer = function (event) {
|
|
eventsHandledViewer++;
|
|
//TODO Provide a better check for the original event...simulate doesn't currently extend the object
|
|
// with arbitrary user data.
|
|
if (event && event.originalEvent) {
|
|
originalEventsPassedViewer++;
|
|
}
|
|
};
|
|
|
|
var onEventSourceDrag = function (event) {
|
|
checkOriginalEventReceivedViewer(event);
|
|
dragsHandledEventSource++;
|
|
};
|
|
|
|
var onEventSourceDragEnd = function (event) {
|
|
checkOriginalEventReceivedViewer(event);
|
|
dragEndsHandledEventSource++;
|
|
};
|
|
|
|
var onEventSourceRelease = function (event) {
|
|
checkOriginalEventReceivedViewer(event);
|
|
releasesHandledEventSource++;
|
|
};
|
|
|
|
var onEventSourceClick = function (event) {
|
|
checkOriginalEventReceivedViewer(event);
|
|
clicksHandledEventSource++;
|
|
};
|
|
|
|
var checkOriginalEventReceived = function (event) {
|
|
eventsHandledMouseTracker++;
|
|
if (event && event.eventSource === mouseTracker) {
|
|
eventSourcePassedMouseTracker++;
|
|
}
|
|
//TODO Provide a better check for the original event...simulate doesn't currently extend the object
|
|
// with arbitrary user data.
|
|
if (event && event.originalEvent) {
|
|
originalEventsPassedMouseTracker++;
|
|
}
|
|
};
|
|
|
|
var onMouseTrackerFocus = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerBlur = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerEnter = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerPress = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerMove = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerDrag = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerDragEnd = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerRelease = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerClick = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
};
|
|
|
|
var onMouseTrackerLeave = function (event) {
|
|
checkOriginalEventReceived(event);
|
|
|
|
mouseTracker.destroy();
|
|
viewer.removeHandler("canvas-drag", onEventSourceDrag);
|
|
viewer.removeHandler("canvas-release", onEventSourceRelease);
|
|
viewer.removeHandler("canvas-click", onEventSourceClick);
|
|
|
|
assert.equal(
|
|
dragsHandledEventSource,
|
|
dragCount,
|
|
"'canvas-drag' event count matches 'mousemove' event count (" +
|
|
dragCount +
|
|
")"
|
|
);
|
|
assert.equal(
|
|
dragEndsHandledEventSource,
|
|
dragEndsExpected,
|
|
"'canvas-drag-end' event count matches expected (" +
|
|
dragEndsExpected +
|
|
")"
|
|
);
|
|
assert.equal(
|
|
releasesHandledEventSource,
|
|
releasesExpected,
|
|
"'canvas-release' event count matches expected (" +
|
|
releasesExpected +
|
|
")"
|
|
);
|
|
assert.equal(
|
|
clicksHandledEventSource,
|
|
releasesExpected,
|
|
"'canvas-click' event count matches expected (" +
|
|
releasesExpected +
|
|
")"
|
|
);
|
|
assert.equal(
|
|
originalEventsPassedViewer,
|
|
eventsHandledViewer,
|
|
"Original event received count matches expected (" +
|
|
eventsHandledViewer +
|
|
")"
|
|
);
|
|
|
|
assert.equal(
|
|
eventSourcePassedMouseTracker,
|
|
eventsHandledMouseTracker,
|
|
"Event source received count matches expected (" +
|
|
eventsHandledMouseTracker +
|
|
")"
|
|
);
|
|
assert.equal(
|
|
originalEventsPassedMouseTracker,
|
|
eventsHandledMouseTracker,
|
|
"Original event received count matches expected (" +
|
|
eventsHandledMouseTracker +
|
|
")"
|
|
);
|
|
assert.deepEqual(
|
|
event.userData,
|
|
originalUserData,
|
|
"MouseTracker userData was untouched"
|
|
);
|
|
|
|
viewer.close();
|
|
done();
|
|
};
|
|
|
|
viewer.addHandler("open", onOpen);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
}
|
|
);
|
|
|
|
// ----------
|
|
QUnit.test("EventSource: addHandler without userData", function (assert) {
|
|
var done = assert.async();
|
|
var openHandler = function (event) {
|
|
viewer.removeHandler("open", openHandler);
|
|
assert.ok(event, "Event handler received event data");
|
|
if (event) {
|
|
assert.strictEqual(
|
|
event.eventSource,
|
|
viewer,
|
|
"eventSource sent, eventSource is viewer"
|
|
);
|
|
assert.strictEqual(
|
|
event.userData,
|
|
null,
|
|
"User data defaulted to null"
|
|
);
|
|
}
|
|
viewer.close();
|
|
done();
|
|
};
|
|
|
|
viewer.addHandler("open", openHandler);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
});
|
|
|
|
// ----------
|
|
QUnit.test("EventSource: addHandler with userData", function (assert) {
|
|
var done = assert.async();
|
|
var userData = { item1: "Test user data", item2: Math.random() },
|
|
originalUserData = { item1: userData.item1, item2: userData.item2 };
|
|
|
|
var openHandler = function (event) {
|
|
viewer.removeHandler("open", openHandler);
|
|
assert.ok(event, "Event handler received event data");
|
|
assert.ok(
|
|
event && event.userData,
|
|
"Event handler received user data"
|
|
);
|
|
if (event && event.userData) {
|
|
assert.deepEqual(
|
|
event.userData,
|
|
originalUserData,
|
|
"User data was untouched"
|
|
);
|
|
}
|
|
viewer.close();
|
|
done();
|
|
};
|
|
|
|
viewer.addHandler("open", openHandler, userData);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
});
|
|
|
|
// ----------
|
|
QUnit.test("EventSource: addOnceHandler", function (assert) {
|
|
var eventSource = new OpenSeadragon.EventSource();
|
|
var userData = "data";
|
|
var eventData = {
|
|
foo: 1,
|
|
};
|
|
var handlerCalledCount = 0;
|
|
eventSource.addOnceHandler(
|
|
"test-event",
|
|
function (event) {
|
|
handlerCalledCount++;
|
|
assert.strictEqual(
|
|
event.foo,
|
|
eventData.foo,
|
|
"Event data should be transmitted to the event."
|
|
);
|
|
assert.strictEqual(
|
|
event.userData,
|
|
userData,
|
|
"User data should be transmitted to the event."
|
|
);
|
|
},
|
|
userData
|
|
);
|
|
assert.strictEqual(
|
|
0,
|
|
handlerCalledCount,
|
|
"Handler should not have been called yet."
|
|
);
|
|
eventSource.raiseEvent("test-event", eventData);
|
|
assert.strictEqual(
|
|
1,
|
|
handlerCalledCount,
|
|
"Handler should have been called once."
|
|
);
|
|
eventSource.raiseEvent("test-event", eventData);
|
|
assert.strictEqual(
|
|
1,
|
|
handlerCalledCount,
|
|
"Handler should still have been called once."
|
|
);
|
|
});
|
|
|
|
// ----------
|
|
QUnit.test("EventSource: addOnceHandler 2 times", function (assert) {
|
|
var eventSource = new OpenSeadragon.EventSource();
|
|
var userData = "data";
|
|
var eventData = {
|
|
foo: 1,
|
|
};
|
|
var handlerCalledCount = 0;
|
|
eventSource.addOnceHandler(
|
|
"test-event",
|
|
function (event) {
|
|
handlerCalledCount++;
|
|
assert.strictEqual(
|
|
event.foo,
|
|
eventData.foo,
|
|
"Event data should be transmitted to the event."
|
|
);
|
|
assert.strictEqual(
|
|
event.userData,
|
|
userData,
|
|
"User data should be transmitted to the event."
|
|
);
|
|
},
|
|
userData,
|
|
2
|
|
);
|
|
assert.strictEqual(
|
|
0,
|
|
handlerCalledCount,
|
|
"Handler should not have been called yet."
|
|
);
|
|
eventSource.raiseEvent("test-event", eventData);
|
|
assert.strictEqual(
|
|
1,
|
|
handlerCalledCount,
|
|
"Handler should have been called once."
|
|
);
|
|
eventSource.raiseEvent("test-event", eventData);
|
|
assert.strictEqual(
|
|
2,
|
|
handlerCalledCount,
|
|
"Handler should have been called twice."
|
|
);
|
|
eventSource.raiseEvent("test-event", eventData);
|
|
assert.strictEqual(
|
|
2,
|
|
handlerCalledCount,
|
|
"Handler should still have been called twice."
|
|
);
|
|
});
|
|
|
|
// ----------
|
|
QUnit.test("Viewer: tile-drawing event", function (assert) {
|
|
var done = assert.async();
|
|
var tileDrawing = function (event) {
|
|
viewer.removeHandler("tile-drawing", tileDrawing);
|
|
assert.ok(event, "Event handler should be invoked");
|
|
if (event) {
|
|
// Make sure we have the expected elements set
|
|
assert.ok(event.context, "Context should be set");
|
|
assert.ok(event.tile, "Tile should be set");
|
|
assert.ok(event.rendered, "Rendered should be set");
|
|
}
|
|
viewer.close();
|
|
done();
|
|
};
|
|
|
|
viewer.addHandler("tile-drawing", tileDrawing);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
});
|
|
|
|
// tile-loaded event tests
|
|
QUnit.test(
|
|
"Viewer: tile-loaded event without callback.",
|
|
function (assert) {
|
|
var done = assert.async();
|
|
function tileLoaded(event) {
|
|
viewer.removeHandler("tile-loaded", tileLoaded);
|
|
var tile = event.tile;
|
|
assert.ok(
|
|
tile.loading,
|
|
"The tile should be marked as loading."
|
|
);
|
|
assert.notOk(
|
|
tile.loaded,
|
|
"The tile should not be marked as loaded."
|
|
);
|
|
setTimeout(function () {
|
|
assert.notOk(
|
|
tile.loading,
|
|
"The tile should not be marked as loading."
|
|
);
|
|
assert.ok(
|
|
tile.loaded,
|
|
"The tile should be marked as loaded."
|
|
);
|
|
done();
|
|
}, 0);
|
|
}
|
|
|
|
viewer.addHandler("tile-loaded", tileLoaded);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
}
|
|
);
|
|
|
|
QUnit.test("Viewer: tile-loaded event with 1 callback.", function (assert) {
|
|
var done = assert.async();
|
|
function tileLoaded(event) {
|
|
viewer.removeHandler("tile-loaded", tileLoaded);
|
|
var tile = event.tile;
|
|
var callback = event.getCompletionCallback();
|
|
assert.ok(tile.loading, "The tile should be marked as loading.");
|
|
assert.notOk(
|
|
tile.loaded,
|
|
"The tile should not be marked as loaded."
|
|
);
|
|
assert.ok(callback, "The event should have a callback.");
|
|
setTimeout(function () {
|
|
assert.ok(
|
|
tile.loading,
|
|
"The tile should be marked as loading."
|
|
);
|
|
assert.notOk(
|
|
tile.loaded,
|
|
"The tile should not be marked as loaded."
|
|
);
|
|
callback();
|
|
assert.notOk(
|
|
tile.loading,
|
|
"The tile should not be marked as loading."
|
|
);
|
|
assert.ok(tile.loaded, "The tile should be marked as loaded.");
|
|
done();
|
|
}, 0);
|
|
}
|
|
|
|
viewer.addHandler("tile-loaded", tileLoaded);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
});
|
|
|
|
QUnit.test(
|
|
"Viewer: tile-loaded event with 2 callbacks.",
|
|
function (assert) {
|
|
var done = assert.async();
|
|
function tileLoaded(event) {
|
|
viewer.removeHandler("tile-loaded", tileLoaded);
|
|
var tile = event.tile;
|
|
var callback1 = event.getCompletionCallback();
|
|
var callback2 = event.getCompletionCallback();
|
|
assert.ok(
|
|
tile.loading,
|
|
"The tile should be marked as loading."
|
|
);
|
|
assert.notOk(
|
|
tile.loaded,
|
|
"The tile should not be marked as loaded."
|
|
);
|
|
setTimeout(function () {
|
|
assert.ok(
|
|
tile.loading,
|
|
"The tile should be marked as loading."
|
|
);
|
|
assert.notOk(
|
|
tile.loaded,
|
|
"The tile should not be marked as loaded."
|
|
);
|
|
callback1();
|
|
assert.ok(
|
|
tile.loading,
|
|
"The tile should be marked as loading."
|
|
);
|
|
assert.notOk(
|
|
tile.loaded,
|
|
"The tile should not be marked as loaded."
|
|
);
|
|
setTimeout(function () {
|
|
assert.ok(
|
|
tile.loading,
|
|
"The tile should be marked as loading."
|
|
);
|
|
assert.notOk(
|
|
tile.loaded,
|
|
"The tile should not be marked as loaded."
|
|
);
|
|
callback2();
|
|
assert.notOk(
|
|
tile.loading,
|
|
"The tile should not be marked as loading."
|
|
);
|
|
assert.ok(
|
|
tile.loaded,
|
|
"The tile should be marked as loaded."
|
|
);
|
|
done();
|
|
}, 0);
|
|
}, 0);
|
|
}
|
|
|
|
viewer.addHandler("tile-loaded", tileLoaded);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
}
|
|
);
|
|
|
|
QUnit.test("Viewer: tile-unloaded event.", function (assert) {
|
|
var tiledImage;
|
|
var tile;
|
|
var done = assert.async();
|
|
|
|
function tileLoaded(event) {
|
|
viewer.removeHandler("tile-loaded", tileLoaded);
|
|
tiledImage = event.tiledImage;
|
|
tile = event.tile;
|
|
setTimeout(function () {
|
|
tiledImage.reset();
|
|
}, 0);
|
|
}
|
|
|
|
function tileUnloaded(event) {
|
|
viewer.removeHandler("tile-unloaded", tileUnloaded);
|
|
assert.equal(
|
|
tile,
|
|
event.tile,
|
|
"The unloaded tile should be the same than the loaded one."
|
|
);
|
|
assert.equal(
|
|
tiledImage,
|
|
event.tiledImage,
|
|
"The tiledImage of the unloaded tile should be the same than the one of the loaded one."
|
|
);
|
|
done();
|
|
}
|
|
|
|
viewer.addHandler("tile-loaded", tileLoaded);
|
|
viewer.addHandler("tile-unloaded", tileUnloaded);
|
|
viewer.open("/test/data/testpattern.dzi");
|
|
});
|
|
})();
|