Review changes

modules/javafx.graphics/src/main/docs/javafx/scene/doc-files/cssref.html

@@ -1716,20 +1716,20 @@ <h3><a id="typeeasingfunction">&lt;easing-function&gt;</a></h3>
         <tr><td><br/></td></tr>
         <tr>
             <td style="width: 120px; vertical-align: top"><span class="grammar">jump-start</span></td>
-            <td>the interval starts with a rise point when the input progress value is 0</span></td>
+            <td>the interval starts with a rise point when the input progress value is 0</td>
         </tr>
         <tr>
             <td style="width: 120px; vertical-align: top"><span class="grammar">jump-end</span></td>
-            <td>the interval ends with a rise point when the input progress value is 1</span></td>
+            <td>the interval ends with a rise point when the input progress value is 1</td>
         </tr>
         <tr>
             <td style="width: 120px; vertical-align: top"><span class="grammar">jump-none</span></td>
-            <td>all rise points are within the open interval (0..1)</span></td>
+            <td>all rise points are within the open interval (0..1)</td>
         </tr>
         <tr>
             <td style="width: 120px; vertical-align: top"><span class="grammar">jump-both</span></td>
             <td>the interval starts with a rise point when the input progress value is 0,
-                and ends with a rise point when the input progress value is 1</span></td>
+                and ends with a rise point when the input progress value is 1</td>
         </tr>
         <tr>
             <td style="width: 120px; vertical-align: top"><span class="grammar">start</span></td>

modules/javafx.graphics/src/main/java/com/sun/javafx/css/TransitionDefinitionCssMetaData.java

@@ -86,7 +86,7 @@ public StyleableProperty<String[]> getStyleableProperty(S styleable) {
                     return null;
                 }
             },
