<!DOCTYPE html>
<html>
	<head>
		<title>Drag and drop alternating between incompleted windowless Flash drag and page</title>
		<style type="text/css">
div {
	width: 100px;
	height: 100px;
	background: fuchsia;
}
object {
	width: 400px;
	height: 400px;
	border: 5px solid black;
}
		</style>
		<script type="text/javascript">
window.onload = function () {
	document.getElementsByTagName('div')[0].ondragstart = function (e) {
		e.dataTransfer.effectAllowed = 'copy';
		e.dataTransfer.setData('text','dummy text');
	};
};
		</script>
	</head>
	<body>
		<noscript><p>Enable JavaScript and reload</p></noscript>
		<ol>
			<li>Drag the orange square until the mouse is outside the right side of the black square but the edge of the orange square can still be seen, then release it.</li>
			<li>Without passing over the black square again, move the mouse to the pink square.</li>
			<li>Drag the pink square onto the white area inside the black square and release it. The drag placeholder should disappear (either when releasing, or when passing the black square), and the mouse cursor should return to normal. The orange square should jump to the mouse position. Fail if the pink square does not immediately respond to the drag attempt.</li>
			<li>The orange square may optionally continue to follow the mouse.</li>
			<!-- There are no rules here. Browsers may mask the mouseup event from the plugin (since a dnd operation was in progress), or they may pass the mouseup to the plugin (since the dnd operation has completed). -->
		</ol>
		<div draggable="true"></div>
		<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>