modules/graphics/src/test/java/test/javafx/scene/input/ScrollEventTest.java

Print this page


   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 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.ScrollEvent;
  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 ScrollEventTest {
  46 
  47     private boolean scrolled;


 201         assertEquals(40, e.getScreenY(), 10e-20);
 202         assertNotNull(e.getPickResult());
 203         assertNotNull(e.getPickResult().getIntersectedPoint());
 204         assertEquals(10, e.getPickResult().getIntersectedPoint().getX(), 10e-20);
 205         assertEquals(20, e.getPickResult().getIntersectedPoint().getY(), 10e-20);
 206         assertEquals(0, e.getPickResult().getIntersectedPoint().getZ(), 10e-20);
 207     }
 208 
 209 
 210     @Test
 211     public void shouldDeliverScrollEventToPickedNode() {
 212         Scene scene = createScene();
 213         Rectangle rect =
 214                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 215 
 216         scrolled = false;
 217         rect.setOnScroll(event -> {
 218             scrolled = true;
 219         });
 220 
 221         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 222                 ScrollEvent.SCROLL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 223                 50, 50, 50, 50, false, false, false, false, false, false);
 224 
 225         assertFalse(scrolled);
 226 
 227         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 228                 ScrollEvent.SCROLL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 229                 150, 150, 150, 150, false, false, false, false, false, false);
 230 
 231         assertTrue(scrolled);
 232     }
 233 
 234     @Test
 235     public void shouldUseMultiplier() {
 236         Scene scene = createScene();
 237         Rectangle rect =
 238                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 239 
 240         scrolled = false;
 241         rect.setOnScroll(event -> {
 242             Assert.assertEquals(66.0, event.getDeltaX(), 0.0001);
 243             Assert.assertEquals(99.0, event.getDeltaY(), 0.0001);
 244             Assert.assertEquals(132.0, event.getTotalDeltaX(), 0.0001);
 245             Assert.assertEquals(198.0, event.getTotalDeltaY(), 0.0001);
 246             scrolled = true;
 247         });
 248 
 249         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 250                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 1, 1,
 251                 150, 150, 150, 150, false, false, false, false, false, false);
 252 
 253         assertTrue(scrolled);
 254     }
 255 
 256     @Test
 257     public void shouldUseTextDeltasForUnitsAndValues() {
 258         Scene scene = createScene();
 259         Rectangle rect =
 260                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 261 
 262         scrolled = false;
 263         rect.setOnScroll(event -> {
 264             Assert.assertEquals(0.0, event.getTextDeltaX(), 0.0001);
 265             Assert.assertEquals(0.0, event.getTextDeltaY(), 0.0001);
 266             assertSame(ScrollEvent.HorizontalTextScrollUnits.NONE, event.getTextDeltaXUnits());
 267             assertSame(ScrollEvent.VerticalTextScrollUnits.NONE, event.getTextDeltaYUnits());
 268             scrolled = true;
 269         });
 270         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 271                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 0, 0, 0, 0,
 272                 150, 150, 150, 150, false, false, false, false, false, false);
 273         assertTrue(scrolled);
 274 
 275         scrolled = false;
 276         rect.setOnScroll(event -> {
 277             Assert.assertEquals(8.0, event.getTextDeltaX(), 0.0001);
 278             Assert.assertEquals(15.0, event.getTextDeltaY(), 0.0001);
 279             assertSame(ScrollEvent.HorizontalTextScrollUnits.CHARACTERS, event.getTextDeltaXUnits());
 280             assertSame(ScrollEvent.VerticalTextScrollUnits.LINES, event.getTextDeltaYUnits());
 281             scrolled = true;
 282         });
 283         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 284                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 4, 5, 3, 3,
 285                 150, 150, 150, 150, false, false, false, false, false, false);
 286         assertTrue(scrolled);
 287 
 288         scrolled = false;
 289         rect.setOnScroll(event -> {
 290             Assert.assertEquals(0.0, event.getTextDeltaX(), 0.0001);
 291             Assert.assertEquals(3.0, event.getTextDeltaY(), 0.0001);
 292             assertSame(ScrollEvent.HorizontalTextScrollUnits.NONE, event.getTextDeltaXUnits());
 293             assertSame(ScrollEvent.VerticalTextScrollUnits.PAGES, event.getTextDeltaYUnits());
 294             scrolled = true;
 295         });
 296         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 297                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 5, -1, -1, 3, 3,
 298                 150, 150, 150, 150, false, false, false, false, false, false);
 299         assertTrue(scrolled);
 300 
 301     }
 302 
 303     @Test
 304     public void shouldPassModifiers() {
 305         Scene scene = createScene();
 306         Rectangle rect =
 307                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 308 
 309         scrolled = false;
 310         rect.setOnScroll(event -> {
 311             assertTrue(event.isShiftDown());
 312             assertFalse(event.isControlDown());
 313             assertTrue(event.isAltDown());
 314             assertFalse(event.isMetaDown());
 315             scrolled = true;
 316         });
 317         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 318                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 319                 150, 150, 150, 150, true, false, true, false, false, false);
 320         assertTrue(scrolled);
 321 
 322         scrolled = false;
 323         rect.setOnScroll(event -> {
 324             assertFalse(event.isShiftDown());
 325             assertTrue(event.isControlDown());
 326             assertFalse(event.isAltDown());
 327             assertTrue(event.isMetaDown());
 328             scrolled = true;
 329         });
 330         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 331                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 332                 150, 150, 150, 150, false, true, false, true, false, false);
 333         assertTrue(scrolled);
 334     }
 335 
 336     @Test
 337     public void shouldPassDirect() {
 338         Scene scene = createScene();
 339         Rectangle rect =
 340                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 341 
 342         scrolled = false;
 343         rect.setOnScroll(event -> {
 344             assertTrue(event.isDirect());
 345             scrolled = true;
 346         });
 347         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 348                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 349                 150, 150, 150, 150, true, false, true, false, true, false);
 350         assertTrue(scrolled);
 351 
 352         scrolled = false;
 353         rect.setOnScroll(event -> {
 354             assertFalse(event.isDirect());
 355             scrolled = true;
 356         });
 357         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 358                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 359                 150, 150, 150, 150, false, true, false, true, false, false);
 360         assertTrue(scrolled);
 361     }
 362 
 363     @Test
 364     public void shouldPassInertia() {
 365         Scene scene = createScene();
 366         Rectangle rect =
 367                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 368 
 369         scrolled = false;
 370         rect.setOnScroll(event -> {
 371             assertTrue(event.isInertia());
 372             scrolled = true;
 373         });
 374         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 375                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 376                 150, 150, 150, 150, true, false, true, false, false, true);
 377         assertTrue(scrolled);
 378 
 379         scrolled = false;
 380         rect.setOnScroll(event -> {
 381             assertFalse(event.isInertia());
 382             scrolled = true;
 383         });
 384         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 385                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 386                 150, 150, 150, 150, false, true, false, true, false, false);
 387         assertTrue(scrolled);
 388     }
 389 
 390     @Test
 391     public void shouldPassTouchCount() {
 392         Scene scene = createScene();
 393         Rectangle rect =
 394                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 395 
 396         scrolled = false;
 397         rect.setOnScroll(event -> {
 398             Assert.assertEquals(0, event.getTouchCount());
 399             scrolled = true;
 400         });
 401         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 402                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 403                 150, 150, 150, 150, true, false, true, false, true, false);
 404         assertTrue(scrolled);
 405 
 406         scrolled = false;
 407         rect.setOnScroll(event -> {
 408             Assert.assertEquals(5, event.getTouchCount());
 409             scrolled = true;
 410         });
 411         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 412                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 5, 1, 1, 3, 3,
 413                 150, 150, 150, 150, true, false, true, false, true, false);
 414         assertTrue(scrolled);
 415     }
 416 
 417     @Test
 418     public void shouldPassEventType() {
 419         Scene scene = createScene();
 420         Rectangle rect =
 421                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 422 
 423         scrolled = false;
 424         rect.setOnScrollStarted(event -> {
 425             scrolled = true;
 426         });
 427         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 428                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 429                 150, 150, 150, 150, true, false, true, false, true, false);
 430         assertTrue(scrolled);
 431 
 432         scrolled = false;
 433         rect.setOnScrollFinished(event -> {
 434             scrolled = true;
 435         });
 436         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 437                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 5, 1, 1, 3, 3,
 438                 150, 150, 150, 150, true, false, true, false, true, false);
 439         assertTrue(scrolled);
 440     }
 441 
 442     @Test
 443     public void handlingAnyShouldGetAllTypes() {
 444         Scene scene = createScene();
 445         Rectangle rect =
 446                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 447 
 448         rect.addEventHandler(ScrollEvent.ANY, event -> {
 449             scrolled = true;
 450         });
 451 
 452         scrolled = false;
 453         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 454                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 455                 150, 150, 150, 150, true, false, true, false, true, false);
 456         assertTrue(scrolled);
 457 
 458         scrolled = false;
 459         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 460                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 5, 1, 1, 3, 3,
 461                 150, 150, 150, 150, true, false, true, false, true, false);
 462         assertTrue(scrolled);
 463 
 464         scrolled = false;
 465         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 466                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 5, 1, 1, 3, 3,
 467                 150, 150, 150, 150, true, false, true, false, true, false);
 468         assertTrue(scrolled);
 469     }
 470 
 471     @Test
 472     public void shouldDeliverWholeGestureToOneNode() {
 473         Scene scene = createScene();
 474         Rectangle rect1 =
 475                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 476         Rectangle rect2 =
 477                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
 478 
 479         rect1.addEventHandler(ScrollEvent.ANY, event -> {
 480             scrolled = true;
 481         });
 482         rect2.addEventHandler(ScrollEvent.ANY, event -> {
 483             scrolled2 = true;
 484         });
 485 
 486         scrolled = false;
 487         scrolled2 = false;
 488         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 489                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 490                 150, 150, 150, 150, true, false, true, false, true, false);
 491         assertTrue(scrolled);
 492         assertFalse(scrolled2);
 493 
 494         scrolled = false;
 495         scrolled2 = false;
 496         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 497                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 498                 250, 250, 250, 250, true, false, true, false, true, false);
 499         assertTrue(scrolled);
 500         assertFalse(scrolled2);
 501 
 502         scrolled = false;
 503         scrolled2 = false;
 504         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 505                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 506                 250, 250, 250, 250, true, false, true, false, true, false);
 507         assertTrue(scrolled);
 508         assertFalse(scrolled2);
 509 
 510         // inertia
 511         scrolled = false;
 512         scrolled2 = false;
 513         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 514                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 515                 250, 250, 250, 250, true, false, true, false, true, true);
 516         assertTrue(scrolled);
 517         assertFalse(scrolled2);
 518     }
 519 
 520     @Test
 521     public void shouldCompute3dCoordinates() {
 522         Scene scene = createScene();
 523         Rectangle rect =
 524                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 525         rect.setTranslateZ(50);
 526 
 527         scrolled = false;
 528         scrolled2 = false;
 529         rect.setOnScroll(event -> {
 530             Assert.assertEquals(150, event.getX(), 0.00001);
 531             Assert.assertEquals(150, event.getY(), 0.00001);
 532             Assert.assertEquals(0, event.getZ(), 0.00001);
 533             scrolled = true;
 534         });
 535 
 536         scene.setOnScroll(event -> {
 537             Assert.assertEquals(150, event.getX(), 0.00001);
 538             Assert.assertEquals(150, event.getY(), 0.00001);
 539             Assert.assertEquals(50, event.getZ(), 0.00001);
 540             scrolled2 = true;
 541         });
 542 
 543         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 544                 ScrollEvent.SCROLL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 545                 150, 150, 150, 150, false, false, false, false, false, false);
 546 
 547         assertTrue(scrolled);
 548         assertTrue(scrolled2);
 549     }
 550 
 551     @Test
 552     public void shouldContainPickResult() {
 553         Scene scene = createScene();
 554         Rectangle rect1 =
 555                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 556         Rectangle rect2 =
 557                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
 558 
 559         rect1.addEventHandler(ScrollEvent.ANY, event -> {
 560             pickRes = event.getPickResult();
 561             scrolled = true;
 562         });
 563         rect2.addEventHandler(ScrollEvent.ANY, event -> {
 564             pickRes = event.getPickResult();
 565             scrolled2 = true;
 566         });
 567 
 568         scrolled = false;
 569         scrolled2 = false;
 570         pickRes = null;
 571         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 572                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 573                 150, 150, 150, 150, true, false, true, false, true, false);
 574         assertTrue(scrolled);
 575         assertFalse(scrolled2);
 576         assertNotNull(pickRes);
 577         assertSame(rect1, pickRes.getIntersectedNode());
 578         assertEquals(150, pickRes.getIntersectedPoint().getX(), 0.00001);
 579         assertEquals(150, pickRes.getIntersectedPoint().getY(), 0.00001);
 580         assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
 581 
 582         scrolled = false;
 583         scrolled2 = false;
 584         pickRes = null;
 585         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 586                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 587                 250, 250, 250, 250, true, false, true, false, true, false);
 588         assertTrue(scrolled);
 589         assertFalse(scrolled2);
 590         assertNotNull(pickRes);
 591         assertSame(rect2, pickRes.getIntersectedNode());
 592         assertEquals(250, pickRes.getIntersectedPoint().getX(), 0.00001);
 593         assertEquals(250, pickRes.getIntersectedPoint().getY(), 0.00001);
 594         assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
 595 
 596         scrolled = false;
 597         scrolled2 = false;
 598         pickRes = null;
 599         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 600                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 601                 250, 250, 250, 250, true, false, true, false, true, false);
 602         assertTrue(scrolled);
 603         assertFalse(scrolled2);
 604         assertNotNull(pickRes);
 605         assertSame(rect2, pickRes.getIntersectedNode());
 606         assertEquals(250, pickRes.getIntersectedPoint().getX(), 0.00001);
 607         assertEquals(250, pickRes.getIntersectedPoint().getY(), 0.00001);
 608         assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
 609 
 610         // inertia
 611         scrolled = false;
 612         scrolled2 = false;
 613         pickRes = null;
 614         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 615                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 616                 250, 250, 250, 250, true, false, true, false, true, true);
 617         assertTrue(scrolled);
 618         assertFalse(scrolled2);
 619         assertNotNull(pickRes);
 620         assertSame(rect2, pickRes.getIntersectedNode());
 621         assertEquals(250, pickRes.getIntersectedPoint().getX(), 0.00001);
 622         assertEquals(250, pickRes.getIntersectedPoint().getY(), 0.00001);
 623         assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
 624     }
 625 
 626     @Test
 627     public void shouldPickForMouseWheelDuringInertia() {
 628         Scene scene = createScene();
 629         Rectangle rect1 =
 630                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 631         Rectangle rect2 =
 632                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
 633 
 634         rect1.addEventHandler(ScrollEvent.ANY, event -> {
 635             scrolled = true;
 636         });
 637         rect2.addEventHandler(ScrollEvent.ANY, event -> {
 638             scrolled2 = true;
 639         });
 640 
 641         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 642                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 643                 150, 150, 150, 150, true, false, true, false, true, false);
 644         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 645                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 646                 250, 250, 250, 250, true, false, true, false, true, false);
 647         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 648                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 649                 250, 250, 250, 250, true, false, true, false, true, false);
 650 
 651         // inertia
 652         scrolled = false;
 653         scrolled2 = false;
 654         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 655                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 656                 250, 250, 250, 250, true, false, true, false, true, true);
 657         assertTrue(scrolled);
 658         assertFalse(scrolled2);
 659 
 660         // wheel
 661         scrolled = false;
 662         scrolled2 = false;
 663         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 664                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 665                 250, 250, 250, 250, true, false, true, false, true, false);
 666         assertFalse(scrolled);
 667         assertTrue(scrolled2);
 668 
 669         // inertia
 670         scrolled = false;
 671         scrolled2 = false;
 672         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 673                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 674                 250, 250, 250, 250, true, false, true, false, true, true);
 675         assertTrue(scrolled);
 676         assertFalse(scrolled2);
 677     }
 678 
 679     @Test
 680     public void unknownLocationShouldBeReplacedByMouseLocation() {
 681         Scene scene = createScene();
 682         Rectangle rect1 =
 683                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 684         Rectangle rect2 =
 685                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
 686         rect1.addEventHandler(ScrollEvent.ANY, event -> {
 687             scrolled = true;
 688         });
 689 
 690         MouseEventGenerator generator = new MouseEventGenerator();
 691 
 692         scrolled = false;
 693         scrolled2 = false;
 694         rect2.setOnScrollStarted(event -> {
 695             Assert.assertEquals(250.0, event.getSceneX(), 0.0001);
 696             Assert.assertEquals(250.0, event.getSceneY(), 0.0001);
 697             scrolled2 = true;
 698         });
 699         scene.impl_processMouseEvent(generator.generateMouseEvent(
 700                 MouseEvent.MOUSE_MOVED, 250, 250));
 701         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 702                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 703                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 704                 true, false, true, false, true, false);
 705         assertFalse(scrolled);
 706         assertTrue(scrolled2);
 707 
 708         scrolled = false;
 709         scrolled2 = false;
 710         rect2.setOnScroll(event -> {
 711             Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
 712             Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
 713             scrolled2 = true;
 714         });
 715         scene.impl_processMouseEvent(generator.generateMouseEvent(
 716                 MouseEvent.MOUSE_MOVED, 150, 150));
 717         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 718                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 719                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 720                 true, false, true, false, true, false);
 721         assertFalse(scrolled);
 722         assertTrue(scrolled2);
 723 
 724         scrolled = false;
 725         scrolled2 = false;
 726         rect2.setOnScrollFinished(event -> {
 727             Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
 728             Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
 729             scrolled2 = true;
 730         });
 731         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 732                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 733                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 734                 true, false, true, false, true, false);
 735         assertFalse(scrolled);
 736         assertTrue(scrolled2);
 737     }
 738 
 739     @Test
 740     public void finishedLocationShouldBeFixed() {
 741         Scene scene = createScene();
 742         Rectangle rect =
 743                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 744         rect.setOnScrollFinished(event -> {
 745             Assert.assertEquals(250.0, event.getSceneX(), 0.0001);
 746             Assert.assertEquals(250.0, event.getSceneY(), 0.0001);
 747             scrolled = true;
 748         });
 749 
 750         scrolled = false;
 751 
 752         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 753                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 754                 150, 150, 150, 150, true, false, true, false, true, false);
 755 
 756         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 757                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 758                 250, 250, 250, 250, true, false, true, false, true, false);
 759 
 760         assertFalse(scrolled);
 761 
 762         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 763                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 764                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 765                 true, false, true, false, true, false);
 766 
 767         assertTrue(scrolled);
 768     }
 769 
 770     @Test
 771     public void unknownLocalShouldBeFixedByMousePosition() {
 772         MouseEventGenerator gen = new MouseEventGenerator();
 773         Scene scene = createScene();
 774         Rectangle rect =
 775                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 776 
 777         rect.setOnScroll(event -> {
 778             Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
 779             Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
 780             scrolled = true;
 781         });
 782 
 783         scrolled = false;
 784 
 785         scene.impl_processMouseEvent(
 786                 gen.generateMouseEvent(MouseEvent.MOUSE_MOVED, 250, 250));
 787 
 788         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 789                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 790                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 791                 true, false, true, false, true, false);
 792 
 793         assertFalse(scrolled);
 794 
 795         scene.impl_processMouseEvent(
 796                 gen.generateMouseEvent(MouseEvent.MOUSE_MOVED, 150, 150));
 797 
 798         ((StubScene) scene.impl_getPeer()).getListener().scrollEvent(
 799                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 800                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 801                 true, false, true, false, true, false);
 802 
 803         assertTrue(scrolled);
 804     }
 805 
 806     @Test public void testToString() {
 807         ScrollEvent e = new ScrollEvent(ScrollEvent.SCROLL,
 808             100, 100, 200, 200,
 809             false, false, false, false,
 810             true, false, 10, 10, 20, 20,ScrollEvent.HorizontalTextScrollUnits.NONE, 0,
 811             ScrollEvent.VerticalTextScrollUnits.NONE, 0,
 812             3, null);
 813 
 814         String s = e.toString();
 815 
 816         assertNotNull(s);
 817         assertFalse(s.isEmpty());
 818     }
   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 test.com.sun.javafx.pgstub.StubScene;
  30 import test.com.sun.javafx.test.MouseEventGenerator;
  31 import javafx.event.Event;
  32 import javafx.event.EventHandler;
  33 import javafx.geometry.Point3D;
  34 import javafx.scene.Group;
  35 import javafx.scene.ParentShim;
  36 import javafx.scene.Scene;
  37 import javafx.scene.input.MouseEvent;
  38 import javafx.scene.input.PickResult;
  39 import javafx.scene.input.ScrollEvent;
  40 import javafx.scene.shape.Rectangle;
  41 import javafx.stage.Stage;
  42 import org.junit.Assert;
  43 import org.junit.Test;
  44 import static org.junit.Assert.*;
  45 
  46 public class ScrollEventTest {
  47 
  48     private boolean scrolled;


 202         assertEquals(40, e.getScreenY(), 10e-20);
 203         assertNotNull(e.getPickResult());
 204         assertNotNull(e.getPickResult().getIntersectedPoint());
 205         assertEquals(10, e.getPickResult().getIntersectedPoint().getX(), 10e-20);
 206         assertEquals(20, e.getPickResult().getIntersectedPoint().getY(), 10e-20);
 207         assertEquals(0, e.getPickResult().getIntersectedPoint().getZ(), 10e-20);
 208     }
 209 
 210 
 211     @Test
 212     public void shouldDeliverScrollEventToPickedNode() {
 213         Scene scene = createScene();
 214         Rectangle rect =
 215                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 216 
 217         scrolled = false;
 218         rect.setOnScroll(event -> {
 219             scrolled = true;
 220         });
 221 
 222         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 223                 ScrollEvent.SCROLL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 224                 50, 50, 50, 50, false, false, false, false, false, false);
 225 
 226         assertFalse(scrolled);
 227 
 228         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 229                 ScrollEvent.SCROLL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 230                 150, 150, 150, 150, false, false, false, false, false, false);
 231 
 232         assertTrue(scrolled);
 233     }
 234 
 235     @Test
 236     public void shouldUseMultiplier() {
 237         Scene scene = createScene();
 238         Rectangle rect =
 239                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 240 
 241         scrolled = false;
 242         rect.setOnScroll(event -> {
 243             Assert.assertEquals(66.0, event.getDeltaX(), 0.0001);
 244             Assert.assertEquals(99.0, event.getDeltaY(), 0.0001);
 245             Assert.assertEquals(132.0, event.getTotalDeltaX(), 0.0001);
 246             Assert.assertEquals(198.0, event.getTotalDeltaY(), 0.0001);
 247             scrolled = true;
 248         });
 249 
 250         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 251                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 1, 1,
 252                 150, 150, 150, 150, false, false, false, false, false, false);
 253 
 254         assertTrue(scrolled);
 255     }
 256 
 257     @Test
 258     public void shouldUseTextDeltasForUnitsAndValues() {
 259         Scene scene = createScene();
 260         Rectangle rect =
 261                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 262 
 263         scrolled = false;
 264         rect.setOnScroll(event -> {
 265             Assert.assertEquals(0.0, event.getTextDeltaX(), 0.0001);
 266             Assert.assertEquals(0.0, event.getTextDeltaY(), 0.0001);
 267             assertSame(ScrollEvent.HorizontalTextScrollUnits.NONE, event.getTextDeltaXUnits());
 268             assertSame(ScrollEvent.VerticalTextScrollUnits.NONE, event.getTextDeltaYUnits());
 269             scrolled = true;
 270         });
 271         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 272                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 0, 0, 0, 0,
 273                 150, 150, 150, 150, false, false, false, false, false, false);
 274         assertTrue(scrolled);
 275 
 276         scrolled = false;
 277         rect.setOnScroll(event -> {
 278             Assert.assertEquals(8.0, event.getTextDeltaX(), 0.0001);
 279             Assert.assertEquals(15.0, event.getTextDeltaY(), 0.0001);
 280             assertSame(ScrollEvent.HorizontalTextScrollUnits.CHARACTERS, event.getTextDeltaXUnits());
 281             assertSame(ScrollEvent.VerticalTextScrollUnits.LINES, event.getTextDeltaYUnits());
 282             scrolled = true;
 283         });
 284         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 285                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 4, 5, 3, 3,
 286                 150, 150, 150, 150, false, false, false, false, false, false);
 287         assertTrue(scrolled);
 288 
 289         scrolled = false;
 290         rect.setOnScroll(event -> {
 291             Assert.assertEquals(0.0, event.getTextDeltaX(), 0.0001);
 292             Assert.assertEquals(3.0, event.getTextDeltaY(), 0.0001);
 293             assertSame(ScrollEvent.HorizontalTextScrollUnits.NONE, event.getTextDeltaXUnits());
 294             assertSame(ScrollEvent.VerticalTextScrollUnits.PAGES, event.getTextDeltaYUnits());
 295             scrolled = true;
 296         });
 297         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 298                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 5, -1, -1, 3, 3,
 299                 150, 150, 150, 150, false, false, false, false, false, false);
 300         assertTrue(scrolled);
 301 
 302     }
 303 
 304     @Test
 305     public void shouldPassModifiers() {
 306         Scene scene = createScene();
 307         Rectangle rect =
 308                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 309 
 310         scrolled = false;
 311         rect.setOnScroll(event -> {
 312             assertTrue(event.isShiftDown());
 313             assertFalse(event.isControlDown());
 314             assertTrue(event.isAltDown());
 315             assertFalse(event.isMetaDown());
 316             scrolled = true;
 317         });
 318         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 319                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 320                 150, 150, 150, 150, true, false, true, false, false, false);
 321         assertTrue(scrolled);
 322 
 323         scrolled = false;
 324         rect.setOnScroll(event -> {
 325             assertFalse(event.isShiftDown());
 326             assertTrue(event.isControlDown());
 327             assertFalse(event.isAltDown());
 328             assertTrue(event.isMetaDown());
 329             scrolled = true;
 330         });
 331         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 332                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 333                 150, 150, 150, 150, false, true, false, true, false, false);
 334         assertTrue(scrolled);
 335     }
 336 
 337     @Test
 338     public void shouldPassDirect() {
 339         Scene scene = createScene();
 340         Rectangle rect =
 341                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 342 
 343         scrolled = false;
 344         rect.setOnScroll(event -> {
 345             assertTrue(event.isDirect());
 346             scrolled = true;
 347         });
 348         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 349                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 350                 150, 150, 150, 150, true, false, true, false, true, false);
 351         assertTrue(scrolled);
 352 
 353         scrolled = false;
 354         rect.setOnScroll(event -> {
 355             assertFalse(event.isDirect());
 356             scrolled = true;
 357         });
 358         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 359                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 360                 150, 150, 150, 150, false, true, false, true, false, false);
 361         assertTrue(scrolled);
 362     }
 363 
 364     @Test
 365     public void shouldPassInertia() {
 366         Scene scene = createScene();
 367         Rectangle rect =
 368                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 369 
 370         scrolled = false;
 371         rect.setOnScroll(event -> {
 372             assertTrue(event.isInertia());
 373             scrolled = true;
 374         });
 375         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 376                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 377                 150, 150, 150, 150, true, false, true, false, false, true);
 378         assertTrue(scrolled);
 379 
 380         scrolled = false;
 381         rect.setOnScroll(event -> {
 382             assertFalse(event.isInertia());
 383             scrolled = true;
 384         });
 385         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 386                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 1, 1, 1, 3, 3,
 387                 150, 150, 150, 150, false, true, false, true, false, false);
 388         assertTrue(scrolled);
 389     }
 390 
 391     @Test
 392     public void shouldPassTouchCount() {
 393         Scene scene = createScene();
 394         Rectangle rect =
 395                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 396 
 397         scrolled = false;
 398         rect.setOnScroll(event -> {
 399             Assert.assertEquals(0, event.getTouchCount());
 400             scrolled = true;
 401         });
 402         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 403                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 404                 150, 150, 150, 150, true, false, true, false, true, false);
 405         assertTrue(scrolled);
 406 
 407         scrolled = false;
 408         rect.setOnScroll(event -> {
 409             Assert.assertEquals(5, event.getTouchCount());
 410             scrolled = true;
 411         });
 412         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 413                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 5, 1, 1, 3, 3,
 414                 150, 150, 150, 150, true, false, true, false, true, false);
 415         assertTrue(scrolled);
 416     }
 417 
 418     @Test
 419     public void shouldPassEventType() {
 420         Scene scene = createScene();
 421         Rectangle rect =
 422                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 423 
 424         scrolled = false;
 425         rect.setOnScrollStarted(event -> {
 426             scrolled = true;
 427         });
 428         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 429                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 430                 150, 150, 150, 150, true, false, true, false, true, false);
 431         assertTrue(scrolled);
 432 
 433         scrolled = false;
 434         rect.setOnScrollFinished(event -> {
 435             scrolled = true;
 436         });
 437         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 438                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 5, 1, 1, 3, 3,
 439                 150, 150, 150, 150, true, false, true, false, true, false);
 440         assertTrue(scrolled);
 441     }
 442 
 443     @Test
 444     public void handlingAnyShouldGetAllTypes() {
 445         Scene scene = createScene();
 446         Rectangle rect =
 447                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 448 
 449         rect.addEventHandler(ScrollEvent.ANY, event -> {
 450             scrolled = true;
 451         });
 452 
 453         scrolled = false;
 454         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 455                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 456                 150, 150, 150, 150, true, false, true, false, true, false);
 457         assertTrue(scrolled);
 458 
 459         scrolled = false;
 460         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 461                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 5, 1, 1, 3, 3,
 462                 150, 150, 150, 150, true, false, true, false, true, false);
 463         assertTrue(scrolled);
 464 
 465         scrolled = false;
 466         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 467                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 5, 1, 1, 3, 3,
 468                 150, 150, 150, 150, true, false, true, false, true, false);
 469         assertTrue(scrolled);
 470     }
 471 
 472     @Test
 473     public void shouldDeliverWholeGestureToOneNode() {
 474         Scene scene = createScene();
 475         Rectangle rect1 =
 476                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 477         Rectangle rect2 =
 478                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
 479 
 480         rect1.addEventHandler(ScrollEvent.ANY, event -> {
 481             scrolled = true;
 482         });
 483         rect2.addEventHandler(ScrollEvent.ANY, event -> {
 484             scrolled2 = true;
 485         });
 486 
 487         scrolled = false;
 488         scrolled2 = false;
 489         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 490                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 491                 150, 150, 150, 150, true, false, true, false, true, false);
 492         assertTrue(scrolled);
 493         assertFalse(scrolled2);
 494 
 495         scrolled = false;
 496         scrolled2 = false;
 497         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 498                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 499                 250, 250, 250, 250, true, false, true, false, true, false);
 500         assertTrue(scrolled);
 501         assertFalse(scrolled2);
 502 
 503         scrolled = false;
 504         scrolled2 = false;
 505         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 506                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 507                 250, 250, 250, 250, true, false, true, false, true, false);
 508         assertTrue(scrolled);
 509         assertFalse(scrolled2);
 510 
 511         // inertia
 512         scrolled = false;
 513         scrolled2 = false;
 514         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 515                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 516                 250, 250, 250, 250, true, false, true, false, true, true);
 517         assertTrue(scrolled);
 518         assertFalse(scrolled2);
 519     }
 520 
 521     @Test
 522     public void shouldCompute3dCoordinates() {
 523         Scene scene = createScene();
 524         Rectangle rect =
 525                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 526         rect.setTranslateZ(50);
 527 
 528         scrolled = false;
 529         scrolled2 = false;
 530         rect.setOnScroll(event -> {
 531             Assert.assertEquals(150, event.getX(), 0.00001);
 532             Assert.assertEquals(150, event.getY(), 0.00001);
 533             Assert.assertEquals(0, event.getZ(), 0.00001);
 534             scrolled = true;
 535         });
 536 
 537         scene.setOnScroll(event -> {
 538             Assert.assertEquals(150, event.getX(), 0.00001);
 539             Assert.assertEquals(150, event.getY(), 0.00001);
 540             Assert.assertEquals(50, event.getZ(), 0.00001);
 541             scrolled2 = true;
 542         });
 543 
 544         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 545                 ScrollEvent.SCROLL, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 546                 150, 150, 150, 150, false, false, false, false, false, false);
 547 
 548         assertTrue(scrolled);
 549         assertTrue(scrolled2);
 550     }
 551 
 552     @Test
 553     public void shouldContainPickResult() {
 554         Scene scene = createScene();
 555         Rectangle rect1 =
 556                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 557         Rectangle rect2 =
 558                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
 559 
 560         rect1.addEventHandler(ScrollEvent.ANY, event -> {
 561             pickRes = event.getPickResult();
 562             scrolled = true;
 563         });
 564         rect2.addEventHandler(ScrollEvent.ANY, event -> {
 565             pickRes = event.getPickResult();
 566             scrolled2 = true;
 567         });
 568 
 569         scrolled = false;
 570         scrolled2 = false;
 571         pickRes = null;
 572         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 573                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 574                 150, 150, 150, 150, true, false, true, false, true, false);
 575         assertTrue(scrolled);
 576         assertFalse(scrolled2);
 577         assertNotNull(pickRes);
 578         assertSame(rect1, pickRes.getIntersectedNode());
 579         assertEquals(150, pickRes.getIntersectedPoint().getX(), 0.00001);
 580         assertEquals(150, pickRes.getIntersectedPoint().getY(), 0.00001);
 581         assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
 582 
 583         scrolled = false;
 584         scrolled2 = false;
 585         pickRes = null;
 586         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 587                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 588                 250, 250, 250, 250, true, false, true, false, true, false);
 589         assertTrue(scrolled);
 590         assertFalse(scrolled2);
 591         assertNotNull(pickRes);
 592         assertSame(rect2, pickRes.getIntersectedNode());
 593         assertEquals(250, pickRes.getIntersectedPoint().getX(), 0.00001);
 594         assertEquals(250, pickRes.getIntersectedPoint().getY(), 0.00001);
 595         assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
 596 
 597         scrolled = false;
 598         scrolled2 = false;
 599         pickRes = null;
 600         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 601                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 602                 250, 250, 250, 250, true, false, true, false, true, false);
 603         assertTrue(scrolled);
 604         assertFalse(scrolled2);
 605         assertNotNull(pickRes);
 606         assertSame(rect2, pickRes.getIntersectedNode());
 607         assertEquals(250, pickRes.getIntersectedPoint().getX(), 0.00001);
 608         assertEquals(250, pickRes.getIntersectedPoint().getY(), 0.00001);
 609         assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
 610 
 611         // inertia
 612         scrolled = false;
 613         scrolled2 = false;
 614         pickRes = null;
 615         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 616                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 617                 250, 250, 250, 250, true, false, true, false, true, true);
 618         assertTrue(scrolled);
 619         assertFalse(scrolled2);
 620         assertNotNull(pickRes);
 621         assertSame(rect2, pickRes.getIntersectedNode());
 622         assertEquals(250, pickRes.getIntersectedPoint().getX(), 0.00001);
 623         assertEquals(250, pickRes.getIntersectedPoint().getY(), 0.00001);
 624         assertEquals(0, pickRes.getIntersectedPoint().getZ(), 0.00001);
 625     }
 626 
 627     @Test
 628     public void shouldPickForMouseWheelDuringInertia() {
 629         Scene scene = createScene();
 630         Rectangle rect1 =
 631                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 632         Rectangle rect2 =
 633                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
 634 
 635         rect1.addEventHandler(ScrollEvent.ANY, event -> {
 636             scrolled = true;
 637         });
 638         rect2.addEventHandler(ScrollEvent.ANY, event -> {
 639             scrolled2 = true;
 640         });
 641 
 642         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 643                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 644                 150, 150, 150, 150, true, false, true, false, true, false);
 645         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 646                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 647                 250, 250, 250, 250, true, false, true, false, true, false);
 648         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 649                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 650                 250, 250, 250, 250, true, false, true, false, true, false);
 651 
 652         // inertia
 653         scrolled = false;
 654         scrolled2 = false;
 655         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 656                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 657                 250, 250, 250, 250, true, false, true, false, true, true);
 658         assertTrue(scrolled);
 659         assertFalse(scrolled2);
 660 
 661         // wheel
 662         scrolled = false;
 663         scrolled2 = false;
 664         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 665                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 666                 250, 250, 250, 250, true, false, true, false, true, false);
 667         assertFalse(scrolled);
 668         assertTrue(scrolled2);
 669 
 670         // inertia
 671         scrolled = false;
 672         scrolled2 = false;
 673         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 674                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 675                 250, 250, 250, 250, true, false, true, false, true, true);
 676         assertTrue(scrolled);
 677         assertFalse(scrolled2);
 678     }
 679 
 680     @Test
 681     public void unknownLocationShouldBeReplacedByMouseLocation() {
 682         Scene scene = createScene();
 683         Rectangle rect1 =
 684                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 685         Rectangle rect2 =
 686                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(1);
 687         rect1.addEventHandler(ScrollEvent.ANY, event -> {
 688             scrolled = true;
 689         });
 690 
 691         MouseEventGenerator generator = new MouseEventGenerator();
 692 
 693         scrolled = false;
 694         scrolled2 = false;
 695         rect2.setOnScrollStarted(event -> {
 696             Assert.assertEquals(250.0, event.getSceneX(), 0.0001);
 697             Assert.assertEquals(250.0, event.getSceneY(), 0.0001);
 698             scrolled2 = true;
 699         });
 700         SceneHelper.processMouseEvent(scene, generator.generateMouseEvent(
 701                 MouseEvent.MOUSE_MOVED, 250, 250));
 702         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 703                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 704                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 705                 true, false, true, false, true, false);
 706         assertFalse(scrolled);
 707         assertTrue(scrolled2);
 708 
 709         scrolled = false;
 710         scrolled2 = false;
 711         rect2.setOnScroll(event -> {
 712             Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
 713             Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
 714             scrolled2 = true;
 715         });
 716         SceneHelper.processMouseEvent(scene, generator.generateMouseEvent(
 717                 MouseEvent.MOUSE_MOVED, 150, 150));
 718         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 719                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 720                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 721                 true, false, true, false, true, false);
 722         assertFalse(scrolled);
 723         assertTrue(scrolled2);
 724 
 725         scrolled = false;
 726         scrolled2 = false;
 727         rect2.setOnScrollFinished(event -> {
 728             Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
 729             Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
 730             scrolled2 = true;
 731         });
 732         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 733                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 734                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 735                 true, false, true, false, true, false);
 736         assertFalse(scrolled);
 737         assertTrue(scrolled2);
 738     }
 739 
 740     @Test
 741     public void finishedLocationShouldBeFixed() {
 742         Scene scene = createScene();
 743         Rectangle rect =
 744                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 745         rect.setOnScrollFinished(event -> {
 746             Assert.assertEquals(250.0, event.getSceneX(), 0.0001);
 747             Assert.assertEquals(250.0, event.getSceneY(), 0.0001);
 748             scrolled = true;
 749         });
 750 
 751         scrolled = false;
 752 
 753         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 754                 ScrollEvent.SCROLL_STARTED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 755                 150, 150, 150, 150, true, false, true, false, true, false);
 756 
 757         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 758                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 759                 250, 250, 250, 250, true, false, true, false, true, false);
 760 
 761         assertFalse(scrolled);
 762 
 763         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 764                 ScrollEvent.SCROLL_FINISHED, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 765                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 766                 true, false, true, false, true, false);
 767 
 768         assertTrue(scrolled);
 769     }
 770 
 771     @Test
 772     public void unknownLocalShouldBeFixedByMousePosition() {
 773         MouseEventGenerator gen = new MouseEventGenerator();
 774         Scene scene = createScene();
 775         Rectangle rect =
 776                 (Rectangle) scene.getRoot().getChildrenUnmodifiable().get(0);
 777 
 778         rect.setOnScroll(event -> {
 779             Assert.assertEquals(150.0, event.getSceneX(), 0.0001);
 780             Assert.assertEquals(150.0, event.getSceneY(), 0.0001);
 781             scrolled = true;
 782         });
 783 
 784         scrolled = false;
 785 
 786         SceneHelper.processMouseEvent(scene,
 787                 gen.generateMouseEvent(MouseEvent.MOUSE_MOVED, 250, 250));
 788 
 789         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 790                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 791                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 792                 true, false, true, false, true, false);
 793 
 794         assertFalse(scrolled);
 795 
 796         SceneHelper.processMouseEvent(scene,
 797                 gen.generateMouseEvent(MouseEvent.MOUSE_MOVED, 150, 150));
 798 
 799         ((StubScene) SceneHelper.getPeer(scene)).getListener().scrollEvent(
 800                 ScrollEvent.SCROLL, 2, 3, 4, 6, 33, 33, 0, 1, 1, 3, 3,
 801                 Double.NaN, Double.NaN, Double.NaN, Double.NaN,
 802                 true, false, true, false, true, false);
 803 
 804         assertTrue(scrolled);
 805     }
 806 
 807     @Test public void testToString() {
 808         ScrollEvent e = new ScrollEvent(ScrollEvent.SCROLL,
 809             100, 100, 200, 200,
 810             false, false, false, false,
 811             true, false, 10, 10, 20, 20,ScrollEvent.HorizontalTextScrollUnits.NONE, 0,
 812             ScrollEvent.VerticalTextScrollUnits.NONE, 0,
 813             3, null);
 814 
 815         String s = e.toString();
 816 
 817         assertNotNull(s);
 818         assertFalse(s.isEmpty());
 819     }