1 /*
2 * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package test.javafx.scene.input;
27
28 import test.com.sun.javafx.pgstub.StubScene;
29 import test.com.sun.javafx.test.MouseEventGenerator;
30 import javafx.event.Event;
31 import javafx.event.EventHandler;
32 import javafx.geometry.Point3D;
33 import javafx.scene.Group;
34 import javafx.scene.ParentShim;
35 import javafx.scene.Scene;
36 import javafx.scene.input.MouseEvent;
37 import javafx.scene.input.PickResult;
38 import javafx.scene.input.RotateEvent;
39 import javafx.scene.shape.Rectangle;
40 import javafx.stage.Stage;
41 import org.junit.Assert;
42 import org.junit.Test;
43 import static org.junit.Assert.*;
44
45 public class RotateEventTest {
46
47 private boolean rotated;
48 private boolean rotated2;
49 private PickResult pickRes;
50
51 @Test public void testShortConstructor() {
52 Rectangle node = new Rectangle();
53 node.setTranslateX(3);
54 node.setTranslateY(2);
55 node.setTranslateZ(50);
56
57 pickRes = new PickResult(node, new Point3D(15, 25, 100), 33);
58 RotateEvent e = new RotateEvent(
59 RotateEvent.ROTATION_FINISHED, 10, 20, 30, 40,
60 false, true, false, true, false, true,
61 45, 55, pickRes);
62
63 assertSame(RotateEvent.ROTATION_FINISHED, e.getEventType());
64 assertSame(pickRes, e.getPickResult());
65 assertEquals(18, e.getX(), 10e-20);
66 assertEquals(27, e.getY(), 10e-20);
67 assertEquals(150, e.getZ(), 10e-20);
68 assertEquals(10, e.getSceneX(), 10e-20);
69 assertEquals(20, e.getSceneY(), 10e-20);
70 assertEquals(30, e.getScreenX(), 10e-20);
71 assertEquals(40, e.getScreenY(), 10e-20);
72 assertFalse(e.isShiftDown());
73 assertTrue(e.isControlDown());
74 assertFalse(e.isAltDown());
75 assertTrue(e.isMetaDown());
76 assertFalse(e.isDirect());
77 assertTrue(e.isInertia());
78 assertEquals(45.0, e.getAngle(), 10e-20);
79 assertEquals(55.0, e.getTotalAngle(), 10e-20);
80 assertSame(Event.NULL_SOURCE_TARGET, e.getSource());
81 assertSame(Event.NULL_SOURCE_TARGET, e.getTarget());
82 assertFalse(e.isConsumed());
83
84 e = new RotateEvent(
85 RotateEvent.ROTATION_FINISHED, 10, 20, 30, 40,
86 true, false, true, false, true, false,
87 45, 55, pickRes);
88 assertTrue(e.isShiftDown());
89 assertFalse(e.isControlDown());
90 assertTrue(e.isAltDown());
91 assertFalse(e.isMetaDown());
92 assertTrue(e.isDirect());
93 assertFalse(e.isInertia());
94 }
95
96 @Test public void testShortConstructorWithoutPickResult() {
97 RotateEvent e = new RotateEvent(
98 RotateEvent.ROTATION_FINISHED, 10, 20, 30, 40,
99 false, true, false, true, false, true,
100 45, 55, null);
101
102 assertEquals(10, e.getX(), 10e-20);
103 assertEquals(20, e.getY(), 10e-20);
104 assertEquals(0, e.getZ(), 10e-20);
105 assertEquals(10, e.getSceneX(), 10e-20);
106 assertEquals(20, e.getSceneY(), 10e-20);
107 assertEquals(30, e.getScreenX(), 10e-20);
108 assertEquals(40, e.getScreenY(), 10e-20);
109 assertNotNull(e.getPickResult());
110 assertNotNull(e.getPickResult().getIntersectedPoint());
111 assertEquals(10, e.getPickResult().getIntersectedPoint().getX(), 10e-20);
112 assertEquals(20, e.getPickResult().getIntersectedPoint().getY(), 10e-20);
113 assertEquals(0, e.getPickResult().getIntersectedPoint().getZ(), 10e-20);
114 assertSame(Event.NULL_SOURCE_TARGET, e.getSource());
115 assertSame(Event.NULL_SOURCE_TARGET, e.getTarget());
116 }
117
118 @Test public void testLongConstructor() {
119 Rectangle node = new Rectangle(10, 10);
120 node.setTranslateX(3);
121 node.setTranslateY(2);
122 node.setTranslateZ(50);
123 Rectangle n1 = new Rectangle(10, 10);
124 Rectangle n2 = new Rectangle(10, 10);
125
126 pickRes = new PickResult(node, new Point3D(15, 25, 100), 33);
127 RotateEvent e = new RotateEvent(n1, n2,
128 RotateEvent.ROTATION_FINISHED, 10, 20, 30, 40,
129 false, true, false, true, false, true,
130 45, 55, pickRes);
131
132 assertSame(n1, e.getSource());
133 assertSame(n2, e.getTarget());
134 assertSame(RotateEvent.ROTATION_FINISHED, e.getEventType());
135 assertSame(pickRes, e.getPickResult());
136 assertEquals(18, e.getX(), 10e-20);
137 assertEquals(27, e.getY(), 10e-20);
138 assertEquals(150, e.getZ(), 10e-20);
139 assertEquals(10, e.getSceneX(), 10e-20);
140 assertEquals(20, e.getSceneY(), 10e-20);
141 assertEquals(30, e.getScreenX(), 10e-20);
142 assertEquals(40, e.getScreenY(), 10e-20);
143 assertFalse(e.isShiftDown());
144 assertTrue(e.isControlDown());
145 assertFalse(e.isAltDown());
146 assertTrue(e.isMetaDown());
147 assertFalse(e.isDirect());
148 assertTrue(e.isInertia());
149 assertEquals(45.0, e.getAngle(), 10e-20);
150 assertEquals(55.0, e.getTotalAngle(), 10e-20);
151 assertFalse(e.isConsumed());
152
153 e = new RotateEvent(n1, n2,
154 RotateEvent.ROTATION_FINISHED, 10, 20, 30, 40,
155 true, false, true, false, true, false,
156 45, 55, pickRes);
157 assertTrue(e.isShiftDown());
158 assertFalse(e.isControlDown());
159 assertTrue(e.isAltDown());
160 assertFalse(e.isMetaDown());
161 assertTrue(e.isDirect());
162 assertFalse(e.isInertia());
163 }
164
165 @Test public void testLongConstructorWithoutPickResult() {
166 Rectangle n1 = new Rectangle(10, 10);
167 Rectangle n2 = new Rectangle(10, 10);
168 RotateEvent e = new RotateEvent(n1, n2,
169 RotateEvent.ROTATION_FINISHED, 10, 20, 30, 40,
170 false, true, false, true, false, true,
171 45, 55, null);
172
173 assertSame(n1, e.getSource());
174 assertSame(n2, e.getTarget());
175 assertEquals(10, e.getX(), 10e-20);
176 assertEquals(20, e.getY(), 10e-20);
177 assertEquals(0, e.getZ(), 10e-20);
178 assertEquals(10, e.getSceneX(), 10e-20);
179 assertEquals(20, e.getSceneY(), 10e-20);
180 assertEquals(30, e.getScreenX(), 10e-20);
181 assertEquals(40, e.getScreenY(), 10e-20);
182 assertNotNull(e.getPickResult());
183 assertNotNull(e.getPickResult().getIntersectedPoint());
184 assertEquals(10, e.getPickResult().getIntersectedPoint().getX(), 10e-20);
185 assertEquals(20, e.getPickResult().getIntersectedPoint().getY(), 10e-20);
186 assertEquals(0, e.getPickResult().getIntersectedPoint().getZ(), 10e-20);
187 }
188
189 @Test
190 public void shouldDeliverRotateEventToPickedNode() {
191 Scene scene = createScene();
192 Rectangle rect =
193 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
194
195 rotated = false;
196 rect.setOnRotate(event -> {
197 rotated = true;
198 });
199
200 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
201 RotateEvent.ROTATE, 1, 1,
202 50, 50, 50, 50, false, false, false, false, false, false);
203
204 assertFalse(rotated);
205
206 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
207 RotateEvent.ROTATE, 1, 1,
208 150, 150, 150, 150, false, false, false, false, false, false);
209
210 assertTrue(rotated);
211 }
212
213 @Test
214 public void shouldPassAngles() {
215 Scene scene = createScene();
216 Rectangle rect =
217 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
218
219 rotated = false;
220 rect.setOnRotate(event -> {
221 Assert.assertEquals(90, event.getAngle(), 0.0001);
222 Assert.assertEquals(-180, event.getTotalAngle(), 0.0001);
223 rotated = true;
224 });
225
226 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
227 RotateEvent.ROTATE, 90, -180,
228 150, 150, 150, 150, false, false, false, false, false, false);
229
230 assertTrue(rotated);
231 }
232
233 @Test
234 public void shouldPassModifiers() {
235 Scene scene = createScene();
236 Rectangle rect =
237 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
238
239 rotated = false;
240 rect.setOnRotate(event -> {
241 assertTrue(event.isShiftDown());
242 assertFalse(event.isControlDown());
243 assertTrue(event.isAltDown());
244 assertFalse(event.isMetaDown());
245 rotated = true;
246 });
247 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
248 RotateEvent.ROTATE, 2, 3,
249 150, 150, 150, 150, true, false, true, false, false, false);
250 assertTrue(rotated);
251
252 rotated = false;
253 rect.setOnRotate(event -> {
254 assertFalse(event.isShiftDown());
255 assertTrue(event.isControlDown());
256 assertFalse(event.isAltDown());
257 assertTrue(event.isMetaDown());
258 rotated = true;
259 });
260 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
261 RotateEvent.ROTATE, 2, 3,
262 150, 150, 150, 150, false, true, false, true, false, false);
263 assertTrue(rotated);
264 }
265
266 @Test
267 public void shouldPassDirect() {
268 Scene scene = createScene();
269 Rectangle rect =
270 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
271
272 rotated = false;
273 rect.setOnRotate(event -> {
274 assertTrue(event.isDirect());
275 rotated = true;
276 });
277 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
278 RotateEvent.ROTATE, 2, 3,
279 150, 150, 150, 150, true, false, true, false, true, false);
280 assertTrue(rotated);
281
282 rotated = false;
283 rect.setOnRotate(event -> {
284 assertFalse(event.isDirect());
285 rotated = true;
286 });
287 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
288 RotateEvent.ROTATE, 2, 3,
289 150, 150, 150, 150, false, true, false, true, false, false);
290 assertTrue(rotated);
291 }
292
293 @Test
294 public void shouldPassInertia() {
295 Scene scene = createScene();
296 Rectangle rect =
297 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
298
299 rotated = false;
300 rect.setOnRotate(event -> {
301 assertTrue(event.isInertia());
302 rotated = true;
303 });
304 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
305 RotateEvent.ROTATE, 2, 3,
306 150, 150, 150, 150, true, false, true, false, true, true);
307 assertTrue(rotated);
308
309 rotated = false;
310 rect.setOnRotate(event -> {
311 assertFalse(event.isInertia());
312 rotated = true;
313 });
314 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
315 RotateEvent.ROTATE, 2, 3,
316 150, 150, 150, 150, false, true, false, true, true, false);
317 assertTrue(rotated);
318 }
319
320 @Test
321 public void shouldPassEventType() {
322 Scene scene = createScene();
323 Rectangle rect =
324 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
325
326 rotated = false;
327 rect.setOnRotationStarted(event -> {
328 rotated = true;
329 });
330 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
331 RotateEvent.ROTATION_STARTED, 2, 3,
332 150, 150, 150, 150, true, false, true, false, true, false);
333 assertTrue(rotated);
334
335 rotated = false;
336 rect.setOnRotationFinished(event -> {
337 rotated = true;
338 });
339 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
340 RotateEvent.ROTATION_FINISHED, 2, 3,
341 150, 150, 150, 150, true, false, true, false, true, false);
342 assertTrue(rotated);
343 }
344
345 @Test
346 public void handlingAnyShouldGetAllTypes() {
347 Scene scene = createScene();
348 Rectangle rect =
349 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
350
351 rect.addEventHandler(RotateEvent.ANY, event -> {
352 rotated = true;
353 });
354
355 rotated = false;
356 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
357 RotateEvent.ROTATION_STARTED, 2, 3,
358 150, 150, 150, 150, true, false, true, false, true, false);
359 assertTrue(rotated);
360
361 rotated = false;
362 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
363 RotateEvent.ROTATE, 2, 3,
364 150, 150, 150, 150, true, false, true, false, true, false);
365 assertTrue(rotated);
366
367 rotated = false;
368 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
369 RotateEvent.ROTATION_FINISHED, 2, 3,
370 150, 150, 150, 150, true, false, true, false, true, false);
371 assertTrue(rotated);
372 }
373
374 @Test
375 public void shouldDeliverWholeGestureToOneNode() {
376 Scene scene = createScene();
377 Rectangle rect1 =
378 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
379 Rectangle rect2 =
380 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
381
382 rect1.addEventHandler(RotateEvent.ANY, event -> {
383 rotated = true;
384 });
385 rect2.addEventHandler(RotateEvent.ANY, event -> {
386 rotated2 = true;
387 });
388
389 rotated = false;
390 rotated2 = false;
391 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
392 RotateEvent.ROTATION_STARTED, 2, 3,
393 150, 150, 150, 150, true, false, true, false, true, false);
394 assertTrue(rotated);
395 assertFalse(rotated2);
396
397 rotated = false;
398 rotated2 = false;
399 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
400 RotateEvent.ROTATE, 2, 3,
401 250, 250, 250, 250, true, false, true, false, true, false);
402 assertTrue(rotated);
403 assertFalse(rotated2);
404
405 rotated = false;
406 rotated2 = false;
407 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
408 RotateEvent.ROTATION_FINISHED, 2, 3,
409 250, 250, 250, 250, true, false, true, false, true, false);
410 assertTrue(rotated);
411 assertFalse(rotated2);
412 }
413
414 @Test
415 public void shouldCompute3dCoordinates() {
416 Scene scene = createScene();
417 Rectangle rect =
418 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
419 rect.setTranslateZ(50);
420
421 rotated = false;
422 rotated2 = false;
423 rect.setOnRotate(event -> {
424 Assert.assertEquals(150, event.getX(), 0.00001);
425 Assert.assertEquals(150, event.getY(), 0.00001);
426 Assert.assertEquals(0, event.getZ(), 0.00001);
427 rotated = true;
428 });
429
430 scene.setOnRotate(event -> {
431 Assert.assertEquals(150, event.getX(), 0.00001);
432 Assert.assertEquals(150, event.getY(), 0.00001);
433 Assert.assertEquals(50, event.getZ(), 0.00001);
434 rotated2 = true;
435 });
436
437 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
438 RotateEvent.ROTATE, 1, 1,
439 150, 150, 150, 150, false, false, false, false, false, false);
440
441 assertTrue(rotated);
442 assertTrue(rotated2);
443 }
444
445 @Test
446 public void shouldContainPickResult() {
447 Scene scene = createScene();
448 Rectangle rect1 =
449 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
450 Rectangle rect2 =
451 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
452
453 rect1.addEventHandler(RotateEvent.ANY, event -> {
454 pickRes = event.getPickResult();
455 rotated = true;
456 });
457 rect2.addEventHandler(RotateEvent.ANY, event -> {
458 pickRes = event.getPickResult();
459 rotated2 = true;
460 });
461
462 rotated = false;
463 rotated2 = false;
464 pickRes = null;
465 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
466 RotateEvent.ROTATION_STARTED, 2, 3,
467 150, 150, 150, 150, true, false, true, false, true, false);
468 assertTrue(rotated);
469 assertFalse(rotated2);
470 assertNotNull(pickRes);
471 assertSame(rect1, pickRes.getIntersectedNode());
472 assertEquals(150, pickRes.getIntersectedPoint().getX(), 0.00001);
473 assertEquals(150, pickRes.getIntersectedPoint().getY(), 0.00001);
474 assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
475
476 rotated = false;
477 rotated2 = false;
478 pickRes = null;
479 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
480 RotateEvent.ROTATE, 2, 3,
481 250, 250, 250, 250, true, false, true, false, true, false);
482 assertTrue(rotated);
483 assertFalse(rotated2);
484 assertNotNull(pickRes);
485 assertSame(rect2, pickRes.getIntersectedNode());
486 assertEquals(250, pickRes.getIntersectedPoint().getX(), 0.00001);
487 assertEquals(250, pickRes.getIntersectedPoint().getY(), 0.00001);
488 assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
489
490 rotated = false;
491 rotated2 = false;
492 pickRes = null;
493 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
494 RotateEvent.ROTATION_FINISHED, 2, 3,
495 250, 250, 250, 250, true, false, true, false, true, false);
496 assertTrue(rotated);
497 assertFalse(rotated2);
498 assertNotNull(pickRes);
499 assertSame(rect2, pickRes.getIntersectedNode());
500 assertEquals(250, pickRes.getIntersectedPoint().getX(), 0.00001);
501 assertEquals(250, pickRes.getIntersectedPoint().getY(), 0.00001);
502 assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
503 }
504
505 @Test
506 public void unknownLocationShouldBeReplacedByMouseLocation() {
507 Scene scene = createScene();
508 Rectangle rect1 =
509 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
510 Rectangle rect2 =
511 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
512 rect1.addEventHandler(RotateEvent.ANY, event -> {
513 rotated = true;
514 });
515
516 MouseEventGenerator generator = new MouseEventGenerator();
517
518 rotated = false;
519 rotated2 = false;
520 rect2.setOnRotationStarted(event -> {
521 Assert.assertEquals(250.0, event.getSceneX(), 0.0001);
522 Assert.assertEquals(250.0, event.getSceneY(), 0.0001);
523 rotated2 = true;
524 });
525 scene.impl_processMouseEvent(generator.generateMouseEvent(
526 MouseEvent.MOUSE_MOVED, 250, 250));
527 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
528 RotateEvent.ROTATION_STARTED, 2, 3,
529 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
530 true, false, true, false, true, false);
531 assertFalse(rotated);
532 assertTrue(rotated2);
533
534 rotated = false;
535 rotated2 = false;
536 rect2.setOnRotate(event -> {
537 Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
538 Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
539 rotated2 = true;
540 });
541 scene.impl_processMouseEvent(generator.generateMouseEvent(
542 MouseEvent.MOUSE_MOVED, 150, 150));
543 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
544 RotateEvent.ROTATE, 2, 3,
545 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
546 true, false, true, false, true, false);
547 assertFalse(rotated);
548 assertTrue(rotated2);
549
550 rotated = false;
551 rotated2 = false;
552 rect2.setOnRotationFinished(event -> {
553 Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
554 Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
555 rotated2 = true;
556 });
557 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
558 RotateEvent.ROTATION_FINISHED, 2, 3,
559 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
560 true, false, true, false, true, false);
561 assertFalse(rotated);
562 assertTrue(rotated2);
563 }
564
565 @Test
566 public void finishedLocationShouldBeFixed() {
567 Scene scene = createScene();
568 Rectangle rect =
569 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
570 rect.setOnRotationFinished(event -> {
571 Assert.assertEquals(250.0, event.getSceneX(), 0.0001);
572 Assert.assertEquals(250.0, event.getSceneY(), 0.0001);
573 rotated = true;
574 });
575
576 rotated = false;
577
578 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
579 RotateEvent.ROTATION_STARTED, 2, 3,
580 150, 150, 150, 150, true, false, true, false, true, false);
581
582 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
583 RotateEvent.ROTATE, 2, 3,
584 250, 250, 250, 250, true, false, true, false, true, false);
585
586 assertFalse(rotated);
587
588 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
589 RotateEvent.ROTATION_FINISHED, 2, 3,
590 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
591 true, false, true, false, true, false);
592
593 assertTrue(rotated);
594 }
595
596 @Test
597 public void unknownLocalShouldBeFixedByMousePosition() {
598 MouseEventGenerator gen = new MouseEventGenerator();
599 Scene scene = createScene();
600 Rectangle rect =
601 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
602 rect.setOnRotate(event -> {
603 Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
604 Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
605 rotated = true;
606 });
607
608 rotated = false;
609
610 scene.impl_processMouseEvent(
611 gen.generateMouseEvent(MouseEvent.MOUSE_MOVED, 250, 250));
612
613 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
614 RotateEvent.ROTATE, 2, 3,
615 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
616 true, false, true, false, true, false);
617
618 assertFalse(rotated);
619
620 scene.impl_processMouseEvent(
621 gen.generateMouseEvent(MouseEvent.MOUSE_MOVED, 150, 150));
622
623 ((StubScene) scene.impl_getPeer()).getListener().rotateEvent(
624 RotateEvent.ROTATE, 2, 3,
625 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
626 true, false, true, false, true, false);
627
628 assertTrue(rotated);
629 }
630
631 @Test public void testToString() {
632 RotateEvent e = new RotateEvent(RotateEvent.ROTATE,
633 100, 100, 200, 200,
634 false, false, false, false,
635 true, false, 10, 20, null);
636
637 String s = e.toString();
638
639 assertNotNull(s);
640 assertFalse(s.isEmpty());
641 }
642
643 private Scene createScene() {
644 final Group root = new Group();
645
646 final Scene scene = new Scene(root, 400, 400);
647
648 Rectangle rect = new Rectangle(100, 100, 100, 100);
649 Rectangle rect2 = new Rectangle(200, 200, 100, 100);
650
651 ParentShim.getChildren(root).addAll(rect, rect2);
652
653 Stage stage = new Stage();
654 stage.setScene(scene);
655 stage.show();
656
657 return scene;
658 }
659 }