The Tor Browser / file comparison

comparison: widget/tests/native_mouse_mac_window.xul

widget/tests/native_mouse_mac_window.xul

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:3c43962a5e61
1 <?xml version="1.0"?>
2
3 <!-- This Source Code Form is subject to the terms of the Mozilla Public
4 - License, v. 2.0. If a copy of the MPL was not distributed with this
5 - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
6
7 <?xml-stylesheet href="chrome://global/skin" type="text/css"?>
8
9 <window id="NativeMenuWindow"
10 xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
11 xmlns:html="http://www.w3.org/1999/xhtml"
12 width="600"
13 height="600"
14 title="Native Mouse Event Test"
15 orient="vertical">
16 <script type="application/javascript"
17 src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js" />
18
19 <box height="200" id="box"/>
20 <menupopup id="popup" width="250" height="50"/>
21 <panel id="panel" width="250" height="50" noautohide="true"/>
22
23 <script type="application/javascript"><![CDATA[
24
25 function ok(condition, message) {
26 window.opener.wrappedJSObject.SimpleTest.ok(condition, message);
27 }
28
29 function is(a, b, message) {
30 window.opener.wrappedJSObject.SimpleTest.is(a, b, message);
31 }
32
33 function todo(condition, message) {
34 window.opener.wrappedJSObject.SimpleTest.todo(condition, message);
35 }
36
37 function todo_is(a, b, message) {
38 window.opener.wrappedJSObject.SimpleTest.todo_is(a, b, message);
39 }
40
41 function onTestsFinished() {
42 clearTimeout(gAfterLoopExecution);
43 observe(window, eventMonitor, false);
44 observe(gRightWindow, eventMonitor, false);
45 observe(gPopup, eventMonitor, false);
46 gRightWindow.close();
47 var openerSimpleTest = window.opener.wrappedJSObject.SimpleTest;
48 window.close();
49 openerSimpleTest.finish();
50 }
51
52 const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
53 const xulWin = 'data:application/vnd.mozilla.xul+xml,<?xml version="1.0"?><?xml-stylesheet href="chrome://global/skin" type="text/css"?><window xmlns="' + XUL_NS + '"/>';
54
55 const NSLeftMouseDown = 1,
56 NSLeftMouseUp = 2,
57 NSRightMouseDown = 3,
58 NSRightMouseUp = 4,
59 NSMouseMoved = 5,
60 NSLeftMouseDragged = 6,
61 NSRightMouseDragged = 7,
62 NSMouseEntered = 8,
63 NSMouseExited = 9,
64 NSKeyDown = 10,
65 NSKeyUp = 11,
66 NSFlagsChanged = 12,
67 NSAppKitDefined = 13,
68 NSSystemDefined = 14,
69 NSApplicationDefined = 15,
70 NSPeriodic = 16,
71 NSCursorUpdate = 17,
72 NSScrollWheel = 22,
73 NSTabletPoint = 23,
74 NSTabletProximity = 24,
75 NSOtherMouseDown = 25,
76 NSOtherMouseUp = 26,
77 NSOtherMouseDragged = 27,
78 NSEventTypeGesture = 29,
79 NSEventTypeMagnify = 30,
80 NSEventTypeSwipe = 31,
81 NSEventTypeRotate = 18,
82 NSEventTypeBeginGesture = 19,
83 NSEventTypeEndGesture = 20;
84
85 const NSAlphaShiftKeyMask = 1 << 16,
86 NSShiftKeyMask = 1 << 17,
87 NSControlKeyMask = 1 << 18,
88 NSAlternateKeyMask = 1 << 19,
89 NSCommandKeyMask = 1 << 20,
90 NSNumericPadKeyMask = 1 << 21,
91 NSHelpKeyMask = 1 << 22,
92 NSFunctionKeyMask = 1 << 23;
93
94 const gDebug = false;
95
96 function printDebug(msg) { if (gDebug) dump(msg); }
97
98 var gExpectedEvents = [];
99 var gRightWindow = null, gPopup = null;
100 var gCurrentMouseX = 0, gCurrentMouseY = 0;
101 var gAfterLoopExecution = 0;
102
103 function testMouse(x, y, msg, elem, win, exp, flags, callback) {
104 clearExpectedEvents();
105 var syntheticEvent = null;
106 exp.forEach(function (expEv) {
107 expEv.screenX = x;
108 expEv.screenY = y;
109 if (expEv.synthetic) {
110 is(syntheticEvent, null,
111 "Can't handle two synthetic events in a single testMouse call");
112 syntheticEvent = expEv;
113 }
114 gExpectedEvents.push(expEv);
115 });
116 printDebug("sending event: " + x + ", " + y + " (" + msg + ")\n");
117 gCurrentMouseX = x;
118 gCurrentMouseY = y;
119 var utils = win.QueryInterface(Components.interfaces.nsIInterfaceRequestor).
120 getInterface(Components.interfaces.nsIDOMWindowUtils);
121 var callbackFunc = function() {
122 clearExpectedEvents();
123 callback();
124 }
125 if (syntheticEvent) {
126 // Set up this listener before we sendNativeMouseEvent, just
127 // in case that synchronously calls us.
128 eventListenOnce(syntheticEvent.target, syntheticEvent.type,
129 // Trigger callbackFunc async, so we're not assuming
130 // anything about how our listener gets ordered with
131 // others.
132 function () { SimpleTest.executeSoon(callbackFunc) });
133 }
134 utils.sendNativeMouseEvent(x, y, msg, flags || 0, elem);
135 if (!syntheticEvent) {
136 gAfterLoopExecution = setTimeout(callbackFunc, 0);
137 }
138 }
139
140 function eventListenOnce(elem, name, callback) {
141 elem.addEventListener(name, function(e) {
142 elem.removeEventListener(name, arguments.callee, false);
143 callback(e);
144 }, false);
145 }
146
147 function focusAndThen(win, callback) {
148 eventListenOnce(win, "focus", callback);
149 printDebug("focusing a window\n");
150 win.focus();
151 }
152
153 function eventToString(e) {
154 return JSON.stringify({
155 type: e.type, target: e.target.nodeName, screenX: e.screenX, screenY: e.screenY
156 });
157 }
158
159 function clearExpectedEvents() {
160 while (gExpectedEvents.length > 0) {
161 var expectedEvent = gExpectedEvents.shift();
162 var errFun = expectedEvent.shouldFireButDoesnt ? todo : ok;
163 errFun(false, "Didn't receive expected event: " + eventToString(expectedEvent));
164 }
165 }
166
167 var gEventNum = 0;
168
169 function eventMonitor(e) {
170 printDebug("got event: " + eventToString(e) + "\n");
171 processEvent(e);
172 }
173
174 function processEvent(e) {
175 if (e.screenX != gCurrentMouseX || e.screenY != gCurrentMouseY) {
176 todo(false, "Oh no! Received a stray event from a confused tracking area. Aborting test.");
177 onTestsFinished();
178 return;
179 }
180 var expectedEvent = gExpectedEvents.shift();
181 if (!expectedEvent) {
182 ok(false, "received event I didn't expect: " + eventToString(e));
183 return;
184 }
185 if (e.type != expectedEvent.type) {
186 // Didn't get expectedEvent.
187 var errFun = expectedEvent.shouldFireButDoesnt ? todo : ok;
188 errFun(false, "Didn't receive expected event: " + eventToString(expectedEvent));
189 return processEvent(e);
190 }
191 gEventNum++;
192 is(e.screenX, expectedEvent.screenX, gEventNum + " | wrong X coord for event " + eventToString(e));
193 is(e.screenY, expectedEvent.screenY, gEventNum + " | wrong Y coord for event " + eventToString(e));
194 is(e.target, expectedEvent.target, gEventNum + " | wrong target for event " + eventToString(e));
195 if (expectedEvent.firesButShouldnt) {
196 todo(false, gEventNum + " | Got an event that should not have fired: " + eventToString(e));
197 }
198 }
199
200 function observe(elem, fun, add) {
201 var addOrRemove = add ? "addEventListener" : "removeEventListener";
202 elem[addOrRemove]("mousemove", fun, false);
203 elem[addOrRemove]("mouseover", fun, false);
204 elem[addOrRemove]("mouseout", fun, false);
205 elem[addOrRemove]("mousedown", fun, false);
206 elem[addOrRemove]("mouseup", fun, false);
207 elem[addOrRemove]("click", fun, false);
208 }
209
210 function start() {
211 window.resizeTo(200, 200);
212 window.moveTo(50, 50);
213 gRightWindow = open(xulWin, '', 'chrome,screenX=300,screenY=50,width=200,height=200');
214 eventListenOnce(gRightWindow, "focus", function () {
215 focusAndThen(window, runTests);
216 });
217 gPopup = document.getElementById("popup");
218 }
219
220 function runTests() {
221 observe(window, eventMonitor, true);
222 observe(gRightWindow, eventMonitor, true);
223 var left = window, right = gRightWindow;
224 var leftElem = document.getElementById("box");
225 var rightElem = gRightWindow.document.documentElement;
226 var panel = document.getElementById("panel");
227 var tooltip = (function createTooltipInRightWindow() {
228 var _tooltip = right.document.createElementNS(XUL_NS, "tooltip");
229 _tooltip.setAttribute("id", "tip");
230 _tooltip.setAttribute("width", "80");
231 _tooltip.setAttribute("height", "20");
232 right.document.documentElement.appendChild(_tooltip);
233 return _tooltip;
234 })();
235 var tests = [
236
237 // Part 1: Disallow click-through
238
239 function blockClickThrough(callback) {
240 document.documentElement.setAttribute("clickthrough", "never");
241 gRightWindow.document.documentElement.setAttribute("clickthrough", "never");
242 callback();
243 },
244 // Enter the left window, which is focused.
245 [150, 150, NSMouseMoved, null, left, [
246 { type: "mouseover", target: leftElem },
247 { type: "mousemove", target: leftElem }
248 ]],
249 // Test that moving inside the window fires mousemove events.
250 [170, 150, NSMouseMoved, null, left, [
251 { type: "mousemove", target: leftElem },
252 ]],
253 // Leaving the window should fire a mouseout event...
254 [170, 20, NSMouseMoved, null, left, [
255 { type: "mouseout", target: leftElem },
256 ]],
257 // ... and entering a mouseover event.
258 [170, 120, NSMouseMoved, null, left, [
259 { type: "mouseover", target: leftElem },
260 { type: "mousemove", target: leftElem },
261 ]],
262 // Move over the right window, which is inactive.
263 // Inactive windows shouldn't respond to mousemove events when clickthrough="never",
264 // so we should only get a mouseout event, no mouseover event.
265 [400, 150, NSMouseMoved, null, right, [
266 { type: "mouseout", target: leftElem },
267 ]],
268 // Left-clicking while holding Cmd and middle clicking should work even
269 // on inactive windows, but without making them active.
270 [400, 150, NSLeftMouseDown, null, right, [
271 { type: "mousedown", target: rightElem },
272 ], NSCommandKeyMask],
273 [400, 150, NSLeftMouseUp, null, right, [
274 { type: "mouseup", target: rightElem },
275 { type: "click", target: rightElem },
276 ], NSCommandKeyMask],
277 [400, 150, NSOtherMouseDown, null, right, [
278 { type: "mousedown", target: rightElem },
279 ]],
280 [400, 150, NSOtherMouseUp, null, right, [
281 { type: "mouseup", target: rightElem },
282 { type: "click", target: rightElem },
283 ]],
284 // Clicking an inactive window should make it active and fire a mouseover
285 // event.
286 [400, 150, NSLeftMouseDown, null, right, [
287 { type: "mouseover", target: rightElem, synthetic: true },
288 ]],
289 [400, 150, NSLeftMouseUp, null, right, [
290 ]],
291 // Now it's focused, so we should get a mousedown event when clicking.
292 [400, 150, NSLeftMouseDown, null, right, [
293 { type: "mousedown", target: rightElem },
294 ]],
295 // Let's drag to the right without letting the button go.
296 [410, 150, NSLeftMouseDragged, null, right, [
297 { type: "mousemove", target: rightElem },
298 ]],
299 // Let go of the mouse.
300 [410, 150, NSLeftMouseUp, null, right, [
301 { type: "mouseup", target: rightElem },
302 { type: "click", target: rightElem },
303 ]],
304 // Move the mouse back over the left window, which is inactive.
305 [150, 170, NSMouseMoved, null, left, [
306 { type: "mouseout", target: rightElem },
307 ]],
308 // Now we're being sneaky. The left window is inactive, but *right*-clicks to it
309 // should still get through. Test that.
310 // Ideally we'd be bracketing that event with over and out events, too, but it
311 // probably doesn't matter too much.
312 [150, 170, NSRightMouseDown, null, left, [
313 { type: "mouseover", target: leftElem, shouldFireButDoesnt: true },
314 { type: "mousedown", target: leftElem },
315 { type: "mouseout", target: leftElem, shouldFireButDoesnt: true },
316 ]],
317 // Let go of the mouse.
318 [150, 170, NSRightMouseUp, null, left, [
319 { type: "mouseover", target: leftElem, shouldFireButDoesnt: true },
320 { type: "mouseup", target: leftElem },
321 { type: "click", target: leftElem },
322 { type: "mouseout", target: leftElem, shouldFireButDoesnt: true },
323 ]],
324 // Right clicking hasn't focused it, so the window is still inactive.
325 // Let's focus it; this time without the mouse, for variaton's sake.
326 // Still, mouseout and mouseover events should fire.
327 function raiseLeftWindow(callback) {
328 clearExpectedEvents();
329 gExpectedEvents.push({ screenX: 150, screenY: 170, type: "mouseover", target: leftElem });
330 // We have to be a bit careful here. The synthetic mouse event may
331 // not fire for a bit after we focus the left window.
332 eventListenOnce(leftElem, "mouseover", function() {
333 // Trigger callback async, so we're not assuming
334 // anything about how our listener gets ordered with others.
335 SimpleTest.executeSoon(callback);
336 });
337 printDebug("focusing left window");
338 left.focus();
339 },
340 // It's active, so it should respond to mousemove events now.
341 [150, 170, NSMouseMoved, null, left, [
342 { type: "mousemove", target: leftElem },
343 ]],
344 // This was boring... let's introduce a popup. It will overlap both the left
345 // and the right window.
346 function openPopupInLeftWindow(callback) {
347 eventListenOnce(gPopup, "popupshown", callback);
348 gPopup.openPopupAtScreen(150, 50, true);
349 },
350 // Move the mouse over the popup.
351 [200, 80, NSMouseMoved, gPopup, left, [
352 { type: "mouseout", target: leftElem },
353 { type: "mouseover", target: gPopup },
354 { type: "mousemove", target: gPopup },
355 ]],
356 // Move the mouse back over the left window outside the popup.
357 [160, 170, NSMouseMoved, null, left, [
358 { type: "mouseout", target: gPopup },
359 { type: "mouseover", target: leftElem },
360 { type: "mousemove", target: leftElem },
361 ]],
362 // Back over the popup...
363 [190, 80, NSMouseMoved, gPopup, left, [
364 { type: "mouseout", target: leftElem },
365 { type: "mouseover", target: gPopup },
366 { type: "mousemove", target: gPopup },
367 ]],
368 // ...and over into the right window.
369 // It's inactive, so it shouldn't get mouseover events yet.
370 [400, 170, NSMouseMoved, null, right, [
371 { type: "mouseout", target: gPopup },
372 ]],
373 // Again, no mouse events please, even though a popup is open. (bug 425556)
374 [400, 180, NSMouseMoved, null, right, [
375 ]],
376 // Activate the right window with a click.
377 // This will close the popup and make the mouse enter the right window.
378 [400, 180, NSLeftMouseDown, null, right, [
379 { type: "mouseover", target: rightElem, synthetic: true },
380 ]],
381 [400, 180, NSLeftMouseUp, null, right, [
382 ]],
383 function verifyPopupClosed2(callback) {
384 is(gPopup.popupBoxObject.popupState, "closed", "popup should have closed when clicking");
385 callback();
386 },
387 // Now the right window is active; click it again, just for fun.
388 [400, 180, NSLeftMouseDown, null, right, [
389 { type: "mousedown", target: rightElem },
390 ]],
391 [400, 180, NSLeftMouseUp, null, right, [
392 { type: "mouseup", target: rightElem },
393 { type: "click", target: rightElem },
394 ]],
395
396 // Time for our next trick: a tooltip!
397 // Install the tooltip, but don't show it yet.
398 function setTooltip(callback) {
399 rightElem.setAttribute("tooltip", "tip");
400 gExpectedEvents.push({ screenX: 410, screenY: 180, type: "mousemove", target: rightElem });
401 eventListenOnce(rightElem, "popupshown", callback);
402 gCurrentMouseX = 410;
403 gCurrentMouseY = 180;
404 var utils = right.QueryInterface(Components.interfaces.nsIInterfaceRequestor).
405 getInterface(Components.interfaces.nsIDOMWindowUtils);
406 utils.sendNativeMouseEvent(410, 180, NSMouseMoved, 0, null);
407 },
408 // Now the tooltip is visible.
409 // Move the mouse a little to the right.
410 [411, 180, NSMouseMoved, null, right, [
411 { type: "mousemove", target: rightElem },
412 ]],
413 // Move another pixel.
414 [412, 180, NSMouseMoved, null, right, [
415 { type: "mousemove", target: rightElem },
416 ]],
417 // Move up and click to make the tooltip go away.
418 [412, 80, NSMouseMoved, null, right, [
419 { type: "mousemove", target: rightElem },
420 ]],
421 [412, 80, NSLeftMouseDown, null, right, [
422 { type: "mousedown", target: rightElem },
423 ]],
424 [412, 80, NSLeftMouseUp, null, right, [
425 { type: "mouseup", target: rightElem },
426 { type: "click", target: rightElem },
427 ]],
428 // OK, next round. Open a panel in the left window, which is inactive.
429 function openPanel(callback) {
430 eventListenOnce(panel, "popupshown", callback);
431 panel.openPopupAtScreen(150, 150, false);
432 },
433 // The panel is parented, so it will be z-ordered over its parent but
434 // under the active window.
435 // Now we move the mouse over the part where the panel rect intersects the
436 // right window's rect. Since the panel is under the window, all the events
437 // should target the right window.
438 [390, 170, NSMouseMoved, null, right, [
439 { type: "mousemove", target: rightElem },
440 ]],
441 [390, 171, NSMouseMoved, null, right, [
442 { type: "mousemove", target: rightElem },
443 ]],
444 [391, 171, NSMouseMoved, null, right, [
445 { type: "mousemove", target: rightElem },
446 ]],
447 // Now move off the right window, so that the mouse is directly over the
448 // panel.
449 [260, 170, NSMouseMoved, panel, left, [
450 { type: "mouseout", target: rightElem },
451 ]],
452 [260, 171, NSMouseMoved, panel, left, [
453 ]],
454 [261, 171, NSMouseMoved, panel, left, [
455 ]],
456 // Let's be evil and click it.
457 [261, 171, NSLeftMouseDown, panel, left, [
458 ]],
459 [261, 171, NSLeftMouseUp, panel, left, [
460 ]],
461 // This didn't focus the window, unfortunately, so let's do it ourselves.
462 function raiseLeftWindowTakeTwo(callback) {
463 focusAndThen(left, callback);
464 },
465 // Now mouse events should get through to the panel (which is now over the
466 // right window).
467 [387, 170, NSMouseMoved, panel, left, [
468 { type: "mouseover", target: panel },
469 { type: "mousemove", target: panel },
470 ]],
471 [387, 171, NSMouseMoved, panel, left, [
472 { type: "mousemove", target: panel },
473 ]],
474 [388, 171, NSMouseMoved, panel, left, [
475 { type: "mousemove", target: panel },
476 ]],
477 // Click the panel.
478 [388, 171, NSLeftMouseDown, panel, left, [
479 { type: "mousedown", target: panel }
480 ]],
481 [388, 171, NSLeftMouseUp, panel, left, [
482 { type: "mouseup", target: panel },
483 { type: "click", target: panel },
484 ]],
485
486 // Last test for this part: Hit testing in the Canyon of Nowhere -
487 // the pixel row directly south of the panel, over the left window.
488 // Before bug 515003 we wrongly thought the mouse wasn't over any window.
489 [173, 200, NSMouseMoved, null, left, [
490 { type: "mouseout", target: panel },
491 { type: "mouseover", target: leftElem },
492 { type: "mousemove", target: leftElem },
493 ]],
494 [173, 201, NSMouseMoved, null, left, [
495 { type: "mousemove", target: leftElem },
496 ]],
497
498 // Part 2: Allow click-through
499
500 function hideThatPanel(callback) {
501 eventListenOnce(panel, "popuphidden", callback);
502 panel.hidePopup();
503 },
504 function unblockClickThrough(callback) {
505 document.documentElement.removeAttribute("clickthrough");
506 gRightWindow.document.documentElement.removeAttribute("clickthrough");
507 callback();
508 },
509 // Enter the left window, which is focused.
510 [150, 150, NSMouseMoved, null, left, [
511 { type: "mousemove", target: leftElem }
512 ]],
513 // Test that moving inside the window fires mousemove events.
514 [170, 150, NSMouseMoved, null, left, [
515 { type: "mousemove", target: leftElem },
516 ]],
517 // Leaving the window should fire a mouseout event...
518 [170, 20, NSMouseMoved, null, left, [
519 { type: "mouseout", target: leftElem },
520 ]],
521 // ... and entering a mouseover event.
522 [170, 120, NSMouseMoved, null, left, [
523 { type: "mouseover", target: leftElem },
524 { type: "mousemove", target: leftElem },
525 ]],
526 // Move over the right window, which is inactive but still accepts
527 // mouse events.
528 [400, 150, NSMouseMoved, null, right, [
529 { type: "mouseout", target: leftElem },
530 { type: "mouseover", target: rightElem },
531 { type: "mousemove", target: rightElem },
532 ]],
533 // Left-clicking while holding Cmd and middle clicking should work
534 // on inactive windows, but without making them active.
535 [400, 150, NSLeftMouseDown, null, right, [
536 { type: "mousedown", target: rightElem },
537 ], NSCommandKeyMask],
538 [400, 150, NSLeftMouseUp, null, right, [
539 { type: "mouseup", target: rightElem },
540 { type: "click", target: rightElem },
541 ], NSCommandKeyMask],
542 [400, 150, NSOtherMouseDown, null, right, [
543 { type: "mousedown", target: rightElem },
544 ]],
545 [400, 150, NSOtherMouseUp, null, right, [
546 { type: "mouseup", target: rightElem },
547 { type: "click", target: rightElem },
548 ]],
549 // Clicking an inactive window should make it active
550 [400, 150, NSLeftMouseDown, null, right, [
551 { type: "mousedown", target: rightElem },
552 ]],
553 [400, 150, NSLeftMouseUp, null, right, [
554 { type: "mouseup", target: rightElem },
555 { type: "click", target: rightElem },
556 ]],
557 // Now it's focused.
558 [401, 150, NSLeftMouseDown, null, right, [
559 { type: "mousedown", target: rightElem },
560 ]],
561 // Let's drag to the right without letting the button go.
562 [410, 150, NSLeftMouseDragged, null, right, [
563 { type: "mousemove", target: rightElem },
564 ]],
565 // Let go of the mouse.
566 [410, 150, NSLeftMouseUp, null, right, [
567 { type: "mouseup", target: rightElem },
568 { type: "click", target: rightElem },
569 ]],
570 // Move the mouse back over the left window, which is inactive.
571 [150, 170, NSMouseMoved, null, left, [
572 { type: "mouseout", target: rightElem },
573 { type: "mouseover", target: leftElem },
574 { type: "mousemove", target: leftElem },
575 ]],
576 // Right-click it.
577 [150, 170, NSRightMouseDown, null, left, [
578 { type: "mousedown", target: leftElem },
579 ]],
580 // Let go of the mouse.
581 [150, 170, NSRightMouseUp, null, left, [
582 { type: "mouseup", target: leftElem },
583 { type: "click", target: leftElem },
584 ]],
585 // Right clicking hasn't focused it, so the window is still inactive.
586 // Let's focus it; this time without the mouse, for variaton's sake.
587 function raiseLeftWindow(callback) {
588 clearExpectedEvents();
589 focusAndThen(left, function () { SimpleTest.executeSoon(callback); });
590 },
591 // It's active and should still respond to mousemove events.
592 [150, 170, NSMouseMoved, null, left, [
593 { type: "mousemove", target: leftElem },
594 ]],
595
596 // This was boring... let's introduce a popup. It will overlap both the left
597 // and the right window.
598 function openPopupInLeftWindow(callback) {
599 eventListenOnce(gPopup, "popupshown", callback);
600 gPopup.openPopupAtScreen(150, 50, true);
601 },
602 // Move the mouse over the popup.
603 [200, 80, NSMouseMoved, gPopup, left, [
604 { type: "mouseout", target: leftElem },
605 { type: "mouseover", target: gPopup },
606 { type: "mousemove", target: gPopup },
607 ]],
608 // Move the mouse back over the left window outside the popup.
609 [160, 170, NSMouseMoved, null, left, [
610 { type: "mouseout", target: gPopup },
611 { type: "mouseover", target: leftElem },
612 { type: "mousemove", target: leftElem },
613 ]],
614 // Back over the popup...
615 [190, 80, NSMouseMoved, gPopup, left, [
616 { type: "mouseout", target: leftElem },
617 { type: "mouseover", target: gPopup },
618 { type: "mousemove", target: gPopup },
619 ]],
620 // ...and over into the right window.
621 [400, 170, NSMouseMoved, null, right, [
622 { type: "mouseout", target: gPopup },
623 { type: "mouseover", target: rightElem },
624 { type: "mousemove", target: rightElem },
625 ]],
626 [400, 180, NSMouseMoved, null, right, [
627 { type: "mousemove", target: rightElem },
628 ]],
629 // Activate the right window with a click.
630 [400, 180, NSLeftMouseDown, null, right, [
631 { type: "mousedown", target: rightElem },
632 ]],
633 [400, 180, NSLeftMouseUp, null, right, [
634 { type: "mouseup", target: rightElem },
635 { type: "click", target: rightElem },
636 ]],
637 function verifyPopupClosed2(callback) {
638 is(gPopup.popupBoxObject.popupState, "closed", "popup should have closed when clicking");
639 callback();
640 },
641 // Now the right window is active; click it again, just for fun.
642 [400, 180, NSLeftMouseDown, null, right, [
643 { type: "mousedown", target: rightElem },
644 ]],
645 [400, 180, NSLeftMouseUp, null, right, [
646 { type: "mouseup", target: rightElem },
647 { type: "click", target: rightElem },
648 ]],
649
650 // Time for our next trick: a tooltip!
651 // Install the tooltip, but don't show it yet.
652 function setTooltip2(callback) {
653 rightElem.setAttribute("tooltip", "tip");
654 gExpectedEvents.push({ screenX: 410, screenY: 180, type: "mousemove", target: rightElem });
655 eventListenOnce(rightElem, "popupshown", callback);
656 gCurrentMouseX = 410;
657 gCurrentMouseY = 180;
658 var utils = right.QueryInterface(Components.interfaces.nsIInterfaceRequestor).
659 getInterface(Components.interfaces.nsIDOMWindowUtils);
660 utils.sendNativeMouseEvent(410, 180, NSMouseMoved, 0, null);
661 },
662 // Now the tooltip is visible.
663 // Move the mouse a little to the right.
664 [411, 180, NSMouseMoved, null, right, [
665 { type: "mousemove", target: rightElem },
666 ]],
667 // Move another pixel.
668 [412, 180, NSMouseMoved, null, right, [
669 { type: "mousemove", target: rightElem },
670 ]],
671 // Move up and click to make the tooltip go away.
672 [412, 80, NSMouseMoved, null, right, [
673 { type: "mousemove", target: rightElem },
674 ]],
675 [412, 80, NSLeftMouseDown, null, right, [
676 { type: "mousedown", target: rightElem },
677 ]],
678 [412, 80, NSLeftMouseUp, null, right, [
679 { type: "mouseup", target: rightElem },
680 { type: "click", target: rightElem },
681 ]],
682 // OK, next round. Open a panel in the left window, which is inactive.
683 function openPanel2(callback) {
684 eventListenOnce(panel, "popupshown", callback);
685 panel.openPopupAtScreen(150, 150, false);
686 },
687 // The panel is parented, so it will be z-ordered over its parent but
688 // under the active window.
689 // Now we move the mouse over the part where the panel rect intersects the
690 // right window's rect. Since the panel is under the window, all the events
691 // should target the right window.
692 [390, 170, NSMouseMoved, null, right, [
693 { type: "mousemove", target: rightElem },
694 ]],
695 [390, 171, NSMouseMoved, null, right, [
696 { type: "mousemove", target: rightElem },
697 ]],
698 [391, 171, NSMouseMoved, null, right, [
699 { type: "mousemove", target: rightElem },
700 ]],
701 // Now move off the right window, so that the mouse is directly over the
702 // panel.
703 [260, 170, NSMouseMoved, panel, left, [
704 { type: "mouseout", target: rightElem },
705 { type: "mouseover", target: panel },
706 { type: "mousemove", target: panel },
707 ]],
708 [260, 171, NSMouseMoved, panel, left, [
709 { type: "mousemove", target: panel },
710 ]],
711 [261, 171, NSMouseMoved, panel, left, [
712 { type: "mousemove", target: panel },
713 ]],
714 // Let's be evil and click it.
715 [261, 171, NSLeftMouseDown, panel, left, [
716 { type: "mousedown", target: panel },
717 ]],
718 [261, 171, NSLeftMouseUp, panel, left, [
719 { type: "mouseup", target: panel },
720 { type: "click", target: panel },
721 ]],
722 // This didn't focus the window, unfortunately, so let's do it ourselves.
723 function raiseLeftWindowTakeTwo(callback) {
724 focusAndThen(left, callback);
725 },
726 [387, 170, NSMouseMoved, panel, left, [
727 { type: "mousemove", target: panel },
728 ]],
729 [387, 171, NSMouseMoved, panel, left, [
730 { type: "mousemove", target: panel },
731 ]],
732 [388, 171, NSMouseMoved, panel, left, [
733 { type: "mousemove", target: panel },
734 ]],
735 // Click the panel.
736 [388, 171, NSLeftMouseDown, panel, left, [
737 { type: "mousedown", target: panel }
738 ]],
739 [388, 171, NSLeftMouseUp, panel, left, [
740 { type: "mouseup", target: panel },
741 { type: "click", target: panel },
742 ]],
743
744 // Last test for today: Hit testing in the Canyon of Nowhere -
745 // the pixel row directly south of the panel, over the left window.
746 // Before bug 515003 we wrongly thought the mouse wasn't over any window.
747 [173, 200, NSMouseMoved, null, left, [
748 { type: "mouseout", target: panel },
749 { type: "mouseover", target: leftElem },
750 { type: "mousemove", target: leftElem },
751 ]],
752 [173, 201, NSMouseMoved, null, left, [
753 { type: "mousemove", target: leftElem },
754 ]],
755 ];
756 function runNextTest() {
757 if (!tests.length)
758 return onTestsFinished();
759
760 var test = tests.shift();
761 if (typeof test == "function")
762 return test(runNextTest);
763
764 var [x, y, msg, elem, win, exp, flags] = test;
765 testMouse(x, y, msg, elem, win, exp, flags, runNextTest);
766 }
767 runNextTest();
768 }
769
770 SimpleTest.waitForFocus(start);
771
772 ]]></script>
773 </window>

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial