1 /*
2 * Copyright (c) 2000, 2015, 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 static org.junit.Assert.assertNull;
29 import static org.junit.Assert.fail;
30
31 import java.security.AccessControlContext;
32 import java.util.ArrayList;
33 import java.util.Arrays;
34 import java.util.HashSet;
35 import java.util.List;
36 import java.util.Set;
37
38 import com.sun.javafx.tk.TKScene;
39 import javafx.event.EventHandler;
40 import javafx.scene.Group;
41 import javafx.scene.Node;
42 import javafx.scene.Scene;
43 import javafx.scene.shape.Rectangle;
44 import javafx.stage.Stage;
45 import javafx.util.Pair;
46
47 import org.junit.After;
266 /* DRAG INITIATION */
267 /************************************************************************/
268
269
270 @Test
271 public void dragDetectionShouldUseHysteresis() {
272 Node n = oneNode();
273 MouseEventGenerator gen = new MouseEventGenerator();
274
275 EventHandler<MouseEvent> thirdEventFailsHysteresis =
276 event -> {
277 counter++;
278 assertTrue((counter != 3 && !event.isDragDetect()) ||
279 (counter == 3 && event.isDragDetect()));
280 };
281
282 n.addEventHandler(MouseEvent.MOUSE_PRESSED, thirdEventFailsHysteresis);
283 n.addEventHandler(MouseEvent.MOUSE_DRAGGED, thirdEventFailsHysteresis);
284 n.addEventHandler(MouseEvent.MOUSE_RELEASED, thirdEventFailsHysteresis);
285
286 n.getScene().impl_processMouseEvent(
287 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
288 n.getScene().impl_processMouseEvent(
289 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 52, 48));
290 n.getScene().impl_processMouseEvent(
291 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 70, 70));
292 n.getScene().impl_processMouseEvent(
293 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
294 n.getScene().impl_processMouseEvent(
295 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
296
297 assertEquals(5, counter);
298 }
299
300 @Test
301 public void dragShouldNotBeDetectedBasedOnMoveOrRelase() {
302 Node n = oneNode();
303 MouseEventGenerator gen = new MouseEventGenerator();
304
305 n.setOnDragDetected(detector);
306 n.setOnMousePressed(dontDetect);
307 n.setOnMouseMoved(doDetect);
308 n.setOnMouseReleased(doDetect);
309
310 /* dontDetect prevents detection */
311 n.getScene().impl_processMouseEvent(
312 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
313 assertFalse(detected);
314
315 n.getScene().impl_processMouseEvent(
316 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
317 assertFalse(detected);
318
319 n.getScene().impl_processMouseEvent(
320 gen.generateMouseEvent(MouseEvent.MOUSE_MOVED, 60, 60));
321 assertFalse(detected);
322 }
323
324 @Test
325 public void dragShouldBeDetectedBasedOnMouseEvent() {
326 Node n = oneNode();
327 MouseEventGenerator gen = new MouseEventGenerator();
328
329 n.setOnDragDetected(detector);
330 n.setOnMousePressed(dontDetect);
331 n.setOnMouseDragged(dontDetect);
332 n.setOnMouseReleased(doDetect);
333
334 /* dontDetect prevents detection */
335 n.getScene().impl_processMouseEvent(
336 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
337 assertFalse(detected);
338 n.getScene().impl_processMouseEvent(
339 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 52, 48));
340 assertFalse(detected);
341 n.getScene().impl_processMouseEvent(
342 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 70, 70));
343 assertFalse(detected);
344
345 /* doDetect fires detection */
346 n.setOnMouseDragged(doDetect);
347
348 n.getScene().impl_processMouseEvent(
349 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
350 assertTrue(detected);
351 detected = false;
352
353 /* but fires it only once */
354 n.getScene().impl_processMouseEvent(
355 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 70, 70));
356 assertFalse(detected);
357
358 n.getScene().impl_processMouseEvent(
359 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
360 assertFalse(detected);
361 }
362
363 @Test
364 public void dragDetectionShouldBeOverridable() {
365 Node n = oneNode();
366 MouseEventGenerator gen = new MouseEventGenerator();
367
368 n.setOnDragDetected(detector);
369 n.setOnMousePressed(doDetect);
370 n.setOnMouseDragged(dontDetect);
371 n.getParent().setOnMousePressed(dontDetect);
372 n.getParent().setOnMouseDragged(doDetect);
373
374 /* dontDetect prevents detection */
375 n.getScene().impl_processMouseEvent(
376 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
377 assertFalse(detected);
378
379 n.getScene().impl_processMouseEvent(
380 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
381 assertTrue(detected);
382 detected = false;
383
384 n.getScene().impl_processMouseEvent(
385 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
386 assertFalse(detected);
387 }
388
389 @Test
390 public void startDragShouldNotBeCalledIfNothingPutOnDragboard() {
391 final Node n = oneNode();
392 final MouseEventGenerator gen = new MouseEventGenerator();
393
394 n.setOnMousePressed(doDetect);
395 n.setOnDragDetected(event -> {
396 n.startDragAndDrop(TransferMode.COPY);
397 });
398
399 n.getScene().impl_processMouseEvent(
400 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
401 n.getScene().impl_processMouseEvent(
402 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
403 n.getScene().impl_processMouseEvent(
404 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
405
406 assertFalse(toolkit.dragging);
407 }
408
409 @Test
410 public void startDragShouldBeCalledIfStringPutOnDragboard() {
411 final Node n = oneNode();
412 final MouseEventGenerator gen = new MouseEventGenerator();
413
414 dragSource = n;
415 n.setOnMousePressed(doDetect);
416 n.setOnDragDetected(stringSource(TransferMode.ANY));
417
418 n.getScene().impl_processMouseEvent(
419 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
420 assertTrue(toolkit.dragging);
421 }
422
423 /************************************************************************/
424 /* SOURCE/TARGET */
425 /************************************************************************/
426
427 @Test
428 public void nodeThatCallsStartDndShouldBecomeGestureSource() {
429 final Node n = oneNode();
430 final MouseEventGenerator gen = new MouseEventGenerator();
431
432 dragSource = n.getParent();
433 n.setOnMousePressed(doDetect);
434 n.setOnDragDetected(stringSource(TransferMode.ANY));
435 n.setOnDragOver(event -> {
436 assertSame(dragSource, event.getGestureSource());
437 counter++;
438 });
439
440 n.getScene().impl_processMouseEvent(
441 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
442 toolkit.dragTo(52, 52, TransferMode.COPY);
443
444 assertEquals(1, counter);
445 }
446
447 @Test
448 public void parentThatCallsStartDndShouldBecomeGestureSource() {
449 final Node n = oneNode();
450 final MouseEventGenerator gen = new MouseEventGenerator();
451
452 dragSource = n.getParent();
453 n.setOnMousePressed(doDetect);
454 n.getParent().setOnDragDetected(stringSource(TransferMode.ANY));
455 n.setOnDragOver(event -> {
456 assertSame(dragSource, event.getGestureSource());
457 counter++;
458 });
459
460 n.getScene().impl_processMouseEvent(
461 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
462 toolkit.dragTo(52, 52, TransferMode.COPY);
463
464 assertEquals(1, counter);
465 }
466
467 @Test
468 public void nodeThatAcceptsDragShouldBecomeGestureTarget() {
469 final Node n = oneNode();
470 final MouseEventGenerator gen = new MouseEventGenerator();
471
472 dragSource = n;
473 n.setOnMousePressed(doDetect);
474 n.setOnDragDetected(stringSource(TransferMode.ANY));
475 n.setOnDragOver(event -> {
476 event.acceptTransferModes(TransferMode.ANY);
477 if (counter == 0) {
478 assertNull(event.getGestureTarget());
479 } else {
480 assertSame(n, event.getGestureTarget());
481 }
482 counter++;
483 });
484 n.setOnDragDropped(event -> {
485 assertSame(n, event.getGestureTarget());
486 counter++;
487 });
488
489 n.getScene().impl_processMouseEvent(
490 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
491 toolkit.dragTo(51, 51, TransferMode.COPY);
492 toolkit.dragTo(52, 52, TransferMode.COPY);
493 toolkit.drop(52, 52, TransferMode.COPY);
494
495 assertEquals(3, counter);
496 }
497
498 @Test
499 public void parentThatAcceptsDragShouldBecomeGestureTarget() {
500 final Node n = oneNode();
501 final MouseEventGenerator gen = new MouseEventGenerator();
502
503 dragSource = n;
504 n.setOnMousePressed(doDetect);
505 n.setOnDragDetected(stringSource(TransferMode.ANY));
506 n.setOnDragOver(event -> {
507 event.acceptTransferModes(TransferMode.ANY);
508 if (counter == 0) {
509 assertNull(event.getGestureTarget());
510 } else {
511 assertSame(n.getParent(), event.getGestureTarget());
512 }
513 counter++;
514 });
515 n.getParent().setOnDragOver(acceptAny);
516 n.setOnDragDropped(event -> {
517 assertSame(n.getParent(), event.getGestureTarget());
518 counter++;
519 });
520
521 n.getScene().impl_processMouseEvent(
522 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
523 toolkit.dragTo(51, 51, TransferMode.COPY);
524 toolkit.dragTo(52, 52, TransferMode.COPY);
525 toolkit.drop(52, 52, TransferMode.COPY);
526
527 assertEquals(3, counter);
528 }
529
530 @Test
531 public void sceneCanBecomeGestureSource() {
532 final Node n = oneNode();
533 final MouseEventGenerator gen = new MouseEventGenerator();
534
535 n.setOnMousePressed(doDetect);
536 n.getScene().setOnDragDetected(event -> {
537 Dragboard db = n.getScene().startDragAndDrop(TransferMode.ANY);
538 ClipboardContent cc = new ClipboardContent();
539 cc.putString("Hello");
540 db.setContent(cc);
541 });
542 n.setOnDragOver(event -> {
543 assertSame(n.getScene(), event.getGestureSource());
544 counter++;
545 });
546
547 n.getScene().impl_processMouseEvent(
548 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
549 toolkit.dragTo(52, 52, TransferMode.COPY);
550
551 assertEquals(1, counter);
552 }
553
554 @Test
555 public void sceneCanBecomeGestureTarget() {
556 final Node n = oneNode();
557 final MouseEventGenerator gen = new MouseEventGenerator();
558
559 dragSource = n;
560 n.setOnMousePressed(doDetect);
561 n.setOnDragDetected(stringSource(TransferMode.ANY));
562 n.getScene().setOnDragOver(event -> {
563 event.acceptTransferModes(TransferMode.ANY);
564 if (counter == 0) {
565 assertNull(event.getGestureTarget());
566 } else {
567 assertSame(n.getScene(), event.getGestureTarget());
568 }
569 counter++;
570 });
571 n.setOnDragDropped(event -> {
572 assertSame(n.getScene(), event.getGestureTarget());
573 counter++;
574 });
575
576 n.getScene().impl_processMouseEvent(
577 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
578 toolkit.dragTo(51, 51, TransferMode.COPY);
579 toolkit.dragTo(52, 52, TransferMode.COPY);
580 toolkit.drop(52, 52, TransferMode.COPY);
581
582 assertEquals(3, counter);
583 }
584
585 /************************************************************************/
586 /* TRANSFER MODES */
587 /************************************************************************/
588
589 @Test
590 public void defaultTransferModeShouldBeUsedIfSupported() {
591 final Node n = oneNode();
592 final MouseEventGenerator gen = new MouseEventGenerator();
593
594 dragSource = n;
595 n.setOnMousePressed(doDetect);
596 n.setOnDragDetected(stringSource(TransferMode.ANY));
597 n.setOnDragOver(acceptAny);
598
599 /* start drag */
600 n.getScene().impl_processMouseEvent(
601 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
602
603 /* drag */
604 assertSame(TransferMode.LINK, toolkit.dragTo(52, 52, TransferMode.LINK));
605 }
606
607 @Test
608 public void defaultTransferModeShouldNotBeUsedIfNotSupported() {
609 final Node n = oneNode();
610 final MouseEventGenerator gen = new MouseEventGenerator();
611
612 dragSource = n;
613 n.setOnMousePressed(doDetect);
614 n.setOnDragDetected(stringSource(TransferMode.COPY));
615 n.setOnDragOver(acceptAny);
616
617 /* start drag */
618 n.getScene().impl_processMouseEvent(
619 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
620
621 /* drag */
622 assertSame(TransferMode.COPY, toolkit.dragTo(52, 52, TransferMode.LINK));
623 }
624
625 @Test
626 public void mostCommonTransferModeShouldBeChosen() {
627 final Node n = oneNode();
628 final MouseEventGenerator gen = new MouseEventGenerator();
629
630 dragSource = n;
631 n.setOnMousePressed(doDetect);
632 n.setOnDragDetected(stringSource(TransferMode.COPY_OR_MOVE));
633 n.setOnDragOver(acceptAny);
634
635 /* start drag */
636 n.getScene().impl_processMouseEvent(
637 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
638
639 /* drag */
640 assertSame(TransferMode.MOVE, toolkit.dragTo(52, 52, TransferMode.LINK));
641 }
642
643 @Test
644 public void transferModeAcceptanceShouldBeOverridable_restriction() {
645 final Node n = oneNode();
646 final MouseEventGenerator gen = new MouseEventGenerator();
647
648 dragSource = n;
649 n.setOnMousePressed(doDetect);
650 n.setOnDragDetected(stringSource(TransferMode.COPY_OR_MOVE));
651 n.setOnDragOver(acceptAny);
652 n.getParent().setOnDragOver(acceptCopy);
653
654 /* start drag */
655 n.getScene().impl_processMouseEvent(
656 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
657
658 /* drag */
659 assertSame(TransferMode.COPY, toolkit.dragTo(52, 52, TransferMode.MOVE));
660 }
661
662 @Test
663 public void transferModeAcceptanceShouldBeOverridable_loosening() {
664 final Node n = oneNode();
665 final MouseEventGenerator gen = new MouseEventGenerator();
666
667 dragSource = n;
668 n.setOnMousePressed(doDetect);
669 n.setOnDragDetected(stringSource(TransferMode.COPY_OR_MOVE));
670 n.setOnDragOver(acceptCopy);
671 n.getParent().setOnDragOver(acceptAny);
672
673 /* start drag */
674 n.getScene().impl_processMouseEvent(
675 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
676
677 /* drag */
678 assertSame(TransferMode.MOVE, toolkit.dragTo(52, 52, TransferMode.MOVE));
679 }
680
681 @Test
682 public void noTransferShouldHappenWhenUnsupportedModeIsAccepted() {
683 final Node n = oneNode();
684 final MouseEventGenerator gen = new MouseEventGenerator();
685
686 dragSource = n;
687 n.setOnMousePressed(doDetect);
688 n.setOnDragDetected(stringSource(TransferMode.LINK));
689 n.setOnDragOver(acceptCopyOrMove);
690
691 /* start drag */
692 n.getScene().impl_processMouseEvent(
693 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
694
695 /* drag */
696 assertNull(toolkit.dragTo(52, 52, TransferMode.MOVE));
697 }
698
699 @Test
700 public void noTransferShouldHappenWhenNotAccepted() {
701 final Node n = oneNode();
702 final MouseEventGenerator gen = new MouseEventGenerator();
703
704 dragSource = n;
705 n.setOnMousePressed(doDetect);
706 n.setOnDragDetected(stringSource(TransferMode.ANY));
707
708 /* start drag */
709 n.getScene().impl_processMouseEvent(
710 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
711
712 /* drag */
713 assertNull(toolkit.dragTo(52, 52, TransferMode.MOVE));
714 }
715
716 @Test
717 public void dropShouldGetAcceptedTransferMode() {
718 final Node n = oneNode();
719 final MouseEventGenerator gen = new MouseEventGenerator();
720
721 dragSource = n;
722 n.setOnMousePressed(doDetect);
723 n.setOnDragDetected(stringSource(TransferMode.ANY));
724 n.setOnDragOver(acceptCopy);
725 n.setOnDragDropped(event -> {
726 counter++;
727 assertSame(TransferMode.COPY, event.getTransferMode());
728 assertSame(TransferMode.COPY, event.getAcceptedTransferMode());
729 });
730
731 /* start drag */
732 n.getScene().impl_processMouseEvent(
733 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
734
735 /* drag and drop*/
736 toolkit.dragTo(52, 52, TransferMode.MOVE);
737 toolkit.drop(52, 52, TransferMode.MOVE);
738
739 assertEquals(1, counter);
740 }
741
742 @Test
743 public void shouldBePossibleToAcceptInDrop() {
744 final Node n = oneNode();
745 final MouseEventGenerator gen = new MouseEventGenerator();
746
747 dragSource = n;
748 n.setOnMousePressed(doDetect);
749 n.setOnDragDetected(stringSource(TransferMode.ANY));
750 n.setOnDragOver(acceptCopy);
751 n.setOnDragDropped(event -> {
752 assertSame(TransferMode.COPY, event.getTransferMode());
753 assertSame(TransferMode.COPY, event.getAcceptedTransferMode());
754 event.acceptTransferModes(TransferMode.MOVE);
755 event.setDropCompleted(true);
756 assertSame(TransferMode.COPY, event.getTransferMode());
757 assertSame(TransferMode.MOVE, event.getAcceptedTransferMode());
758 });
759
760 /* start drag */
761 n.getScene().impl_processMouseEvent(
762 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
763
764 /* drag and drop*/
765 toolkit.dragTo(52, 52, TransferMode.MOVE);
766 assertEquals(TransferMode.MOVE, toolkit.drop(52, 52, TransferMode.LINK));
767 }
768
769 @Test
770 public void acceptingNonSupportedTransferModeInDropShouldThrowException() {
771 final Node n = oneNode();
772 final MouseEventGenerator gen = new MouseEventGenerator();
773
774 dragSource = n;
775 n.setOnMousePressed(doDetect);
776 n.setOnDragDetected(stringSource(TransferMode.COPY_OR_MOVE));
777 n.setOnDragOver(acceptCopy);
778 n.setOnDragDropped(event -> {
779 try {
780 event.acceptTransferModes(TransferMode.LINK);
781 fail("Exception was not thrown");
782 } catch (IllegalStateException e) {
783 /* expceted */
784 counter++;
785 }
786 });
787
788 /* start drag */
789 n.getScene().impl_processMouseEvent(
790 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
791
792 /* drag and drop*/
793 toolkit.dragTo(52, 52, TransferMode.MOVE);
794 toolkit.drop(52, 52, TransferMode.LINK);
795
796 assertEquals(1, counter);
797 }
798
799 @Test
800 public void modifyingStaticArraysShouldNotInfluenceResult() {
801 TransferMode.ANY[0] = TransferMode.LINK;
802 TransferMode.ANY[1] = TransferMode.LINK;
803 TransferMode.ANY[2] = TransferMode.LINK;
804
805 TransferMode.COPY_OR_MOVE[0] = TransferMode.LINK;
806 TransferMode.COPY_OR_MOVE[1] = TransferMode.LINK;
807
808 final Node n = oneNode();
809 final MouseEventGenerator gen = new MouseEventGenerator();
810
811 dragSource = n;
812 n.setOnMousePressed(doDetect);
813 n.setOnDragDetected(stringSource(TransferMode.ANY));
814 n.setOnDragOver(acceptCopyOrMove);
815 n.setOnDragDropped(event -> {
816 event.acceptTransferModes(TransferMode.ANY);
817 event.setDropCompleted(true);
818 });
819
820 /* start drag */
821 n.getScene().impl_processMouseEvent(
822 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
823
824 /* drag and drop*/
825 assertSame(TransferMode.COPY, toolkit.dragTo(52, 52, TransferMode.COPY));
826 assertSame(TransferMode.COPY, toolkit.drop(52, 52, TransferMode.COPY));
827
828 TransferMode.ANY[0] = TransferMode.COPY;
829 TransferMode.ANY[1] = TransferMode.MOVE;
830 TransferMode.ANY[2] = TransferMode.LINK;
831
832 TransferMode.COPY_OR_MOVE[0] = TransferMode.COPY;
833 TransferMode.COPY_OR_MOVE[1] = TransferMode.MOVE;
834 }
835
836 /************************************************************************/
837 /* GESTURE FINISH */
838 /************************************************************************/
839
840 @Test
841 public void dropShouldBeAcceptedByCompletion() {
842 final Node n = oneNode();
843 final MouseEventGenerator gen = new MouseEventGenerator();
844
845 dragSource = n;
846 n.setOnMousePressed(doDetect);
847 n.setOnDragDetected(stringSource(TransferMode.ANY));
848 n.setOnDragOver(acceptCopy);
849 n.setOnDragDropped(event -> {
850 event.setDropCompleted(true);
851 });
852
853 /* start drag */
854 n.getScene().impl_processMouseEvent(
855 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
856
857 /* drag and drop*/
858 toolkit.dragTo(52, 52, TransferMode.MOVE);
859 assertSame(TransferMode.COPY, toolkit.drop(52, 52, TransferMode.MOVE));
860 }
861
862 @Test
863 public void dropShouldNotBeAcceptedWithUnsuccessfulCompletion() {
864 final Node n = oneNode();
865 final MouseEventGenerator gen = new MouseEventGenerator();
866
867 dragSource = n;
868 n.setOnMousePressed(doDetect);
869 n.setOnDragDetected(stringSource(TransferMode.ANY));
870 n.setOnDragOver(acceptCopy);
871 n.setOnDragDropped(event -> {
872 event.setDropCompleted(false);
873 });
874
875 /* start drag */
876 n.getScene().impl_processMouseEvent(
877 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
878
879 /* drag and drop*/
880 toolkit.dragTo(52, 52, TransferMode.MOVE);
881 assertNull(toolkit.drop(52, 52, TransferMode.MOVE));
882 }
883
884 @Test
885 public void dropShouldNotBeAcceptedWithoutCompletion() {
886 final Node n = oneNode();
887 final MouseEventGenerator gen = new MouseEventGenerator();
888
889 dragSource = n;
890 n.setOnMousePressed(doDetect);
891 n.setOnDragDetected(stringSource(TransferMode.ANY));
892 n.setOnDragOver(acceptCopy);
893
894 /* start drag */
895 n.getScene().impl_processMouseEvent(
896 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
897
898 /* drag and drop*/
899 toolkit.dragTo(52, 52, TransferMode.MOVE);
900 assertNull(toolkit.drop(52, 52, TransferMode.MOVE));
901 }
902
903 @Test
904 public void dropCompletionShouldBeOverridable() {
905 final Node n = oneNode();
906 final MouseEventGenerator gen = new MouseEventGenerator();
907
908 dragSource = n;
909 n.setOnMousePressed(doDetect);
910 n.setOnDragDetected(stringSource(TransferMode.ANY));
911 n.setOnDragOver(acceptCopyOrMove);
912 n.setOnDragDropped(event -> {
913 event.setDropCompleted(false);
914 });
915 n.getParent().setOnDragDropped(event -> {
916 event.setDropCompleted(true);
917 });
918
919 /* start drag */
920 n.getScene().impl_processMouseEvent(
921 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
922
923 /* drag and drop*/
924 toolkit.dragTo(52, 52, TransferMode.MOVE);
925 assertSame(TransferMode.MOVE, toolkit.drop(52, 52, TransferMode.MOVE));
926 }
927
928 @Test
929 public void dropDoneShouldBeSentToGestureSource() {
930 final Node[] ns = twoNodes();
931 Node src = ns[0];
932 Node trgt = ns[1];
933
934 final MouseEventGenerator gen = new MouseEventGenerator();
935
936 dragSource = src;
937 src.setOnMousePressed(doDetect);
938 src.setOnDragDetected(stringSource(TransferMode.ANY));
939 trgt.setOnDragOver(acceptCopyOrMove);
940 trgt.setOnDragDropped(event -> {
941 event.setDropCompleted(true);
942 });
943 src.getParent().setOnDragDone(event -> {
944 Assert.assertEquals(TransferMode.MOVE, event.getTransferMode());
945 Assert.assertEquals(TransferMode.MOVE, event.getAcceptedTransferMode());
946 counter++;
947 });
948
949 /* start drag */
950 src.getScene().impl_processMouseEvent(
951 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
952
953 /* drag and drop*/
954 toolkit.dragTo(52, 52, TransferMode.MOVE);
955 toolkit.dragTo(252, 52, TransferMode.MOVE);
956 toolkit.drop(252, 52, TransferMode.COPY);
957 toolkit.done(TransferMode.MOVE);
958 assertEquals(counter, 1);
959 }
960
961 /************************************************************************/
962 /* ENTERED/EXITED */
963 /************************************************************************/
964
965 @Test
966 public void dragSourceShouldGetEnteredImmediately() {
967 final Node n = oneNode();
968 final MouseEventGenerator gen = new MouseEventGenerator();
969
970 dragSource = n;
971 n.setOnMousePressed(doDetect);
972 n.setOnDragDetected(stringSource(TransferMode.ANY));
973 n.setOnDragOver(acceptAny);
974 n.setOnDragEntered(event -> {
975 counter++;
976 });
977
978 /* start drag */
979 n.getScene().impl_processMouseEvent(
980 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
981 assertEquals(0, counter);
982
983 /* drag */
984 toolkit.dragTo(52, 52, TransferMode.MOVE);
985 assertEquals(1, counter);
986 }
987
988 @Test
989 public void dragSourcesParentShouldGetEnteredImmediately() {
990 final Node n = oneNode();
991 final MouseEventGenerator gen = new MouseEventGenerator();
992
993 dragSource = n;
994 n.setOnMousePressed(doDetect);
995 n.setOnDragDetected(stringSource(TransferMode.ANY));
996 n.setOnDragOver(acceptAny);
997 n.getParent().setOnDragEntered(event -> {
998 counter++;
999 });
1000
1001 /* start drag */
1002 n.getScene().impl_processMouseEvent(
1003 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1004 assertEquals(0, counter);
1005
1006 /* drag */
1007 toolkit.dragTo(52, 52, TransferMode.MOVE);
1008 assertEquals(1, counter);
1009 }
1010
1011 @Test
1012 public void dragSourcesSubScenesParentShouldGetEnteredImmediately() {
1013 final Node[] ns = oneNodeInSubScene();
1014 final Node n = ns[0];
1015 final Node subScene = ns[1];
1016
1017 dragSource = n;
1018 n.setOnMousePressed(doDetect);
1019 n.setOnDragDetected(stringSource(TransferMode.ANY));
1020 n.setOnDragOver(acceptAny);
1021 subScene.setOnDragEntered(event -> {
1022 counter++;
1023 });
1024 subScene.getParent().setOnDragEntered(event -> {
1025 counter++;
1026 });
1027
1028 /* start drag */
1029 n.getScene().impl_processMouseEvent(
1030 MouseEventGenerator.generateMouseEvent(
1031 MouseEvent.MOUSE_PRESSED, 50, 50));
1032 assertEquals(0, counter);
1033
1034 /* drag */
1035 toolkit.dragTo(52, 52, TransferMode.MOVE);
1036 assertEquals(2, counter);
1037 }
1038
1039 @Test
1040 public void dragSourcesParentShouldGetEnteredTargetTwice() {
1041 final Node n = oneNode();
1042 final MouseEventGenerator gen = new MouseEventGenerator();
1043
1044 dragSource = n;
1045 n.setOnMousePressed(doDetect);
1046 n.setOnDragDetected(stringSource(TransferMode.ANY));
1047 n.setOnDragOver(acceptAny);
1048 n.getParent().addEventHandler(DragEvent.DRAG_ENTERED_TARGET,
1049 event -> {
1050 counter++;
1051 }
1052 );
1053
1054 /* start drag */
1055 n.getScene().impl_processMouseEvent(
1056 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1057 assertEquals(0, counter);
1058
1059 /* drag */
1060 toolkit.dragTo(52, 52, TransferMode.MOVE);
1061 assertEquals(2, counter);
1062 }
1063
1064 @Test
1065 public void dragSourceShouldGetExitedWhenLeft() {
1066 final Node n = oneNode();
1067 final MouseEventGenerator gen = new MouseEventGenerator();
1068
1069 dragSource = n;
1070 n.setOnMousePressed(doDetect);
1071 n.setOnDragDetected(stringSource(TransferMode.ANY));
1072 n.setOnDragOver(acceptAny);
1073 n.setOnDragExited(event -> {
1074 counter++;
1075 });
1076
1077 /* start drag */
1078 n.getScene().impl_processMouseEvent(
1079 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1080 assertEquals(0, counter);
1081
1082 /* drag */
1083 toolkit.dragTo(52, 52, TransferMode.MOVE);
1084 assertEquals(0, counter);
1085
1086 toolkit.dragTo(150, 52, TransferMode.MOVE);
1087 assertEquals(1, counter);
1088 }
1089
1090 @Test
1091 public void dragSourcesSubScenesParentShouldGetExitedWhenLeft() {
1092 final Node[] ns = oneNodeInSubScene();
1093 final Node n = ns[0];
1094 final Node subScene = ns[1];
1095
1096 dragSource = n;
1097 n.setOnMousePressed(doDetect);
1098 n.setOnDragDetected(stringSource(TransferMode.ANY));
1099 n.setOnDragOver(acceptAny);
1100 subScene.setOnDragExited(event -> {
1101 counter++;
1102 });
1103 subScene.getParent().setOnDragExited(event -> {
1104 counter++;
1105 });
1106
1107 /* start drag */
1108 n.getScene().impl_processMouseEvent(
1109 MouseEventGenerator.generateMouseEvent(
1110 MouseEvent.MOUSE_PRESSED, 50, 50));
1111 assertEquals(0, counter);
1112
1113 /* drag */
1114 toolkit.dragTo(52, 52, TransferMode.MOVE);
1115 assertEquals(0, counter);
1116
1117 toolkit.dragTo(250, 52, TransferMode.MOVE);
1118 assertEquals(2, counter);
1119 }
1120
1121 @Test
1122 public void dragSourceShouldGetEnteredWhenReturned() {
1123 final Node n = oneNode();
1124 final MouseEventGenerator gen = new MouseEventGenerator();
1125
1126 dragSource = n;
1127 n.setOnMousePressed(doDetect);
1128 n.setOnDragDetected(stringSource(TransferMode.ANY));
1129 n.setOnDragOver(acceptAny);
1130 n.setOnDragEntered(event -> {
1131 counter++;
1132 });
1133
1134 /* start drag */
1135 n.getScene().impl_processMouseEvent(
1136 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1137 assertEquals(0, counter);
1138
1139 /* drag */
1140 toolkit.dragTo(52, 52, TransferMode.MOVE);
1141 assertEquals(1, counter);
1142
1143 toolkit.dragTo(150, 52, TransferMode.MOVE);
1144 assertEquals(1, counter);
1145
1146 toolkit.dragTo(60, 52, TransferMode.MOVE);
1147 assertEquals(2, counter);
1148 }
1149
1150 @Test
1151 public void anotherNodeShouldGetEntered() {
1152 final Node[] ns = twoNodes();
1153 Node src = ns[0];
1154 Node trgt = ns[1];
1155 final MouseEventGenerator gen = new MouseEventGenerator();
1156
1157 dragSource = src;
1158 src.setOnMousePressed(doDetect);
1159 src.setOnDragDetected(stringSource(TransferMode.ANY));
1160 src.setOnDragOver(acceptAny);
1161 trgt.setOnDragEntered(event -> {
1162 counter++;
1163 });
1164
1165 /* start drag */
1166 src.getScene().impl_processMouseEvent(
1167 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1168 assertEquals(0, counter);
1169
1170 /* drag */
1171 toolkit.dragTo(52, 52, TransferMode.MOVE);
1172 assertEquals(0, counter);
1173
1174 toolkit.dragTo(250, 52, TransferMode.MOVE);
1175 assertEquals(1, counter);
1176 }
1177
1178 @Test
1179 public void anotherNodeShouldGetExited() {
1180 final Node[] ns = twoNodes();
1181 Node src = ns[0];
1182 Node trgt = ns[1];
1183 final MouseEventGenerator gen = new MouseEventGenerator();
1184
1185 dragSource = src;
1186 src.setOnMousePressed(doDetect);
1187 src.setOnDragDetected(stringSource(TransferMode.ANY));
1188 src.setOnDragOver(acceptAny);
1189 trgt.setOnDragExited(event -> {
1190 counter++;
1191 });
1192
1193 /* start drag */
1194 src.getScene().impl_processMouseEvent(
1195 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1196 assertEquals(0, counter);
1197
1198 /* drag */
1199 toolkit.dragTo(52, 52, TransferMode.MOVE);
1200 assertEquals(0, counter);
1201
1202 toolkit.dragTo(250, 52, TransferMode.MOVE);
1203 assertEquals(0, counter);
1204
1205 toolkit.dragTo(150, 52, TransferMode.MOVE);
1206 assertEquals(1, counter);
1207 }
1208
1209 @Test
1210 public void parentShouldNotGetExitedWhenDraggingOverChildren() {
1211 final Node[] ns = twoNodes();
1212 Node src = ns[0];
1213 Node trgt = ns[1];
1214 final MouseEventGenerator gen = new MouseEventGenerator();
1215
1216 dragSource = src;
1217 src.setOnMousePressed(doDetect);
1218 src.setOnDragDetected(stringSource(TransferMode.ANY));
1219 src.setOnDragOver(acceptAny);
1220 trgt.getParent().setOnDragExited(event -> {
1221 counter++;
1222 });
1223
1224 /* start drag */
1225 src.getScene().impl_processMouseEvent(
1226 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1227 assertEquals(0, counter);
1228
1229 /* drag */
1230 toolkit.dragTo(52, 52, TransferMode.MOVE);
1231 assertEquals(0, counter);
1232
1233 toolkit.dragTo(250, 52, TransferMode.MOVE);
1234 assertEquals(0, counter);
1235
1236 toolkit.dragTo(50, 52, TransferMode.MOVE);
1237 assertEquals(0, counter);
1238 }
1239
1240 @Test
1241 public void parentShouldGetExitedTargetWhenDraggingOverChildren() {
1242 final Node[] ns = twoNodes();
1243 Node src = ns[0];
1244 Node trgt = ns[1];
1245 final MouseEventGenerator gen = new MouseEventGenerator();
1246
1247 dragSource = src;
1248 src.setOnMousePressed(doDetect);
1249 src.setOnDragDetected(stringSource(TransferMode.ANY));
1250 src.setOnDragOver(acceptAny);
1251 trgt.getParent().addEventHandler(DragEvent.DRAG_EXITED_TARGET,
1252 event -> {
1253 counter++;
1254 }
1255 );
1256
1257 /* start drag */
1258 src.getScene().impl_processMouseEvent(
1259 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1260 assertEquals(0, counter);
1261
1262 /* drag */
1263 toolkit.dragTo(52, 52, TransferMode.MOVE);
1264 assertEquals(0, counter);
1265
1266 toolkit.dragTo(250, 52, TransferMode.MOVE);
1267 assertEquals(1, counter);
1268
1269 toolkit.dragTo(50, 52, TransferMode.MOVE);
1270 assertEquals(2, counter);
1271 }
1272
1273 /************************************************************************/
1274 /* DRAGVIEW */
1275 /************************************************************************/
1276 @Test
1277 public void startDragShouldNotBeCalledIfNothingPutOnDragboardWithDragView() {
1278 final Node n = oneNode();
1279 final MouseEventGenerator gen = new MouseEventGenerator();
1280 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1281
1282 n.setOnMousePressed(doDetect);
1283 n.setOnDragDetected(event -> {
1284 Dragboard db = n.startDragAndDrop(TransferMode.COPY);
1285 db.setDragView(img);
1286 db.setDragViewOffsetX(20);
1287 db.setDragViewOffsetX(15);
1288 });
1289
1290 n.getScene().impl_processMouseEvent(
1291 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1292 n.getScene().impl_processMouseEvent(
1293 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
1294 n.getScene().impl_processMouseEvent(
1295 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
1296
1297 assertFalse(toolkit.dragging);
1298 }
1299
1300 @Test
1301 public void startDragShouldBeCalledIfStringPutOnDragboardsWithDragView() {
1302 final Node n = oneNode();
1303 final MouseEventGenerator gen = new MouseEventGenerator();
1304 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1305
1306 dragSource = n;
1307 n.setOnMousePressed(doDetect);
1308 n.setOnDragDetected(event -> {
1309 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1310 ClipboardContent cc = new ClipboardContent();
1311 cc.putString("Hello");
1312 db.setContent(cc);
1313 db.setDragView(img);
1314 db.setDragViewOffsetX(20);
1315 db.setDragViewOffsetX(15);
1316 });
1317
1318 n.getScene().impl_processMouseEvent(
1319 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1320
1321 assertTrue(toolkit.dragging);
1322 }
1323
1324 @Test
1325 public void changeDragViewInParentHandlerShouldBePossible() {
1326 final Node n = oneNode();
1327 final Node parent = n.getParent();
1328 final MouseEventGenerator gen = new MouseEventGenerator();
1329 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1330 final Image imgParent = new Image("file:testImg_" + 200 + "x" + 200 + ".png");
1331
1332 dragSource = n;
1333 n.setOnMousePressed(doDetect);
1334 n.setOnDragDetected(event -> {
1335 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1336 ClipboardContent cc = new ClipboardContent();
1337 cc.putString("Hello");
1338 db.setContent(cc);
1343
1344 parent.setOnDragDetected(event -> {
1345 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1346 ClipboardContent cc = new ClipboardContent();
1347 cc.putString("HelloParent");
1348 db.setContent(cc);
1349
1350 assertEquals(img, db.getDragView());
1351 assertEquals(20, db.getDragViewOffsetX(), 1e-10);
1352 assertEquals(15, db.getDragViewOffsetY(), 1e-10);
1353
1354 db.setDragView(imgParent);
1355 db.setDragViewOffsetX(40);
1356 db.setDragViewOffsetY(55);
1357
1358 assertEquals(imgParent, db.getDragView());
1359 assertEquals(40, db.getDragViewOffsetX(), 1e-10);
1360 assertEquals(55, db.getDragViewOffsetY(), 1e-10);
1361 });
1362
1363 n.getScene().impl_processMouseEvent(
1364 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1365 }
1366
1367 @Test
1368 public void settingDragViewAndCursorPositionShouldReturnSameResults() {
1369 final Node n = oneNode();
1370 final Node parent = n.getParent();
1371 final MouseEventGenerator gen = new MouseEventGenerator();
1372 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1373 final Image imgParent = new Image("file:testImg_" + 200 + "x" + 200 + ".png");
1374
1375 dragSource = n;
1376 n.setOnMousePressed(doDetect);
1377 n.setOnDragDetected(event -> {
1378 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1379 ClipboardContent cc = new ClipboardContent();
1380 cc.putString("Hello");
1381 db.setContent(cc);
1382 db.setDragView(img, 20, 15);
1383 });
1384
1385 parent.setOnDragDetected(event -> {
1386 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1387 ClipboardContent cc = new ClipboardContent();
1388 cc.putString("HelloParent");
1389 db.setContent(cc);
1390
1391 assertEquals(img, db.getDragView());
1392 assertEquals(20, db.getDragViewOffsetX(), 1e-10);
1393 assertEquals(15, db.getDragViewOffsetY(), 1e-10);
1394
1395 db.setDragView(imgParent);
1396 db.setDragViewOffsetX(40);
1397 db.setDragViewOffsetY(55);
1398
1399 assertEquals(imgParent, db.getDragView());
1400 assertEquals(40, db.getDragViewOffsetX(), 1e-10);
1401 assertEquals(55, db.getDragViewOffsetY(), 1e-10);
1402 });
1403
1404 n.getScene().impl_processMouseEvent(
1405 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1406 }
1407
1408 @Test
1409 public void dragViewShouldBeClearedInSubsequentDragDetectedCall() {
1410 final Node n = oneNode();
1411 final MouseEventGenerator gen = new MouseEventGenerator();
1412 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1413
1414 dragSource = n;
1415 n.setOnMousePressed(doDetect);
1416 n.setOnDragDetected(event -> {
1417 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1418
1419 assertNull(db.getDragView());
1420 assertEquals(0, db.getDragViewOffsetX(), 1e-10);
1421 assertEquals(0, db.getDragViewOffsetY(), 1e-10);
1422
1423 ClipboardContent cc = new ClipboardContent();
1424 cc.putString("Hello");
1425 db.setContent(cc);
1426 db.setDragView(img);
1427 db.setDragViewOffsetX(20);
1428 db.setDragViewOffsetX(15);
1429 });
1430
1431 n.getScene().impl_processMouseEvent(
1432 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1433 n.getScene().impl_processMouseEvent(
1434 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 40, 40));
1435 n.getScene().impl_processMouseEvent(
1436 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 55, 55));
1437 n.getScene().impl_processMouseEvent(
1438 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 81, 81));
1439 }
1440
1441 /************************************************************************/
1442 /* PICK RESULT */
1443 /************************************************************************/
1444
1445 @Test
1446 public void shouldCompute3dCoordinates() {
1447 Node n = twoNodes()[0];
1448 n.setTranslateZ(50);
1449 dragSource = n;
1450
1451 MouseEventGenerator gen = new MouseEventGenerator();
1452
1453 counter = 0;
1454 n.setOnMousePressed(doDetect);
1455 n.setOnDragDetected(stringSource(TransferMode.ANY));
1456 n.setOnDragOver(event -> {
1457 counter++;
1458 Assert.assertEquals(52, event.getX(), 0.00001);
1459 Assert.assertEquals(52, event.getY(), 0.00001);
1460 Assert.assertEquals(0, event.getZ(), 0.00001);
1461 });
1462
1463 n.getScene().setOnDragOver(event -> {
1464 counter++;
1465 Assert.assertEquals(52, event.getX(), 0.00001);
1466 Assert.assertEquals(52, event.getY(), 0.00001);
1467 Assert.assertEquals(50, event.getZ(), 0.00001);
1468 });
1469
1470 n.getScene().impl_processMouseEvent(
1471 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1472 toolkit.dragTo(52, 52, TransferMode.COPY);
1473 toolkit.drop(252, 52, TransferMode.COPY);
1474 toolkit.done(TransferMode.COPY);
1475
1476 assertEquals(2, counter);
1477 }
1478
1479 @Test
1480 public void dragEventsHavePickResult() {
1481 final Node[] nodes = twoNodes();
1482 final Node n1 = nodes[0];
1483 final Node n2 = nodes[1];
1484 final MouseEventGenerator gen = new MouseEventGenerator();
1485
1486 dragSource = n1;
1487 n1.setOnMousePressed(doDetect);
1488 n1.setOnDragDetected(stringSource(TransferMode.ANY));
1489 n1.setOnDragOver(event -> {
1490 PickResult pickRes = event.getPickResult();
1502 assertEquals(252, pickRes.getIntersectedPoint().getX(), 0.00001);
1503 assertEquals(52, pickRes.getIntersectedPoint().getY(), 0.00001);
1504 assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
1505 event.acceptTransferModes(TransferMode.COPY);
1506 counter++;
1507 };
1508 n1.setOnDragExited(switchNodeHandler);
1509 n2.setOnDragEntered(switchNodeHandler);
1510 n2.setOnDragOver(switchNodeHandler);
1511 n2.setOnDragDropped(switchNodeHandler);
1512 n1.setOnDragDone(event -> {
1513 PickResult pickRes = event.getPickResult();
1514 assertNotNull(pickRes);
1515 assertNull(pickRes.getIntersectedNode());
1516 assertEquals(0, pickRes.getIntersectedPoint().getX(), 0.00001);
1517 assertEquals(0, pickRes.getIntersectedPoint().getY(), 0.00001);
1518 assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
1519 counter++;
1520 });
1521
1522 n1.getScene().impl_processMouseEvent(
1523 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1524 toolkit.dragTo(52, 52, TransferMode.COPY);
1525 toolkit.dragTo(252, 52, TransferMode.COPY);
1526 toolkit.drop(252, 52, TransferMode.COPY);
1527 toolkit.done(TransferMode.COPY);
1528
1529 assertEquals(6, counter);
1530 }
1531
1532
1533 /************************************************************************/
1534 /* HELPER CODE */
1535 /************************************************************************/
1536
1537 // Event handlers
1538
1539 private final EventHandler<MouseEvent> dontDetect =
1540 event -> event.setDragDetect(false);
1541
1542 private final EventHandler<MouseEvent> doDetect =
|
1 /*
2 * Copyright (c) 2000, 2016, 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 com.sun.javafx.scene.SceneHelper;
29 import static org.junit.Assert.assertNull;
30 import static org.junit.Assert.fail;
31
32 import java.security.AccessControlContext;
33 import java.util.ArrayList;
34 import java.util.Arrays;
35 import java.util.HashSet;
36 import java.util.List;
37 import java.util.Set;
38
39 import com.sun.javafx.tk.TKScene;
40 import javafx.event.EventHandler;
41 import javafx.scene.Group;
42 import javafx.scene.Node;
43 import javafx.scene.Scene;
44 import javafx.scene.shape.Rectangle;
45 import javafx.stage.Stage;
46 import javafx.util.Pair;
47
48 import org.junit.After;
267 /* DRAG INITIATION */
268 /************************************************************************/
269
270
271 @Test
272 public void dragDetectionShouldUseHysteresis() {
273 Node n = oneNode();
274 MouseEventGenerator gen = new MouseEventGenerator();
275
276 EventHandler<MouseEvent> thirdEventFailsHysteresis =
277 event -> {
278 counter++;
279 assertTrue((counter != 3 && !event.isDragDetect()) ||
280 (counter == 3 && event.isDragDetect()));
281 };
282
283 n.addEventHandler(MouseEvent.MOUSE_PRESSED, thirdEventFailsHysteresis);
284 n.addEventHandler(MouseEvent.MOUSE_DRAGGED, thirdEventFailsHysteresis);
285 n.addEventHandler(MouseEvent.MOUSE_RELEASED, thirdEventFailsHysteresis);
286
287 SceneHelper.processMouseEvent(n.getScene(),
288 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
289 SceneHelper.processMouseEvent(n.getScene(),
290 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 52, 48));
291 SceneHelper.processMouseEvent(n.getScene(),
292 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 70, 70));
293 SceneHelper.processMouseEvent(n.getScene(),
294 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
295 SceneHelper.processMouseEvent(n.getScene(),
296 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
297
298 assertEquals(5, counter);
299 }
300
301 @Test
302 public void dragShouldNotBeDetectedBasedOnMoveOrRelase() {
303 Node n = oneNode();
304 MouseEventGenerator gen = new MouseEventGenerator();
305
306 n.setOnDragDetected(detector);
307 n.setOnMousePressed(dontDetect);
308 n.setOnMouseMoved(doDetect);
309 n.setOnMouseReleased(doDetect);
310
311 /* dontDetect prevents detection */
312 SceneHelper.processMouseEvent(n.getScene(),
313 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
314 assertFalse(detected);
315
316 SceneHelper.processMouseEvent(n.getScene(),
317 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
318 assertFalse(detected);
319
320 SceneHelper.processMouseEvent(n.getScene(),
321 gen.generateMouseEvent(MouseEvent.MOUSE_MOVED, 60, 60));
322 assertFalse(detected);
323 }
324
325 @Test
326 public void dragShouldBeDetectedBasedOnMouseEvent() {
327 Node n = oneNode();
328 MouseEventGenerator gen = new MouseEventGenerator();
329
330 n.setOnDragDetected(detector);
331 n.setOnMousePressed(dontDetect);
332 n.setOnMouseDragged(dontDetect);
333 n.setOnMouseReleased(doDetect);
334
335 /* dontDetect prevents detection */
336 SceneHelper.processMouseEvent(n.getScene(),
337 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
338 assertFalse(detected);
339 SceneHelper.processMouseEvent(n.getScene(),
340 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 52, 48));
341 assertFalse(detected);
342 SceneHelper.processMouseEvent(n.getScene(),
343 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 70, 70));
344 assertFalse(detected);
345
346 /* doDetect fires detection */
347 n.setOnMouseDragged(doDetect);
348
349 SceneHelper.processMouseEvent(n.getScene(),
350 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
351 assertTrue(detected);
352 detected = false;
353
354 /* but fires it only once */
355 SceneHelper.processMouseEvent(n.getScene(),
356 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 70, 70));
357 assertFalse(detected);
358
359 SceneHelper.processMouseEvent(n.getScene(),
360 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
361 assertFalse(detected);
362 }
363
364 @Test
365 public void dragDetectionShouldBeOverridable() {
366 Node n = oneNode();
367 MouseEventGenerator gen = new MouseEventGenerator();
368
369 n.setOnDragDetected(detector);
370 n.setOnMousePressed(doDetect);
371 n.setOnMouseDragged(dontDetect);
372 n.getParent().setOnMousePressed(dontDetect);
373 n.getParent().setOnMouseDragged(doDetect);
374
375 /* dontDetect prevents detection */
376 SceneHelper.processMouseEvent(n.getScene(),
377 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
378 assertFalse(detected);
379
380 SceneHelper.processMouseEvent(n.getScene(),
381 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
382 assertTrue(detected);
383 detected = false;
384
385 SceneHelper.processMouseEvent(n.getScene(),
386 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
387 assertFalse(detected);
388 }
389
390 @Test
391 public void startDragShouldNotBeCalledIfNothingPutOnDragboard() {
392 final Node n = oneNode();
393 final MouseEventGenerator gen = new MouseEventGenerator();
394
395 n.setOnMousePressed(doDetect);
396 n.setOnDragDetected(event -> {
397 n.startDragAndDrop(TransferMode.COPY);
398 });
399
400 SceneHelper.processMouseEvent(n.getScene(),
401 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
402 SceneHelper.processMouseEvent(n.getScene(),
403 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
404 SceneHelper.processMouseEvent(n.getScene(),
405 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
406
407 assertFalse(toolkit.dragging);
408 }
409
410 @Test
411 public void startDragShouldBeCalledIfStringPutOnDragboard() {
412 final Node n = oneNode();
413 final MouseEventGenerator gen = new MouseEventGenerator();
414
415 dragSource = n;
416 n.setOnMousePressed(doDetect);
417 n.setOnDragDetected(stringSource(TransferMode.ANY));
418
419 SceneHelper.processMouseEvent(n.getScene(),
420 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
421 assertTrue(toolkit.dragging);
422 }
423
424 /************************************************************************/
425 /* SOURCE/TARGET */
426 /************************************************************************/
427
428 @Test
429 public void nodeThatCallsStartDndShouldBecomeGestureSource() {
430 final Node n = oneNode();
431 final MouseEventGenerator gen = new MouseEventGenerator();
432
433 dragSource = n.getParent();
434 n.setOnMousePressed(doDetect);
435 n.setOnDragDetected(stringSource(TransferMode.ANY));
436 n.setOnDragOver(event -> {
437 assertSame(dragSource, event.getGestureSource());
438 counter++;
439 });
440
441 SceneHelper.processMouseEvent(n.getScene(),
442 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
443 toolkit.dragTo(52, 52, TransferMode.COPY);
444
445 assertEquals(1, counter);
446 }
447
448 @Test
449 public void parentThatCallsStartDndShouldBecomeGestureSource() {
450 final Node n = oneNode();
451 final MouseEventGenerator gen = new MouseEventGenerator();
452
453 dragSource = n.getParent();
454 n.setOnMousePressed(doDetect);
455 n.getParent().setOnDragDetected(stringSource(TransferMode.ANY));
456 n.setOnDragOver(event -> {
457 assertSame(dragSource, event.getGestureSource());
458 counter++;
459 });
460
461 SceneHelper.processMouseEvent(n.getScene(),
462 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
463 toolkit.dragTo(52, 52, TransferMode.COPY);
464
465 assertEquals(1, counter);
466 }
467
468 @Test
469 public void nodeThatAcceptsDragShouldBecomeGestureTarget() {
470 final Node n = oneNode();
471 final MouseEventGenerator gen = new MouseEventGenerator();
472
473 dragSource = n;
474 n.setOnMousePressed(doDetect);
475 n.setOnDragDetected(stringSource(TransferMode.ANY));
476 n.setOnDragOver(event -> {
477 event.acceptTransferModes(TransferMode.ANY);
478 if (counter == 0) {
479 assertNull(event.getGestureTarget());
480 } else {
481 assertSame(n, event.getGestureTarget());
482 }
483 counter++;
484 });
485 n.setOnDragDropped(event -> {
486 assertSame(n, event.getGestureTarget());
487 counter++;
488 });
489
490 SceneHelper.processMouseEvent(n.getScene(),
491 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
492 toolkit.dragTo(51, 51, TransferMode.COPY);
493 toolkit.dragTo(52, 52, TransferMode.COPY);
494 toolkit.drop(52, 52, TransferMode.COPY);
495
496 assertEquals(3, counter);
497 }
498
499 @Test
500 public void parentThatAcceptsDragShouldBecomeGestureTarget() {
501 final Node n = oneNode();
502 final MouseEventGenerator gen = new MouseEventGenerator();
503
504 dragSource = n;
505 n.setOnMousePressed(doDetect);
506 n.setOnDragDetected(stringSource(TransferMode.ANY));
507 n.setOnDragOver(event -> {
508 event.acceptTransferModes(TransferMode.ANY);
509 if (counter == 0) {
510 assertNull(event.getGestureTarget());
511 } else {
512 assertSame(n.getParent(), event.getGestureTarget());
513 }
514 counter++;
515 });
516 n.getParent().setOnDragOver(acceptAny);
517 n.setOnDragDropped(event -> {
518 assertSame(n.getParent(), event.getGestureTarget());
519 counter++;
520 });
521
522 SceneHelper.processMouseEvent(n.getScene(),
523 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
524 toolkit.dragTo(51, 51, TransferMode.COPY);
525 toolkit.dragTo(52, 52, TransferMode.COPY);
526 toolkit.drop(52, 52, TransferMode.COPY);
527
528 assertEquals(3, counter);
529 }
530
531 @Test
532 public void sceneCanBecomeGestureSource() {
533 final Node n = oneNode();
534 final MouseEventGenerator gen = new MouseEventGenerator();
535
536 n.setOnMousePressed(doDetect);
537 n.getScene().setOnDragDetected(event -> {
538 Dragboard db = n.getScene().startDragAndDrop(TransferMode.ANY);
539 ClipboardContent cc = new ClipboardContent();
540 cc.putString("Hello");
541 db.setContent(cc);
542 });
543 n.setOnDragOver(event -> {
544 assertSame(n.getScene(), event.getGestureSource());
545 counter++;
546 });
547
548 SceneHelper.processMouseEvent(n.getScene(),
549 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
550 toolkit.dragTo(52, 52, TransferMode.COPY);
551
552 assertEquals(1, counter);
553 }
554
555 @Test
556 public void sceneCanBecomeGestureTarget() {
557 final Node n = oneNode();
558 final MouseEventGenerator gen = new MouseEventGenerator();
559
560 dragSource = n;
561 n.setOnMousePressed(doDetect);
562 n.setOnDragDetected(stringSource(TransferMode.ANY));
563 n.getScene().setOnDragOver(event -> {
564 event.acceptTransferModes(TransferMode.ANY);
565 if (counter == 0) {
566 assertNull(event.getGestureTarget());
567 } else {
568 assertSame(n.getScene(), event.getGestureTarget());
569 }
570 counter++;
571 });
572 n.setOnDragDropped(event -> {
573 assertSame(n.getScene(), event.getGestureTarget());
574 counter++;
575 });
576
577 SceneHelper.processMouseEvent(n.getScene(),
578 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
579 toolkit.dragTo(51, 51, TransferMode.COPY);
580 toolkit.dragTo(52, 52, TransferMode.COPY);
581 toolkit.drop(52, 52, TransferMode.COPY);
582
583 assertEquals(3, counter);
584 }
585
586 /************************************************************************/
587 /* TRANSFER MODES */
588 /************************************************************************/
589
590 @Test
591 public void defaultTransferModeShouldBeUsedIfSupported() {
592 final Node n = oneNode();
593 final MouseEventGenerator gen = new MouseEventGenerator();
594
595 dragSource = n;
596 n.setOnMousePressed(doDetect);
597 n.setOnDragDetected(stringSource(TransferMode.ANY));
598 n.setOnDragOver(acceptAny);
599
600 /* start drag */
601 SceneHelper.processMouseEvent(n.getScene(),
602 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
603
604 /* drag */
605 assertSame(TransferMode.LINK, toolkit.dragTo(52, 52, TransferMode.LINK));
606 }
607
608 @Test
609 public void defaultTransferModeShouldNotBeUsedIfNotSupported() {
610 final Node n = oneNode();
611 final MouseEventGenerator gen = new MouseEventGenerator();
612
613 dragSource = n;
614 n.setOnMousePressed(doDetect);
615 n.setOnDragDetected(stringSource(TransferMode.COPY));
616 n.setOnDragOver(acceptAny);
617
618 /* start drag */
619 SceneHelper.processMouseEvent(n.getScene(),
620 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
621
622 /* drag */
623 assertSame(TransferMode.COPY, toolkit.dragTo(52, 52, TransferMode.LINK));
624 }
625
626 @Test
627 public void mostCommonTransferModeShouldBeChosen() {
628 final Node n = oneNode();
629 final MouseEventGenerator gen = new MouseEventGenerator();
630
631 dragSource = n;
632 n.setOnMousePressed(doDetect);
633 n.setOnDragDetected(stringSource(TransferMode.COPY_OR_MOVE));
634 n.setOnDragOver(acceptAny);
635
636 /* start drag */
637 SceneHelper.processMouseEvent(n.getScene(),
638 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
639
640 /* drag */
641 assertSame(TransferMode.MOVE, toolkit.dragTo(52, 52, TransferMode.LINK));
642 }
643
644 @Test
645 public void transferModeAcceptanceShouldBeOverridable_restriction() {
646 final Node n = oneNode();
647 final MouseEventGenerator gen = new MouseEventGenerator();
648
649 dragSource = n;
650 n.setOnMousePressed(doDetect);
651 n.setOnDragDetected(stringSource(TransferMode.COPY_OR_MOVE));
652 n.setOnDragOver(acceptAny);
653 n.getParent().setOnDragOver(acceptCopy);
654
655 /* start drag */
656 SceneHelper.processMouseEvent(n.getScene(),
657 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
658
659 /* drag */
660 assertSame(TransferMode.COPY, toolkit.dragTo(52, 52, TransferMode.MOVE));
661 }
662
663 @Test
664 public void transferModeAcceptanceShouldBeOverridable_loosening() {
665 final Node n = oneNode();
666 final MouseEventGenerator gen = new MouseEventGenerator();
667
668 dragSource = n;
669 n.setOnMousePressed(doDetect);
670 n.setOnDragDetected(stringSource(TransferMode.COPY_OR_MOVE));
671 n.setOnDragOver(acceptCopy);
672 n.getParent().setOnDragOver(acceptAny);
673
674 /* start drag */
675 SceneHelper.processMouseEvent(n.getScene(),
676 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
677
678 /* drag */
679 assertSame(TransferMode.MOVE, toolkit.dragTo(52, 52, TransferMode.MOVE));
680 }
681
682 @Test
683 public void noTransferShouldHappenWhenUnsupportedModeIsAccepted() {
684 final Node n = oneNode();
685 final MouseEventGenerator gen = new MouseEventGenerator();
686
687 dragSource = n;
688 n.setOnMousePressed(doDetect);
689 n.setOnDragDetected(stringSource(TransferMode.LINK));
690 n.setOnDragOver(acceptCopyOrMove);
691
692 /* start drag */
693 SceneHelper.processMouseEvent(n.getScene(),
694 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
695
696 /* drag */
697 assertNull(toolkit.dragTo(52, 52, TransferMode.MOVE));
698 }
699
700 @Test
701 public void noTransferShouldHappenWhenNotAccepted() {
702 final Node n = oneNode();
703 final MouseEventGenerator gen = new MouseEventGenerator();
704
705 dragSource = n;
706 n.setOnMousePressed(doDetect);
707 n.setOnDragDetected(stringSource(TransferMode.ANY));
708
709 /* start drag */
710 SceneHelper.processMouseEvent(n.getScene(),
711 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
712
713 /* drag */
714 assertNull(toolkit.dragTo(52, 52, TransferMode.MOVE));
715 }
716
717 @Test
718 public void dropShouldGetAcceptedTransferMode() {
719 final Node n = oneNode();
720 final MouseEventGenerator gen = new MouseEventGenerator();
721
722 dragSource = n;
723 n.setOnMousePressed(doDetect);
724 n.setOnDragDetected(stringSource(TransferMode.ANY));
725 n.setOnDragOver(acceptCopy);
726 n.setOnDragDropped(event -> {
727 counter++;
728 assertSame(TransferMode.COPY, event.getTransferMode());
729 assertSame(TransferMode.COPY, event.getAcceptedTransferMode());
730 });
731
732 /* start drag */
733 SceneHelper.processMouseEvent(n.getScene(),
734 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
735
736 /* drag and drop*/
737 toolkit.dragTo(52, 52, TransferMode.MOVE);
738 toolkit.drop(52, 52, TransferMode.MOVE);
739
740 assertEquals(1, counter);
741 }
742
743 @Test
744 public void shouldBePossibleToAcceptInDrop() {
745 final Node n = oneNode();
746 final MouseEventGenerator gen = new MouseEventGenerator();
747
748 dragSource = n;
749 n.setOnMousePressed(doDetect);
750 n.setOnDragDetected(stringSource(TransferMode.ANY));
751 n.setOnDragOver(acceptCopy);
752 n.setOnDragDropped(event -> {
753 assertSame(TransferMode.COPY, event.getTransferMode());
754 assertSame(TransferMode.COPY, event.getAcceptedTransferMode());
755 event.acceptTransferModes(TransferMode.MOVE);
756 event.setDropCompleted(true);
757 assertSame(TransferMode.COPY, event.getTransferMode());
758 assertSame(TransferMode.MOVE, event.getAcceptedTransferMode());
759 });
760
761 /* start drag */
762 SceneHelper.processMouseEvent(n.getScene(),
763 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
764
765 /* drag and drop*/
766 toolkit.dragTo(52, 52, TransferMode.MOVE);
767 assertEquals(TransferMode.MOVE, toolkit.drop(52, 52, TransferMode.LINK));
768 }
769
770 @Test
771 public void acceptingNonSupportedTransferModeInDropShouldThrowException() {
772 final Node n = oneNode();
773 final MouseEventGenerator gen = new MouseEventGenerator();
774
775 dragSource = n;
776 n.setOnMousePressed(doDetect);
777 n.setOnDragDetected(stringSource(TransferMode.COPY_OR_MOVE));
778 n.setOnDragOver(acceptCopy);
779 n.setOnDragDropped(event -> {
780 try {
781 event.acceptTransferModes(TransferMode.LINK);
782 fail("Exception was not thrown");
783 } catch (IllegalStateException e) {
784 /* expceted */
785 counter++;
786 }
787 });
788
789 /* start drag */
790 SceneHelper.processMouseEvent(n.getScene(),
791 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
792
793 /* drag and drop*/
794 toolkit.dragTo(52, 52, TransferMode.MOVE);
795 toolkit.drop(52, 52, TransferMode.LINK);
796
797 assertEquals(1, counter);
798 }
799
800 @Test
801 public void modifyingStaticArraysShouldNotInfluenceResult() {
802 TransferMode.ANY[0] = TransferMode.LINK;
803 TransferMode.ANY[1] = TransferMode.LINK;
804 TransferMode.ANY[2] = TransferMode.LINK;
805
806 TransferMode.COPY_OR_MOVE[0] = TransferMode.LINK;
807 TransferMode.COPY_OR_MOVE[1] = TransferMode.LINK;
808
809 final Node n = oneNode();
810 final MouseEventGenerator gen = new MouseEventGenerator();
811
812 dragSource = n;
813 n.setOnMousePressed(doDetect);
814 n.setOnDragDetected(stringSource(TransferMode.ANY));
815 n.setOnDragOver(acceptCopyOrMove);
816 n.setOnDragDropped(event -> {
817 event.acceptTransferModes(TransferMode.ANY);
818 event.setDropCompleted(true);
819 });
820
821 /* start drag */
822 SceneHelper.processMouseEvent(n.getScene(),
823 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
824
825 /* drag and drop*/
826 assertSame(TransferMode.COPY, toolkit.dragTo(52, 52, TransferMode.COPY));
827 assertSame(TransferMode.COPY, toolkit.drop(52, 52, TransferMode.COPY));
828
829 TransferMode.ANY[0] = TransferMode.COPY;
830 TransferMode.ANY[1] = TransferMode.MOVE;
831 TransferMode.ANY[2] = TransferMode.LINK;
832
833 TransferMode.COPY_OR_MOVE[0] = TransferMode.COPY;
834 TransferMode.COPY_OR_MOVE[1] = TransferMode.MOVE;
835 }
836
837 /************************************************************************/
838 /* GESTURE FINISH */
839 /************************************************************************/
840
841 @Test
842 public void dropShouldBeAcceptedByCompletion() {
843 final Node n = oneNode();
844 final MouseEventGenerator gen = new MouseEventGenerator();
845
846 dragSource = n;
847 n.setOnMousePressed(doDetect);
848 n.setOnDragDetected(stringSource(TransferMode.ANY));
849 n.setOnDragOver(acceptCopy);
850 n.setOnDragDropped(event -> {
851 event.setDropCompleted(true);
852 });
853
854 /* start drag */
855 SceneHelper.processMouseEvent(n.getScene(),
856 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
857
858 /* drag and drop*/
859 toolkit.dragTo(52, 52, TransferMode.MOVE);
860 assertSame(TransferMode.COPY, toolkit.drop(52, 52, TransferMode.MOVE));
861 }
862
863 @Test
864 public void dropShouldNotBeAcceptedWithUnsuccessfulCompletion() {
865 final Node n = oneNode();
866 final MouseEventGenerator gen = new MouseEventGenerator();
867
868 dragSource = n;
869 n.setOnMousePressed(doDetect);
870 n.setOnDragDetected(stringSource(TransferMode.ANY));
871 n.setOnDragOver(acceptCopy);
872 n.setOnDragDropped(event -> {
873 event.setDropCompleted(false);
874 });
875
876 /* start drag */
877 SceneHelper.processMouseEvent(n.getScene(),
878 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
879
880 /* drag and drop*/
881 toolkit.dragTo(52, 52, TransferMode.MOVE);
882 assertNull(toolkit.drop(52, 52, TransferMode.MOVE));
883 }
884
885 @Test
886 public void dropShouldNotBeAcceptedWithoutCompletion() {
887 final Node n = oneNode();
888 final MouseEventGenerator gen = new MouseEventGenerator();
889
890 dragSource = n;
891 n.setOnMousePressed(doDetect);
892 n.setOnDragDetected(stringSource(TransferMode.ANY));
893 n.setOnDragOver(acceptCopy);
894
895 /* start drag */
896 SceneHelper.processMouseEvent(n.getScene(),
897 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
898
899 /* drag and drop*/
900 toolkit.dragTo(52, 52, TransferMode.MOVE);
901 assertNull(toolkit.drop(52, 52, TransferMode.MOVE));
902 }
903
904 @Test
905 public void dropCompletionShouldBeOverridable() {
906 final Node n = oneNode();
907 final MouseEventGenerator gen = new MouseEventGenerator();
908
909 dragSource = n;
910 n.setOnMousePressed(doDetect);
911 n.setOnDragDetected(stringSource(TransferMode.ANY));
912 n.setOnDragOver(acceptCopyOrMove);
913 n.setOnDragDropped(event -> {
914 event.setDropCompleted(false);
915 });
916 n.getParent().setOnDragDropped(event -> {
917 event.setDropCompleted(true);
918 });
919
920 /* start drag */
921 SceneHelper.processMouseEvent(n.getScene(),
922 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
923
924 /* drag and drop*/
925 toolkit.dragTo(52, 52, TransferMode.MOVE);
926 assertSame(TransferMode.MOVE, toolkit.drop(52, 52, TransferMode.MOVE));
927 }
928
929 @Test
930 public void dropDoneShouldBeSentToGestureSource() {
931 final Node[] ns = twoNodes();
932 Node src = ns[0];
933 Node trgt = ns[1];
934
935 final MouseEventGenerator gen = new MouseEventGenerator();
936
937 dragSource = src;
938 src.setOnMousePressed(doDetect);
939 src.setOnDragDetected(stringSource(TransferMode.ANY));
940 trgt.setOnDragOver(acceptCopyOrMove);
941 trgt.setOnDragDropped(event -> {
942 event.setDropCompleted(true);
943 });
944 src.getParent().setOnDragDone(event -> {
945 Assert.assertEquals(TransferMode.MOVE, event.getTransferMode());
946 Assert.assertEquals(TransferMode.MOVE, event.getAcceptedTransferMode());
947 counter++;
948 });
949
950 /* start drag */
951 SceneHelper.processMouseEvent(src.getScene(),
952 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
953
954 /* drag and drop*/
955 toolkit.dragTo(52, 52, TransferMode.MOVE);
956 toolkit.dragTo(252, 52, TransferMode.MOVE);
957 toolkit.drop(252, 52, TransferMode.COPY);
958 toolkit.done(TransferMode.MOVE);
959 assertEquals(counter, 1);
960 }
961
962 /************************************************************************/
963 /* ENTERED/EXITED */
964 /************************************************************************/
965
966 @Test
967 public void dragSourceShouldGetEnteredImmediately() {
968 final Node n = oneNode();
969 final MouseEventGenerator gen = new MouseEventGenerator();
970
971 dragSource = n;
972 n.setOnMousePressed(doDetect);
973 n.setOnDragDetected(stringSource(TransferMode.ANY));
974 n.setOnDragOver(acceptAny);
975 n.setOnDragEntered(event -> {
976 counter++;
977 });
978
979 /* start drag */
980 SceneHelper.processMouseEvent(n.getScene(),
981 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
982 assertEquals(0, counter);
983
984 /* drag */
985 toolkit.dragTo(52, 52, TransferMode.MOVE);
986 assertEquals(1, counter);
987 }
988
989 @Test
990 public void dragSourcesParentShouldGetEnteredImmediately() {
991 final Node n = oneNode();
992 final MouseEventGenerator gen = new MouseEventGenerator();
993
994 dragSource = n;
995 n.setOnMousePressed(doDetect);
996 n.setOnDragDetected(stringSource(TransferMode.ANY));
997 n.setOnDragOver(acceptAny);
998 n.getParent().setOnDragEntered(event -> {
999 counter++;
1000 });
1001
1002 /* start drag */
1003 SceneHelper.processMouseEvent(n.getScene(),
1004 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1005 assertEquals(0, counter);
1006
1007 /* drag */
1008 toolkit.dragTo(52, 52, TransferMode.MOVE);
1009 assertEquals(1, counter);
1010 }
1011
1012 @Test
1013 public void dragSourcesSubScenesParentShouldGetEnteredImmediately() {
1014 final Node[] ns = oneNodeInSubScene();
1015 final Node n = ns[0];
1016 final Node subScene = ns[1];
1017
1018 dragSource = n;
1019 n.setOnMousePressed(doDetect);
1020 n.setOnDragDetected(stringSource(TransferMode.ANY));
1021 n.setOnDragOver(acceptAny);
1022 subScene.setOnDragEntered(event -> {
1023 counter++;
1024 });
1025 subScene.getParent().setOnDragEntered(event -> {
1026 counter++;
1027 });
1028
1029 /* start drag */
1030 SceneHelper.processMouseEvent(n.getScene(),
1031 MouseEventGenerator.generateMouseEvent(
1032 MouseEvent.MOUSE_PRESSED, 50, 50));
1033 assertEquals(0, counter);
1034
1035 /* drag */
1036 toolkit.dragTo(52, 52, TransferMode.MOVE);
1037 assertEquals(2, counter);
1038 }
1039
1040 @Test
1041 public void dragSourcesParentShouldGetEnteredTargetTwice() {
1042 final Node n = oneNode();
1043 final MouseEventGenerator gen = new MouseEventGenerator();
1044
1045 dragSource = n;
1046 n.setOnMousePressed(doDetect);
1047 n.setOnDragDetected(stringSource(TransferMode.ANY));
1048 n.setOnDragOver(acceptAny);
1049 n.getParent().addEventHandler(DragEvent.DRAG_ENTERED_TARGET,
1050 event -> {
1051 counter++;
1052 }
1053 );
1054
1055 /* start drag */
1056 SceneHelper.processMouseEvent(n.getScene(),
1057 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1058 assertEquals(0, counter);
1059
1060 /* drag */
1061 toolkit.dragTo(52, 52, TransferMode.MOVE);
1062 assertEquals(2, counter);
1063 }
1064
1065 @Test
1066 public void dragSourceShouldGetExitedWhenLeft() {
1067 final Node n = oneNode();
1068 final MouseEventGenerator gen = new MouseEventGenerator();
1069
1070 dragSource = n;
1071 n.setOnMousePressed(doDetect);
1072 n.setOnDragDetected(stringSource(TransferMode.ANY));
1073 n.setOnDragOver(acceptAny);
1074 n.setOnDragExited(event -> {
1075 counter++;
1076 });
1077
1078 /* start drag */
1079 SceneHelper.processMouseEvent(n.getScene(),
1080 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1081 assertEquals(0, counter);
1082
1083 /* drag */
1084 toolkit.dragTo(52, 52, TransferMode.MOVE);
1085 assertEquals(0, counter);
1086
1087 toolkit.dragTo(150, 52, TransferMode.MOVE);
1088 assertEquals(1, counter);
1089 }
1090
1091 @Test
1092 public void dragSourcesSubScenesParentShouldGetExitedWhenLeft() {
1093 final Node[] ns = oneNodeInSubScene();
1094 final Node n = ns[0];
1095 final Node subScene = ns[1];
1096
1097 dragSource = n;
1098 n.setOnMousePressed(doDetect);
1099 n.setOnDragDetected(stringSource(TransferMode.ANY));
1100 n.setOnDragOver(acceptAny);
1101 subScene.setOnDragExited(event -> {
1102 counter++;
1103 });
1104 subScene.getParent().setOnDragExited(event -> {
1105 counter++;
1106 });
1107
1108 /* start drag */
1109 SceneHelper.processMouseEvent(n.getScene(),
1110 MouseEventGenerator.generateMouseEvent(
1111 MouseEvent.MOUSE_PRESSED, 50, 50));
1112 assertEquals(0, counter);
1113
1114 /* drag */
1115 toolkit.dragTo(52, 52, TransferMode.MOVE);
1116 assertEquals(0, counter);
1117
1118 toolkit.dragTo(250, 52, TransferMode.MOVE);
1119 assertEquals(2, counter);
1120 }
1121
1122 @Test
1123 public void dragSourceShouldGetEnteredWhenReturned() {
1124 final Node n = oneNode();
1125 final MouseEventGenerator gen = new MouseEventGenerator();
1126
1127 dragSource = n;
1128 n.setOnMousePressed(doDetect);
1129 n.setOnDragDetected(stringSource(TransferMode.ANY));
1130 n.setOnDragOver(acceptAny);
1131 n.setOnDragEntered(event -> {
1132 counter++;
1133 });
1134
1135 /* start drag */
1136 SceneHelper.processMouseEvent(n.getScene(),
1137 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1138 assertEquals(0, counter);
1139
1140 /* drag */
1141 toolkit.dragTo(52, 52, TransferMode.MOVE);
1142 assertEquals(1, counter);
1143
1144 toolkit.dragTo(150, 52, TransferMode.MOVE);
1145 assertEquals(1, counter);
1146
1147 toolkit.dragTo(60, 52, TransferMode.MOVE);
1148 assertEquals(2, counter);
1149 }
1150
1151 @Test
1152 public void anotherNodeShouldGetEntered() {
1153 final Node[] ns = twoNodes();
1154 Node src = ns[0];
1155 Node trgt = ns[1];
1156 final MouseEventGenerator gen = new MouseEventGenerator();
1157
1158 dragSource = src;
1159 src.setOnMousePressed(doDetect);
1160 src.setOnDragDetected(stringSource(TransferMode.ANY));
1161 src.setOnDragOver(acceptAny);
1162 trgt.setOnDragEntered(event -> {
1163 counter++;
1164 });
1165
1166 /* start drag */
1167 SceneHelper.processMouseEvent(src.getScene(),
1168 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1169 assertEquals(0, counter);
1170
1171 /* drag */
1172 toolkit.dragTo(52, 52, TransferMode.MOVE);
1173 assertEquals(0, counter);
1174
1175 toolkit.dragTo(250, 52, TransferMode.MOVE);
1176 assertEquals(1, counter);
1177 }
1178
1179 @Test
1180 public void anotherNodeShouldGetExited() {
1181 final Node[] ns = twoNodes();
1182 Node src = ns[0];
1183 Node trgt = ns[1];
1184 final MouseEventGenerator gen = new MouseEventGenerator();
1185
1186 dragSource = src;
1187 src.setOnMousePressed(doDetect);
1188 src.setOnDragDetected(stringSource(TransferMode.ANY));
1189 src.setOnDragOver(acceptAny);
1190 trgt.setOnDragExited(event -> {
1191 counter++;
1192 });
1193
1194 /* start drag */
1195 SceneHelper.processMouseEvent(src.getScene(),
1196 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1197 assertEquals(0, counter);
1198
1199 /* drag */
1200 toolkit.dragTo(52, 52, TransferMode.MOVE);
1201 assertEquals(0, counter);
1202
1203 toolkit.dragTo(250, 52, TransferMode.MOVE);
1204 assertEquals(0, counter);
1205
1206 toolkit.dragTo(150, 52, TransferMode.MOVE);
1207 assertEquals(1, counter);
1208 }
1209
1210 @Test
1211 public void parentShouldNotGetExitedWhenDraggingOverChildren() {
1212 final Node[] ns = twoNodes();
1213 Node src = ns[0];
1214 Node trgt = ns[1];
1215 final MouseEventGenerator gen = new MouseEventGenerator();
1216
1217 dragSource = src;
1218 src.setOnMousePressed(doDetect);
1219 src.setOnDragDetected(stringSource(TransferMode.ANY));
1220 src.setOnDragOver(acceptAny);
1221 trgt.getParent().setOnDragExited(event -> {
1222 counter++;
1223 });
1224
1225 /* start drag */
1226 SceneHelper.processMouseEvent(src.getScene(),
1227 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1228 assertEquals(0, counter);
1229
1230 /* drag */
1231 toolkit.dragTo(52, 52, TransferMode.MOVE);
1232 assertEquals(0, counter);
1233
1234 toolkit.dragTo(250, 52, TransferMode.MOVE);
1235 assertEquals(0, counter);
1236
1237 toolkit.dragTo(50, 52, TransferMode.MOVE);
1238 assertEquals(0, counter);
1239 }
1240
1241 @Test
1242 public void parentShouldGetExitedTargetWhenDraggingOverChildren() {
1243 final Node[] ns = twoNodes();
1244 Node src = ns[0];
1245 Node trgt = ns[1];
1246 final MouseEventGenerator gen = new MouseEventGenerator();
1247
1248 dragSource = src;
1249 src.setOnMousePressed(doDetect);
1250 src.setOnDragDetected(stringSource(TransferMode.ANY));
1251 src.setOnDragOver(acceptAny);
1252 trgt.getParent().addEventHandler(DragEvent.DRAG_EXITED_TARGET,
1253 event -> {
1254 counter++;
1255 }
1256 );
1257
1258 /* start drag */
1259 SceneHelper.processMouseEvent(src.getScene(),
1260 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1261 assertEquals(0, counter);
1262
1263 /* drag */
1264 toolkit.dragTo(52, 52, TransferMode.MOVE);
1265 assertEquals(0, counter);
1266
1267 toolkit.dragTo(250, 52, TransferMode.MOVE);
1268 assertEquals(1, counter);
1269
1270 toolkit.dragTo(50, 52, TransferMode.MOVE);
1271 assertEquals(2, counter);
1272 }
1273
1274 /************************************************************************/
1275 /* DRAGVIEW */
1276 /************************************************************************/
1277 @Test
1278 public void startDragShouldNotBeCalledIfNothingPutOnDragboardWithDragView() {
1279 final Node n = oneNode();
1280 final MouseEventGenerator gen = new MouseEventGenerator();
1281 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1282
1283 n.setOnMousePressed(doDetect);
1284 n.setOnDragDetected(event -> {
1285 Dragboard db = n.startDragAndDrop(TransferMode.COPY);
1286 db.setDragView(img);
1287 db.setDragViewOffsetX(20);
1288 db.setDragViewOffsetX(15);
1289 });
1290
1291 SceneHelper.processMouseEvent(n.getScene(),
1292 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1293 SceneHelper.processMouseEvent(n.getScene(),
1294 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 50, 50));
1295 SceneHelper.processMouseEvent(n.getScene(),
1296 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 50, 50));
1297
1298 assertFalse(toolkit.dragging);
1299 }
1300
1301 @Test
1302 public void startDragShouldBeCalledIfStringPutOnDragboardsWithDragView() {
1303 final Node n = oneNode();
1304 final MouseEventGenerator gen = new MouseEventGenerator();
1305 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1306
1307 dragSource = n;
1308 n.setOnMousePressed(doDetect);
1309 n.setOnDragDetected(event -> {
1310 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1311 ClipboardContent cc = new ClipboardContent();
1312 cc.putString("Hello");
1313 db.setContent(cc);
1314 db.setDragView(img);
1315 db.setDragViewOffsetX(20);
1316 db.setDragViewOffsetX(15);
1317 });
1318
1319 SceneHelper.processMouseEvent(n.getScene(),
1320 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1321
1322 assertTrue(toolkit.dragging);
1323 }
1324
1325 @Test
1326 public void changeDragViewInParentHandlerShouldBePossible() {
1327 final Node n = oneNode();
1328 final Node parent = n.getParent();
1329 final MouseEventGenerator gen = new MouseEventGenerator();
1330 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1331 final Image imgParent = new Image("file:testImg_" + 200 + "x" + 200 + ".png");
1332
1333 dragSource = n;
1334 n.setOnMousePressed(doDetect);
1335 n.setOnDragDetected(event -> {
1336 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1337 ClipboardContent cc = new ClipboardContent();
1338 cc.putString("Hello");
1339 db.setContent(cc);
1344
1345 parent.setOnDragDetected(event -> {
1346 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1347 ClipboardContent cc = new ClipboardContent();
1348 cc.putString("HelloParent");
1349 db.setContent(cc);
1350
1351 assertEquals(img, db.getDragView());
1352 assertEquals(20, db.getDragViewOffsetX(), 1e-10);
1353 assertEquals(15, db.getDragViewOffsetY(), 1e-10);
1354
1355 db.setDragView(imgParent);
1356 db.setDragViewOffsetX(40);
1357 db.setDragViewOffsetY(55);
1358
1359 assertEquals(imgParent, db.getDragView());
1360 assertEquals(40, db.getDragViewOffsetX(), 1e-10);
1361 assertEquals(55, db.getDragViewOffsetY(), 1e-10);
1362 });
1363
1364 SceneHelper.processMouseEvent(n.getScene(),
1365 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1366 }
1367
1368 @Test
1369 public void settingDragViewAndCursorPositionShouldReturnSameResults() {
1370 final Node n = oneNode();
1371 final Node parent = n.getParent();
1372 final MouseEventGenerator gen = new MouseEventGenerator();
1373 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1374 final Image imgParent = new Image("file:testImg_" + 200 + "x" + 200 + ".png");
1375
1376 dragSource = n;
1377 n.setOnMousePressed(doDetect);
1378 n.setOnDragDetected(event -> {
1379 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1380 ClipboardContent cc = new ClipboardContent();
1381 cc.putString("Hello");
1382 db.setContent(cc);
1383 db.setDragView(img, 20, 15);
1384 });
1385
1386 parent.setOnDragDetected(event -> {
1387 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1388 ClipboardContent cc = new ClipboardContent();
1389 cc.putString("HelloParent");
1390 db.setContent(cc);
1391
1392 assertEquals(img, db.getDragView());
1393 assertEquals(20, db.getDragViewOffsetX(), 1e-10);
1394 assertEquals(15, db.getDragViewOffsetY(), 1e-10);
1395
1396 db.setDragView(imgParent);
1397 db.setDragViewOffsetX(40);
1398 db.setDragViewOffsetY(55);
1399
1400 assertEquals(imgParent, db.getDragView());
1401 assertEquals(40, db.getDragViewOffsetX(), 1e-10);
1402 assertEquals(55, db.getDragViewOffsetY(), 1e-10);
1403 });
1404
1405 SceneHelper.processMouseEvent(n.getScene(),
1406 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1407 }
1408
1409 @Test
1410 public void dragViewShouldBeClearedInSubsequentDragDetectedCall() {
1411 final Node n = oneNode();
1412 final MouseEventGenerator gen = new MouseEventGenerator();
1413 final Image img = new Image("file:testImg_" + 100 + "x" + 100 + ".png");
1414
1415 dragSource = n;
1416 n.setOnMousePressed(doDetect);
1417 n.setOnDragDetected(event -> {
1418 Dragboard db = dragSource.startDragAndDrop(TransferMode.ANY);
1419
1420 assertNull(db.getDragView());
1421 assertEquals(0, db.getDragViewOffsetX(), 1e-10);
1422 assertEquals(0, db.getDragViewOffsetY(), 1e-10);
1423
1424 ClipboardContent cc = new ClipboardContent();
1425 cc.putString("Hello");
1426 db.setContent(cc);
1427 db.setDragView(img);
1428 db.setDragViewOffsetX(20);
1429 db.setDragViewOffsetX(15);
1430 });
1431
1432 SceneHelper.processMouseEvent(n.getScene(),
1433 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1434 SceneHelper.processMouseEvent(n.getScene(),
1435 gen.generateMouseEvent(MouseEvent.MOUSE_DRAGGED, 40, 40));
1436 SceneHelper.processMouseEvent(n.getScene(),
1437 gen.generateMouseEvent(MouseEvent.MOUSE_RELEASED, 55, 55));
1438 SceneHelper.processMouseEvent(n.getScene(),
1439 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 81, 81));
1440 }
1441
1442 /************************************************************************/
1443 /* PICK RESULT */
1444 /************************************************************************/
1445
1446 @Test
1447 public void shouldCompute3dCoordinates() {
1448 Node n = twoNodes()[0];
1449 n.setTranslateZ(50);
1450 dragSource = n;
1451
1452 MouseEventGenerator gen = new MouseEventGenerator();
1453
1454 counter = 0;
1455 n.setOnMousePressed(doDetect);
1456 n.setOnDragDetected(stringSource(TransferMode.ANY));
1457 n.setOnDragOver(event -> {
1458 counter++;
1459 Assert.assertEquals(52, event.getX(), 0.00001);
1460 Assert.assertEquals(52, event.getY(), 0.00001);
1461 Assert.assertEquals(0, event.getZ(), 0.00001);
1462 });
1463
1464 n.getScene().setOnDragOver(event -> {
1465 counter++;
1466 Assert.assertEquals(52, event.getX(), 0.00001);
1467 Assert.assertEquals(52, event.getY(), 0.00001);
1468 Assert.assertEquals(50, event.getZ(), 0.00001);
1469 });
1470
1471 SceneHelper.processMouseEvent(n.getScene(),
1472 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1473 toolkit.dragTo(52, 52, TransferMode.COPY);
1474 toolkit.drop(252, 52, TransferMode.COPY);
1475 toolkit.done(TransferMode.COPY);
1476
1477 assertEquals(2, counter);
1478 }
1479
1480 @Test
1481 public void dragEventsHavePickResult() {
1482 final Node[] nodes = twoNodes();
1483 final Node n1 = nodes[0];
1484 final Node n2 = nodes[1];
1485 final MouseEventGenerator gen = new MouseEventGenerator();
1486
1487 dragSource = n1;
1488 n1.setOnMousePressed(doDetect);
1489 n1.setOnDragDetected(stringSource(TransferMode.ANY));
1490 n1.setOnDragOver(event -> {
1491 PickResult pickRes = event.getPickResult();
1503 assertEquals(252, pickRes.getIntersectedPoint().getX(), 0.00001);
1504 assertEquals(52, pickRes.getIntersectedPoint().getY(), 0.00001);
1505 assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
1506 event.acceptTransferModes(TransferMode.COPY);
1507 counter++;
1508 };
1509 n1.setOnDragExited(switchNodeHandler);
1510 n2.setOnDragEntered(switchNodeHandler);
1511 n2.setOnDragOver(switchNodeHandler);
1512 n2.setOnDragDropped(switchNodeHandler);
1513 n1.setOnDragDone(event -> {
1514 PickResult pickRes = event.getPickResult();
1515 assertNotNull(pickRes);
1516 assertNull(pickRes.getIntersectedNode());
1517 assertEquals(0, pickRes.getIntersectedPoint().getX(), 0.00001);
1518 assertEquals(0, pickRes.getIntersectedPoint().getY(), 0.00001);
1519 assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
1520 counter++;
1521 });
1522
1523 SceneHelper.processMouseEvent(n1.getScene(),
1524 gen.generateMouseEvent(MouseEvent.MOUSE_PRESSED, 50, 50));
1525 toolkit.dragTo(52, 52, TransferMode.COPY);
1526 toolkit.dragTo(252, 52, TransferMode.COPY);
1527 toolkit.drop(252, 52, TransferMode.COPY);
1528 toolkit.done(TransferMode.COPY);
1529
1530 assertEquals(6, counter);
1531 }
1532
1533
1534 /************************************************************************/
1535 /* HELPER CODE */
1536 /************************************************************************/
1537
1538 // Event handlers
1539
1540 private final EventHandler<MouseEvent> dontDetect =
1541 event -> event.setDragDetect(false);
1542
1543 private final EventHandler<MouseEvent> doDetect =
|