Action Animations addition (REMADE FROM SCRATCH)

src/main/java/com/stream_pi/client/animations/AnimateFXInterpolator.java

@@ -0,0 +1,13 @@
+package com.stream_pi.client.animations;
+
+import javafx.animation.Interpolator;
+
+public final class AnimateFXInterpolator {
+
+    private AnimateFXInterpolator() {
+        throw new IllegalStateException("AnimateFX Interpolator");
+    }
+
+    public static final Interpolator EASE = Interpolator.SPLINE(0.25, 0.1, 0.25, 1);
+
+}

src/main/java/com/stream_pi/client/animations/AnimationFX.java

@@ -0,0 +1,204 @@
+package com.stream_pi.client.animations;
+
+import javafx.animation.Animation;
+import javafx.animation.Timeline;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.Node;
+import javafx.util.Duration;
+
+
+/**
+ * @author Loïc Sculier aka typhon0
+ */
+public abstract class AnimationFX {
+
+    /**
+     * Used to specify an animation that repeats indefinitely, until the
+     * {@code stop()} method is called.
+     */
+    public static final int INDEFINITE = -1;
+    private Timeline timeline;
+    private boolean reset;
+    private Node node;
+    private AnimationFX nextAnimation;
+    private boolean hasNextAnimation;
+
+    /**
+     * Create a new animation
+     *
+     * @param node the node to affect
+     */
+    public AnimationFX(Node node) {
+        super();
+        setNode(node);
+
+    }
+
+    /**
+     * Default constructor
+     */
+    public AnimationFX() {
+        hasNextAnimation = false;
+        this.reset = false;
+    }
+
+    /**
+     * Handle when the animation is finished
+     *
+     * @return
+     */
+    private AnimationFX onFinished() {
+        if (reset) {
+            resetNode();
+        }
+        if (this.nextAnimation != null) {
+            this.nextAnimation.play();
+        }
+        return this;
+    }
+
+    /**
+     * Set the next animation to play
+     *
+     * @param animation
+     * @return
+     */
+    public AnimationFX playOnFinished(AnimationFX animation) {
+        setNextAnimation(animation);
+        return this;
+
+    }
+
+    /**
+     * Function to reset the node or not when the animation is finished
+     *
+     * @param reset
+     * @return
+     */
+    public AnimationFX setResetOnFinished(boolean reset) {
+        this.reset = reset;
+        return this;
+    }
+
+    /**
+     * Play the animation
+     */
+    public void play() {
+        timeline.play();
+    }
+
+    /**
+     * Stop the animation
+     *
+     * @return
+     */
+    public AnimationFX stop() {
+        timeline.stop();
+        return this;
+    }
+
+    /**
+     * Function the reset the node to original state
+     *
+     * @return
+     */
+    abstract AnimationFX resetNode();
+
+    /**
+     * Function to initialize the timeline
+     */
+    abstract void initTimeline();
+
+
+    public Timeline getTimeline() {
+        return timeline;
+    }
+
+    public void setTimeline(Timeline timeline) {
+        this.timeline = timeline;
+    }
+
+    public boolean isResetOnFinished() {
+        return reset;
+    }
+
+    protected void setReset(boolean reset) {
+        this.reset = reset;
+    }
+
+    public Node getNode() {
+        return node;
+    }
+
+    public void setNode(Node node) {
+        this.node = node;
+        initTimeline();
+        timeline.statusProperty().addListener((observable, oldValue, newValue) -> {
+            if (newValue.equals(Animation.Status.STOPPED)) {
+                onFinished();
+            }
+
+        });
+    }
+
+    public AnimationFX getNextAnimation() {
+        return nextAnimation;
+    }
+
+    protected void setNextAnimation(AnimationFX nextAnimation) {
+        hasNextAnimation = true;
+        this.nextAnimation = nextAnimation;
+    }
+
+    public boolean hasNextAnimation() {
+        return hasNextAnimation;
+    }
+
+    protected void setHasNextAnimation(boolean hasNextAnimation) {
+        this.hasNextAnimation = hasNextAnimation;
+    }
+
+    /**
+     * Define the number of cycles in this animation
+     *
+     * @param value
+     * @return
+     */
+    public AnimationFX setCycleCount(int value) {
+        this.timeline.setCycleCount(value);
+        return this;
+    }
+
+    /**
+     * Set the speed factor of the animation
+     *
+     * @param value
+     * @return
+     */
+    public AnimationFX setSpeed(double value) {
+        this.timeline.setRate(value);
+        return this;
+    }
+
+    /**
+     * Delays the start of an animation
+     *
+     * @param value
+     * @return
+     */
+    public AnimationFX setDelay(Duration value) {
+        this.timeline.setDelay(value);
+        return this;
+    }
+
+    /**
+     * Set event when the animation ended.
+     *
+     * @param value
+     */
+    public final void setOnFinished(EventHandler<ActionEvent> value) {
+        this.timeline.setOnFinished(value);
+    }
+
+}

src/main/java/com/stream_pi/client/animations/Bounce.java

@@ -0,0 +1,66 @@
+package com.stream_pi.client.animations;
+
+import javafx.animation.Interpolator;
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.animation.Timeline;
+import javafx.scene.Node;
+import javafx.util.Duration;
+
+
+/**
+ * @author Loïc Sculier aka typhon0
+ */
+public class Bounce extends AnimationFX {
+
+
+    /**
+     * Create new Bounce
+     *
+     * @param node The node to affect
+     */
+    public Bounce(Node node) {
+        super(node);
+    }
+
+    public Bounce() {
+        super();
+    }
+
+    @Override
+    public AnimationFX resetNode() {
+        getNode().setTranslateY(0);
+        return this;
+    }
+
+    @Override
+    void initTimeline() {
+        setTimeline(
+                new Timeline(
+
+                        new KeyFrame(Duration.millis(0),
+                                new KeyValue(getNode().translateYProperty(), 0, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                        ),
+                        new KeyFrame(Duration.millis(400),
+                                new KeyValue(getNode().translateYProperty(), -30, Interpolator.SPLINE(0.755, 0.050, 0.855, 0.060))
+                        ),
+                        new KeyFrame(Duration.millis(550),
+                                new KeyValue(getNode().translateYProperty(), 0, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                        ),
+                        new KeyFrame(Duration.millis(700),
+                                new KeyValue(getNode().translateYProperty(), -15, Interpolator.SPLINE(0.755, 0.050, 0.855, 0.060))
+                        ),
+                        new KeyFrame(Duration.millis(800),
+                                new KeyValue(getNode().translateYProperty(), 0, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                        ),
+                        new KeyFrame(Duration.millis(900),
+                                new KeyValue(getNode().translateYProperty(), -5, Interpolator.SPLINE(0.755, 0.050, 0.855, 0.060))
+                        ),
+                        new KeyFrame(Duration.millis(1000),
+                                new KeyValue(getNode().translateYProperty(), 0, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                        )
+
+                ));
+    }
+}
+

src/main/java/com/stream_pi/client/animations/BounceIn.java

@@ -0,0 +1,72 @@
+package com.stream_pi.client.animations;
+
+import javafx.animation.Interpolator;
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.animation.Timeline;
+import javafx.scene.Node;
+import javafx.util.Duration;
+
+/**
+ * @author Loïc Sculier aka typhon0
+ */
+public class BounceIn extends AnimationFX {
+
+
+    /**
+     * Create new BounceIn
+     *
+     * @param node The node to affect
+     */
+    public BounceIn(Node node) {
+        super(node);
+
+    }
+
+    public BounceIn() {
+        super();
+    }
+
+    @Override
+    AnimationFX resetNode() {
+        getNode().setOpacity(1);
+        getNode().setScaleX(1);
+        getNode().setScaleY(1);
+        return this;
+    }
+
+    @Override
+    void initTimeline() {
+        setTimeline(new Timeline(
+                new KeyFrame(Duration.millis(0),
+                        new KeyValue(getNode().opacityProperty(), 0, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleXProperty(), 0.3, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleYProperty(), 0.3, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                ),
+                new KeyFrame(Duration.millis(200),
+                        new KeyValue(getNode().scaleXProperty(), 1.1, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleYProperty(), 1.1, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                ),
+                new KeyFrame(Duration.millis(400),
+                        new KeyValue(getNode().scaleXProperty(), 0.9, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleYProperty(), 0.9, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                ),
+                new KeyFrame(Duration.millis(600),
+                        new KeyValue(getNode().opacityProperty(), 1, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleXProperty(), 1.03, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleYProperty(), 1.03, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                ),
+                new KeyFrame(Duration.millis(800),
+                        new KeyValue(getNode().scaleXProperty(), 0.97, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleYProperty(), 0.97, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                ),
+                new KeyFrame(Duration.millis(1000),
+                        new KeyValue(getNode().opacityProperty(), 1, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleXProperty(), 1, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000)),
+                        new KeyValue(getNode().scaleYProperty(), 1, Interpolator.SPLINE(0.215, 0.610, 0.355, 1.000))
+                )
+
+        ));
+
+    }
+}