modules/graphics/src/main/java/com/sun/javafx/tk/quantum/GlassViewEventHandler.java

Print this page




 329                     return null;
 330                 default:
 331                     if (QuantumToolkit.verbose) {
 332                         System.out.println("handleMouseEvent: unhandled type: " + type);
 333                     }
 334             }
 335 
 336             WindowStage stage = scene.getWindowStage();
 337             try {
 338                 if (stage != null) {
 339                     stage.setInEventHandler(true);
 340                 }
 341                 if (scene.sceneListener != null) {
 342                     boolean shiftDown = (modifiers & KeyEvent.MODIFIER_SHIFT) != 0;
 343                     boolean controlDown = (modifiers & KeyEvent.MODIFIER_CONTROL) != 0;
 344                     boolean altDown = (modifiers & KeyEvent.MODIFIER_ALT) != 0;
 345                     boolean metaDown = (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0;
 346                     boolean primaryButtonDown = (modifiers & KeyEvent.MODIFIER_BUTTON_PRIMARY) != 0;
 347                     boolean middleButtonDown = (modifiers & KeyEvent.MODIFIER_BUTTON_MIDDLE) != 0;
 348                     boolean secondaryButtonDown = (modifiers & KeyEvent.MODIFIER_BUTTON_SECONDARY) != 0;
 349                     Window w = view.getWindow();
 350                     double pScale = (w == null) ? 1.0 : w.getPlatformScale();

 351 
 352                     scene.sceneListener.mouseEvent(mouseEventType(type),
 353                             x / pScale, y / pScale, xAbs / pScale, yAbs / pScale,
 354                             mouseEventButton(button), isPopupTrigger, isSynthesized,
 355                             shiftDown, controlDown, altDown, metaDown,
 356                             primaryButtonDown, middleButtonDown, secondaryButtonDown);
 357                 }
 358             } finally {
 359                 if (stage != null) {
 360                     stage.setInEventHandler(false);
 361                 }
 362                 if (PULSE_LOGGING_ENABLED) {
 363                     PulseLogger.newInput(null);
 364                 }
 365             }
 366             return null;
 367         }
 368     }
 369 
 370     @Override
 371     public void handleMouseEvent(View view, long time, int type, int button,
 372                                  int x, int y, int xAbs, int yAbs,
 373                                  int modifiers, boolean isPopupTrigger, boolean isSynthesized)


 387         QuantumToolkit.runWithoutRenderLock(() -> {
 388             return AccessController.doPrivileged(mouseNotification, scene.getAccessControlContext());
 389         });
 390     }
 391 
 392     @Override public void handleMenuEvent(final View view,
 393                                           final int x, final int y, final int xAbs, final int yAbs,
 394                                           final boolean isKeyboardTrigger)
 395     {
 396         if (PULSE_LOGGING_ENABLED) {
 397             PulseLogger.newInput("MENU_EVENT");
 398         }
 399         WindowStage stage = scene.getWindowStage();
 400         try {
 401             if (stage != null) {
 402                 stage.setInEventHandler(true);
 403             }
 404             QuantumToolkit.runWithoutRenderLock(() -> {
 405                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 406                     if (scene.sceneListener != null) {
 407                         Window w = view.getWindow();
 408                         double pScale = (w == null) ? 1.0 : w.getPlatformScale();
 409                         scene.sceneListener.menuEvent(x / pScale, y / pScale,
 410                                                       xAbs / pScale, yAbs / pScale,

 411                                                       isKeyboardTrigger);
 412                     }
 413                     return null;
 414                 }, scene.getAccessControlContext());
 415             });
 416         } finally {
 417             if (stage != null) {
 418                 stage.setInEventHandler(false);
 419             }
 420             if (PULSE_LOGGING_ENABLED) {
 421                 PulseLogger.newInput(null);
 422             }
 423         }
 424     }
 425 
 426     @Override public void handleScrollEvent(final View view, final long time,
 427                                             final int x, final int y, final int xAbs, final int yAbs,
 428                                             final double deltaX, final double deltaY, final int modifiers,
 429                                             final int lines, final int chars,
 430                                             final int defaultLines, final int defaultChars,
 431                                             final double xMultiplier, final double yMultiplier)
 432     {
 433         if (PULSE_LOGGING_ENABLED) {
 434             PulseLogger.newInput("SCROLL_EVENT");
 435         }
 436         WindowStage stage = scene.getWindowStage();
 437         try {
 438             if (stage != null) {
 439                 stage.setInEventHandler(true);
 440             }
 441             QuantumToolkit.runWithoutRenderLock(() -> {
 442                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 443                     if (scene.sceneListener != null) {
 444                         Window w = view.getWindow();
 445                         double pScale = (w == null) ? 1.0 : w.getPlatformScale();

 446                         scene.sceneListener.scrollEvent(ScrollEvent.SCROLL,
 447                             deltaX / pScale, deltaY / pScale, 0, 0,
 448                             xMultiplier, yMultiplier,
 449                             0, // touchCount
 450                             chars, lines, defaultChars, defaultLines,
 451                             x / pScale, y / pScale, xAbs / pScale, yAbs / pScale,
 452                             (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
 453                             (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
 454                             (modifiers & KeyEvent.MODIFIER_ALT) != 0,
 455                             (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
 456                             false, // this is always indirect
 457                             false); // this has no inertia
 458                     }
 459                     return null;
 460                 }, scene.getAccessControlContext());
 461             });
 462         } finally {
 463             if (stage != null) {
 464                 stage.setInEventHandler(false);
 465             }
 466             if (PULSE_LOGGING_ENABLED) {
 467                 PulseLogger.newInput(null);
 468             }
 469         }
 470     }
 471 


 756             if (scene.sceneListener == null) {
 757                 return null;
 758             }
 759             switch (type) {
 760                 case ViewEvent.REPAINT: {
 761                     Window w = view.getWindow();
 762                     if (w != null && w.getMinimumWidth() == view.getWidth() && !w.isVisible()) {
 763                         // RT-21057 - ignore initial minimum size setting if not visible
 764                         break;
 765                     }
 766                     if (QuantumToolkit.drawInPaint && w != null && w.isVisible()) {
 767                         WindowStage stage = scene.getWindowStage();
 768                         if (stage != null && !stage.isApplet()) {
 769                             collector.liveRepaintRenderJob(scene);
 770                         }
 771                     }
 772                     scene.entireSceneNeedsRepaint();
 773                     break;
 774                 }
 775                 case ViewEvent.RESIZE: {
 776                     Window w = view.getWindow();
 777                     float pScale = (w == null) ? 1.0f : w.getPlatformScale();
 778                     scene.sceneListener.changedSize(view.getWidth()  / pScale,
 779                                                     view.getHeight() / pScale);

 780                     scene.entireSceneNeedsRepaint();
 781                     QuantumToolkit.runWithRenderLock(() -> {
 782                         scene.updateSceneState();
 783                         return null;
 784                     });
 785                     if (QuantumToolkit.liveResize && w != null && w.isVisible()) {
 786                         WindowStage stage = scene.getWindowStage();
 787                         if (stage != null && !stage.isApplet()) {
 788                             collector.liveRepaintRenderJob(scene);
 789                         }
 790                     }
 791                     break;
 792                 }
 793                 case ViewEvent.MOVE: {
 794                     // MOVE events can be "synthesized" and the window will
 795                     // be null if this is synthesized during a "REMOVE" event
 796                     Window w = view.getWindow();
 797                     float pScale = (w == null) ? 1.0f : w.getPlatformScale();
 798                     scene.sceneListener.changedLocation(view.getX() / pScale,
 799                                                         view.getY() / pScale);

 800                     break;
 801                 }
 802                 case ViewEvent.FULLSCREEN_ENTER:
 803                 case ViewEvent.FULLSCREEN_EXIT:
 804                     if (scene.getWindowStage() != null) {
 805                         scene.getWindowStage().fullscreenChanged(type == ViewEvent.FULLSCREEN_ENTER);
 806                     }
 807                     break;
 808                 case ViewEvent.ADD:
 809                 case ViewEvent.REMOVE:
 810                     // unhandled
 811                     break;
 812                 default:
 813                     throw new RuntimeException("handleViewEvent: unhandled type: " + type);
 814             }
 815             return null;
 816         }
 817     }
 818 
 819     @Override public void handleViewEvent(View view, long time, final int type) {


 849             if (stage != null) {
 850                 stage.setInEventHandler(true);
 851             }
 852             QuantumToolkit.runWithoutRenderLock(() -> {
 853                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 854                     if (scene.sceneListener != null) {
 855                         EventType<ScrollEvent> eventType;
 856                         switch(type) {
 857                             case GestureEvent.GESTURE_STARTED:
 858                                 eventType = ScrollEvent.SCROLL_STARTED;
 859                                 break;
 860                             case GestureEvent.GESTURE_PERFORMED:
 861                                 eventType = ScrollEvent.SCROLL;
 862                                 break;
 863                             case GestureEvent.GESTURE_FINISHED:
 864                                 eventType = ScrollEvent.SCROLL_FINISHED;
 865                                 break;
 866                             default:
 867                                 throw new RuntimeException("Unknown scroll event type: " + type);
 868                         }
 869                         Window w = view.getWindow();
 870                         double pScale = (w == null) ? 1.0 : w.getPlatformScale();

 871                         scene.sceneListener.scrollEvent(eventType,
 872                                 dx / pScale, dy / pScale, totaldx / pScale, totaldy / pScale,
 873                                 multiplierX, multiplierY,
 874                                 touchCount,
 875                                 0, 0, 0, 0,
 876                                 x == View.GESTURE_NO_VALUE ? Double.NaN : x / pScale,
 877                                 y == View.GESTURE_NO_VALUE ? Double.NaN : y / pScale,
 878                                 xAbs == View.GESTURE_NO_VALUE ? Double.NaN : xAbs / pScale,
 879                                 yAbs == View.GESTURE_NO_VALUE ? Double.NaN : yAbs / pScale,
 880                                 (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
 881                                 (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
 882                                 (modifiers & KeyEvent.MODIFIER_ALT) != 0,
 883                                 (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
 884                                 isDirect, isInertia);
 885                     }
 886                     return null;
 887                 }, scene.getAccessControlContext());
 888             });
 889         } finally {
 890             if (stage != null) {
 891                 stage.setInEventHandler(false);
 892             }
 893             if (PULSE_LOGGING_ENABLED) {
 894                 PulseLogger.newInput(null);
 895             }
 896         }
 897     }
 898 
 899     @Override public void handleZoomGestureEvent(


 912             if (stage != null) {
 913                 stage.setInEventHandler(true);
 914             }
 915             QuantumToolkit.runWithoutRenderLock(() -> {
 916                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 917                     if (scene.sceneListener != null) {
 918                         EventType<ZoomEvent> eventType;
 919                         switch (type) {
 920                             case GestureEvent.GESTURE_STARTED:
 921                                 eventType = ZoomEvent.ZOOM_STARTED;
 922                                 break;
 923                             case GestureEvent.GESTURE_PERFORMED:
 924                                 eventType = ZoomEvent.ZOOM;
 925                                 break;
 926                             case GestureEvent.GESTURE_FINISHED:
 927                                 eventType = ZoomEvent.ZOOM_FINISHED;
 928                                 break;
 929                             default:
 930                                 throw new RuntimeException("Unknown scroll event type: " + type);
 931                         }
 932                         Window w = view.getWindow();
 933                         double pScale = (w == null) ? 1.0 : w.getPlatformScale();

 934                         // REMIND: Scale the [total]scale params too?
 935                         scene.sceneListener.zoomEvent(eventType, scale, totalscale,
 936                                 originx == View.GESTURE_NO_VALUE ? Double.NaN : originx / pScale,
 937                                 originy == View.GESTURE_NO_VALUE ? Double.NaN : originy / pScale,
 938                                 originxAbs == View.GESTURE_NO_VALUE ? Double.NaN : originxAbs / pScale,
 939                                 originyAbs == View.GESTURE_NO_VALUE ? Double.NaN : originyAbs / pScale,
 940                                 (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
 941                                 (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
 942                                 (modifiers & KeyEvent.MODIFIER_ALT) != 0,
 943                                 (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
 944                                 isDirect, isInertia);
 945                     }
 946                     return null;
 947                 }, scene.getAccessControlContext());
 948             });
 949         } finally {
 950             if (stage != null) {
 951                 stage.setInEventHandler(false);
 952             }
 953             if (PULSE_LOGGING_ENABLED) {
 954                 PulseLogger.newInput(null);
 955             }
 956         }
 957     }
 958 
 959     @Override public void handleRotateGestureEvent(


 971             if (stage != null) {
 972                 stage.setInEventHandler(true);
 973             }
 974             QuantumToolkit.runWithoutRenderLock(() -> {
 975                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 976                     if (scene.sceneListener != null) {
 977                         EventType<RotateEvent> eventType;
 978                         switch (type) {
 979                             case GestureEvent.GESTURE_STARTED:
 980                                 eventType = RotateEvent.ROTATION_STARTED;
 981                                 break;
 982                             case GestureEvent.GESTURE_PERFORMED:
 983                                 eventType = RotateEvent.ROTATE;
 984                                 break;
 985                             case GestureEvent.GESTURE_FINISHED:
 986                                 eventType = RotateEvent.ROTATION_FINISHED;
 987                                 break;
 988                             default:
 989                                 throw new RuntimeException("Unknown scroll event type: " + type);
 990                         }
 991                         Window w = view.getWindow();
 992                         double pScale = (w == null) ? 1.0 : w.getPlatformScale();

 993                         scene.sceneListener.rotateEvent(eventType, dangle, totalangle,
 994                                 originx == View.GESTURE_NO_VALUE ? Double.NaN : originx / pScale,
 995                                 originy == View.GESTURE_NO_VALUE ? Double.NaN : originy / pScale,
 996                                 originxAbs == View.GESTURE_NO_VALUE ? Double.NaN : originxAbs / pScale,
 997                                 originyAbs == View.GESTURE_NO_VALUE ? Double.NaN : originyAbs / pScale,
 998                                 (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
 999                                 (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
1000                                 (modifiers & KeyEvent.MODIFIER_ALT) != 0,
1001                                 (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
1002                                 isDirect, isInertia);
1003                     }
1004                     return null;
1005                 }, scene.getAccessControlContext());
1006             });
1007         } finally {
1008             if (stage != null) {
1009                 stage.setInEventHandler(false);
1010             }
1011             if (PULSE_LOGGING_ENABLED) {
1012                 PulseLogger.newInput(null);
1013             }
1014         }
1015     }
1016 
1017     @Override public void handleSwipeGestureEvent(


1031             QuantumToolkit.runWithoutRenderLock(() -> {
1032                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
1033                     if (scene.sceneListener != null) {
1034                         EventType<SwipeEvent> eventType;
1035                         switch (dir) {
1036                             case SwipeGesture.DIR_UP:
1037                                 eventType = SwipeEvent.SWIPE_UP;
1038                                 break;
1039                             case SwipeGesture.DIR_DOWN:
1040                                 eventType = SwipeEvent.SWIPE_DOWN;
1041                                 break;
1042                             case SwipeGesture.DIR_LEFT:
1043                                 eventType = SwipeEvent.SWIPE_LEFT;
1044                                 break;
1045                             case SwipeGesture.DIR_RIGHT:
1046                                 eventType = SwipeEvent.SWIPE_RIGHT;
1047                                 break;
1048                             default:
1049                                 throw new RuntimeException("Unknown swipe event direction: " + dir);
1050                         }
1051                         Window w = view.getWindow();
1052                         double pScale = (w == null) ? 1.0 : w.getPlatformScale();

1053                         scene.sceneListener.swipeEvent(eventType, touchCount,
1054                                 x == View.GESTURE_NO_VALUE ? Double.NaN : x / pScale,
1055                                 y == View.GESTURE_NO_VALUE ? Double.NaN : y / pScale,
1056                                 xAbs == View.GESTURE_NO_VALUE ? Double.NaN : xAbs / pScale,
1057                                 yAbs == View.GESTURE_NO_VALUE ? Double.NaN : yAbs / pScale,
1058                                 (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
1059                                 (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
1060                                 (modifiers & KeyEvent.MODIFIER_ALT) != 0,
1061                                 (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
1062                                 isDirect);
1063                     }
1064                     return null;
1065                 }, scene.getAccessControlContext());
1066             });
1067         } finally {
1068             if (stage != null) {
1069                 stage.setInEventHandler(false);
1070             }
1071             if (PULSE_LOGGING_ENABLED) {
1072                 PulseLogger.newInput(null);
1073             }
1074         }
1075     }
1076 
1077     @Override public void handleBeginTouchEvent(


1126             QuantumToolkit.runWithoutRenderLock(() -> {
1127                     return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
1128                     if (scene.sceneListener != null) {
1129                         TouchPoint.State state;
1130                         switch (type) {
1131                             case TouchEvent.TOUCH_PRESSED:
1132                                 state = TouchPoint.State.PRESSED;
1133                                 break;
1134                             case TouchEvent.TOUCH_MOVED:
1135                                 state = TouchPoint.State.MOVED;
1136                                 break;
1137                             case TouchEvent.TOUCH_STILL:
1138                                 state = TouchPoint.State.STATIONARY;
1139                                 break;
1140                             case TouchEvent.TOUCH_RELEASED:
1141                                 state = TouchPoint.State.RELEASED;
1142                                 break;
1143                             default:
1144                                 throw new RuntimeException("Unknown touch state: " + type);
1145                         }
1146                         Window w = view.getWindow();
1147                         double pScale = (w == null) ? 1.0 : w.getPlatformScale();

1148                         scene.sceneListener.touchEventNext(state, touchId,
1149                                 x / pScale, y / pScale, xAbs / pScale, yAbs / pScale);
1150                     }
1151                     return null;
1152                 }, scene.getAccessControlContext());
1153             });
1154         } finally {
1155             if (stage != null) {
1156                 stage.setInEventHandler(false);
1157             }
1158             if (PULSE_LOGGING_ENABLED) {
1159                 PulseLogger.newInput(null);
1160             }
1161         }
1162 
1163         gestures.notifyNextTouchEvent(time, type, touchId, x, y, xAbs, yAbs);
1164     }
1165 
1166     @Override public void handleEndTouchEvent(View view, long time) {
1167         if (PULSE_LOGGING_ENABLED) {
1168             PulseLogger.newInput("END_TOUCH_EVENT");
1169         }




 329                     return null;
 330                 default:
 331                     if (QuantumToolkit.verbose) {
 332                         System.out.println("handleMouseEvent: unhandled type: " + type);
 333                     }
 334             }
 335 
 336             WindowStage stage = scene.getWindowStage();
 337             try {
 338                 if (stage != null) {
 339                     stage.setInEventHandler(true);
 340                 }
 341                 if (scene.sceneListener != null) {
 342                     boolean shiftDown = (modifiers & KeyEvent.MODIFIER_SHIFT) != 0;
 343                     boolean controlDown = (modifiers & KeyEvent.MODIFIER_CONTROL) != 0;
 344                     boolean altDown = (modifiers & KeyEvent.MODIFIER_ALT) != 0;
 345                     boolean metaDown = (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0;
 346                     boolean primaryButtonDown = (modifiers & KeyEvent.MODIFIER_BUTTON_PRIMARY) != 0;
 347                     boolean middleButtonDown = (modifiers & KeyEvent.MODIFIER_BUTTON_MIDDLE) != 0;
 348                     boolean secondaryButtonDown = (modifiers & KeyEvent.MODIFIER_BUTTON_SECONDARY) != 0;
 349                     final Window w = view.getWindow();
 350                     double pScaleX = (w == null) ? 1.0 : w.getPlatformScaleX();
 351                     double pScaleY = (w == null) ? 1.0 : w.getPlatformScaleY();
 352 
 353                     scene.sceneListener.mouseEvent(mouseEventType(type),
 354                             x / pScaleX, y / pScaleY, xAbs / pScaleX, yAbs / pScaleY,
 355                             mouseEventButton(button), isPopupTrigger, isSynthesized,
 356                             shiftDown, controlDown, altDown, metaDown,
 357                             primaryButtonDown, middleButtonDown, secondaryButtonDown);
 358                 }
 359             } finally {
 360                 if (stage != null) {
 361                     stage.setInEventHandler(false);
 362                 }
 363                 if (PULSE_LOGGING_ENABLED) {
 364                     PulseLogger.newInput(null);
 365                 }
 366             }
 367             return null;
 368         }
 369     }
 370 
 371     @Override
 372     public void handleMouseEvent(View view, long time, int type, int button,
 373                                  int x, int y, int xAbs, int yAbs,
 374                                  int modifiers, boolean isPopupTrigger, boolean isSynthesized)


 388         QuantumToolkit.runWithoutRenderLock(() -> {
 389             return AccessController.doPrivileged(mouseNotification, scene.getAccessControlContext());
 390         });
 391     }
 392 
 393     @Override public void handleMenuEvent(final View view,
 394                                           final int x, final int y, final int xAbs, final int yAbs,
 395                                           final boolean isKeyboardTrigger)
 396     {
 397         if (PULSE_LOGGING_ENABLED) {
 398             PulseLogger.newInput("MENU_EVENT");
 399         }
 400         WindowStage stage = scene.getWindowStage();
 401         try {
 402             if (stage != null) {
 403                 stage.setInEventHandler(true);
 404             }
 405             QuantumToolkit.runWithoutRenderLock(() -> {
 406                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 407                     if (scene.sceneListener != null) {
 408                         final Window w = view.getWindow();
 409                         double pScaleX = (w == null) ? 1.0 : w.getPlatformScaleX();
 410                         double pScaleY = (w == null) ? 1.0 : w.getPlatformScaleY();
 411                         scene.sceneListener.menuEvent(x / pScaleX, y / pScaleY,
 412                                                       xAbs / pScaleX, yAbs / pScaleY,
 413                                                       isKeyboardTrigger);
 414                     }
 415                     return null;
 416                 }, scene.getAccessControlContext());
 417             });
 418         } finally {
 419             if (stage != null) {
 420                 stage.setInEventHandler(false);
 421             }
 422             if (PULSE_LOGGING_ENABLED) {
 423                 PulseLogger.newInput(null);
 424             }
 425         }
 426     }
 427 
 428     @Override public void handleScrollEvent(final View view, final long time,
 429                                             final int x, final int y, final int xAbs, final int yAbs,
 430                                             final double deltaX, final double deltaY, final int modifiers,
 431                                             final int lines, final int chars,
 432                                             final int defaultLines, final int defaultChars,
 433                                             final double xMultiplier, final double yMultiplier)
 434     {
 435         if (PULSE_LOGGING_ENABLED) {
 436             PulseLogger.newInput("SCROLL_EVENT");
 437         }
 438         WindowStage stage = scene.getWindowStage();
 439         try {
 440             if (stage != null) {
 441                 stage.setInEventHandler(true);
 442             }
 443             QuantumToolkit.runWithoutRenderLock(() -> {
 444                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 445                     if (scene.sceneListener != null) {
 446                         final Window w = view.getWindow();
 447                         double pScaleX = (w == null) ? 1.0 : w.getPlatformScaleX();
 448                         double pScaleY = (w == null) ? 1.0 : w.getPlatformScaleY();
 449                         scene.sceneListener.scrollEvent(ScrollEvent.SCROLL,
 450                             deltaX / pScaleX, deltaY / pScaleY, 0, 0,
 451                             xMultiplier, yMultiplier,
 452                             0, // touchCount
 453                             chars, lines, defaultChars, defaultLines,
 454                             x / pScaleX, y / pScaleY, xAbs / pScaleX, yAbs / pScaleY,
 455                             (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
 456                             (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
 457                             (modifiers & KeyEvent.MODIFIER_ALT) != 0,
 458                             (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
 459                             false, // this is always indirect
 460                             false); // this has no inertia
 461                     }
 462                     return null;
 463                 }, scene.getAccessControlContext());
 464             });
 465         } finally {
 466             if (stage != null) {
 467                 stage.setInEventHandler(false);
 468             }
 469             if (PULSE_LOGGING_ENABLED) {
 470                 PulseLogger.newInput(null);
 471             }
 472         }
 473     }
 474 


 759             if (scene.sceneListener == null) {
 760                 return null;
 761             }
 762             switch (type) {
 763                 case ViewEvent.REPAINT: {
 764                     Window w = view.getWindow();
 765                     if (w != null && w.getMinimumWidth() == view.getWidth() && !w.isVisible()) {
 766                         // RT-21057 - ignore initial minimum size setting if not visible
 767                         break;
 768                     }
 769                     if (QuantumToolkit.drawInPaint && w != null && w.isVisible()) {
 770                         WindowStage stage = scene.getWindowStage();
 771                         if (stage != null && !stage.isApplet()) {
 772                             collector.liveRepaintRenderJob(scene);
 773                         }
 774                     }
 775                     scene.entireSceneNeedsRepaint();
 776                     break;
 777                 }
 778                 case ViewEvent.RESIZE: {
 779                     final Window w = view.getWindow();
 780                     float pScaleX = (w == null) ? 1.0f : w.getPlatformScaleX();
 781                     float pScaleY = (w == null) ? 1.0f : w.getPlatformScaleY();
 782                     scene.sceneListener.changedSize(view.getWidth()  / pScaleX,
 783                                                     view.getHeight() / pScaleY);
 784                     scene.entireSceneNeedsRepaint();
 785                     QuantumToolkit.runWithRenderLock(() -> {
 786                         scene.updateSceneState();
 787                         return null;
 788                     });
 789                     if (QuantumToolkit.liveResize && w != null && w.isVisible()) {
 790                         WindowStage stage = scene.getWindowStage();
 791                         if (stage != null && !stage.isApplet()) {
 792                             collector.liveRepaintRenderJob(scene);
 793                         }
 794                     }
 795                     break;
 796                 }
 797                 case ViewEvent.MOVE: {
 798                     // MOVE events can be "synthesized" and the window will
 799                     // be null if this is synthesized during a "REMOVE" event
 800                     final Window w = view.getWindow();
 801                     float pScaleX = (w == null) ? 1.0f : w.getPlatformScaleX();
 802                     float pScaleY = (w == null) ? 1.0f : w.getPlatformScaleY();
 803                     scene.sceneListener.changedLocation(view.getX() / pScaleX,
 804                                                         view.getY() / pScaleY);
 805                     break;
 806                 }
 807                 case ViewEvent.FULLSCREEN_ENTER:
 808                 case ViewEvent.FULLSCREEN_EXIT:
 809                     if (scene.getWindowStage() != null) {
 810                         scene.getWindowStage().fullscreenChanged(type == ViewEvent.FULLSCREEN_ENTER);
 811                     }
 812                     break;
 813                 case ViewEvent.ADD:
 814                 case ViewEvent.REMOVE:
 815                     // unhandled
 816                     break;
 817                 default:
 818                     throw new RuntimeException("handleViewEvent: unhandled type: " + type);
 819             }
 820             return null;
 821         }
 822     }
 823 
 824     @Override public void handleViewEvent(View view, long time, final int type) {


 854             if (stage != null) {
 855                 stage.setInEventHandler(true);
 856             }
 857             QuantumToolkit.runWithoutRenderLock(() -> {
 858                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 859                     if (scene.sceneListener != null) {
 860                         EventType<ScrollEvent> eventType;
 861                         switch(type) {
 862                             case GestureEvent.GESTURE_STARTED:
 863                                 eventType = ScrollEvent.SCROLL_STARTED;
 864                                 break;
 865                             case GestureEvent.GESTURE_PERFORMED:
 866                                 eventType = ScrollEvent.SCROLL;
 867                                 break;
 868                             case GestureEvent.GESTURE_FINISHED:
 869                                 eventType = ScrollEvent.SCROLL_FINISHED;
 870                                 break;
 871                             default:
 872                                 throw new RuntimeException("Unknown scroll event type: " + type);
 873                         }
 874                         final Window w = view.getWindow();
 875                         double pScaleX = (w == null) ? 1.0 : w.getPlatformScaleX();
 876                         double pScaleY = (w == null) ? 1.0 : w.getPlatformScaleY();
 877                         scene.sceneListener.scrollEvent(eventType,
 878                                 dx / pScaleX, dy / pScaleY, totaldx / pScaleX, totaldy / pScaleY,
 879                                 multiplierX, multiplierY,
 880                                 touchCount,
 881                                 0, 0, 0, 0,
 882                                 x == View.GESTURE_NO_VALUE ? Double.NaN : x / pScaleX,
 883                                 y == View.GESTURE_NO_VALUE ? Double.NaN : y / pScaleY,
 884                                 xAbs == View.GESTURE_NO_VALUE ? Double.NaN : xAbs / pScaleX,
 885                                 yAbs == View.GESTURE_NO_VALUE ? Double.NaN : yAbs / pScaleY,
 886                                 (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
 887                                 (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
 888                                 (modifiers & KeyEvent.MODIFIER_ALT) != 0,
 889                                 (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
 890                                 isDirect, isInertia);
 891                     }
 892                     return null;
 893                 }, scene.getAccessControlContext());
 894             });
 895         } finally {
 896             if (stage != null) {
 897                 stage.setInEventHandler(false);
 898             }
 899             if (PULSE_LOGGING_ENABLED) {
 900                 PulseLogger.newInput(null);
 901             }
 902         }
 903     }
 904 
 905     @Override public void handleZoomGestureEvent(


 918             if (stage != null) {
 919                 stage.setInEventHandler(true);
 920             }
 921             QuantumToolkit.runWithoutRenderLock(() -> {
 922                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 923                     if (scene.sceneListener != null) {
 924                         EventType<ZoomEvent> eventType;
 925                         switch (type) {
 926                             case GestureEvent.GESTURE_STARTED:
 927                                 eventType = ZoomEvent.ZOOM_STARTED;
 928                                 break;
 929                             case GestureEvent.GESTURE_PERFORMED:
 930                                 eventType = ZoomEvent.ZOOM;
 931                                 break;
 932                             case GestureEvent.GESTURE_FINISHED:
 933                                 eventType = ZoomEvent.ZOOM_FINISHED;
 934                                 break;
 935                             default:
 936                                 throw new RuntimeException("Unknown scroll event type: " + type);
 937                         }
 938                         final Window w = view.getWindow();
 939                         double pScaleX = (w == null) ? 1.0 : w.getPlatformScaleX();
 940                         double pScaleY = (w == null) ? 1.0 : w.getPlatformScaleY();
 941                         // REMIND: Scale the [total]scale params too?
 942                         scene.sceneListener.zoomEvent(eventType, scale, totalscale,
 943                                 originx == View.GESTURE_NO_VALUE ? Double.NaN : originx / pScaleX,
 944                                 originy == View.GESTURE_NO_VALUE ? Double.NaN : originy / pScaleY,
 945                                 originxAbs == View.GESTURE_NO_VALUE ? Double.NaN : originxAbs / pScaleX,
 946                                 originyAbs == View.GESTURE_NO_VALUE ? Double.NaN : originyAbs / pScaleY,
 947                                 (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
 948                                 (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
 949                                 (modifiers & KeyEvent.MODIFIER_ALT) != 0,
 950                                 (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
 951                                 isDirect, isInertia);
 952                     }
 953                     return null;
 954                 }, scene.getAccessControlContext());
 955             });
 956         } finally {
 957             if (stage != null) {
 958                 stage.setInEventHandler(false);
 959             }
 960             if (PULSE_LOGGING_ENABLED) {
 961                 PulseLogger.newInput(null);
 962             }
 963         }
 964     }
 965 
 966     @Override public void handleRotateGestureEvent(


 978             if (stage != null) {
 979                 stage.setInEventHandler(true);
 980             }
 981             QuantumToolkit.runWithoutRenderLock(() -> {
 982                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
 983                     if (scene.sceneListener != null) {
 984                         EventType<RotateEvent> eventType;
 985                         switch (type) {
 986                             case GestureEvent.GESTURE_STARTED:
 987                                 eventType = RotateEvent.ROTATION_STARTED;
 988                                 break;
 989                             case GestureEvent.GESTURE_PERFORMED:
 990                                 eventType = RotateEvent.ROTATE;
 991                                 break;
 992                             case GestureEvent.GESTURE_FINISHED:
 993                                 eventType = RotateEvent.ROTATION_FINISHED;
 994                                 break;
 995                             default:
 996                                 throw new RuntimeException("Unknown scroll event type: " + type);
 997                         }
 998                         final Window w = view.getWindow();
 999                         double pScaleX = (w == null) ? 1.0 : w.getPlatformScaleX();
1000                         double pScaleY = (w == null) ? 1.0 : w.getPlatformScaleY();
1001                         scene.sceneListener.rotateEvent(eventType, dangle, totalangle,
1002                                 originx == View.GESTURE_NO_VALUE ? Double.NaN : originx / pScaleX,
1003                                 originy == View.GESTURE_NO_VALUE ? Double.NaN : originy / pScaleY,
1004                                 originxAbs == View.GESTURE_NO_VALUE ? Double.NaN : originxAbs / pScaleX,
1005                                 originyAbs == View.GESTURE_NO_VALUE ? Double.NaN : originyAbs / pScaleY,
1006                                 (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
1007                                 (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
1008                                 (modifiers & KeyEvent.MODIFIER_ALT) != 0,
1009                                 (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
1010                                 isDirect, isInertia);
1011                     }
1012                     return null;
1013                 }, scene.getAccessControlContext());
1014             });
1015         } finally {
1016             if (stage != null) {
1017                 stage.setInEventHandler(false);
1018             }
1019             if (PULSE_LOGGING_ENABLED) {
1020                 PulseLogger.newInput(null);
1021             }
1022         }
1023     }
1024 
1025     @Override public void handleSwipeGestureEvent(


1039             QuantumToolkit.runWithoutRenderLock(() -> {
1040                 return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
1041                     if (scene.sceneListener != null) {
1042                         EventType<SwipeEvent> eventType;
1043                         switch (dir) {
1044                             case SwipeGesture.DIR_UP:
1045                                 eventType = SwipeEvent.SWIPE_UP;
1046                                 break;
1047                             case SwipeGesture.DIR_DOWN:
1048                                 eventType = SwipeEvent.SWIPE_DOWN;
1049                                 break;
1050                             case SwipeGesture.DIR_LEFT:
1051                                 eventType = SwipeEvent.SWIPE_LEFT;
1052                                 break;
1053                             case SwipeGesture.DIR_RIGHT:
1054                                 eventType = SwipeEvent.SWIPE_RIGHT;
1055                                 break;
1056                             default:
1057                                 throw new RuntimeException("Unknown swipe event direction: " + dir);
1058                         }
1059                         final Window w = view.getWindow();
1060                         double pScaleX = (w == null) ? 1.0 : w.getPlatformScaleX();
1061                         double pScaleY = (w == null) ? 1.0 : w.getPlatformScaleY();
1062                         scene.sceneListener.swipeEvent(eventType, touchCount,
1063                                 x == View.GESTURE_NO_VALUE ? Double.NaN : x / pScaleX,
1064                                 y == View.GESTURE_NO_VALUE ? Double.NaN : y / pScaleY,
1065                                 xAbs == View.GESTURE_NO_VALUE ? Double.NaN : xAbs / pScaleX,
1066                                 yAbs == View.GESTURE_NO_VALUE ? Double.NaN : yAbs / pScaleY,
1067                                 (modifiers & KeyEvent.MODIFIER_SHIFT) != 0,
1068                                 (modifiers & KeyEvent.MODIFIER_CONTROL) != 0,
1069                                 (modifiers & KeyEvent.MODIFIER_ALT) != 0,
1070                                 (modifiers & KeyEvent.MODIFIER_WINDOWS) != 0,
1071                                 isDirect);
1072                     }
1073                     return null;
1074                 }, scene.getAccessControlContext());
1075             });
1076         } finally {
1077             if (stage != null) {
1078                 stage.setInEventHandler(false);
1079             }
1080             if (PULSE_LOGGING_ENABLED) {
1081                 PulseLogger.newInput(null);
1082             }
1083         }
1084     }
1085 
1086     @Override public void handleBeginTouchEvent(


1135             QuantumToolkit.runWithoutRenderLock(() -> {
1136                     return AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
1137                     if (scene.sceneListener != null) {
1138                         TouchPoint.State state;
1139                         switch (type) {
1140                             case TouchEvent.TOUCH_PRESSED:
1141                                 state = TouchPoint.State.PRESSED;
1142                                 break;
1143                             case TouchEvent.TOUCH_MOVED:
1144                                 state = TouchPoint.State.MOVED;
1145                                 break;
1146                             case TouchEvent.TOUCH_STILL:
1147                                 state = TouchPoint.State.STATIONARY;
1148                                 break;
1149                             case TouchEvent.TOUCH_RELEASED:
1150                                 state = TouchPoint.State.RELEASED;
1151                                 break;
1152                             default:
1153                                 throw new RuntimeException("Unknown touch state: " + type);
1154                         }
1155                         final Window w = view.getWindow();
1156                         double pScaleX = (w == null) ? 1.0 : w.getPlatformScaleX();
1157                         double pScaleY = (w == null) ? 1.0 : w.getPlatformScaleY();
1158                         scene.sceneListener.touchEventNext(state, touchId,
1159                                 x / pScaleX, y / pScaleY, xAbs / pScaleX, yAbs / pScaleY);
1160                     }
1161                     return null;
1162                 }, scene.getAccessControlContext());
1163             });
1164         } finally {
1165             if (stage != null) {
1166                 stage.setInEventHandler(false);
1167             }
1168             if (PULSE_LOGGING_ENABLED) {
1169                 PulseLogger.newInput(null);
1170             }
1171         }
1172 
1173         gestures.notifyNextTouchEvent(time, type, touchId, x, y, xAbs, yAbs);
1174     }
1175 
1176     @Override public void handleEndTouchEvent(View view, long time) {
1177         if (PULSE_LOGGING_ENABLED) {
1178             PulseLogger.newInput("END_TOUCH_EVENT");
1179         }