<!DOCTYPE html>
<html>
	<head>
		<title>Drag and drop in windowless Flash with Alt+Tab over page</title>
		<style type="text/css">
object {
	width: 400px;
	height: 400px;
	border: 5px solid black;
}
		</style>
	</head>
	<body>
		<noscript><p>Enable JavaScript and reload</p></noscript>
		<ol>
			<li>Ensure at least one other program is running, with its window maximised.</li>
			<li>Drag the orange square around until the mouse is outside the black square.</li>
			<li>Without releasing the mouse button, use Alt+Tab (or your system's equivalent) to switch to the other program, then back to this one.</li>
			<li>Move the mouse inside the black square. The orange square should continue to follow the mouse.</li>
		</ol>
		<script type="text/javascript">
var plugincode = '<object data="dragndrop.swf" type="application/x-shockwave-flash"><param name="wmode" value="opaque">Flash plugin is required for this test.</object>';
		</script>
		<script type="text/javascript" src="click-to-activate.js"></script>
	</body>
</html>