-            new CssMetaData<S, Duration[]>( "transition-duration",
+            new CssMetaData<S, Duration[]>("transition-duration",
                     DurationConverter.SequenceConverter.getInstance(), DURATION_ZERO, false) {
                 @Override
                 public boolean isSettable(S styleable) {
@@ -98,7 +98,7 @@ public StyleableProperty<Duration[]> getStyleableProperty(S styleable) {
                     return null;
                 }
             },
-            new CssMetaData<S, Duration[]>( "transition-delay",
+            new CssMetaData<S, Duration[]>("transition-delay",
                     DurationConverter.SequenceConverter.getInstance(), DURATION_ZERO, false) {
                 @Override
                 public boolean isSettable(S styleable) {
@@ -110,7 +110,7 @@ public StyleableProperty<Duration[]> getStyleableProperty(S styleable) {
                     return null;
                 }
             },
-            new CssMetaData<S, Interpolator[]>( "transition-timing-function",
+            new CssMetaData<S, Interpolator[]>("transition-timing-function",
                     InterpolatorConverter.SequenceConverter.getInstance(), INTERPOLATOR_EASE, false) {
                 @Override
                 public boolean isSettable(S styleable) {

modules/javafx.graphics/src/main/java/com/sun/javafx/css/TransitionTimer.java

@@ -41,14 +41,17 @@
 /**
  * {@code TransitionTimer} is the base class for timers that compute intermediate
  * values for implicit transitions of a {@link StyleableProperty}.
+ *
+ * @param <T> the value type
+ * @param <P> the property type
  */
 public abstract class TransitionTimer<T, P extends Property<T> & StyleableProperty<T>> extends AnimationTimer {
 
     private final P property;
     private Interpolator interpolator;
-    private long startTime, endTime, delay, duration;
     private double reversingShorteningFactor;
-    private long currentTime;
+    private long startTime, endTime, delay, duration; // in nanoseconds
+    private long currentTime; // in nanoseconds
     private boolean updating;
     private boolean started;
 
@@ -61,14 +64,18 @@ protected TransitionTimer(P property) {
      * If the combined duration of the transition is zero or if the targeted node is not
      * showing, no transition timer is started, no events are dispatched, and this method
      * returns {@code null}.
+     *
+     * @param timer the {@code TransitionTimer} that will be started
+     * @param transition the {@code TransitionDefinition} used to initialize the {@code timer}
+     * @return the {@code timer} instance if the timer was started, {@code null} otherwise
      */
     @SuppressWarnings("unchecked")
     public static <T, P extends Property<T> & StyleableProperty<T>> TransitionTimer<T, P> run(
             TransitionTimer<T, P> timer, TransitionDefinition transition) {
         long now = AnimationTimerHelper.getPrimaryTimer(timer).nanos();
         timer.interpolator = transition.interpolator();
-        timer.delay = (long)(transition.delay().toMillis() * 1_000_000);
-        timer.duration = (long)(transition.duration().toMillis() * 1_000_000);
+        timer.delay = millisToNanos(transition.delay().toMillis());
+        timer.duration = millisToNanos(transition.duration().toMillis());
         timer.currentTime = now;
         timer.startTime = now + timer.delay;
         timer.endTime = timer.startTime + timer.duration;
@@ -94,14 +101,14 @@ public static <T, P extends Property<T> & StyleableProperty<T>> TransitionTimer<
                 // timer, which means that the new timer is a reversing timer that needs to be
                 // adjusted by the reversing shortening algorithm.
                 if (combinedDuration > 0) {
-                    adjustReversingTimer(existingTimer, timer, transition, now);
+                    adjustReversingTimer(existingTimer, timer, now);
                 }
 
                 existingTimer.stop(TransitionEvent.CANCEL);
             }
 
             if (combinedDuration > 0) {
-                timer.start();
+                timer.startImpl();
                 return timer;
             }
         }
@@ -151,10 +158,14 @@ public static boolean cancel(TransitionTimer<?, ?> timer, boolean forceStop) {
      * now takes the entire duration (4s) to progress just one quarter of the original value space,
      * which means that the transition speed is much slower than what would be expected.
      *
+     * @param existingTimer the timer of the running transition
+     * @param newTimer the timer of the new transition
+     * @param now the current time, in nanoseconds
      * @see <a href="https://www.w3.org/TR/css-transitions-1/#reversing">Faster reversing of interrupted transitions</a>
      */
-    private static void adjustReversingTimer(TransitionTimer<?, ?> existingTimer, TransitionTimer<?, ?> newTimer,
-                                             TransitionDefinition transition, long now) {
+    private static void adjustReversingTimer(TransitionTimer<?, ?> existingTimer,
+                                             TransitionTimer<?, ?> newTimer,
+                                             long now) {
         double progress = InterpolatorHelper.curve(existingTimer.interpolator, existingTimer.getProgress());
 
         if (progress > 0 && progress < 1) {
@@ -164,36 +175,63 @@ private static void adjustReversingTimer(TransitionTimer<?, ?> existingTimer, Tr
         }
 
         if (newTimer.delay < 0) {
-            double adjustedDelay = transition.delay().toMillis() * newTimer.reversingShorteningFactor;
-            newTimer.startTime = now + (long)(adjustedDelay * 1_000_000);
+            double adjustedDelay = nanosToMillis(newTimer.delay) * newTimer.reversingShorteningFactor;
+            newTimer.startTime = now + millisToNanos(adjustedDelay);
         }
 
-        double adjustedDuration = transition.duration().toMillis() * newTimer.reversingShorteningFactor;
-        newTimer.endTime = newTimer.startTime + (long)(adjustedDuration * 1_000_000);
+        double adjustedDuration = nanosToMillis(newTimer.duration) * newTimer.reversingShorteningFactor;
+        newTimer.endTime = newTimer.startTime + millisToNanos(adjustedDuration);
+    }
+
+    /**
+     * Converts the specified duration in nanoseconds to fractional milliseconds.
+     *
+     * @param nanos the duration in nanoseconds
+     * @return the duration in fractional milliseconds
+     */
+    private static double nanosToMillis(long nanos) {
+        long millis = nanos / 1_000_000L;
+        double frac = (double)(nanos - (millis * 1_000_000L)) / 1_000_000D;
+        return (double)millis + frac;
+    }
+
+    /**
+     * Converts the specified duration in fractional milliseconds to nanoseconds.
+     *
+     * @param millis the duration in fractional milliseconds
+     * @return the duration in nanoseconds
+     */
+    private static long millisToNanos(double millis) {
+        long wholeMillis = (long)millis;
+        double frac = millis - (double)wholeMillis;
+        return wholeMillis * 1_000_000L + (long)(frac * 1_000_000D);
     }
 
     /**
      * Fires a {@link TransitionEvent} of the specified type.
      * The elapsed time is computed according to the CSS Transitions specification.
+     *
+     * @param timer the {@code TransitionTimer} that fires the event
+     * @param eventType the event type
      */
     private static <T, P extends Property<T> & StyleableProperty<T>> void fireTransitionEvent(
             TransitionTimer<T, P> timer, EventType<TransitionEvent> eventType) {
         try {
-            double elapsedTime;
+            Duration elapsedTime;
 
             // Elapsed time specification: https://www.w3.org/TR/css-transitions-1/#event-transitionevent
             if (eventType == TransitionEvent.RUN || eventType == TransitionEvent.START) {
-                elapsedTime = (double)Math.min(Math.max(-timer.delay, 0), timer.duration) / 1_000_000.0;
+                elapsedTime = Duration.millis(nanosToMillis(Math.min(Math.max(-timer.delay, 0), timer.duration)));
             } else if (eventType == TransitionEvent.CANCEL) {
-                elapsedTime = (double)Math.max(0, timer.currentTime - timer.startTime) / 1_000_000.0;
+                elapsedTime = Duration.millis(nanosToMillis(Math.max(0, timer.currentTime - timer.startTime)));
             } else if (eventType == TransitionEvent.END) {
-                elapsedTime = (double)timer.duration / 1_000_000.0;
+                elapsedTime = Duration.millis(nanosToMillis(timer.duration));
             } else {
                 throw new IllegalArgumentException("eventType");
             }
 
             Node node = (Node)timer.getProperty().getBean();
-            node.fireEvent(new TransitionEvent(eventType, timer.getProperty(), Duration.millis(elapsedTime)));
+            node.fireEvent(new TransitionEvent(eventType, timer.getProperty(), elapsedTime));
         } catch (Throwable ex) {
             Thread currentThread = Thread.currentThread();
             currentThread.getUncaughtExceptionHandler().uncaughtException(currentThread, ex);
@@ -202,6 +240,8 @@ private static <T, P extends Property<T> & StyleableProperty<T>> void fireTransi
 
     /**
      * Gets the styleable property targeted by this {@code TransitionTimer}.
+     *
+     * @return the styleable property
      */
     public final P getProperty() {
         return property;
@@ -238,13 +278,11 @@ public final void handle(long now) {
     }
 
     /**
-     * Starts this timer, and adds it to the list of running transitions.
+     * This method is unused, calling it will throw {@link UnsupportedOperationException}.
      */
     @Override
     public final void start() {
-        super.start();
-        NodeHelper.addTransitionTimer((Node)property.getBean(), this);
-        fireTransitionEvent(this, TransitionEvent.RUN);
+        throw new UnsupportedOperationException();
     }
 
     /**
@@ -259,6 +297,8 @@ public final void stop() {
      * Stops the running transition and fires the specified event.
      * This happens when the value of a CSS property targeted by a transition is changed by the user,
      * when the transition is interrupted by another transition, or when it ends normally.
+     *
+     * @param eventType the event type that is fired after the timer is stopped
      */
     public final void stop(EventType<TransitionEvent> eventType) {
         super.stop();
@@ -276,6 +316,15 @@ public final void complete() {
         stop(TransitionEvent.CANCEL);
     }
 
+    /**
+     * Starts this timer, and adds it to the list of running transitions.
+     */
+    private void startImpl() {
+        super.start();
+        NodeHelper.addTransitionTimer((Node)property.getBean(), this);
+        fireTransitionEvent(this, TransitionEvent.RUN);
+    }
+
     /**
      * Updates the transition timer by mapping the specified input progress to an output progress
      * value using the timer's interpolator, and then calling {@link #onUpdate(P, double)}} with the
@@ -298,6 +347,8 @@ private void update(double progress) {
     /**
      * Polls whether the timer is currently updating the value of the property.
      * After this method is called, the {@link #updating} flag is {@code false}.
+     *
+     * @return {@code true} if the timer is currently updating the property, {@code false} otherwise
      */
     private boolean pollUpdating() {
         boolean updating = this.updating;
@@ -306,7 +357,9 @@ private boolean pollUpdating() {
     }
 
     /**
-     * Gets the progress of this timer along the input progress axis, ranging from 0 to 1.
+     * Gets the progress of this timer along the input progress axis.
+     *
+     * @return the input progress, ranging from 0 to 1
      */
     private double getProgress() {
         if (currentTime <= startTime) {

modules/javafx.graphics/src/main/java/com/sun/scenario/animation/StepInterpolator.java

@@ -32,7 +32,7 @@
  * Implementation of a step interpolator as described by
  * <a href="https://www.w3.org/TR/css-easing-1/#step-easing-algo">CSS Easing Functions Level 1</a>
  */
-public class StepInterpolator extends Interpolator {
+public final class StepInterpolator extends Interpolator {
 
     private final int intervals;
     private final StepPosition position;

modules/javafx.graphics/src/main/java/javafx/css/CssParser.java

@@ -675,7 +675,7 @@ private Size time(Token token) throws ParseException {
                 if (LOGGER.isLoggable(Level.FINEST)) {
                     LOGGER.finest("Expected \'<duration>\'");
                 }
-                ParseException re = new ParseException("Expected \'<duration>\'",token, this);
+                ParseException re = new ParseException("Expected \'<duration>\'", token, this);
                 reportError(createError(re.toString()));
                 throw re;
             }
@@ -1012,14 +1012,14 @@ private ParsedValueImpl<?, Size> parseTime(final Term root) throws ParseExceptio
         if (root.token.getType() != CssLexer.IDENT) {
             Size time = time(root.token);
             return new ParsedValueImpl<>(time, null);
-        } else {
-            String key = root.token.getText();
-            return switch (key) {
-                case "initial", "inherit" -> new ParsedValueImpl<>(new Size(0, SizeUnits.S), null);
-                case "indefinite" -> new ParsedValueImpl<>(new Size(Double.POSITIVE_INFINITY, SizeUnits.S), null);
-                default -> new ParsedValueImpl<>(key, null, true);
-            };
         }
+
+        String key = root.token.getText();
+        return switch (key) {
+            case "initial", "inherit" -> new ParsedValueImpl<>(new Size(0, SizeUnits.S), null);
+            case "indefinite" -> new ParsedValueImpl<>(new Size(Double.POSITIVE_INFINITY, SizeUnits.S), null);
+            default -> new ParsedValueImpl<>(key, null, true);
+        };
     }
 
     private ParsedValueImpl<ParsedValue<?, Size>, Duration> parseDuration(
@@ -3946,7 +3946,7 @@ private ParsedValueImpl<ParsedValue[],Font> parseFont(Term root) throws ParseExc
     }
 
     private ParsedValueImpl<ParsedValue[], TransitionDefinition> parseTransition(Term term)
-            throws ParseException{
+            throws ParseException {
         ParsedValue<?, String> parsedProperty = null;
         ParsedValue<ParsedValue<?, Size>, Duration> parsedDuration = null;
         ParsedValue<ParsedValue<?, Size>, Duration> parsedDelay = null;
@@ -3955,7 +3955,9 @@ private ParsedValueImpl<ParsedValue[], TransitionDefinition> parseTransition(Ter
         for (int i = 0; i < 4; ++i) {
             if (term == null) {
                 break;
-            } else if (isEasingFunction(term.token)) {
+            }
+
+            if (isEasingFunction(term.token)) {
                 if (parsedTimingFunction != null) {
                     error(term, "Expected \'<single-transition-property>\' or \'<duration>\'");
                 }

modules/javafx.graphics/src/main/java/javafx/css/TransitionEvent.java

@@ -30,6 +30,7 @@
 import javafx.event.EventType;
 import javafx.scene.Node;
 import javafx.util.Duration;
+import java.util.Objects;
 
 /**
  * An event that signals the creation, beginning, completion and cancellation of implicit CSS transitions.
@@ -40,7 +41,7 @@
  */
 public final class TransitionEvent extends Event {
 
-    private static final long serialVersionUID = 20220820L;
+    private static final long serialVersionUID = 1L;
 
     /**
      * Common supertype for all {@code TransitionEvent} types.
@@ -86,13 +87,14 @@ public final class TransitionEvent extends Event {
      * @param eventType the event type
      * @param property the {@code StyleableProperty} that is targeted by the transition
      * @param elapsedTime the time that has elapsed since the transition has entered its active period
+     * @throws NullPointerException if {@code property} or {@code elapsedTime} is {@code null}
      */
     public TransitionEvent(EventType<? extends Event> eventType,
                            StyleableProperty<?> property,
                            Duration elapsedTime) {
         super(eventType);
-        this.property = property;
-        this.elapsedTime = elapsedTime;
+        this.property = Objects.requireNonNull(property, "property cannot be null");
+        this.elapsedTime = Objects.requireNonNull(elapsedTime, "elapsedTime cannot be null");
     }
 
     /**
@@ -108,7 +110,7 @@ public StyleableProperty<?> getProperty() {
      * Gets the time that has elapsed since the transition has entered its active period,
      * not including the time spent in the delay phase.
      *
-     * @return the elapsed time
+     * @return the elapsed time, or zero if the transition has not entered its active period
      */
     public Duration getElapsedTime() {
         return elapsedTime;