├── .gitignore
├── src
    ├── test
    │   ├── resources
    │   │   ├── themes
    │   │   │   ├── button.css
    │   │   │   ├── global.css
    │   │   │   ├── dark.css
    │   │   │   └── light.css
    │   │   └── fxml
    │   │   │   ├── AnimatedValueLabel.fxml
    │   │   │   ├── AnimatedContainer.fxml
    │   │   │   ├── AnimatedSwitcher.fxml
    │   │   │   └── Animated.fxml
    │   └── java
    │   │   └── eu
    │   │       └── iamgio
    │   │           └── animatedtest
    │   │               ├── fxml
    │   │                   ├── FxmlAnimatedContainerTest.java
    │   │                   ├── FxmlAnimatedTest.java
    │   │                   ├── FxmlAnimatedValueLabelTest.java
    │   │                   └── FxmlAnimatedSwitcherTest.java
    │   │               ├── AnimatedCurrencyTest.java
    │   │               ├── AnimatedSwitcherTest.java
    │   │               ├── TestUtil.java
    │   │               ├── AnimatedLayoutTest.java
    │   │               ├── AnimatedRootSwitchTest.java
    │   │               ├── AnimatedThemeTest.java
    │   │               ├── AnimatedButtonTest.java
    │   │               ├── AnimatedShadowTest.java
    │   │               ├── AnimatedContainerTest.java
    │   │               └── AnimatedTest.java
    └── main
    │   ├── java
    │       └── eu
    │       │   └── iamgio
    │       │       └── animated
    │       │           ├── transition
    │       │               ├── EntranceAndExitAnimationCompatible.java
    │       │               ├── animations
    │       │               │   ├── RequiresScene.java
    │       │               │   ├── None.java
    │       │               │   └── clip
    │       │               │   │   ├── CircleClipOut.java
    │       │               │   │   ├── CircleClipIn.java
    │       │               │   │   ├── RectangleClipOut.java
    │       │               │   │   ├── RectangleClipIn.java
    │       │               │   │   ├── CircleClip.java
    │       │               │   │   ├── RectangleClip.java
    │       │               │   │   └── ClipAnimation.java
    │       │               ├── ExitAnimationCompatible.java
    │       │               ├── EntranceAnimationCompatible.java
    │       │               ├── container
    │       │               │   ├── AnimatedContainer.java
    │       │               │   ├── AnimatedVBox.java
    │       │               │   ├── AnimatedHBox.java
    │       │               │   └── AnimatedContainerHandler.java
    │       │               ├── AnimatedSwitcher.java
    │       │               ├── AnimationPair.java
    │       │               ├── AnimatedThemeSwitcher.java
    │       │               ├── Animation.java
    │       │               └── AnimatedLabel.java
    │       │           ├── binding
    │       │               ├── property
    │       │               │   ├── animation
    │       │               │   │   ├── BindableContextNode.java
    │       │               │   │   ├── OnDemandAnimationPropertyGroup.java
    │       │               │   │   ├── OnDemandAnimationProperty.java
    │       │               │   │   ├── SimpleAnimationProperty.java
    │       │               │   │   └── AnimationProperty.java
    │       │               │   └── wrapper
    │       │               │   │   ├── ObjectPropertyWrapper.java
    │       │               │   │   ├── DoublePropertyWrapper.java
    │       │               │   │   ├── IntegerPropertyWrapper.java
    │       │               │   │   └── PropertyWrapper.java
    │       │               ├── value
    │       │               │   ├── AnimatedIntValueLabel.java
    │       │               │   ├── AnimatedDoubleValueLabel.java
    │       │               │   ├── AnimatedValue.java
    │       │               │   ├── AnimatedValueImpl.java
    │       │               │   └── AnimatedValueLabel.java
    │       │               ├── presets
    │       │               │   ├── AnimatedOpacity.java
    │       │               │   ├── AnimatedRotation.java
    │       │               │   ├── AnimatedColor.java
    │       │               │   ├── AnimatedPrefSize.java
    │       │               │   ├── AnimatedScale.java
    │       │               │   ├── AnimatedTranslatePosition.java
    │       │               │   ├── AnimatedBlur.java
    │       │               │   ├── AnimatedDropShadow.java
    │       │               │   └── AnimatedLayout.java
    │       │               ├── event
    │       │               │   ├── ListenableAnimation.java
    │       │               │   └── AnimationEvent.java
    │       │               ├── CustomizableAnimation.java
    │       │               ├── SingleChildParent.java
    │       │               ├── AnimationSettings.java
    │       │               ├── misc
    │       │               │   └── AnimatedSlider.java
    │       │               └── Animated.java
    │       │           ├── util
    │       │               ├── ReflectionUtils.java
    │       │               └── PositionUtils.java
    │       │           └── common
    │       │               ├── Pausable.java
    │       │               └── Curve.java
    │   └── kotlin
    │       └── eu
    │           └── iamgio
    │               └── animated
    │                   └── AnimatedExtensions.kt
├── LICENSE
├── pom.xml
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | target/
2 | .idea/
3 | *.iml


--------------------------------------------------------------------------------
/src/test/resources/themes/button.css:
--------------------------------------------------------------------------------
 1 | .root {
 2 |     -fx-background-color: #1A1A1A;
 3 | }
 4 | 
 5 | .button {
 6 |     -fx-background-color: transparent;
 7 |     -fx-border-color: white;
 8 |     -fx-border-width: 4;
 9 |     -fx-text-fill: white;
10 |     -fx-font-weight: bold;
11 |     -fx-font-size: 16;
12 |     -fx-padding: 16 32 16 32;
13 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/EntranceAndExitAnimationCompatible.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition;
 2 | 
 3 | /**
 4 |  * Represents an element that features both entrance and exit animations.
 5 |  */
 6 | public interface EntranceAndExitAnimationCompatible extends EntranceAnimationCompatible,
 7 |                                                             ExitAnimationCompatible {
 8 | 
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/test/resources/themes/global.css:
--------------------------------------------------------------------------------
 1 | .central-box {
 2 |     -fx-padding: 32;
 3 |     -fx-spacing: 12;
 4 |     -fx-alignment: center;
 5 |     -fx-background-radius: 24;
 6 | }
 7 | 
 8 | .icon {
 9 |     -fx-background-color: #FF7373;
10 |     -fx-pref-height: 50;
11 | }
12 | 
13 | .title {
14 |     -fx-font-size: 18;
15 |     -fx-font-weight: bold;
16 | }
17 | 
18 | .subtitle {
19 |     -fx-font-size: 14;
20 |     -fx-opacity: .8;
21 |     -fx-text-alignment: center;
22 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/animation/BindableContextNode.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.property.animation;
 2 | 
 3 | import javafx.beans.property.ObjectProperty;
 4 | import javafx.scene.Node;
 5 | 
 6 | /**
 7 |  * A container for a writable node property.
 8 |  */
 9 | public interface BindableContextNode<N extends Node> {
10 | 
11 |     /**
12 |      * @return the target node for the context
13 |      */
14 |     ObjectProperty<N> targetNodeProperty();
15 | }
16 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/RequiresScene.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.animations;
 2 | 
 3 | /**
 4 |  * A tag interface that, when implemented by {@link animatefx.animation.AnimationFX} subclasses,
 5 |  * lets animations play after adding the target node to the scene.
 6 |  * This is required when the animation needs to access information about the scene,
 7 |  * but doing so may alter the visual results.
 8 |  */
 9 | public interface RequiresScene {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/value/AnimatedIntValueLabel.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.value;
 2 | 
 3 | import javafx.beans.NamedArg;
 4 | 
 5 | /**
 6 |  * An {@link AnimatedValueLabel} that wraps an integer value.
 7 |  */
 8 | public class AnimatedIntValueLabel extends AnimatedValueLabel<Integer> {
 9 | 
10 |     /**
11 |      * Instantiates an {@link AnimatedIntValueLabel}.
12 |      * @param value initial wrapped value
13 |      */
14 |     public AnimatedIntValueLabel(@NamedArg("value") int value) {
15 |         super(value);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/test/resources/themes/dark.css:
--------------------------------------------------------------------------------
 1 | .root {
 2 |     -fx-background-color: #1A1A1A;
 3 | }
 4 | 
 5 | .central-box {
 6 |     -fx-background-color: rgba(255, 255, 255, .1);
 7 | }
 8 | 
 9 | .icon {
10 |     -fx-max-width: 40;
11 |     -fx-shape: "M15.5,22c1.05,0,2.05-0.16,3-0.46c-4.06-1.27-7-5.06-7-9.54s2.94-8.27,7-9.54C17.55,2.16,16.55,2,15.5,2 c-5.52,0-10,4.48-10,10S9.98,22,15.5,22L15.5,22z";
12 | }
13 | 
14 | .label {
15 |     -fx-text-fill: white;
16 | }
17 | 
18 | .layout-test .label {
19 |     -fx-font-size: 16;
20 |     -fx-font-weight: bold;
21 |     -fx-padding: 12;
22 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/value/AnimatedDoubleValueLabel.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.value;
 2 | 
 3 | import javafx.beans.NamedArg;
 4 | 
 5 | /**
 6 |  * An {@link AnimatedValueLabel} that wraps a double value.
 7 |  */
 8 | public class AnimatedDoubleValueLabel extends AnimatedValueLabel<Double> {
 9 | 
10 |     /**
11 |      * Instantiates an {@link AnimatedDoubleValueLabel}.
12 |      * @param value initial wrapped value
13 |      */
14 |     public AnimatedDoubleValueLabel(@NamedArg("value") double value) {
15 |         super(value);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/test/resources/fxml/AnimatedValueLabel.fxml:
--------------------------------------------------------------------------------
 1 | <?import eu.iamgio.animated.binding.AnimationSettings?>
 2 | <?import eu.iamgio.animated.binding.value.AnimatedIntValueLabel?>
 3 | <?import javafx.scene.control.Button?>
 4 | <?import javafx.scene.layout.AnchorPane?>
 5 | <AnchorPane prefWidth="650" prefHeight="500">
 6 |     <Button id="button" text="Update" layoutX="300"/>
 7 |     <AnimatedIntValueLabel id="label" value="0">
 8 |         <settings>
 9 |             <AnimationSettings duration="1500ms" curve="EASE_IN_OUT"/>
10 |         </settings>
11 |     </AnimatedIntValueLabel>
12 | </AnchorPane>


--------------------------------------------------------------------------------
/src/test/resources/themes/light.css:
--------------------------------------------------------------------------------
 1 | .root {
 2 |     -fx-background-color: white;
 3 | }
 4 | 
 5 | .central-box {
 6 |     -fx-background-color: rgba(0, 0, 0, .1);
 7 | }
 8 | 
 9 | .icon {
10 |     -fx-max-width: 50;
11 |     -fx-shape: "M3.55,18.54L4.96,19.95L6.76,18.16L5.34,16.74M11,22.45C11.32,22.45 13,22.45 13,22.45V19.5H11M12,5.5A6,6 0 0,0 6,11.5A6,6 0 0,0 12,17.5A6,6 0 0,0 18,11.5C18,8.18 15.31,5.5 12,5.5M20,12.5H23V10.5H20M17.24,18.16L19.04,19.95L20.45,18.54L18.66,16.74M20.45,4.46L19.04,3.05L17.24,4.84L18.66,6.26M13,0.55H11V3.5H13M4,10.5H1V12.5H4M6.76,4.84L4.96,3.05L3.55,4.46L5.34,6.26L6.76,4.84Z";
12 | }
13 | 
14 | .central-box > .label {
15 |     -fx-text-fill: #1A1A1A;
16 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/None.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.animations;
 2 | 
 3 | import animatefx.animation.AnimationFX;
 4 | import javafx.animation.KeyFrame;
 5 | import javafx.animation.Timeline;
 6 | import javafx.util.Duration;
 7 | 
 8 | /**
 9 |  * An 1-frame-long animation that does not perform any motion or transition.
10 |  */
11 | public class None extends AnimationFX {
12 | 
13 |     @Override
14 |     protected AnimationFX resetNode() {
15 |         return this;
16 |     }
17 | 
18 |     @Override
19 |     protected void initTimeline() {
20 |         this.setTimeline(new Timeline(new KeyFrame(Duration.ONE, e -> {})));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedOpacity.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.presets;
 2 | 
 3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationProperty;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.scene.Node;
 6 | 
 7 | /**
 8 |  * Property that animates its child's opacity.
 9 |  */
10 | public class AnimatedOpacity extends OnDemandAnimationProperty<Node, Double> {
11 | 
12 |     public AnimatedOpacity() {
13 |         super(node -> PropertyWrapper.of(node.opacityProperty()));
14 |     }
15 | 
16 |     public AnimatedOpacity(Node child) {
17 |         this();
18 |         targetNodeProperty().set(child);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedRotation.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.presets;
 2 | 
 3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationProperty;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.scene.Node;
 6 | 
 7 | /**
 8 |  * Property that animates its child's rotation.
 9 |  */
10 | public class AnimatedRotation extends OnDemandAnimationProperty<Node, Double> {
11 | 
12 |     public AnimatedRotation() {
13 |         super(node -> PropertyWrapper.of(node.opacityProperty()));
14 |     }
15 | 
16 |     public AnimatedRotation(Node child) {
17 |         this();
18 |         targetNodeProperty().set(child);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/test/resources/fxml/AnimatedContainer.fxml:
--------------------------------------------------------------------------------
 1 | <?import eu.iamgio.animated.transition.Animation?>
 2 | <?import eu.iamgio.animated.transition.container.AnimatedHBox?>
 3 | <?import javafx.scene.control.Button?>
 4 | <?import javafx.scene.layout.AnchorPane?>
 5 | <?import javafx.scene.shape.Rectangle?>
 6 | <AnchorPane prefWidth="650" prefHeight="500">
 7 |     <Button text="Remove last" id="button" layoutY="100" />
 8 |     <AnimatedHBox id="animated-container">
 9 |         <out>
10 |             <Animation type="SlideOutUp"/>
11 |         </out>
12 |         <Rectangle width="50" height="50" fill="indianred" />
13 |         <Rectangle width="50" height="50" fill="aqua" />
14 |         <Rectangle width="50" height="50" fill="darkgreen" />
15 |     </AnimatedHBox>
16 | </AnchorPane>


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedColor.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.presets;
 2 | 
 3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationProperty;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.scene.paint.Paint;
 6 | import javafx.scene.shape.Shape;
 7 | 
 8 | /**
 9 |  * Property that animates its child's color, for {@link Shape} nodes.
10 |  * @author Giorgio Garofalo
11 |  */
12 | public class AnimatedColor extends OnDemandAnimationProperty<Shape, Paint> {
13 | 
14 |     public AnimatedColor() {
15 |         super(node -> PropertyWrapper.of(node.fillProperty()));
16 |     }
17 | 
18 |     public AnimatedColor(Shape child) {
19 |         this();
20 |         targetNodeProperty().set(child);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/test/resources/fxml/AnimatedSwitcher.fxml:
--------------------------------------------------------------------------------
 1 | <?import eu.iamgio.animated.transition.*?>
 2 | <?import javafx.scene.control.Button?>
 3 | <?import javafx.scene.layout.AnchorPane?>
 4 | <?import javafx.scene.shape.Rectangle?>
 5 | <AnchorPane prefWidth="650" prefHeight="500">
 6 |     <Button text="Switch" id="button" layoutY="100" />
 7 |     <AnimatedSwitcher id="animated-switcher">
 8 |         <in>
 9 |             <Animation type="CircleClipIn" speed="0.5"/>
10 |         </in>
11 |         <out>
12 |             <Animation type="None" delay="2.5s"/>
13 |         </out>
14 |         <child>
15 |             <Rectangle width="50" height="50" fill="indianred" />
16 |         </child>
17 |     </AnimatedSwitcher>
18 |     <AnimatedLabel id="animated-label" text="Animated" layoutY="150">
19 |         <in>
20 |             <Animation type="ZoomInRight"/>
21 |         </in>
22 |     </AnimatedLabel>
23 | </AnchorPane>


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedPrefSize.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.presets;
 2 | 
 3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationPropertyGroup;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.scene.layout.Region;
 6 | 
 7 | import java.util.Arrays;
 8 | 
 9 | /**
10 |  * Property that animates its child's preferred size.
11 |  */
12 | public class AnimatedPrefSize extends OnDemandAnimationPropertyGroup<Region, Double> {
13 | 
14 |     public AnimatedPrefSize() {
15 |         super(Arrays.asList(
16 |                 node -> PropertyWrapper.of(node.prefWidthProperty()),
17 |                 node -> PropertyWrapper.of(node.prefHeightProperty())
18 |         ));
19 |     }
20 | 
21 |     public AnimatedPrefSize(Region child) {
22 |         this();
23 |         targetNodeProperty().set(child);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedScale.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.presets;
 2 | 
 3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationPropertyGroup;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.scene.Node;
 6 | import javafx.scene.layout.Region;
 7 | 
 8 | import java.util.Arrays;
 9 | 
10 | /**
11 |  * Property that animates its child's scale X/Y.
12 |  */
13 | public class AnimatedScale extends OnDemandAnimationPropertyGroup<Node, Double> {
14 | 
15 |     public AnimatedScale() {
16 |         super(Arrays.asList(
17 |                 node -> PropertyWrapper.of(node.scaleXProperty()),
18 |                 node -> PropertyWrapper.of(node.scaleYProperty())
19 |         ));
20 |     }
21 | 
22 |     public AnimatedScale(Region child) {
23 |         this();
24 |         targetNodeProperty().set(child);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/util/ReflectionUtils.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.util;
 2 | 
 3 | /**
 4 |  * Utilities for reflective operations.
 5 |  */
 6 | public final class ReflectionUtils {
 7 | 
 8 |     private ReflectionUtils() {
 9 |     }
10 | 
11 |     /**
12 |      * @param name name of the class to search for
13 |      * @param packages packages to scan, in order
14 |      * @return the matching class found in one of the given packages
15 |      * @throws ClassNotFoundException if no class is found
16 |      */
17 |     public static Class<?> findClassInPackages(String name, String... packages) throws ClassNotFoundException {
18 |         for (String pack : packages) {
19 |             try {
20 |                 return Class.forName(pack + "." + name);
21 |             } catch (ClassNotFoundException ignored) {}
22 |         }
23 | 
24 |         throw new ClassNotFoundException(name);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedTranslatePosition.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.presets;
 2 | 
 3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationPropertyGroup;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.scene.Node;
 6 | import javafx.scene.layout.Region;
 7 | 
 8 | import java.util.Arrays;
 9 | 
10 | /**
11 |  * Property that animates its child's translate X/Y coordinates.
12 |  */
13 | public class AnimatedTranslatePosition extends OnDemandAnimationPropertyGroup<Node, Double> {
14 | 
15 |     public AnimatedTranslatePosition() {
16 |         super(Arrays.asList(
17 |                 node -> PropertyWrapper.of(node.translateXProperty()),
18 |                 node -> PropertyWrapper.of(node.translateYProperty())
19 |         ));
20 |     }
21 | 
22 |     public AnimatedTranslatePosition(Region child) {
23 |         this();
24 |         targetNodeProperty().set(child);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright 2021-2023 Giorgio Garofalo
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/ExitAnimationCompatible.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition;
 2 | 
 3 | import animatefx.animation.AnimationFX;
 4 | import javafx.beans.property.ObjectProperty;
 5 | 
 6 | /**
 7 |  * Represents an element that features an exit animation.
 8 |  */
 9 | public interface ExitAnimationCompatible {
10 | 
11 |     /**
12 |      * @return exit animation
13 |      */
14 |     ObjectProperty<Animation> animationOutProperty();
15 | 
16 |     /**
17 |      * @return exit animation
18 |      */
19 |     default Animation getOut() {
20 |         return this.animationOutProperty().get();
21 |     }
22 | 
23 |     /**
24 |      * Sets a new exit animation.
25 |      * @param out new non-null exit animation
26 |      */
27 |     default void setOut(Animation out) {
28 |         this.animationOutProperty().set(Animation.requireNonNull(out));
29 |     }
30 | 
31 |     /**
32 |      * Sets a new exit animation.
33 |      * @param out new non-null raw exit animation
34 |      */
35 |     default void setOut(AnimationFX out) {
36 |         this.setOut(new Animation(out));
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/EntranceAnimationCompatible.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition;
 2 | 
 3 | import animatefx.animation.AnimationFX;
 4 | import javafx.beans.property.ObjectProperty;
 5 | 
 6 | /**
 7 |  * Represents an element that features an entrance animation.
 8 |  */
 9 | public interface EntranceAnimationCompatible {
10 | 
11 |     /**
12 |      * @return entrance animation
13 |      */
14 |     ObjectProperty<Animation> animationInProperty();
15 | 
16 |     /**
17 |      * @return entrance animation
18 |      */
19 |     default Animation getIn() {
20 |         return this.animationInProperty().get();
21 |     }
22 | 
23 |     /**
24 |      * Sets a new entrance animation.
25 |      * @param in new non-null entrance animation
26 |      */
27 |     default void setIn(Animation in) {
28 |         this.animationInProperty().set(Animation.requireNonNull(in));
29 |     }
30 | 
31 |     /**
32 |      * Sets a new entrance animation.
33 |      * @param in new non-null raw entrance animation
34 |      */
35 |     default void setIn(AnimationFX in) {
36 |         this.setIn(new Animation(in));
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/test/resources/fxml/Animated.fxml:
--------------------------------------------------------------------------------
 1 | <?import eu.iamgio.animated.binding.Animated?>
 2 | <?import eu.iamgio.animated.binding.AnimationSettings?>
 3 | <?import eu.iamgio.animated.binding.presets.AnimatedBlur?>
 4 | <?import eu.iamgio.animated.binding.presets.AnimatedColor?>
 5 | <?import javafx.scene.control.Button?>
 6 | <?import javafx.scene.layout.AnchorPane?>
 7 | <?import javafx.scene.shape.Rectangle?>
 8 | <AnchorPane prefWidth="650" prefHeight="500">
 9 |     <Button id="button" text="Update" layoutX="300"/>
10 |     <Animated>
11 |         <child>
12 |             <Rectangle id="rectangle" width="200" height="200"/>
13 |         </child>
14 |         <targetProperties>
15 |             <AnimatedColor>
16 |                 <settings>
17 |                     <AnimationSettings duration="1500ms" curve="EASE_IN_OUT"/>
18 |                 </settings>
19 |             </AnimatedColor>
20 |             <AnimatedBlur>
21 |                 <settings>
22 |                     <AnimationSettings duration="900ms" curve="EASE_IN_OUT_BACK"/>
23 |                 </settings>
24 |             </AnimatedBlur>
25 |         </targetProperties>
26 |     </Animated>
27 | </AnchorPane>


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/event/ListenableAnimation.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.event;
 2 | 
 3 | import javafx.beans.property.ObjectProperty;
 4 | import javafx.event.EventHandler;
 5 | 
 6 | /**
 7 |  * A provider of listeners for animation-related events.
 8 |  * @see AnimationEvent
 9 |  */
10 | public interface ListenableAnimation {
11 | 
12 |     /**
13 |      * @return the action to run when an animation begins
14 |      */
15 |     ObjectProperty<EventHandler<AnimationEvent>> onAnimationStartedProperty();
16 | 
17 |     /**
18 |      * @param handler the action to run when an animation begins
19 |      */
20 |     default void setOnAnimationStarted(EventHandler<AnimationEvent> handler) {
21 |         onAnimationStartedProperty().set(handler);
22 |     }
23 | 
24 |     /**
25 |      * @return the action to run when an animation finishes
26 |      */
27 |     ObjectProperty<EventHandler<AnimationEvent>> onAnimationEndedProperty();
28 | 
29 |     /**
30 |      * @param handler the action to run when an animation finishes
31 |      */
32 |     default void setOnAnimationEnded(EventHandler<AnimationEvent> handler) {
33 |         onAnimationEndedProperty().set(handler);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/CustomizableAnimation.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding;
 2 | 
 3 | import java.util.function.Function;
 4 | 
 5 | /**
 6 |  * Interface that defines a class with customizable {@link AnimationSettings}.
 7 |  * @param <T> settings owner
 8 |  * @author Giorgio Garofalo
 9 |  */
10 | public interface CustomizableAnimation<T> {
11 | 
12 |     /**
13 |      * Applies custom animation settings.
14 |      * @param settings animation settings to set
15 |      */
16 |     void setSettings(AnimationSettings settings);
17 | 
18 |     /**
19 |      * Applies custom animation settings.
20 |      * @param settings animation settings to set
21 |      * @return this for concatenation
22 |      */
23 |     @SuppressWarnings("unchecked")
24 |     default T withSettings(AnimationSettings settings) {
25 |         setSettings(settings);
26 |         return (T) this;
27 |     }
28 | 
29 |     /**
30 |      * Applies custom animation settings
31 |      * @param settings settings to update. Example: <pre>custom(settings{@literal ->} settings.withDuration(...))</pre>
32 |      * @return this for concatenation
33 |      */
34 |     T custom(Function<AnimationSettings, AnimationSettings> settings);
35 | }
36 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/common/Pausable.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.common;
 2 | 
 3 | import javafx.beans.property.BooleanProperty;
 4 | 
 5 | /**
 6 |  * A {@link Pausable} object exposes a boolean value that represents whether animations on that object should be skipped,
 7 |  * meaning the animated implementation should be ignored and the standard one should be used.
 8 |  * @author Giorgio Garofalo
 9 |  */
10 | public interface Pausable {
11 | 
12 |     /**
13 |      * @return whether animations should be skipped
14 |      */
15 |     BooleanProperty pausedProperty();
16 | 
17 |     /**
18 |      * @return whether animations should be skipped
19 |      */
20 |     default boolean isPaused() {
21 |         return pausedProperty().get();
22 |     }
23 | 
24 |     /**
25 |      * Prevents any animation from playing until {@link #resume()} is called
26 |      * (only effective if {@link #isPaused()} is <tt>false</tt>).
27 |      */
28 |     default void pause() {
29 |         pausedProperty().set(true);
30 |     }
31 | 
32 |     /**
33 |      * Lets animations play (only effective if {@link #isPaused()} is <tt>true</tt>).
34 |      */
35 |     default void resume() {
36 |         pausedProperty().set(false);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/fxml/FxmlAnimatedContainerTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest.fxml;
 2 | 
 3 | import eu.iamgio.animated.transition.container.AnimatedContainer;
 4 | import javafx.application.Application;
 5 | import javafx.fxml.FXMLLoader;
 6 | import javafx.scene.Parent;
 7 | import javafx.scene.Scene;
 8 | import javafx.scene.control.Button;
 9 | import javafx.stage.Stage;
10 | 
11 | import java.util.Objects;
12 | 
13 | import static eu.iamgio.animatedtest.TestUtil.SCENE_HEIGHT;
14 | import static eu.iamgio.animatedtest.TestUtil.SCENE_WIDTH;
15 | 
16 | public class FxmlAnimatedContainerTest extends Application {
17 | 
18 |     public void start(Stage primaryStage) throws Exception {
19 |         Parent root = FXMLLoader.load(Objects.requireNonNull(getClass().getResource("/fxml/AnimatedContainer.fxml")));
20 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
21 | 
22 |         primaryStage.setTitle("FXML");
23 |         primaryStage.setScene(scene);
24 |         primaryStage.show();
25 | 
26 |         Button removeButton = (Button) Objects.requireNonNull(root.lookup("#button"));
27 |         AnimatedContainer container = (AnimatedContainer) Objects.requireNonNull(root.lookup("#animated-container"));
28 | 
29 |         removeButton.setOnAction(e -> container.getChildren().remove(container.getChildren().size() - 1));
30 |     }
31 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/event/AnimationEvent.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.event;
 2 | 
 3 | import javafx.event.Event;
 4 | import javafx.event.EventType;
 5 | 
 6 | /**
 7 |  * An animation-related event.
 8 |  * @see ListenableAnimation
 9 |  */
10 | public final class AnimationEvent extends Event {
11 | 
12 |     private static final EventType<AnimationEvent> ANIMATION = new EventType<>("ANIMATION");
13 | 
14 |     private final boolean interrupted;
15 | 
16 |     public AnimationEvent(boolean interrupted) {
17 |         super(ANIMATION);
18 |         this.interrupted = interrupted;
19 |     }
20 | 
21 |     /**
22 |      * @return whether this animation was interrupted.
23 |      * Note:
24 |      * <ul>
25 |      *     <li>
26 |      *         If this event represents the end of an animation, the interrupted status
27 |      *         means the animation stopped before the expected time because the wrapped value
28 |      *         was externally changed and a new animation has to be played.
29 |      *     </li>
30 |      *     <li>
31 |      *         If this event represents the start of an animation, the interrupted status
32 |      *         means the animation started right after an interrupted end animation.
33 |      *     </li>
34 |      * </ul>
35 |      */
36 |     public boolean isInterrupted() {
37 |         return this.interrupted;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedBlur.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.presets;
 2 | 
 3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationProperty;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.scene.Node;
 6 | import javafx.scene.effect.GaussianBlur;
 7 | 
 8 | /**
 9 |  * Property that animates its child's {@link GaussianBlur} radius.
10 |  * If the target node does not have an {@link javafx.scene.effect.Effect}
11 |  * or if its effect is not a {@link GaussianBlur} at initialization time,
12 |  * a new {@link GaussianBlur} with default radius will be set as its new effect.
13 |  */
14 | public class AnimatedBlur extends OnDemandAnimationProperty<Node, Double> {
15 | 
16 |     public AnimatedBlur() {
17 |         super(node -> PropertyWrapper.of(getEffectOrCreate(node).radiusProperty()));
18 |     }
19 | 
20 |     public AnimatedBlur(Node child) {
21 |         this();
22 |         targetNodeProperty().set(child);
23 |     }
24 | 
25 |     private static GaussianBlur getEffectOrCreate(Node node) {
26 |         if (node.getEffect() == null || !(node.getEffect() instanceof GaussianBlur)) {
27 |             GaussianBlur blur = new GaussianBlur();
28 |             node.setEffect(blur);
29 |             return blur;
30 |         } else {
31 |             return (GaussianBlur) node.getEffect();
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/wrapper/ObjectPropertyWrapper.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.property.wrapper;
 2 | 
 3 | import javafx.beans.property.ObjectProperty;
 4 | import javafx.beans.property.Property;
 5 | import javafx.beans.value.ChangeListener;
 6 | 
 7 | /**
 8 |  * Wrapper of a non-primitive property.
 9 |  * @author Giorgio Garofalo
10 |  */
11 | public class ObjectPropertyWrapper<T> implements PropertyWrapper<T> {
12 | 
13 |     private final ObjectProperty<T> property;
14 | 
15 |     /**
16 |      * Instantiates a wrapper of a non-primitive property
17 |      * @param property property to wrap
18 |      */
19 |     public ObjectPropertyWrapper(ObjectProperty<T> property) {
20 |         this.property = property;
21 |     }
22 | 
23 |     /**
24 |      * {@inheritDoc}
25 |      */
26 |     @Override
27 |     public Property<T> getProperty() {
28 |         return property;
29 |     }
30 | 
31 |     /**
32 |      * {@inheritDoc}
33 |      */
34 |     @Override
35 |     public T getValue() {
36 |         return property.getValue();
37 |     }
38 | 
39 |     /**
40 |      * {@inheritDoc}
41 |      */
42 |     @Override
43 |     public void set(T value) {
44 |         property.set(value);
45 |     }
46 | 
47 |     /**
48 |      * {@inheritDoc}
49 |      */
50 |     @Override
51 |     public void addListener(ChangeListener<? super T> listener) {
52 |         property.addListener(listener);
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/fxml/FxmlAnimatedTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest.fxml;
 2 | 
 3 | import javafx.application.Application;
 4 | import javafx.fxml.FXMLLoader;
 5 | import javafx.scene.Parent;
 6 | import javafx.scene.Scene;
 7 | import javafx.scene.control.Button;
 8 | import javafx.scene.effect.GaussianBlur;
 9 | import javafx.scene.shape.Rectangle;
10 | import javafx.stage.Stage;
11 | 
12 | import java.util.Objects;
13 | import java.util.Random;
14 | 
15 | import static eu.iamgio.animatedtest.TestUtil.*;
16 | 
17 | public class FxmlAnimatedTest extends Application {
18 | 
19 |     public void start(Stage primaryStage) throws Exception {
20 |         Parent root = FXMLLoader.load(Objects.requireNonNull(getClass().getResource("/fxml/Animated.fxml")));
21 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
22 | 
23 |         primaryStage.setTitle("FXML");
24 |         primaryStage.setScene(scene);
25 |         primaryStage.show();
26 | 
27 |         Button updateButton = (Button) Objects.requireNonNull(root.lookup("#button"));
28 |         Rectangle rectangle = (Rectangle) Objects.requireNonNull(root.lookup("#rectangle"));
29 | 
30 |         Random random = new Random();
31 | 
32 |         updateButton.setOnAction(e -> {
33 |             rectangle.setFill(randomColor(random));
34 | 
35 |             GaussianBlur blur = (GaussianBlur) rectangle.getEffect();
36 |             blur.setRadius(random.nextInt(100));
37 |         });
38 |     }
39 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/clip/CircleClipOut.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.animations.clip;
 2 | 
 3 | import eu.iamgio.animated.common.Curve;
 4 | import javafx.geometry.Pos;
 5 | import javafx.util.Duration;
 6 | 
 7 | /**
 8 |  * Exit animation that features a circular clip of decreasing radius of the target node.
 9 |  */
10 | public class CircleClipOut extends CircleClip {
11 | 
12 |     /**
13 |      * Instantiates a circular clip exit animation.
14 |      * @param curve animation curve
15 |      * @param duration animation duration
16 |      * @param alignment position of the circle, relative to the scene
17 |      */
18 |     public CircleClipOut(Curve curve, Duration duration, Pos alignment) {
19 |         super(curve, duration, alignment);
20 |     }
21 | 
22 |     /**
23 |      * Instantiates a circular clip exit animation.
24 |      * @param alignment position of the circle, relative to the scene
25 |      */
26 |     public CircleClipOut(Pos alignment) {
27 |         this(DEFAULT_EXIT_CURVE, DEFAULT_DURATION, alignment);
28 |     }
29 | 
30 |     /**
31 |      * Instantiates a circular clip exit animation from the center of the scene.
32 |      */
33 |     public CircleClipOut() {
34 |         this(DEFAULT_ALIGNMENT);
35 |     }
36 | 
37 |     @Override
38 |     protected double getInitialRadius() {
39 |         return super.calcMaxRadius();
40 |     }
41 | 
42 |     @Override
43 |     protected double getFinalRadius() {
44 |         return 0;
45 |     }
46 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/clip/CircleClipIn.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.animations.clip;
 2 | 
 3 | import eu.iamgio.animated.common.Curve;
 4 | import javafx.geometry.Pos;
 5 | import javafx.util.Duration;
 6 | 
 7 | /**
 8 |  * Entrance animation that features a circular clip of increasing radius of the target node.
 9 |  */
10 | public class CircleClipIn extends CircleClip {
11 | 
12 |     /**
13 |      * Instantiates a circular clip entrance animation.
14 |      * @param curve animation curve
15 |      * @param duration animation duration
16 |      * @param alignment position of the circle, relative to the scene
17 |      */
18 |     public CircleClipIn(Curve curve, Duration duration, Pos alignment) {
19 |         super(curve, duration, alignment);
20 |     }
21 | 
22 |     /**
23 |      * Instantiates a circular clip entrance animation.
24 |      * @param alignment position of the circle, relative to the scene
25 |      */
26 |     public CircleClipIn(Pos alignment) {
27 |         super(DEFAULT_ENTRANCE_CURVE, DEFAULT_DURATION, alignment);
28 |     }
29 | 
30 |     /**
31 |      * Instantiates a circular clip entrance animation from the center of the scene.
32 |      */
33 |     public CircleClipIn() {
34 |         this(DEFAULT_ALIGNMENT);
35 |     }
36 | 
37 |     @Override
38 |     protected double getInitialRadius() {
39 |         return 0;
40 |     }
41 | 
42 |     @Override
43 |     protected double getFinalRadius() {
44 |         return super.calcMaxRadius();
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/wrapper/DoublePropertyWrapper.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.property.wrapper;
 2 | 
 3 | import javafx.beans.property.DoubleProperty;
 4 | import javafx.beans.property.Property;
 5 | import javafx.beans.value.ChangeListener;
 6 | 
 7 | /**
 8 |  * Wrapper of a {@link Double} property.
 9 |  * @author Giorgio Garofalo
10 |  */
11 | public class DoublePropertyWrapper implements PropertyWrapper<Double> {
12 | 
13 |     private final DoubleProperty property;
14 | 
15 |     /**
16 |      * Instantiates a wrapper of a {@link Double} property
17 |      * @param property property to wrap
18 |      */
19 |     public DoublePropertyWrapper(DoubleProperty property) {
20 |         this.property = property;
21 |     }
22 | 
23 |     /**
24 |      * {@inheritDoc}
25 |      */
26 |     @Override
27 |     public Property<Double> getProperty() {
28 |         return property.asObject();
29 |     }
30 | 
31 |     /**
32 |      * {@inheritDoc}
33 |      */
34 |     @Override
35 |     public Double getValue() {
36 |         return property.doubleValue();
37 |     }
38 | 
39 |     /**
40 |      * {@inheritDoc}
41 |      */
42 |     @Override
43 |     public void set(Double value) {
44 |         property.set(value);
45 |     }
46 | 
47 |     /**
48 |      * {@inheritDoc}
49 |      */
50 |     @SuppressWarnings("unchecked")
51 |     @Override
52 |     public void addListener(ChangeListener<? super Double> listener) {
53 |         property.addListener((ChangeListener<? super Number>) listener);
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/wrapper/IntegerPropertyWrapper.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.property.wrapper;
 2 | 
 3 | import javafx.beans.property.IntegerProperty;
 4 | import javafx.beans.property.Property;
 5 | import javafx.beans.value.ChangeListener;
 6 | 
 7 | /**
 8 |  * Wrapper of an {@link Integer} property.
 9 |  * @author Giorgio Garofalo
10 |  */
11 | public class IntegerPropertyWrapper implements PropertyWrapper<Integer> {
12 | 
13 |     private final IntegerProperty property;
14 | 
15 |     /**
16 |      * Instantiates a wrapper of an {@link Integer} property
17 |      * @param property property to wrap
18 |      */
19 |     public IntegerPropertyWrapper(IntegerProperty property) {
20 |         this.property = property;
21 |     }
22 | 
23 |     /**
24 |      * {@inheritDoc}
25 |      */
26 |     @Override
27 |     public Property<Integer> getProperty() {
28 |         return property.asObject();
29 |     }
30 | 
31 |     /**
32 |      * {@inheritDoc}
33 |      */
34 |     @Override
35 |     public Integer getValue() {
36 |         return property.intValue();
37 |     }
38 | 
39 |     /**
40 |      * {@inheritDoc}
41 |      */
42 |     @Override
43 |     public void set(Integer value) {
44 |         property.set(value);
45 |     }
46 | 
47 |     /**
48 |      * {@inheritDoc}
49 |      */
50 |     @SuppressWarnings("unchecked")
51 |     @Override
52 |     public void addListener(ChangeListener<? super Integer> listener) {
53 |         property.addListener((ChangeListener<? super Number>) listener);
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/SingleChildParent.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding;
 2 | 
 3 | import javafx.beans.property.ObjectProperty;
 4 | import javafx.beans.property.SimpleObjectProperty;
 5 | import javafx.scene.Node;
 6 | import javafx.scene.Parent;
 7 | 
 8 | /**
 9 |  * Parent node that has only one child
10 |  * @author Giorgio Garofalo
11 |  */
12 | public class SingleChildParent extends Parent {
13 | 
14 |     protected final ObjectProperty<Node> child = new SimpleObjectProperty<>();
15 | 
16 |     protected SingleChildParent() {
17 |         // Registers child listener
18 |         this.child.addListener((observable, oldChild, newChild) -> {
19 |             if (newChild != null) {
20 |                 getChildren().setAll(newChild);
21 |             } else {
22 |                 getChildren().clear();
23 |             }
24 |         });
25 |     }
26 | 
27 |     protected SingleChildParent(Node child) {
28 |         this();
29 |         this.child.set(child);
30 |     }
31 | 
32 |     /**
33 |      * @return the current child
34 |      */
35 |     public ObjectProperty<Node> childProperty() {
36 |         return this.child;
37 |     }
38 | 
39 |     /**
40 |      * @return the current child
41 |      */
42 |     public Node getChild() {
43 |         return this.child.get();
44 |     }
45 | 
46 |     /**
47 |      * Sets the new child.
48 |      * @param child new child. If <tt>null</tt>, the current child is removed and nothing is added.
49 |      */
50 |     public void setChild(Node child) {
51 |         this.childProperty().set(child);
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/fxml/FxmlAnimatedValueLabelTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest.fxml;
 2 | 
 3 | import eu.iamgio.animated.binding.value.AnimatedIntValueLabel;
 4 | import javafx.application.Application;
 5 | import javafx.fxml.FXMLLoader;
 6 | import javafx.scene.Parent;
 7 | import javafx.scene.Scene;
 8 | import javafx.scene.control.Button;
 9 | import javafx.stage.Stage;
10 | 
11 | import java.util.Objects;
12 | import java.util.Random;
13 | 
14 | import static eu.iamgio.animatedtest.TestUtil.SCENE_HEIGHT;
15 | import static eu.iamgio.animatedtest.TestUtil.SCENE_WIDTH;
16 | 
17 | public class FxmlAnimatedValueLabelTest extends Application {
18 | 
19 |     public void start(Stage primaryStage) throws Exception {
20 |         Parent root = FXMLLoader.load(Objects.requireNonNull(getClass().getResource("/fxml/AnimatedValueLabel.fxml")));
21 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
22 | 
23 |         primaryStage.setTitle("FXML");
24 |         primaryStage.setScene(scene);
25 |         primaryStage.show();
26 | 
27 |         Button updateButton = (Button) Objects.requireNonNull(root.lookup("#button"));
28 | 
29 |         AnimatedIntValueLabel label = (AnimatedIntValueLabel) Objects.requireNonNull(root.lookup("#label"));
30 | 
31 |         // The supplied random value changes the text opacity.
32 |         label.animationValueProperty().addListener(o -> label.setOpacity(label.getAnimationValue() / 100.0));
33 | 
34 |         // Random value generation.
35 |         Random random = new Random();
36 |         updateButton.setOnAction(e -> label.setValue(random.nextInt(100)));
37 |     }
38 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/clip/RectangleClipOut.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.animations.clip;
 2 | 
 3 | import eu.iamgio.animated.common.Curve;
 4 | import javafx.geometry.Pos;
 5 | import javafx.util.Duration;
 6 | 
 7 | /**
 8 |  * Exit animation that features a rectangular clip of increasing size of the target node.
 9 |  */
10 | public class RectangleClipOut extends RectangleClip {
11 | 
12 |     /**
13 |      * @param curve animation curve
14 |      * @param duration animation duration
15 |      * @param alignment position of the rectangle, relative to the scene
16 |      */
17 |     public RectangleClipOut(Curve curve, Duration duration, Pos alignment) {
18 |         super(curve, duration, alignment);
19 |     }
20 | 
21 |     /**
22 |      * Instantiates a rectangular clip entrance animation.
23 |      * @param alignment position of the rectangle, relative to the scene
24 |      */
25 |     public RectangleClipOut(Pos alignment) {
26 |         this(DEFAULT_EXIT_CURVE, DEFAULT_DURATION, alignment);
27 |     }
28 | 
29 |     /**
30 |      * Instantiates a rectangular clip entrance animation from the center of the scene.
31 |      */
32 |     public RectangleClipOut() {
33 |         this(DEFAULT_ALIGNMENT);
34 |     }
35 | 
36 |     @Override
37 |     protected double getInitialWidth() {
38 |         return super.getArea().getWidth();
39 |     }
40 | 
41 |     @Override
42 |     protected double getInitialHeight() {
43 |         return super.getArea().getHeight();
44 |     }
45 | 
46 |     @Override
47 |     protected double getFinalWidth() {
48 |         return 0;
49 |     }
50 | 
51 |     @Override
52 |     protected double getFinalHeight() {
53 |         return 0;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/clip/RectangleClipIn.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.animations.clip;
 2 | 
 3 | import eu.iamgio.animated.common.Curve;
 4 | import javafx.geometry.Pos;
 5 | import javafx.util.Duration;
 6 | 
 7 | /**
 8 |  * Entrance animation that features a rectangular clip of increasing size of the target node.
 9 |  */
10 | public class RectangleClipIn extends RectangleClip {
11 | 
12 |     /**
13 |      * @param curve animation curve
14 |      * @param duration animation duration
15 |      * @param alignment position of the rectangle, relative to the scene
16 |      */
17 |     public RectangleClipIn(Curve curve, Duration duration, Pos alignment) {
18 |         super(curve, duration, alignment);
19 |     }
20 | 
21 |     /**
22 |      * Instantiates a rectangular clip entrance animation.
23 |      * @param alignment position of the rectangle, relative to the scene
24 |      */
25 |     public RectangleClipIn(Pos alignment) {
26 |         this(DEFAULT_ENTRANCE_CURVE, DEFAULT_DURATION, alignment);
27 |     }
28 | 
29 |     /**
30 |      * Instantiates a rectangular clip entrance animation from the center of the scene.
31 |      */
32 |     public RectangleClipIn() {
33 |         this(DEFAULT_ALIGNMENT);
34 |     }
35 | 
36 |     @Override
37 |     protected double getInitialWidth() {
38 |         return 0;
39 |     }
40 | 
41 |     @Override
42 |     protected double getInitialHeight() {
43 |         return 0;
44 |     }
45 | 
46 |     @Override
47 |     protected double getFinalWidth() {
48 |         return super.getArea().getWidth();
49 |     }
50 | 
51 |     @Override
52 |     protected double getFinalHeight() {
53 |         return super.getArea().getHeight();
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/fxml/FxmlAnimatedSwitcherTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest.fxml;
 2 | 
 3 | import eu.iamgio.animated.transition.AnimatedLabel;
 4 | import eu.iamgio.animated.transition.AnimatedSwitcher;
 5 | import eu.iamgio.animatedtest.TestUtil;
 6 | import javafx.application.Application;
 7 | import javafx.fxml.FXMLLoader;
 8 | import javafx.scene.Parent;
 9 | import javafx.scene.Scene;
10 | import javafx.scene.control.Button;
11 | import javafx.scene.shape.Rectangle;
12 | import javafx.stage.Stage;
13 | 
14 | import java.util.Objects;
15 | 
16 | import static eu.iamgio.animatedtest.TestUtil.SCENE_HEIGHT;
17 | import static eu.iamgio.animatedtest.TestUtil.SCENE_WIDTH;
18 | 
19 | public class FxmlAnimatedSwitcherTest extends Application {
20 | 
21 |     private int times = 0;
22 | 
23 |     public void start(Stage primaryStage) throws Exception {
24 |         Parent root = FXMLLoader.load(Objects.requireNonNull(getClass().getResource("/fxml/AnimatedSwitcher.fxml")));
25 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
26 | 
27 |         primaryStage.setTitle("FXML");
28 |         primaryStage.setScene(scene);
29 |         primaryStage.show();
30 | 
31 |         Button switchButton = (Button) Objects.requireNonNull(root.lookup("#button"));
32 |         AnimatedSwitcher switcher = (AnimatedSwitcher) Objects.requireNonNull(root.lookup("#animated-switcher"));
33 | 
34 |         AnimatedLabel label = (AnimatedLabel) Objects.requireNonNull(root.lookup("#animated-label"));
35 | 
36 |         switchButton.setOnAction(e -> {
37 |             final Rectangle rectangle = new Rectangle(50, 50);
38 |             rectangle.setFill(TestUtil.randomColor());
39 |             switcher.setChild(rectangle);
40 |             label.setText(String.valueOf(++times));
41 |         });
42 |     }
43 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/AnimationSettings.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding;
 2 | 
 3 | import eu.iamgio.animated.common.Curve;
 4 | import javafx.util.Duration;
 5 | 
 6 | /**
 7 |  * Data that affects the way an animation is played.
 8 |  */
 9 | public class AnimationSettings {
10 | 
11 |     private Duration duration = Duration.seconds(1);
12 |     private Curve curve = Curve.LINEAR;
13 | 
14 |     /**
15 |      * @return duration of the animation
16 |      */
17 |     public Duration getDuration() {
18 |         return duration;
19 |     }
20 | 
21 |     /**
22 |      * Note: using the fluent setter {@link #withDuration(Duration)} is suggested.
23 |      *       This method is kept only for FXML compatibility.
24 |      * @param duration duration of the animation to set
25 |      */
26 |     public void setDuration(Duration duration) {
27 |         this.duration = duration;
28 |     }
29 | 
30 |     /**
31 |      * @param duration duration of the animation to set
32 |      * @return this for concatenation
33 |      */
34 |     public AnimationSettings withDuration(Duration duration) {
35 |         this.duration = duration;
36 |         return this;
37 |     }
38 | 
39 |     /**
40 |      * @return curve of the animation
41 |      */
42 |     public Curve getCurve() {
43 |         return curve;
44 |     }
45 | 
46 |     /**
47 |      * Note: using the fluent setter {@link #withCurve(Curve)} is suggested.
48 |      *       This method is kept only for FXML compatibility.
49 |      * @param curve curve of the animation to set
50 |      *
51 |      */
52 |     public void setCurve(Curve curve) {
53 |         this.curve = curve;
54 |     }
55 | 
56 |     /**
57 |      * @param curve curve of the animation to set
58 |      * @return this for concatenation
59 |      */
60 |     public AnimationSettings withCurve(Curve curve) {
61 |         this.curve = curve;
62 |         return this;
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedCurrencyTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import eu.iamgio.animated.binding.value.AnimatedValueLabel;
 4 | import eu.iamgio.animated.common.Curve;
 5 | import javafx.application.Application;
 6 | import javafx.scene.Scene;
 7 | import javafx.scene.control.Button;
 8 | import javafx.scene.layout.Pane;
 9 | import javafx.stage.Stage;
10 | import javafx.util.Duration;
11 | 
12 | import java.text.NumberFormat;
13 | import java.util.Locale;
14 | 
15 | import static eu.iamgio.animatedtest.TestUtil.SCENE_HEIGHT;
16 | import static eu.iamgio.animatedtest.TestUtil.SCENE_WIDTH;
17 | 
18 | // This demo animates the content (money) of a label.
19 | 
20 | public class AnimatedCurrencyTest extends Application {
21 | 
22 |     private static final int AMOUNT_TO_ADD = 500;
23 | 
24 |     @Override
25 |     public void start(Stage primaryStage) {
26 |         // Set up scene
27 |         Pane root = new Pane();
28 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
29 | 
30 |         // Currency formatter
31 |         NumberFormat formatter = NumberFormat.getCurrencyInstance(Locale.US);
32 | 
33 |         // Set up label
34 |         AnimatedValueLabel<Double> label = new AnimatedValueLabel<>(0.0)
35 |                 .custom(settings -> settings.withCurve(Curve.EASE_IN_OUT_EXPO).withDuration(Duration.millis(1500)));
36 | 
37 |         label.setTextMapper(formatter::format);
38 |         label.relocate(100, 100);
39 |         label.setStyle("-fx-font-size: 20");
40 | 
41 |         // Set up the button
42 |         Button button = new Button("Add");
43 |         button.relocate(100, 160);
44 | 
45 |         button.setOnAction(e -> label.setValue(label.getValue() + AMOUNT_TO_ADD));
46 | 
47 |         root.getChildren().addAll(label, button);
48 | 
49 |         // Show
50 |         primaryStage.setTitle("AnimatedCurrency");
51 |         primaryStage.setScene(scene);
52 |         primaryStage.show();
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/container/AnimatedContainer.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.container;
 2 | 
 3 | import eu.iamgio.animated.common.Curve;
 4 | import eu.iamgio.animated.common.Pausable;
 5 | import eu.iamgio.animated.transition.EntranceAndExitAnimationCompatible;
 6 | import javafx.beans.property.ObjectProperty;
 7 | import javafx.collections.ObservableList;
 8 | import javafx.scene.Node;
 9 | 
10 | /**
11 |  * Interface implemented by containers whose children should be animated.
12 |  * @see AnimatedVBox
13 |  * @see AnimatedHBox
14 |  * @author Giorgio Garofalo
15 |  */
16 | public interface AnimatedContainer extends Pausable, EntranceAndExitAnimationCompatible {
17 | 
18 |     /**
19 |      * @return target container's children
20 |      */
21 |     ObservableList<Node> getChildren();
22 | 
23 |     /**
24 |      * @return spacing between children
25 |      */
26 |     double getSpacing();
27 | 
28 |     /**
29 |      * @return whether the children are displayed horizontally (HBox) or vertically (VBox)
30 |      */
31 |     Direction getDirection();
32 | 
33 |     /**
34 |      * @return curve used by the animation while relocating other nodes after a change
35 |      */
36 |     ObjectProperty<Curve> relocationCurveProperty();
37 | 
38 |     /**
39 |      * @return curve used by the animation while relocating other nodes after a change. Defaults to {@link Curve#EASE_IN_OUT}
40 |      */
41 |     default Curve getRelocationCurve() {
42 |         return relocationCurveProperty().get();
43 |     }
44 | 
45 |     /**
46 |      * Changes the curve used by the animation while relocating other nodes after a change.
47 |      * @param curve relocation curve to set
48 |      */
49 |     default void setRelocationCurve(Curve curve) {
50 |         relocationCurveProperty().set(curve);
51 |     }
52 | 
53 |     /**
54 |      * Registers the handler.
55 |      */
56 |     default void register() {
57 |         AnimatedContainerHandler.register(this);
58 |     }
59 | 
60 |     enum Direction {
61 |         HORIZONTAL, VERTICAL
62 |     }
63 | }


--------------------------------------------------------------------------------
/src/main/kotlin/eu/iamgio/animated/AnimatedExtensions.kt:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated
 2 | 
 3 | import animatefx.animation.AnimationFX
 4 | import eu.iamgio.animated.binding.property.animation.AnimationProperty
 5 | import eu.iamgio.animated.transition.Animation
 6 | import eu.iamgio.animated.transition.AnimationPair
 7 | import javafx.beans.property.DoubleProperty
 8 | import javafx.beans.property.ObjectProperty
 9 | import javafx.util.Duration
10 | 
11 | // Utility extension functions for Kotlin
12 | 
13 | /**
14 |  * Wraps a JavaFX double property into an [AnimationProperty].
15 |  */
16 | fun DoubleProperty.animated(): AnimationProperty<Double> = AnimationProperty.of(this)
17 | 
18 | /**
19 |  * Wraps a JavaFX object property into an [AnimationProperty].
20 |  */
21 | fun <T> ObjectProperty<T>.animated(): AnimationProperty<T> = AnimationProperty.of(this)
22 | 
23 | /**
24 |  * Wraps an AnimateFX animation into an Animated animation that supports customization.
25 |  */
26 | fun AnimationFX.wrapped(): Animation = Animation(this)
27 | 
28 | /**
29 |  * Wraps an AnimateFX animation into an Animated animation that supports customization.
30 |  * @param speed speed multiplier
31 |  * @param delay delay before the animation is played
32 |  * @param cycleCount times the animation should be played
33 |  */
34 | fun AnimationFX.options(speed: Double = 1.0, delay: Duration? = null, cycleCount: Int = 1): Animation =
35 |         this.wrapped().setSpeed(speed).setDelay(delay).setCycleCount(cycleCount)
36 | 
37 | /**
38 |  * Creates an [AnimationPair] from [this] to [animationOut].
39 |  */
40 | infix fun Animation.outTo(animationOut: Animation) = AnimationPair(this, animationOut)
41 | 
42 | /**
43 |  * Creates an [AnimationPair] from [this] to [animationOut].
44 |  */
45 | infix fun Animation.outTo(animationOut: AnimationFX) = AnimationPair(this, animationOut.wrapped())
46 | 
47 | /**
48 |  * Creates an [AnimationPair] from [this] to [animationOut].
49 |  */
50 | infix fun AnimationFX.outTo(animationOut: Animation) = AnimationPair(this.wrapped(), animationOut)
51 | 
52 | /**
53 |  * Creates an [AnimationPair] from [this] to [animationOut].
54 |  */
55 | infix fun AnimationFX.outTo(animationOut: AnimationFX) = AnimationPair(this, animationOut)


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/value/AnimatedValue.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.value;
 2 | 
 3 | import eu.iamgio.animated.binding.AnimationSettings;
 4 | import eu.iamgio.animated.binding.CustomizableAnimation;
 5 | import eu.iamgio.animated.binding.event.ListenableAnimation;
 6 | import eu.iamgio.animated.common.Pausable;
 7 | import javafx.beans.property.Property;
 8 | import javafx.beans.property.ReadOnlyProperty;
 9 | 
10 | /**
11 |  * An object that wraps a value, and exposes a parallel value that is updated with an animated transition
12 |  * whenever the wrapped value is updated via {@link #setValue(Object)}.
13 |  * {@link #animationValueProperty()} can be bound to any other external property to provide
14 |  * an animated effect without affecting the wrapped value.
15 |  */
16 | public interface AnimatedValue<T> extends CustomizableAnimation<AnimatedValue<T>>, ListenableAnimation, Pausable {
17 | 
18 |     /**
19 |      * @return the wrapped value
20 |      */
21 |     Property<T> valueProperty();
22 | 
23 |     /**
24 |      * @return the wrapped value. Note that it only depends on the user-supplied value via {@link #setValue(Object)},
25 |      *         and not on the current animation frame, which is given by {@link #getAnimationValue()}
26 |      */
27 |     T getValue();
28 | 
29 |     /**
30 |      * Sets a new wrapped value and starts the transition.
31 |      * @param value new wrapped value
32 |      */
33 |     void setValue(T value);
34 | 
35 |     /**
36 |      * @return the current value of the wrapped property. While {@link #valueProperty()} only wraps the last user-supplied value,
37 |      *         this method takes into account the latest value produced by the animation, if it is playing.
38 |      */
39 |     ReadOnlyProperty<T> animationValueProperty();
40 | 
41 |     /**
42 |      * @return the current value of the wrapped property. While {@link #getValue()} only returns the last user-supplied value,
43 |      *         this method takes into account the latest value produced by the animation, if it is playing.
44 |      */
45 |     T getAnimationValue();
46 | 
47 |     /**
48 |      * @return the current animation settings
49 |      */
50 |     AnimationSettings getSettings();
51 | }
52 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedSwitcherTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import eu.iamgio.animated.transition.AnimatedSwitcher;
 4 | import eu.iamgio.animated.transition.AnimationPair;
 5 | import javafx.animation.KeyFrame;
 6 | import javafx.animation.Timeline;
 7 | import javafx.application.Application;
 8 | import javafx.scene.Scene;
 9 | import javafx.scene.layout.Pane;
10 | import javafx.stage.Stage;
11 | import javafx.util.Duration;
12 | 
13 | import static eu.iamgio.animatedtest.TestUtil.*;
14 | 
15 | // This demo dynamically generates random rectangles and plays a transition upon attaching it to the screen.
16 | // A zoom-in is played on the 'new' rectangle, while the 'old' one disappears with a zoom-out animation.
17 | 
18 | public class AnimatedSwitcherTest extends Application {
19 | 
20 |     public void start(Stage primaryStage) {
21 |         // Setup scene
22 |         Pane root = new Pane();
23 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
24 | 
25 |         // Setup switcher and attach it to the root
26 |         AnimatedSwitcher switcher = new AnimatedSwitcher(AnimationPair.zoom().setSpeed(2, .8));
27 |         root.getChildren().add(switcher);
28 | 
29 |         // Setup timeline
30 |         Timeline timeline = new Timeline();
31 |         startTimeline(scene, timeline, switcher);
32 | 
33 |         // Show
34 |         primaryStage.setTitle("AnimatedSwitcher");
35 |         primaryStage.setScene(scene);
36 |         primaryStage.show();
37 |     }
38 | 
39 |     // This is called every second
40 |     private void startTimeline(Scene scene, Timeline timeline, AnimatedSwitcher switcher) {
41 |         // Generate a random rectangle
42 |         Pane pane = new Pane(randomRectangle());
43 |         // Center it
44 |         center(pane, scene);
45 |         // Update the child (plays the transition)
46 |         switcher.setChild(pane);
47 |         // Calls the same function after a 1s delay
48 |         timeline.getKeyFrames().add(new KeyFrame(Duration.seconds(1), e -> startTimeline(scene, timeline, switcher)));
49 |         timeline.playFromStart();
50 |     }
51 | 
52 |     public static void main(String[] args) {
53 |         launch(args);
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/TestUtil.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import javafx.scene.Scene;
 4 | import javafx.scene.layout.Region;
 5 | import javafx.scene.paint.Color;
 6 | import javafx.scene.shape.Rectangle;
 7 | 
 8 | import java.util.Random;
 9 | 
10 | /**
11 |  * @author Giorgio Garofalo
12 |  */
13 | public class TestUtil {
14 | 
15 |     public static final double SCENE_WIDTH = 650;
16 |     public static final double SCENE_HEIGHT = 500;
17 | 
18 |     /**
19 |      * Centers a node (rectangles wrapped in Panes)
20 |      * @param parent parent of the rectangle
21 |      * @param scene scene
22 |      */
23 |     public static void center(Region parent, Scene scene) {
24 |         parent.layoutXProperty().bind(scene.widthProperty().divide(2).subtract(parent.widthProperty().divide(2)));
25 |         parent.layoutYProperty().bind(scene.heightProperty().divide(2).subtract(parent.heightProperty().divide(2)));
26 |     }
27 | 
28 |     /**
29 |      * @return randomly generated rectangle
30 |      */
31 |     public static Rectangle randomRectangle() {
32 |         Random random = new Random();
33 |         // Width and height go from 100 to 300
34 |         double width = random.nextInt(200) + 100;
35 |         double height = random.nextInt(200) + 100;
36 |         // R, G and B values in 0.5-1 range
37 |         Color color = randomColor(random);
38 |         return new Rectangle(width, height, color);
39 |     }
40 | 
41 |     /**
42 |      * @param random {@link Random} object
43 |      * @return randomly generated color in 0.5-1 range
44 |      */
45 |     public static Color randomColor(Random random) {
46 |         return new Color((random.nextInt(5) + 5) / 10F, (random.nextInt(5) + 5) / 10F, (random.nextInt(5) + 5) / 10F, 1);
47 |     }
48 | 
49 |     /**
50 |      * @return randomly generated color in 0.5-1 range
51 |      */
52 |     public static Color randomColor() {
53 |         return randomColor(new Random());
54 |     }
55 | 
56 |     /**
57 |      * @param color base color
58 |      * @return complementary (opposite) color
59 |      */
60 |     public static Color complementaryColor(Color color) {
61 |         return Color.color(1 - color.getRed(), 1 - color.getGreen(), 1 - color.getBlue());
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedLayoutTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import eu.iamgio.animated.binding.Animated;
 4 | import eu.iamgio.animated.binding.AnimationSettings;
 5 | import eu.iamgio.animated.binding.presets.AnimatedLayout;
 6 | import javafx.application.Application;
 7 | import javafx.geometry.Pos;
 8 | import javafx.scene.Scene;
 9 | import javafx.scene.control.Label;
10 | import javafx.scene.layout.Pane;
11 | import javafx.stage.Stage;
12 | import javafx.util.Duration;
13 | 
14 | import static eu.iamgio.animatedtest.TestUtil.SCENE_HEIGHT;
15 | import static eu.iamgio.animatedtest.TestUtil.SCENE_WIDTH;
16 | 
17 | // This demo anchors a label to each corner and animates their position changes.
18 | 
19 | public class AnimatedLayoutTest extends Application {
20 | 
21 |     public void start(Stage primaryStage) {
22 |         // Setup scene
23 |         Pane root = new Pane();
24 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
25 |         scene.getStylesheets().add("/themes/dark.css");
26 |         root.getStyleClass().add("layout-test");
27 | 
28 |         // Bind root size to scene size
29 |         root.prefWidthProperty().bind(scene.widthProperty());
30 |         root.prefHeightProperty().bind(scene.heightProperty());
31 | 
32 |         // Initialize a label for each corner
33 |         Label topLeft = new Label("Top left");
34 |         Label topRight = new Label("Top right");
35 |         Label bottomLeft = new Label("Bottom left");
36 |         Label bottomRight = new Label("Bottom right");
37 | 
38 |         // Initialize animation settings
39 |         AnimationSettings settings = new AnimationSettings()
40 |                 .withDuration(new Duration(200));
41 | 
42 |         // Add nodes
43 |         root.getChildren().addAll(
44 |                 new Animated(topLeft, new AnimatedLayout(topLeft, root, Pos.TOP_LEFT)).withSettings(settings),
45 |                 new Animated(topRight, new AnimatedLayout(topRight, root, Pos.TOP_RIGHT)).withSettings(settings),
46 |                 new Animated(bottomLeft, new AnimatedLayout(bottomLeft, root, Pos.BOTTOM_LEFT)).withSettings(settings),
47 |                 new Animated(bottomRight, new AnimatedLayout(bottomRight, root, Pos.BOTTOM_RIGHT)).withSettings(settings)
48 |         );
49 | 
50 |         // Show
51 |         primaryStage.setTitle("AnimatedLayout");
52 |         primaryStage.setScene(scene);
53 |         primaryStage.show();
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/clip/CircleClip.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.animations.clip;
 2 | 
 3 | import eu.iamgio.animated.common.Curve;
 4 | import javafx.animation.KeyFrame;
 5 | import javafx.animation.KeyValue;
 6 | import javafx.animation.Timeline;
 7 | import javafx.geometry.Bounds;
 8 | import javafx.geometry.Pos;
 9 | import javafx.scene.shape.Circle;
10 | import javafx.util.Duration;
11 | 
12 | /**
13 |  * Animation that features a circular clip with a variable radius.
14 |  *
15 |  * @see CircleClipIn
16 |  * @see CircleClipOut
17 |  */
18 | abstract class CircleClip extends ClipAnimation<Circle> {
19 | 
20 |     // The width/height of the scene is multiplied by this value
21 |     // to obtain the maximum radius of the circle that allows it
22 |     // to cover the scene completely.
23 |     private static final double MAX_RADIUS_MULTIPLIER = 1.5;
24 | 
25 |     /**
26 |      * @param curve animation curve
27 |      * @param duration animation duration
28 |      * @param alignment position of the circle, relative to the scene
29 |      */
30 |     CircleClip(Curve curve, Duration duration, Pos alignment) {
31 |         super(curve, duration, alignment);
32 |     }
33 | 
34 |     /**
35 |      * @return radius of the circle at the beginning of the animation
36 |      */
37 |     protected abstract double getInitialRadius();
38 | 
39 |     /**
40 |      * @return radius of the circle at the end of the animation
41 |      */
42 |     protected abstract double getFinalRadius();
43 | 
44 |     /**
45 |      * @return the optimal radius that allows the circle, in any position within the available area, to cover it completely
46 |      */
47 |     protected double calcMaxRadius() {
48 |         final Bounds area = this.getArea();
49 |         return Math.max(area.getWidth(), area.getHeight()) * MAX_RADIUS_MULTIPLIER;
50 |     }
51 | 
52 |     @Override
53 |     protected Circle createClip() {
54 |         return new Circle(this.getInitialRadius());
55 |     }
56 | 
57 |     @Override
58 |     protected Timeline createTimeline(Circle clip) {
59 |         return new Timeline(
60 |                 new KeyFrame(
61 |                         Duration.ZERO,
62 |                         new KeyValue(clip.radiusProperty(), getInitialRadius())
63 |                 ),
64 |                 new KeyFrame(
65 |                         super.getDuration(),
66 |                         new KeyValue(clip.radiusProperty(), getFinalRadius(), super.getCurve().toInterpolator())
67 |                 )
68 |         );
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/animation/OnDemandAnimationPropertyGroup.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.property.animation;
 2 | 
 3 | import eu.iamgio.animated.binding.Animated;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.beans.property.Property;
 6 | import javafx.scene.Node;
 7 | 
 8 | import java.util.List;
 9 | import java.util.function.Function;
10 | import java.util.stream.Stream;
11 | 
12 | /**
13 |  * A group of multiple {@link OnDemandAnimationProperty}.
14 |  * @param <N> type of the JavaFX node to extract the properties from
15 |  * @param <T> type of the wrapped values
16 |  */
17 | public class OnDemandAnimationPropertyGroup<N extends Node, T> extends OnDemandAnimationProperty<N, T> {
18 | 
19 |     private final List<Function<N, PropertyWrapper<T>>> propertyRetrievers;
20 | 
21 |     /**
22 |      * Instantiates a new group of on-demand animation property.
23 |      * @param propertyRetrievers list of function that generate wrapped JavaFX properties when applied to a node.
24 |      */
25 |     public OnDemandAnimationPropertyGroup(List<Function<N, PropertyWrapper<T>>> propertyRetrievers) {
26 |         super(null);
27 |         this.propertyRetrievers = propertyRetrievers;
28 |     }
29 | 
30 |     private Stream<OnDemandAnimationProperty<N, T>> retrieveOnDemandProperties() {
31 |         return this.propertyRetrievers.stream()
32 |                 .map(OnDemandAnimationProperty::new)
33 |                 .peek(property -> property.targetNodeProperty().bind(targetNodeProperty()))
34 |                 .peek(super::copyAttributesTo);
35 |     }
36 | 
37 |     /**
38 |      * {@inheritDoc}
39 |      * All the sub-properties are registered.
40 |      */
41 |     @Override
42 |     public void register(Node target) {
43 |         this.retrieveOnDemandProperties().forEach(property -> property.register(target));
44 |     }
45 | 
46 |     /**
47 |      * {@inheritDoc}
48 |      * All the sub-properties are applied to the target animated node.
49 |      */
50 |     @Override
51 |     public void attachTo(Animated animated) {
52 |         this.retrieveOnDemandProperties().forEach(property -> property.attachTo(animated));
53 |     }
54 | 
55 |     /**
56 |      * @throws UnsupportedOperationException an on-demand property group cannot be bound
57 |      */
58 |     @Override
59 |     public <V> AnimationProperty<T> addBinding(Property<V> targetProperty, Function<T, V> mapper) {
60 |         throw new UnsupportedOperationException("An on-demand property group cannot be bound.");
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedDropShadow.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.presets;
 2 | 
 3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationProperty;
 4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
 5 | import javafx.scene.Node;
 6 | import javafx.scene.effect.DropShadow;
 7 | 
 8 | /**
 9 |  * Container of different drop shadow properties.
10 |  * If the target node does not have an {@link javafx.scene.effect.Effect}
11 |  * or if its effect is not a {@link DropShadow} at initialization time,
12 |  * a new {@link DropShadow} with default color and radius will be set as its new effect.
13 |  */
14 | public class AnimatedDropShadow {
15 | 
16 |     /**
17 |      * Property that animates its child's {@link DropShadow} color.
18 |      * If the target node does not have an {@link javafx.scene.effect.Effect}
19 |      * or if its effect is not a {@link DropShadow} at initialization time,
20 |      * a new {@link DropShadow} with default color and radius will be set as its new effect.
21 |      */
22 |     public static class Color extends OnDemandAnimationProperty<Node, javafx.scene.paint.Color> {
23 | 
24 |         public Color() {
25 |             super(node -> PropertyWrapper.of(getEffectOrCreate(node).colorProperty()));
26 |         }
27 | 
28 |         public Color(Node child) {
29 |             this();
30 |             targetNodeProperty().set(child);
31 |         }
32 |     }
33 | 
34 |     /**
35 |      * Property that animates its child's {@link DropShadow} radius.
36 |      * If the target node does not have an {@link javafx.scene.effect.Effect}
37 |      * or if its effect is not a {@link DropShadow} at initialization time,
38 |      * a new {@link DropShadow} with default color and radius will be set as its new effect.
39 |      */
40 |     public static class Radius extends OnDemandAnimationProperty<Node, Double> {
41 | 
42 |         public Radius() {
43 |             super(node -> PropertyWrapper.of(getEffectOrCreate(node).radiusProperty()));
44 |         }
45 | 
46 |         public Radius(Node child) {
47 |             this();
48 |             targetNodeProperty().set(child);
49 |         }
50 |     }
51 | 
52 |     private static DropShadow getEffectOrCreate(Node node) {
53 |         if (node.getEffect() == null || !(node.getEffect() instanceof DropShadow)) {
54 |             final DropShadow shadow = new DropShadow();
55 |             node.setEffect(shadow);
56 |             return shadow;
57 |         } else {
58 |             return (DropShadow) node.getEffect();
59 |         }
60 |     }
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/misc/AnimatedSlider.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.misc;
 2 | 
 3 | import eu.iamgio.animated.binding.AnimationSettings;
 4 | import eu.iamgio.animated.binding.CustomizableAnimation;
 5 | import eu.iamgio.animated.binding.event.AnimationEvent;
 6 | import eu.iamgio.animated.binding.event.ListenableAnimation;
 7 | import eu.iamgio.animated.binding.property.animation.AnimationProperty;
 8 | import javafx.beans.property.ObjectProperty;
 9 | import javafx.event.EventHandler;
10 | import javafx.scene.control.Slider;
11 | 
12 | import java.util.function.Function;
13 | 
14 | /**
15 |  * A {@link Slider} implementation that animates its value when an external change occurs.
16 |  * The animation does not play when the value is changed by mouse-dragging.
17 |  *
18 |  * @see Slider
19 |  */
20 | public final class AnimatedSlider extends Slider implements CustomizableAnimation<AnimatedSlider>, ListenableAnimation {
21 | 
22 |     private final AnimationProperty<Double> property = AnimationProperty.of(valueProperty());
23 | 
24 |     /**
25 |      * Instantiates an {@link AnimatedSlider}.
26 |      */
27 |     public AnimatedSlider() {
28 |         super();
29 |         this.init();
30 |     }
31 | 
32 |     /**
33 |      * Instantiates an {@link AnimatedSlider}.
34 |      * @param min minimum value
35 |      * @param max maximum value
36 |      * @param value initial value
37 |      */
38 |     public AnimatedSlider(double min, double max, double value) {
39 |         super(min, max, value);
40 |         this.init();
41 |     }
42 | 
43 |     private void init() {
44 |         property.register(this);
45 | 
46 |         // Animation is paused when mouse-dragging
47 |         setOnMouseDragged(e -> property.pause());
48 |         setOnMouseReleased(e -> property.resume());
49 |     }
50 | 
51 |     /**
52 |      * {@inheritDoc}
53 |      */
54 |     @Override
55 |     public void setSettings(AnimationSettings settings) {
56 |         property.setSettings(settings);
57 |     }
58 | 
59 |     /**
60 |      * {@inheritDoc}
61 |      */
62 |     @Override
63 |     public AnimatedSlider custom(Function<AnimationSettings, AnimationSettings> settings) {
64 |         property.custom(settings);
65 |         return this;
66 |     }
67 | 
68 |     /**
69 |      * {@inheritDoc}
70 |      */
71 |     @Override
72 |     public ObjectProperty<EventHandler<AnimationEvent>> onAnimationStartedProperty() {
73 |         return this.property.onAnimationStartedProperty();
74 |     }
75 | 
76 |     /**
77 |      * {@inheritDoc}
78 |      */
79 |     @Override
80 |     public ObjectProperty<EventHandler<AnimationEvent>> onAnimationEndedProperty() {
81 |         return this.property.onAnimationEndedProperty();
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedRootSwitchTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import eu.iamgio.animated.transition.AnimatedSwitcher;
 4 | import eu.iamgio.animated.transition.AnimationPair;
 5 | import javafx.animation.KeyFrame;
 6 | import javafx.animation.Timeline;
 7 | import javafx.application.Application;
 8 | import javafx.geometry.Insets;
 9 | import javafx.geometry.Pos;
10 | import javafx.scene.Scene;
11 | import javafx.scene.control.Label;
12 | import javafx.scene.layout.Background;
13 | import javafx.scene.layout.BackgroundFill;
14 | import javafx.scene.layout.CornerRadii;
15 | import javafx.scene.layout.StackPane;
16 | import javafx.scene.paint.Color;
17 | import javafx.stage.Stage;
18 | import javafx.util.Duration;
19 | 
20 | import static eu.iamgio.animatedtest.TestUtil.*;
21 | 
22 | // This demo animates a root switch within the same scene.
23 | 
24 | public class AnimatedRootSwitchTest extends Application {
25 | 
26 |     private int index = 0;
27 | 
28 |     public void start(Stage primaryStage) {
29 |         // Setup scene
30 |         AnimatedSwitcher switcher = new AnimatedSwitcher(AnimationPair.fadeDown());
31 |         Scene scene = new Scene(switcher, SCENE_WIDTH, SCENE_HEIGHT);
32 | 
33 |         // Setup timeline
34 |         Timeline timeline = new Timeline();
35 |         startTimeline(scene, timeline, switcher);
36 | 
37 |         // Show
38 |         primaryStage.setTitle("AnimatedRootSwitch");
39 |         primaryStage.setScene(scene);
40 |         primaryStage.show();
41 |     }
42 | 
43 |     // This is called every 2 seconds
44 |     private void startTimeline(Scene scene, Timeline timeline, AnimatedSwitcher switcher) {
45 |         // Generate a new root
46 |         StackPane root = new StackPane();
47 |         root.prefWidthProperty().bind(scene.widthProperty());
48 |         root.prefHeightProperty().bind(scene.heightProperty());
49 | 
50 |         Color bgColor = randomColor();
51 |         root.setBackground(new Background(new BackgroundFill(bgColor, CornerRadii.EMPTY, Insets.EMPTY)));
52 | 
53 |         Label text = new Label("Root no." + index);
54 |         text.setTextFill(complementaryColor(bgColor));
55 |         text.setStyle("-fx-font-size: 18; -fx-font-weight: bold;");
56 |         StackPane.setAlignment(text, Pos.CENTER);
57 |         root.getChildren().add(text);
58 | 
59 |         // Update the child (plays the transition if this is not the first iteration)
60 |         if(index++ > 0) {
61 |             switcher.setChild(root);
62 |         } else {
63 |             switcher.of(root);
64 |         }
65 | 
66 |         // Calls the same function after a 2s delay
67 |         timeline.getKeyFrames().add(new KeyFrame(Duration.seconds(2), e -> startTimeline(scene, timeline, switcher)));
68 |         timeline.playFromStart();
69 |     }
70 | 
71 |     public static void main(String[] args) {
72 |         launch(args);
73 |     }
74 | }


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedThemeTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import eu.iamgio.animated.transition.AnimatedThemeSwitcher;
 4 | import eu.iamgio.animated.transition.animations.clip.CircleClipOut;
 5 | import javafx.animation.KeyFrame;
 6 | import javafx.animation.Timeline;
 7 | import javafx.application.Application;
 8 | import javafx.scene.Scene;
 9 | import javafx.scene.control.Label;
10 | import javafx.scene.layout.Pane;
11 | import javafx.scene.layout.Region;
12 | import javafx.scene.layout.VBox;
13 | import javafx.stage.Stage;
14 | import javafx.util.Duration;
15 | 
16 | import static eu.iamgio.animatedtest.TestUtil.*;
17 | 
18 | // This demo animates a theme switch.
19 | 
20 | public class AnimatedThemeTest extends Application {
21 | 
22 |     // Whether the current theme is 'light' (if false = 'dark')
23 |     private boolean isLight = true;
24 | 
25 |     public void start(Stage primaryStage) {
26 |         // Setup scene
27 |         Pane root = new Pane();
28 |         root.getStyleClass().add("root");
29 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
30 |         scene.getStylesheets().add("/themes/global.css");
31 | 
32 |         VBox box = new VBox();
33 |         box.getStyleClass().add("central-box");
34 |         center(box, scene);
35 |         root.getChildren().add(box);
36 | 
37 |         Region icon = new Region();
38 |         icon.getStyleClass().add("icon");
39 |         box.getChildren().add(icon);
40 | 
41 |         Label title = new Label("Theme switch!");
42 |         title.getStyleClass().add("title");
43 |         box.getChildren().add(title);
44 | 
45 |         Label subtitle = new Label("Animated lets you create cool transitions.\nTry it out!");
46 |         subtitle.getStyleClass().add("subtitle");
47 |         box.getChildren().add(subtitle);
48 | 
49 |         // Setup theme
50 |         scene.getStylesheets().add("/themes/light.css");
51 |         AnimatedThemeSwitcher themeSwitcher = new AnimatedThemeSwitcher(scene, new CircleClipOut());
52 |         themeSwitcher.init();
53 | 
54 |         // Setup timeline
55 |         Timeline timeline = new Timeline();
56 |         startTimeline(scene, timeline);
57 | 
58 |         // Show
59 |         primaryStage.setTitle("AnimatedThemeSwitcher");
60 |         primaryStage.setScene(scene);
61 |         primaryStage.show();
62 |     }
63 | 
64 |     // This is called every two seconds
65 |     private void startTimeline(Scene scene, Timeline timeline) {
66 |         timeline.getKeyFrames().add(new KeyFrame(Duration.seconds(2), e -> {
67 |             isLight ^= true;
68 |             scene.getStylesheets().set(1, "/themes/" + (isLight ? "light" : "dark") + ".css");
69 |             startTimeline(scene, timeline);
70 |         }));
71 |         timeline.playFromStart();
72 |     }
73 | 
74 |     public static void main(String[] args) {
75 |         launch(args);
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/clip/RectangleClip.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.transition.animations.clip;
 2 | 
 3 | import eu.iamgio.animated.common.Curve;
 4 | import eu.iamgio.animated.util.PositionUtils;
 5 | import javafx.animation.Interpolator;
 6 | import javafx.animation.KeyFrame;
 7 | import javafx.animation.KeyValue;
 8 | import javafx.animation.Timeline;
 9 | import javafx.geometry.Pos;
10 | import javafx.scene.shape.Rectangle;
11 | import javafx.util.Duration;
12 | 
13 | /**
14 |  * Animation that features a rectangular clip with of variable size.
15 |  *
16 |  * @see RectangleClipIn
17 |  * @see RectangleClipOut
18 |  */
19 | abstract class RectangleClip extends ClipAnimation<Rectangle> {
20 | 
21 |     /**
22 |      * @param curve animation curve
23 |      * @param duration animation duration
24 |      * @param alignment position of the rectangle, relative to the scene
25 |      */
26 |     RectangleClip(Curve curve, Duration duration, Pos alignment) {
27 |         super(curve, duration, alignment);
28 |     }
29 | 
30 |     /**
31 |      * @return width of the rectangle at the beginning of the animation
32 |      */
33 |     protected abstract double getInitialWidth();
34 | 
35 |     /**
36 |      * @return height of the rectangle at the beginning of the animation
37 |      */
38 |     protected abstract double getInitialHeight();
39 | 
40 |     /**
41 |      * @return width of the rectangle at the end of the animation
42 |      */
43 |     protected abstract double getFinalWidth();
44 | 
45 |     /**
46 |      * @return height of the rectangle at the end of the animation
47 |      */
48 |     protected abstract double getFinalHeight();
49 | 
50 |     @Override
51 |     protected Rectangle createClip() {
52 |         Rectangle rectangle = new Rectangle(this.getInitialWidth(), this.getInitialHeight());
53 | 
54 |         // Sets the origin point of the rectangle.
55 |         PositionUtils.bindCornerAlignment(
56 |                 rectangle.translateXProperty(), rectangle.translateYProperty(),
57 |                 rectangle.widthProperty(), rectangle.heightProperty(),
58 |                 super.getAlignment()
59 |         );
60 | 
61 |         return rectangle;
62 |     }
63 | 
64 |     @Override
65 |     protected Timeline createTimeline(Rectangle clip) {
66 |         final Interpolator interpolator = super.getCurve().toInterpolator();
67 | 
68 |         return new Timeline(
69 |                 new KeyFrame(
70 |                         Duration.ZERO,
71 |                         new KeyValue(clip.widthProperty(), this.getInitialWidth()),
72 |                         new KeyValue(clip.heightProperty(), this.getInitialHeight())
73 |                 ),
74 |                 new KeyFrame(
75 |                         super.getDuration(),
76 |                         new KeyValue(clip.widthProperty(), this.getFinalWidth(), interpolator),
77 |                         new KeyValue(clip.heightProperty(), this.getFinalHeight(), interpolator)
78 |                 )
79 |         );
80 |     }
81 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/wrapper/PropertyWrapper.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animated.binding.property.wrapper;
 2 | 
 3 | import javafx.beans.binding.Bindings;
 4 | import javafx.beans.property.DoubleProperty;
 5 | import javafx.beans.property.IntegerProperty;
 6 | import javafx.beans.property.ObjectProperty;
 7 | import javafx.beans.property.Property;
 8 | import javafx.beans.value.ChangeListener;
 9 | 
10 | import java.util.function.Function;
11 | 
12 | /**
13 |  * Wrapper of object and primitive JavaFX properties.
14 |  * @param <T> wrapped property type
15 |  */
16 | public interface PropertyWrapper<T> {
17 | 
18 |     /**
19 |      * @return the wrapped JavaFX property
20 |      */
21 |     Property<T> getProperty();
22 | 
23 |     /**
24 |      * @return the wrapped value
25 |      */
26 |     T getValue();
27 | 
28 |     /**
29 |      * Changes the value of the wrapped property.
30 |      * @param value new value to set
31 |      */
32 |     void set(T value);
33 | 
34 |     /**
35 |      * Registers a listener.
36 |      * @param listener listener to register
37 |      */
38 |     void addListener(ChangeListener<? super T> listener);
39 | 
40 |     /**
41 |      * Adds a binding to a target property: when the value of the wrapped property changes,
42 |      * the target property is updated too, based on a mapper function.
43 |      * @param targetProperty property to bind
44 |      * @param mapper function that takes the value of the wrapped property as input,
45 |      *               and returns the value the target property should get
46 |      * @param <V> type of the target property
47 |      */
48 |     default <V> void bindMapped(Property<V> targetProperty, Function<T, V> mapper) {
49 |         targetProperty.bind(Bindings.createObjectBinding(() -> mapper.apply(getValue()), getProperty()));
50 |     }
51 | 
52 |     /**
53 |      * Creates an {@link ObjectPropertyWrapper} for the given {@link ObjectProperty}.
54 |      * @see eu.iamgio.animated.binding.property
55 |      * @param property JavaFX property to wrap
56 |      * @param <T> property type
57 |      * @return an instance of the proper subclass of {@link PropertyWrapper} that wraps <tt>property</tt>.
58 |      */
59 |     static <T> PropertyWrapper<T> of(ObjectProperty<T> property) {
60 |         return new ObjectPropertyWrapper<>(property);
61 |     }
62 | 
63 |     /**
64 |      * Creates a {@link DoublePropertyWrapper} for the given {@link DoubleProperty}.
65 |      * @see eu.iamgio.animated.binding.property
66 |      * @param property JavaFX property to wrap
67 |      * @return an instance of the proper subclass of {@link PropertyWrapper} that wraps <tt>property</tt>.
68 |      */
69 |     static PropertyWrapper<Double> of(DoubleProperty property) {
70 |         return new DoublePropertyWrapper(property);
71 |     }
72 | 
73 |     /**
74 |      * Creates an {@link IntegerPropertyWrapper} for the given {@link IntegerProperty}.
75 |      * @see eu.iamgio.animated.binding.property
76 |      * @param property JavaFX property to wrap
77 |      * @return an instance of the proper subclass of {@link PropertyWrapper} that wraps <tt>property</tt>.
78 |      */
79 |     static PropertyWrapper<Integer> of(IntegerProperty property) {
80 |         return new IntegerPropertyWrapper(property);
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedButtonTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import eu.iamgio.animated.binding.Animated;
 4 | import eu.iamgio.animated.binding.property.animation.AnimationProperty;
 5 | import eu.iamgio.animated.common.Curve;
 6 | import javafx.application.Application;
 7 | import javafx.beans.binding.Bindings;
 8 | import javafx.beans.property.SimpleObjectProperty;
 9 | import javafx.scene.Scene;
10 | import javafx.scene.control.Button;
11 | import javafx.scene.layout.Background;
12 | import javafx.scene.layout.BackgroundFill;
13 | import javafx.scene.layout.CornerRadii;
14 | import javafx.scene.layout.Pane;
15 | import javafx.scene.paint.Color;
16 | import javafx.stage.Stage;
17 | 
18 | import static eu.iamgio.animatedtest.TestUtil.*;
19 | 
20 | // This demo animates a button's background color and border radius on pressed and hover events.
21 | 
22 | public class AnimatedButtonTest extends Application {
23 | 
24 |     private static final Color COLOR_DEFAULT = Color.TRANSPARENT;
25 |     private static final Color COLOR_HOVER = new Color(1, 1, 1, .5);
26 |     private static final Color COLOR_PRESSED = new Color(1, 1, 1, .8);
27 |     private static final double BASE_BACKGROUND_RADIUS = 60;
28 |     private static final double BORDER_WIDTH = 4;
29 | 
30 |     public void start(Stage primaryStage) {
31 |         // Setup scene
32 |         Pane root = new Pane();
33 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
34 |         scene.getStylesheets().add("/themes/button.css");
35 | 
36 |         // Create button
37 |         Button button = new Button("Animated button!");
38 |         center(button, scene);
39 | 
40 |         // Initialize and bind the background color property
41 |         SimpleObjectProperty<Color> backgroundColorProperty = new SimpleObjectProperty<>(COLOR_DEFAULT);
42 | 
43 |         button.backgroundProperty().bind(Bindings.createObjectBinding(
44 |                 () -> {
45 |                     // The button's background/border radius depends on the color opacity
46 |                     double radius = backgroundColorProperty.getValue().getOpacity() * BASE_BACKGROUND_RADIUS + 16;
47 |                     button.setStyle("-fx-border-radius: " + String.format("%f", radius)); // Format to avoid exponential notations
48 |                     // Bind our new background
49 |                     return new Background(new BackgroundFill(backgroundColorProperty.getValue(), new CornerRadii(radius), null));
50 |                 },
51 |                 backgroundColorProperty // Binding target
52 |         ));
53 | 
54 |         // Set listeners
55 | 
56 |         button.hoverProperty().addListener((observable, oldValue, isHover) ->
57 |                 backgroundColorProperty.set(isHover ? COLOR_HOVER : COLOR_DEFAULT)
58 |         );
59 | 
60 |         button.pressedProperty().addListener((observable, oldValue, isPressed) ->
61 |                 backgroundColorProperty.set(isPressed ? COLOR_PRESSED : button.isHover() ? COLOR_HOVER : COLOR_DEFAULT)
62 |         );
63 | 
64 |         // Setup animation
65 | 
66 |         Animated animated = new Animated(button, AnimationProperty.of(backgroundColorProperty))
67 |                 .custom(settings -> settings.withCurve(Curve.EASE_OUT));
68 | 
69 |         root.getChildren().add(animated);
70 | 
71 |         // Show
72 |         primaryStage.setTitle("AnimatedButton");
73 |         primaryStage.setScene(scene);
74 |         primaryStage.show();
75 |     }
76 | }


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedShadowTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import eu.iamgio.animated.binding.Animated;
 4 | import eu.iamgio.animated.binding.presets.AnimatedDropShadow;
 5 | import eu.iamgio.animated.common.Curve;
 6 | import eu.iamgio.animated.transition.AnimatedLabel;
 7 | import eu.iamgio.animated.transition.AnimationPair;
 8 | import javafx.application.Application;
 9 | import javafx.geometry.Pos;
10 | import javafx.scene.Scene;
11 | import javafx.scene.control.Button;
12 | import javafx.scene.control.Label;
13 | import javafx.scene.effect.DropShadow;
14 | import javafx.scene.layout.Pane;
15 | import javafx.scene.paint.Color;
16 | import javafx.stage.Stage;
17 | import javafx.util.Duration;
18 | 
19 | import static eu.iamgio.animatedtest.TestUtil.*;
20 | 
21 | // This demo animates a button's shadow radius and color on pressed and hover events.
22 | // An animated text (via AnimatedSwitcher) flags the button's status as well.
23 | 
24 | public class AnimatedShadowTest extends Application {
25 | 
26 |     private static final int RADIUS_PRESSED = 100, RADIUS_HOVER = 60, RADIUS_DEFAULT = 20;
27 |     private static final Color COLOR_PRESSED = Color.SLATEBLUE, COLOR_HOVER = Color.CRIMSON, COLOR_DEFAULT = Color.TEAL;
28 |     private static final String TEXT_PRESSED = "PRESSED", TEXT_HOVER = "HOVER", TEXT_DEFAULT = "";
29 | 
30 |     public void start(Stage primaryStage) {
31 |         // Setup scene
32 |         Pane root = new Pane();
33 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
34 | 
35 |         // Create button
36 |         Button button = new Button("Animated shadow");
37 |         center(button, scene);
38 | 
39 |         // Setup animated text label
40 |         AnimatedLabel label = new AnimatedLabel(AnimationPair.fade().setSpeed(1, 2));
41 | 
42 |         label.setLabelFactory(text -> {
43 |             Label newLabel = new Label(text);
44 |             newLabel.prefWidthProperty().bind(scene.widthProperty());
45 |             newLabel.setAlignment(Pos.CENTER);
46 |             newLabel.setStyle("-fx-font-size: 18; -fx-padding: 60");
47 |             return newLabel;
48 |         });
49 | 
50 |         // Create effect
51 |         DropShadow shadow = new DropShadow();
52 |         shadow.setRadius(0);
53 |         button.setEffect(shadow);
54 | 
55 |         // Set listeners
56 | 
57 |         button.pressedProperty().addListener((observable, oldValue, isPressed) -> {
58 |             shadow.setRadius(isPressed ? RADIUS_PRESSED : RADIUS_HOVER);
59 |             shadow.setColor(isPressed ? COLOR_PRESSED : COLOR_HOVER);
60 |             label.setText(isPressed ? TEXT_PRESSED : TEXT_HOVER);
61 |         });
62 | 
63 |         button.hoverProperty().addListener((observable, oldValue, isHover) -> {
64 |             shadow.setRadius(isHover ? RADIUS_HOVER : RADIUS_DEFAULT);
65 |             shadow.setColor(isHover ? COLOR_HOVER : COLOR_DEFAULT);
66 |             label.setText(isHover ? TEXT_HOVER : TEXT_DEFAULT);
67 |         });
68 | 
69 |         // Setup animation
70 |         Animated animated = new Animated(button, new AnimatedDropShadow.Color(), new AnimatedDropShadow.Radius())
71 |                 .custom(settings -> settings.withDuration(Duration.millis(200)).withCurve(Curve.EASE_OUT_SINE));
72 | 
73 |         root.getChildren().addAll(label, animated);
74 | 
75 |         // Show
76 |         primaryStage.setTitle("AnimatedDropShadow");
77 |         primaryStage.setScene(scene);
78 |         primaryStage.show();
79 |     }
80 | }


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/animations/clip/ClipAnimation.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition.animations.clip;
  2 | 
  3 | import animatefx.animation.AnimationFX;
  4 | import eu.iamgio.animated.common.Curve;
  5 | import eu.iamgio.animated.transition.animations.RequiresScene;
  6 | import eu.iamgio.animated.util.PositionUtils;
  7 | import javafx.animation.Timeline;
  8 | import javafx.geometry.Bounds;
  9 | import javafx.geometry.Pos;
 10 | import javafx.scene.Node;
 11 | import javafx.scene.shape.Shape;
 12 | import javafx.util.Duration;
 13 | 
 14 | /**
 15 |  * Animation that features a shape that masks a node.
 16 |  *
 17 |  * @param <S> shape type
 18 |  */
 19 | public abstract class ClipAnimation<S extends Shape> extends AnimationFX implements RequiresScene {
 20 | 
 21 |     protected static final Curve DEFAULT_ENTRANCE_CURVE = Curve.EASE_IN;
 22 |     protected static final Curve DEFAULT_EXIT_CURVE = Curve.EASE_OUT;
 23 |     protected static final Duration DEFAULT_DURATION = Duration.seconds(1);
 24 |     protected static final Pos DEFAULT_ALIGNMENT = Pos.CENTER;
 25 | 
 26 |     private final Curve curve;
 27 |     private final Duration duration;
 28 |     private final Pos alignment;
 29 | 
 30 |     /**
 31 |      * @param curve animation curve
 32 |      * @param duration animation duration
 33 |      * @param alignment position of the clip, relative to the scene
 34 |      */
 35 |     protected ClipAnimation(Curve curve, Duration duration, Pos alignment) {
 36 |         this.curve = curve;
 37 |         this.duration = duration;
 38 |         this.alignment = alignment;
 39 |     }
 40 | 
 41 |     /**
 42 |      * @return a new instance of the clip shape
 43 |      */
 44 |     protected abstract S createClip();
 45 | 
 46 |     /**
 47 |      * @param clip current clip
 48 |      * @return a new instance of the timeline to play
 49 |      */
 50 |     protected abstract Timeline createTimeline(S clip);
 51 | 
 52 |     /**
 53 |      * @return the available area to clip
 54 |      */
 55 |     protected Bounds getArea() {
 56 |         final Bounds layoutBounds = getNode().getLayoutBounds();
 57 |         return layoutBounds.getWidth() <= 0 && layoutBounds.getHeight() <= 0
 58 |                 ? getNode().getScene().getRoot().getLayoutBounds()
 59 |                 : layoutBounds;
 60 |     }
 61 | 
 62 |     @Override
 63 |     protected AnimationFX resetNode() {
 64 |         // This animation is never reset.
 65 |         return this;
 66 |     }
 67 | 
 68 |     @Override
 69 |     protected final void initTimeline() {
 70 |         final Node node = super.getNode();
 71 | 
 72 |         final S clip = this.createClip();
 73 | 
 74 |         // The position of the clip depends on the given alignment.
 75 |         PositionUtils.bindAlignmentToArea(
 76 |                 clip.layoutXProperty(), clip.layoutYProperty(),
 77 |                 node.layoutBoundsProperty(), this.alignment
 78 |         );
 79 | 
 80 |         node.setClip(clip);
 81 | 
 82 |         final Timeline timeline = this.createTimeline(clip);
 83 | 
 84 |         // The clip is removed at the end of the animation.
 85 |         timeline.setOnFinished(e -> node.setClip(null));
 86 | 
 87 |         super.setTimeline(timeline);
 88 |     }
 89 | 
 90 |     protected Curve getCurve() {
 91 |         return this.curve;
 92 |     }
 93 | 
 94 |     protected Duration getDuration() {
 95 |         return this.duration;
 96 |     }
 97 | 
 98 |     protected Pos getAlignment() {
 99 |         return this.alignment;
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedContainerTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import animatefx.animation.FadeInUp;
 4 | import animatefx.animation.SlideOutLeft;
 5 | import eu.iamgio.animated.binding.Animated;
 6 | import eu.iamgio.animated.binding.presets.AnimatedOpacity;
 7 | import eu.iamgio.animated.common.Curve;
 8 | import eu.iamgio.animated.transition.AnimationPair;
 9 | import eu.iamgio.animated.transition.container.AnimatedVBox;
10 | import javafx.application.Application;
11 | import javafx.geometry.Pos;
12 | import javafx.scene.Scene;
13 | import javafx.scene.control.Button;
14 | import javafx.scene.control.Label;
15 | import javafx.scene.layout.AnchorPane;
16 | import javafx.scene.layout.Pane;
17 | import javafx.scene.layout.StackPane;
18 | import javafx.scene.shape.Rectangle;
19 | import javafx.stage.Stage;
20 | import javafx.util.Duration;
21 | 
22 | import static eu.iamgio.animatedtest.TestUtil.*;
23 | 
24 | // This demo animates the content of multi-children containers, such as VBoxes.
25 | 
26 | public class AnimatedContainerTest extends Application {
27 | 
28 |     @Override
29 |     public void start(Stage primaryStage) {
30 |         // Setup scene
31 |         Pane root = new Pane();
32 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
33 | 
34 |         // Setup container
35 |         AnimatedVBox vBox = new AnimatedVBox(new AnimationPair(new FadeInUp(), new SlideOutLeft()).setSpeed(3, 3));
36 | 
37 |         // Also try HBox:
38 |         // AnimatedHBox hBox = new AnimatedHBox(new AnimationPair(new FadeInDown(), new SlideOutUp()).setSpeed(3, 3));
39 | 
40 |         // Setup + buttons
41 | 
42 |         Button topButton = new Button("+ Add on top");
43 |         topButton.setPrefWidth(150);
44 |         topButton.relocate(400, 100);
45 |         topButton.setOnAction(e -> vBox.getChildren().add(0, new RectangleButton(vBox)));
46 | 
47 |         Button bottomButton = new Button("+ Add on bottom");
48 |         bottomButton.setPrefWidth(150);
49 |         bottomButton.relocate(400, 150);
50 |         bottomButton.setOnAction(e -> vBox.getChildren().add(new RectangleButton(vBox)));
51 | 
52 |         root.getChildren().addAll(vBox, topButton, bottomButton);
53 | 
54 |         // Show
55 |         primaryStage.setTitle("AnimatedContainer");
56 |         primaryStage.setScene(scene);
57 |         primaryStage.show();
58 |     }
59 | 
60 |     private static class RectangleButton extends AnchorPane {
61 | 
62 |         // Random-colored rectangle with a "Click to remove" text that appears on hover on it.
63 | 
64 |         public RectangleButton(Pane parent) {
65 |             Rectangle rectangle = randomRectangle();
66 |             setPrefSize(100, 100);
67 |             rectangle.setWidth(100);
68 |             rectangle.setHeight(100);
69 | 
70 |             Label text = new Label("Click to remove");
71 |             text.setPrefSize(100, 100);
72 |             text.setAlignment(Pos.CENTER);
73 |             text.setOpacity(0);
74 | 
75 |             hoverProperty().addListener((observable, oldValue, isHover) -> text.setOpacity(isHover ? 1 : 0));
76 | 
77 |             StackPane.setAlignment(text, Pos.CENTER);
78 | 
79 |             getChildren().addAll(
80 |                     rectangle,
81 |                     new Animated(text, new AnimatedOpacity())
82 |                             .custom(settings -> settings.withDuration(Duration.millis(150)).withCurve(Curve.EASE_IN_OUT))
83 |             );
84 | 
85 |             setOnMouseClicked(ev -> parent.getChildren().remove(this));
86 |         }
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/test/java/eu/iamgio/animatedtest/AnimatedTest.java:
--------------------------------------------------------------------------------
 1 | package eu.iamgio.animatedtest;
 2 | 
 3 | import eu.iamgio.animated.binding.Animated;
 4 | import eu.iamgio.animated.binding.presets.AnimatedOpacity;
 5 | import eu.iamgio.animated.binding.presets.AnimatedPrefSize;
 6 | import eu.iamgio.animated.common.Curve;
 7 | import javafx.application.Application;
 8 | import javafx.geometry.Pos;
 9 | import javafx.scene.Scene;
10 | import javafx.scene.control.Button;
11 | import javafx.scene.control.CheckBox;
12 | import javafx.scene.layout.HBox;
13 | import javafx.scene.layout.Pane;
14 | import javafx.scene.shape.Rectangle;
15 | import javafx.stage.Stage;
16 | import javafx.util.Duration;
17 | 
18 | import static eu.iamgio.animatedtest.TestUtil.*;
19 | 
20 | // This demo dynamically changes several rectangle's properties.
21 | // The Animated class lets the change play a transition.
22 | 
23 | public class AnimatedTest extends Application {
24 | 
25 |     public void start(Stage primaryStage) {
26 |         // Setup scene
27 |         Pane root = new Pane();
28 |         Scene scene = new Scene(root, SCENE_WIDTH, SCENE_HEIGHT);
29 | 
30 |         Rectangle rectangle = randomRectangle();
31 |         Pane pane = new Pane(rectangle);
32 |         center(pane, scene);
33 | 
34 |         // Bind rectangle size to pane size
35 |         pane.setPrefSize(rectangle.getWidth(), rectangle.getHeight());
36 |         rectangle.widthProperty().bind(pane.prefWidthProperty());
37 |         rectangle.heightProperty().bind(pane.heightProperty());
38 | 
39 |         // Set up the node and attach it to the root
40 |         Animated animated = new Animated(pane,
41 |                 new AnimatedOpacity()
42 |                         .custom(settings -> settings.withDuration(Duration.seconds(.4))),
43 |                 new AnimatedPrefSize()
44 |                         .custom(settings -> settings.withDuration(Duration.seconds(.3)))
45 |         ).custom(settings -> settings.withCurve(Curve.EASE_IN_OUT));
46 | 
47 |         root.getChildren().add(animated);
48 | 
49 |         // Set up the controls
50 |         root.getChildren().add(setupControls(pane));
51 | 
52 |         // Show
53 |         primaryStage.setTitle("Animated");
54 |         primaryStage.setScene(scene);
55 |         primaryStage.show();
56 |     }
57 | 
58 |     private HBox setupControls(Pane pane) {
59 |         HBox hbox = new HBox(8);
60 |         hbox.setStyle("-fx-padding: 15;");
61 |         hbox.setAlignment(Pos.CENTER);
62 | 
63 |         CheckBox checkBox = new CheckBox("Visible");
64 |         checkBox.selectedProperty().addListener(o -> pane.setOpacity(checkBox.isSelected() ? 1 : 0));
65 |         checkBox.setSelected(true);
66 | 
67 |         Pane spacer1 = new Pane();
68 |         spacer1.setPrefWidth(5);
69 | 
70 |         Button widthMinus = new Button("Width -");
71 |         widthMinus.setOnAction(e -> pane.setPrefWidth(pane.getPrefWidth() - 100));
72 | 
73 |         Button widthPlus = new Button("Width +");
74 |         widthPlus.setOnAction(e -> pane.setPrefWidth(pane.getPrefWidth() + 100));
75 | 
76 |         Pane spacer2 = new Pane();
77 |         spacer2.setPrefWidth(5);
78 | 
79 |         Button heightMinus = new Button("Height -");
80 |         heightMinus.setOnAction(e -> pane.setPrefHeight(pane.getPrefHeight() - 100));
81 | 
82 |         Button heighPlus = new Button("Height +");
83 |         heighPlus.setOnAction(e -> pane.setPrefHeight(pane.getPrefHeight() + 100));
84 | 
85 |         hbox.getChildren().addAll(checkBox, spacer1, widthMinus, widthPlus, spacer2, heightMinus, heighPlus);
86 |         return hbox;
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/value/AnimatedValueImpl.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.binding.value;
  2 | 
  3 | import eu.iamgio.animated.binding.AnimationSettings;
  4 | import eu.iamgio.animated.binding.event.AnimationEvent;
  5 | import eu.iamgio.animated.binding.property.animation.AnimationProperty;
  6 | import javafx.beans.property.*;
  7 | import javafx.event.EventHandler;
  8 | import javafx.scene.Node;
  9 | 
 10 | import java.util.function.Function;
 11 | 
 12 | /**
 13 |  * A value that animates its wrapped content whenever its wrapped value changes via {@link #setValue(Object)}.
 14 |  * Note that the animated value ({@link #animationValueProperty()}) must be bound to an external property to be effective.
 15 |  *
 16 |  * @param <T> type of the wrapped value.
 17 |  */
 18 | class AnimatedValueImpl<T> implements AnimatedValue<T> {
 19 | 
 20 |     private final Property<T> value;
 21 |     private final AnimationProperty<T> animationProperty;
 22 |     private final BooleanProperty paused = new SimpleBooleanProperty(false);
 23 | 
 24 |     /**
 25 |      * Instantiates an {@link AnimatedValueImpl}.
 26 |      * @param value initial wrapped value
 27 |      */
 28 |     AnimatedValueImpl(T value, Node target) {
 29 |         this.value = new SimpleObjectProperty<>(value);
 30 | 
 31 |         // This is a parallel property to the value property,
 32 |         // which is updated when the other one is updated, but with an animation.
 33 |         final ObjectProperty<T> animatedValue = new SimpleObjectProperty<>(value);
 34 |         this.value.addListener((observable, oldValue, newValue) -> animatedValue.set(newValue));
 35 | 
 36 |         this.animationProperty = AnimationProperty.of(animatedValue);
 37 | 
 38 |         animationProperty.pausedProperty().bind(this.paused);
 39 |         animationProperty.register(target);
 40 |     }
 41 | 
 42 |     /**
 43 |      * {@inheritDoc}
 44 |      */
 45 |     @Override
 46 |     public Property<T> valueProperty() {
 47 |         return this.value;
 48 |     }
 49 | 
 50 |     /**
 51 |      * {@inheritDoc}
 52 |      */
 53 |     @Override
 54 |     public T getValue() {
 55 |         return this.value.getValue();
 56 |     }
 57 | 
 58 |     /**
 59 |      * {@inheritDoc}
 60 |      */
 61 |     @Override
 62 |     public void setValue(T value) {
 63 |         this.value.setValue(value);
 64 |     }
 65 | 
 66 |     /**
 67 |      * {@inheritDoc}
 68 |      */
 69 |     @Override
 70 |     public ReadOnlyProperty<T> animationValueProperty() {
 71 |         return this.animationProperty.getProperty().getProperty();
 72 |     }
 73 | 
 74 |     /**
 75 |      * {@inheritDoc}
 76 |      */
 77 |     @Override
 78 |     public T getAnimationValue() {
 79 |         return this.animationProperty.getProperty().getValue();
 80 |     }
 81 | 
 82 |     /**
 83 |      * {@inheritDoc}
 84 |      */
 85 |     @Override
 86 |     public AnimationSettings getSettings() {
 87 |         return this.animationProperty.getSettings();
 88 |     }
 89 | 
 90 |     /**
 91 |      * {@inheritDoc}
 92 |      */
 93 |     @Override
 94 |     public void setSettings(AnimationSettings settings) {
 95 |         this.animationProperty.setSettings(settings);
 96 |     }
 97 | 
 98 |     /**
 99 |      * {@inheritDoc}
100 |      */
101 |     @Override
102 |     public AnimatedValue<T> custom(Function<AnimationSettings, AnimationSettings> settings) {
103 |         this.animationProperty.custom(settings);
104 |         return this;
105 |     }
106 | 
107 |     /**
108 |      * {@inheritDoc}
109 |      */
110 |     @Override
111 |     public BooleanProperty pausedProperty() {
112 |         return this.paused;
113 |     }
114 | 
115 |     /**
116 |      * {@inheritDoc}
117 |      */
118 |     @Override
119 |     public ObjectProperty<EventHandler<AnimationEvent>> onAnimationStartedProperty() {
120 |         return this.animationProperty.onAnimationStartedProperty();
121 |     }
122 | 
123 |     /**
124 |      * {@inheritDoc}
125 |      */
126 |     @Override
127 |     public ObjectProperty<EventHandler<AnimationEvent>> onAnimationEndedProperty() {
128 |         return this.animationProperty.onAnimationEndedProperty();
129 |     }
130 | }
131 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/container/AnimatedVBox.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition.container;
  2 | 
  3 | import animatefx.animation.AnimationFX;
  4 | import eu.iamgio.animated.common.Curve;
  5 | import eu.iamgio.animated.transition.Animation;
  6 | import eu.iamgio.animated.transition.AnimationPair;
  7 | import javafx.beans.property.BooleanProperty;
  8 | import javafx.beans.property.ObjectProperty;
  9 | import javafx.beans.property.SimpleBooleanProperty;
 10 | import javafx.beans.property.SimpleObjectProperty;
 11 | import javafx.scene.layout.VBox;
 12 | 
 13 | /**
 14 |  * A {@link VBox} with animated children.
 15 |  * @author Giorgio Garofalo
 16 |  */
 17 | public class AnimatedVBox extends VBox implements AnimatedContainer {
 18 | 
 19 |     private final ObjectProperty<Animation> in;
 20 |     private final ObjectProperty<Animation> out;
 21 | 
 22 |     private final BooleanProperty pausedProperty = new SimpleBooleanProperty(false);
 23 |     private final ObjectProperty<Curve> relocationCurveProperty = new SimpleObjectProperty<>(Curve.EASE_IN_OUT);
 24 | 
 25 |     /**
 26 |      * Instantiates an {@link AnimatedVBox}. {@link Animation} wraps an {@link AnimationFX}, allowing customization.
 27 |      * @param animationIn non-null entrance animation
 28 |      * @param animationOut non-null exit animation
 29 |      */
 30 |     public AnimatedVBox(Animation animationIn, Animation animationOut) {
 31 |         this.in = new SimpleObjectProperty<>(Animation.requireNonNull(animationIn));
 32 |         this.out = new SimpleObjectProperty<>(Animation.requireNonNull(animationOut));
 33 |         register();
 34 |     }
 35 | 
 36 |     /**
 37 |      * Instantiates an {@link AnimatedVBox}.
 38 |      * @param animation a pair of in and out animations
 39 |      */
 40 |     public AnimatedVBox(AnimationPair animation) {
 41 |         this(animation.getIn(), animation.getOut());
 42 |     }
 43 | 
 44 |     /**
 45 |      * Instantiates an {@link AnimatedVBox}.
 46 |      * @param in entrance animation
 47 |      * @param out exit animation
 48 |      */
 49 |     public AnimatedVBox(AnimationFX in, AnimationFX out) {
 50 |         this(new Animation(in), new Animation(out));
 51 |     }
 52 | 
 53 |     /**
 54 |      * {@inheritDoc}
 55 |      */
 56 |     @Override
 57 |     public ObjectProperty<Animation> animationInProperty() {
 58 |         return this.in;
 59 |     }
 60 | 
 61 |     /**
 62 |      * {@inheritDoc}
 63 |      */
 64 |     @Override
 65 |     public Animation getIn() {
 66 |         // This overriden method is required for FXML compatibility.
 67 |         return AnimatedContainer.super.getIn();
 68 |     }
 69 | 
 70 |     /**
 71 |      * {@inheritDoc}
 72 |      */
 73 |     @Override
 74 |     public void setIn(Animation in) {
 75 |         // This overriden method is required for FXML compatibility.
 76 |         AnimatedContainer.super.setIn(in);
 77 |     }
 78 | 
 79 |     /**
 80 |      * {@inheritDoc}
 81 |      */
 82 |     @Override
 83 |     public ObjectProperty<Animation> animationOutProperty() {
 84 |         return this.out;
 85 |     }
 86 | 
 87 |     /**
 88 |      * {@inheritDoc}
 89 |      */
 90 |     @Override
 91 |     public Animation getOut() {
 92 |         // This overriden method is required for FXML compatibility.
 93 |         return AnimatedContainer.super.getOut();
 94 |     }
 95 | 
 96 |     /**
 97 |      * {@inheritDoc}
 98 |      */
 99 |     @Override
100 |     public void setOut(Animation out) {
101 |         // This overriden method is required for FXML compatibility.
102 |         AnimatedContainer.super.setOut(out);
103 |     }
104 | 
105 |     /**
106 |      * {@inheritDoc}
107 |      */
108 |     @Override
109 |     public Direction getDirection() {
110 |         return Direction.VERTICAL;
111 |     }
112 | 
113 |     /**
114 |      * {@inheritDoc}
115 |      */
116 |     @Override
117 |     public BooleanProperty pausedProperty() {
118 |         return pausedProperty;
119 |     }
120 | 
121 |     /**
122 |      * {@inheritDoc}
123 |      */
124 |     @Override
125 |     public ObjectProperty<Curve> relocationCurveProperty() {
126 |         return relocationCurveProperty;
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/Animated.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.binding;
  2 | 
  3 | import eu.iamgio.animated.binding.property.animation.AnimationProperty;
  4 | import eu.iamgio.animated.common.Pausable;
  5 | import javafx.beans.property.BooleanProperty;
  6 | import javafx.beans.property.DoubleProperty;
  7 | import javafx.beans.property.SimpleBooleanProperty;
  8 | import javafx.collections.FXCollections;
  9 | import javafx.collections.ListChangeListener;
 10 | import javafx.collections.ObservableList;
 11 | import javafx.scene.Node;
 12 | 
 13 | import java.util.function.Function;
 14 | 
 15 | /**
 16 |  * A node that automatically animates multiple properties related to its child.
 17 |  * @author Giorgio Garofalo
 18 |  */
 19 | public class Animated extends SingleChildParent implements CustomizableAnimation<Animated>, Pausable {
 20 | 
 21 |     private final ObservableList<AnimationProperty<?>> properties = FXCollections.observableArrayList();
 22 |     private final BooleanProperty paused = new SimpleBooleanProperty(false);
 23 | 
 24 |     /**
 25 |      * Instantiates a new {@link Animated} node without a child and with no target properties.
 26 |      */
 27 |     public Animated() {
 28 |         registerPropertyListeners();
 29 |     }
 30 | 
 31 |     /**
 32 |      * Instantiates a new {@link Animated} node.
 33 |      * @param child the target node that should be animated, to be wrapped by this {@link Animated} node
 34 |      * @param properties target properties that should be animated.
 35 |      *                   It is good practice to target properties that are related to this node's child
 36 |      * @see AnimationProperty#of(DoubleProperty)
 37 |      */
 38 |     public Animated(Node child, AnimationProperty<?>... properties) {
 39 |         super(child);
 40 |         registerPropertyListeners();
 41 |         this.properties.addAll(properties);
 42 |     }
 43 | 
 44 |     /**
 45 |      * Instantiates a new {@link Animated} node with no target properties.
 46 |      * @param child the target node that should be animated, to be wrapped by this {@link Animated} node
 47 |      */
 48 |     public Animated(Node child) {
 49 |         super(child);
 50 |         registerPropertyListeners();
 51 |     }
 52 | 
 53 |     /**
 54 |      * Instantiates a new {@link Animated} node without a child.
 55 |      * @param properties target properties that should be animated.
 56 |      *                   It is good practice to target properties that are related to this node's child
 57 |      * @see AnimationProperty#of(DoubleProperty)
 58 |      */
 59 |     public Animated(AnimationProperty<?>... properties) {
 60 |         registerPropertyListeners();
 61 |         this.properties.addAll(properties);
 62 |     }
 63 | 
 64 |     private void registerPropertyListeners() {
 65 |         properties.addListener((ListChangeListener<? super AnimationProperty<?>>) change -> {
 66 |             while (change.next()) {
 67 |                 change.getAddedSubList().forEach(property -> {
 68 |                     property.attachTo(this);
 69 |                     property.pausedProperty().bindBidirectional(this.paused);
 70 |                 });
 71 |                 // TODO unbind on remove
 72 |             }
 73 |         });
 74 |     }
 75 | 
 76 |     /**
 77 |      * {@inheritDoc}
 78 |      */
 79 |     @Override
 80 |     public void setSettings(AnimationSettings settings) {
 81 |         this.properties.forEach(property -> property.setSettings(settings));
 82 |     }
 83 | 
 84 |     /**
 85 |      * {@inheritDoc}
 86 |      */
 87 |     @Override
 88 |     public Animated custom(Function<AnimationSettings, AnimationSettings> settings) {
 89 |         this.properties.forEach(property -> property.custom(settings));
 90 |         return this;
 91 |     }
 92 | 
 93 |     /**
 94 |      * {@inheritDoc}
 95 |      */
 96 |     @Override
 97 |     public BooleanProperty pausedProperty() {
 98 |         return this.paused;
 99 |     }
100 | 
101 |     /**
102 |      * @return a mutable list of the target properties that should be animated.
103 |      *         It is good practice to target properties that are related to this node's child
104 |      */
105 |     public ObservableList<AnimationProperty<?>> getTargetProperties() {
106 |         return this.properties;
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/animation/OnDemandAnimationProperty.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.binding.property.animation;
  2 | 
  3 | import eu.iamgio.animated.binding.Animated;
  4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
  5 | import javafx.beans.InvalidationListener;
  6 | import javafx.beans.property.ObjectProperty;
  7 | import javafx.beans.property.Property;
  8 | import javafx.beans.property.SimpleObjectProperty;
  9 | import javafx.scene.Node;
 10 | 
 11 | import java.util.function.Function;
 12 | 
 13 | /**
 14 |  * An on-demand animation property is a 'lazy evaluation' of an {@link AnimationProperty}:
 15 |  * its wrapped property is defined by a {@link Function} that is applied to the child
 16 |  * of the attached {@link Animated} node only when it changes.
 17 |  * Optionally, a constant target node can be specified instead of using the bound one from the animated node.
 18 |  * @param <N> type of the JavaFX node to extract the property from
 19 |  * @param <T> type of the wrapped value
 20 |  */
 21 | public class OnDemandAnimationProperty<N extends Node, T> extends AnimationProperty<T> implements BindableContextNode<N> {
 22 | 
 23 |     private final Function<N, PropertyWrapper<T>> propertyRetriever;
 24 |     private final ObjectProperty<N> targetNode;
 25 | 
 26 |     /**
 27 |      * Instantiates a new on-demand animation property.
 28 |      * @param propertyRetriever function that generates a wrapped JavaFX property when applied to a node.
 29 |      */
 30 |     public OnDemandAnimationProperty(Function<N, PropertyWrapper<T>> propertyRetriever) {
 31 |         super(null);
 32 |         this.propertyRetriever = propertyRetriever;
 33 |         this.targetNode = new SimpleObjectProperty<>();
 34 |     }
 35 | 
 36 |     /**
 37 |      * {@inheritDoc}
 38 |      */
 39 |     @Override
 40 |     public ObjectProperty<N> targetNodeProperty() {
 41 |         return this.targetNode;
 42 |     }
 43 | 
 44 |     /**
 45 |      * @return a new {@link AnimationProperty} that wraps the output of the function applied to the current target node.
 46 |      * @throws IllegalStateException if the target node is not set
 47 |      */
 48 |     private AnimationProperty<T> requestProperty() {
 49 |         if (targetNode.get() == null) {
 50 |             throw new IllegalStateException("The on-demand property was trying to access its status, " +
 51 |                     "but its target node is not set.");
 52 |         }
 53 | 
 54 |         final AnimationProperty<T> property = new SimpleAnimationProperty<>(propertyRetriever.apply(targetNode.get()));
 55 |         super.copyAttributesTo(property);
 56 |         return property;
 57 |     }
 58 | 
 59 |     /**
 60 |      * {@inheritDoc}
 61 |      */
 62 |     @Override
 63 |     public void register(Node target) {
 64 |         final AnimationProperty<?> requested = requestProperty();
 65 |         requested.register(target != null ? target : targetNode.get());
 66 |     }
 67 | 
 68 |     /**
 69 |      * {@inheritDoc}
 70 |      * A hook is set up so that the child of the animated node generates
 71 |      * and registers a new {@link SimpleAnimationProperty} when it changes.
 72 |      */
 73 |     @SuppressWarnings("unchecked")
 74 |     @Override
 75 |     public void attachTo(Animated animated) {
 76 |         if (targetNode.get() == null) {
 77 |             // Not a beautiful way to achieve this.
 78 |             // Casting is a workaround and should be handled better in the future.
 79 |             targetNode.bind((Property<N>) animated.childProperty());
 80 |         }
 81 | 
 82 |         // Whenever the wrapped child of an animated node changes,
 83 |         // the animation property is evaluated and registered.
 84 | 
 85 |         final InvalidationListener listener = o -> this.register(targetNode.get());
 86 | 
 87 |         // Calling the listener if a child is already present.
 88 |         if (animated.getChild() != null) {
 89 |             listener.invalidated(null);
 90 |         }
 91 | 
 92 |         animated.childProperty().addListener(listener);
 93 |     }
 94 | 
 95 |     /**
 96 |      * {@inheritDoc}
 97 |      */
 98 |     @Override
 99 |     public <V> AnimationProperty<T> addBinding(Property<V> targetProperty, Function<T, V> mapper) {
100 |         requestProperty().addBinding(targetProperty, mapper);
101 |         return this;
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/value/AnimatedValueLabel.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.binding.value;
  2 | 
  3 | import eu.iamgio.animated.binding.AnimationSettings;
  4 | import eu.iamgio.animated.binding.event.AnimationEvent;
  5 | import javafx.beans.NamedArg;
  6 | import javafx.beans.binding.Bindings;
  7 | import javafx.beans.property.*;
  8 | import javafx.event.EventHandler;
  9 | import javafx.scene.control.Label;
 10 | 
 11 | import java.util.Objects;
 12 | import java.util.function.Function;
 13 | 
 14 | /**
 15 |  * A {@link Label} that animates its text content whenever its wrapped value changes via {@link #setValue(Object)}.
 16 |  *
 17 |  * @param <T> type of the wrapped value.
 18 |  */
 19 | public class AnimatedValueLabel<T> extends Label implements AnimatedValue<T> {
 20 | 
 21 |     private final AnimatedValue<T> value;
 22 |     private final Property<Function<T, String>> textMapper;
 23 | 
 24 |     /**
 25 |      * Instantiates an {@link AnimatedValueLabel}.
 26 |      * @param value initial wrapped value
 27 |      */
 28 |     public AnimatedValueLabel(@NamedArg("value") T value) {
 29 |         this.value = new AnimatedValueImpl<>(value, this);
 30 |         this.textMapper = new SimpleObjectProperty<>(Objects::toString);
 31 | 
 32 |         this.textProperty().bind(
 33 |                 Bindings.createStringBinding(
 34 |                         () -> this.textMapper.getValue().apply(getAnimationValue()),
 35 |                         animationValueProperty(), this.textMapper
 36 |                 )
 37 |         );
 38 |     }
 39 | 
 40 |     /**
 41 |      * {@inheritDoc}
 42 |      */
 43 |     @Override
 44 |     public void setSettings(AnimationSettings settings) {
 45 |         this.value.setSettings(settings);
 46 |     }
 47 | 
 48 |     /**
 49 |      * {@inheritDoc}
 50 |      */
 51 |     @Override
 52 |     public AnimatedValueLabel<T> custom(Function<AnimationSettings, AnimationSettings> settings) {
 53 |         this.value.custom(settings);
 54 |         return this;
 55 |     }
 56 | 
 57 |     /**
 58 |      * {@inheritDoc}
 59 |      */
 60 |     @Override
 61 |     public Property<T> valueProperty() {
 62 |         return this.value.valueProperty();
 63 |     }
 64 | 
 65 |     /**
 66 |      * {@inheritDoc}
 67 |      */
 68 |     @Override
 69 |     public T getValue() {
 70 |         return this.value.getValue();
 71 |     }
 72 | 
 73 |     /**
 74 |      * {@inheritDoc}
 75 |      */
 76 |     @Override
 77 |     public void setValue(T value) {
 78 |         this.value.setValue(value);
 79 |     }
 80 | 
 81 |     /**
 82 |      * {@inheritDoc}
 83 |      */
 84 |     @Override
 85 |     public ReadOnlyProperty<T> animationValueProperty() {
 86 |         return this.value.animationValueProperty();
 87 |     }
 88 | 
 89 |     /**
 90 |      * {@inheritDoc}
 91 |      */
 92 |     @Override
 93 |     public T getAnimationValue() {
 94 |         return this.value.getAnimationValue();
 95 |     }
 96 | 
 97 |     /**
 98 |      * {@inheritDoc}
 99 |      */
100 |     @Override
101 |     public AnimationSettings getSettings() {
102 |         return this.value.getSettings();
103 |     }
104 | 
105 |     /**
106 |      * {@inheritDoc}
107 |      */
108 |     @Override
109 |     public BooleanProperty pausedProperty() {
110 |         return this.value.pausedProperty();
111 |     }
112 | 
113 |     /**
114 |      * {@inheritDoc}
115 |      */
116 |     @Override
117 |     public ObjectProperty<EventHandler<AnimationEvent>> onAnimationStartedProperty() {
118 |         return this.value.onAnimationStartedProperty();
119 |     }
120 | 
121 |     /**
122 |      * {@inheritDoc}
123 |      */
124 |     @Override
125 |     public ObjectProperty<EventHandler<AnimationEvent>> onAnimationEndedProperty() {
126 |         return this.value.onAnimationEndedProperty();
127 |     }
128 | 
129 |     /**
130 |      * @return the function that maps the current wrapped value to the displayed text.
131 |      *         It defaults to {@link Objects#toString(Object)}
132 |      */
133 |     public Function<T, String> getTextMapper() {
134 |         return this.textMapper.getValue();
135 |     }
136 | 
137 |     /**
138 |      * Sets the function that maps the current wrapped value to the displayed text.
139 |      * @param textMapper new text mapper
140 |      */
141 |     public void setTextMapper(Function<T, String> textMapper) {
142 |         this.textMapper.setValue(textMapper);
143 |     }
144 | }
145 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/container/AnimatedHBox.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition.container;
  2 | 
  3 | import animatefx.animation.AnimationFX;
  4 | import eu.iamgio.animated.common.Curve;
  5 | import eu.iamgio.animated.transition.Animation;
  6 | import eu.iamgio.animated.transition.AnimationPair;
  7 | import javafx.beans.property.BooleanProperty;
  8 | import javafx.beans.property.ObjectProperty;
  9 | import javafx.beans.property.SimpleBooleanProperty;
 10 | import javafx.beans.property.SimpleObjectProperty;
 11 | import javafx.scene.layout.HBox;
 12 | 
 13 | /**
 14 |  * An {@link HBox} with animated children.
 15 |  * @author Giorgio Garofalo
 16 |  */
 17 | public class AnimatedHBox extends HBox implements AnimatedContainer {
 18 | 
 19 |     private final ObjectProperty<Animation> in;
 20 |     private final ObjectProperty<Animation> out;
 21 | 
 22 |     private final BooleanProperty pausedProperty = new SimpleBooleanProperty(false);
 23 |     private final ObjectProperty<Curve> relocationCurveProperty = new SimpleObjectProperty<>(Curve.EASE_IN_OUT);
 24 | 
 25 |     /**
 26 |      * Instantiates an {@link AnimatedHBox}. {@link Animation} wraps an {@link AnimationFX}, allowing customization.
 27 |      * @param animationIn non-null entrance animation
 28 |      * @param animationOut non-null exit animation
 29 |      */
 30 |     public AnimatedHBox(Animation animationIn, Animation animationOut) {
 31 |         this.in = new SimpleObjectProperty<>(Animation.requireNonNull(animationIn));
 32 |         this.out = new SimpleObjectProperty<>(Animation.requireNonNull(animationOut));
 33 |         register();
 34 |     }
 35 | 
 36 |     /**
 37 |      * Instantiates an {@link AnimatedHBox}.
 38 |      * @param animation a pair of in and out animations
 39 |      */
 40 |     public AnimatedHBox(AnimationPair animation) {
 41 |         this(animation.getIn(), animation.getOut());
 42 |     }
 43 | 
 44 |     /**
 45 |      * Instantiates an {@link AnimatedHBox}.
 46 |      * @param animationIn entrance animation
 47 |      * @param animationOut exit animation
 48 |      */
 49 |     public AnimatedHBox(AnimationFX animationIn, AnimationFX animationOut) {
 50 |         this(new Animation(animationIn), new Animation(animationOut));
 51 |     }
 52 | 
 53 |     /**
 54 |      * Instantiates an {@link AnimatedHBox} with default animations.
 55 |      */
 56 |     public AnimatedHBox() {
 57 |         this(AnimationPair.fade());
 58 |     }
 59 | 
 60 |     /**
 61 |      * {@inheritDoc}
 62 |      */
 63 |     @Override
 64 |     public ObjectProperty<Animation> animationInProperty() {
 65 |         return this.in;
 66 |     }
 67 | 
 68 |     /**
 69 |      * {@inheritDoc}
 70 |      */
 71 |     @Override
 72 |     public Animation getIn() {
 73 |         // This overriden method is required for FXML compatibility.
 74 |         return AnimatedContainer.super.getIn();
 75 |     }
 76 | 
 77 |     /**
 78 |      * {@inheritDoc}
 79 |      */
 80 |     @Override
 81 |     public void setIn(Animation in) {
 82 |         // This overriden method is required for FXML compatibility.
 83 |         AnimatedContainer.super.setIn(in);
 84 |     }
 85 | 
 86 |     /**
 87 |      * {@inheritDoc}
 88 |      */
 89 |     @Override
 90 |     public ObjectProperty<Animation> animationOutProperty() {
 91 |         return this.out;
 92 |     }
 93 | 
 94 |     /**
 95 |      * {@inheritDoc}
 96 |      */
 97 |     @Override
 98 |     public Animation getOut() {
 99 |         // This overriden method is required for FXML compatibility.
100 |         return AnimatedContainer.super.getOut();
101 |     }
102 | 
103 |     /**
104 |      * {@inheritDoc}
105 |      */
106 |     @Override
107 |     public void setOut(Animation out) {
108 |         // This overriden method is required for FXML compatibility.
109 |         AnimatedContainer.super.setOut(out);
110 |     }
111 | 
112 |     /**
113 |      * {@inheritDoc}
114 |      */
115 |     @Override
116 |     public Direction getDirection() {
117 |         return Direction.HORIZONTAL;
118 |     }
119 | 
120 |     /**
121 |      * {@inheritDoc}
122 |      */
123 |     @Override
124 |     public BooleanProperty pausedProperty() {
125 |         return pausedProperty;
126 |     }
127 | 
128 |     /**
129 |      * {@inheritDoc}
130 |      */
131 |     @Override
132 |     public ObjectProperty<Curve> relocationCurveProperty() {
133 |         return relocationCurveProperty;
134 |     }
135 | }
136 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/util/PositionUtils.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.util;
  2 | 
  3 | import javafx.beans.binding.Bindings;
  4 | import javafx.beans.property.DoubleProperty;
  5 | import javafx.beans.property.ReadOnlyDoubleProperty;
  6 | import javafx.beans.property.ReadOnlyObjectProperty;
  7 | import javafx.geometry.Bounds;
  8 | import javafx.geometry.HPos;
  9 | import javafx.geometry.Pos;
 10 | import javafx.geometry.VPos;
 11 | 
 12 | /**
 13 |  * Position and alignment utilities.
 14 |  */
 15 | public final class PositionUtils {
 16 | 
 17 |     private PositionUtils() {
 18 |     }
 19 | 
 20 |     /**
 21 |      * @param alignment position to calculate the X coordinate for
 22 |      * @param areaWidth width of the available area
 23 |      * @return the X coordinate at the given position within an area
 24 |      */
 25 |     public static double getX(Pos alignment, double areaWidth) {
 26 |         switch (alignment.getHpos()) {
 27 |             case CENTER:
 28 |                 return areaWidth / 2;
 29 |             case RIGHT:
 30 |                 return areaWidth;
 31 |             default:
 32 |                 return 0;
 33 |         }
 34 |     }
 35 | 
 36 |     /**
 37 |      * @param alignment position to calculate the Y coordinate for
 38 |      * @param areaHeight height of the available area
 39 |      * @return the Y coordinate at the given position within a scene
 40 |      */
 41 |     public static double getY(Pos alignment, double areaHeight) {
 42 |         switch (alignment.getVpos()) {
 43 |             case CENTER:
 44 |                 return areaHeight / 2;
 45 |             case BOTTOM:
 46 |                 return areaHeight;
 47 |             default:
 48 |                 return 0;
 49 |         }
 50 |     }
 51 | 
 52 |     /**
 53 |      * @return whether the horizontal alignment requires position binding
 54 |      */
 55 |     public static boolean requiresXBinding(Pos alignment) {
 56 |         return alignment.getHpos() != HPos.LEFT;
 57 |     }
 58 | 
 59 |     /**
 60 |      * @return whether the vertical alignment requires position binding
 61 |      */
 62 |     public static boolean requiresYBinding(Pos alignment) {
 63 |         return alignment.getVpos() != VPos.TOP;
 64 |     }
 65 | 
 66 |     /**
 67 |      * Binds X and Y coordinate properties to a position that guarantees the given alignment within the given area.
 68 |      * @param xProperty X coordinate property to bind
 69 |      * @param yProperty Y coordinate property to bind
 70 |      * @param areaProperty available area property
 71 |      * @param alignment position to bind to, relative to the scene
 72 |      */
 73 |     public static void bindAlignmentToArea(DoubleProperty xProperty, DoubleProperty yProperty,
 74 |                                            ReadOnlyObjectProperty<Bounds> areaProperty,
 75 |                                            Pos alignment) {
 76 |         if (requiresXBinding(alignment)) {
 77 |             xProperty.bind(Bindings.createObjectBinding(
 78 |                     () -> getX(alignment, areaProperty.get().getWidth()),
 79 |                     areaProperty
 80 |             ));
 81 |         }
 82 |         if (requiresYBinding(alignment)) {
 83 |             yProperty.bind(Bindings.createObjectBinding(
 84 |                     () -> getY(alignment, areaProperty.get().getHeight()),
 85 |                     areaProperty
 86 |             ));
 87 |         }
 88 |     }
 89 | 
 90 |     /**
 91 |      * Binds X and Y properties to a position that anchors the selected corner to the given alignment.
 92 |      * For example, a rectangle with a <tt>TOP_RIGHT</tt> alignment sets its top right corner as
 93 |      * its origin point.
 94 |      * @param xProperty X coordinate property to bind
 95 |      * @param yProperty Y coordinate property to bind
 96 |      * @param widthProperty width property of the node
 97 |      * @param heightProperty height property of the node
 98 |      * @param alignment position to bind to, relative to the scene
 99 |      */
100 |     public static void bindCornerAlignment(DoubleProperty xProperty, DoubleProperty yProperty,
101 |                                            ReadOnlyDoubleProperty widthProperty, ReadOnlyDoubleProperty heightProperty,
102 |                                            Pos alignment) {
103 |         switch (alignment.getHpos()) {
104 |             case CENTER:
105 |                 xProperty.bind(widthProperty.divide(-2));
106 |                 break;
107 |             case RIGHT:
108 |                 xProperty.bind(widthProperty.negate());
109 |                 break;
110 |         }
111 | 
112 |         switch (alignment.getVpos()) {
113 |             case CENTER:
114 |                 yProperty.bind(heightProperty.divide(-2));
115 |                 break;
116 |             case BOTTOM:
117 |                 yProperty.bind(heightProperty.negate());
118 |                 break;
119 |         }
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/animation/SimpleAnimationProperty.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.binding.property.animation;
  2 | 
  3 | import eu.iamgio.animated.binding.Animated;
  4 | import eu.iamgio.animated.binding.AnimationSettings;
  5 | import eu.iamgio.animated.binding.event.AnimationEvent;
  6 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
  7 | import javafx.animation.*;
  8 | import javafx.beans.property.ObjectProperty;
  9 | import javafx.beans.property.Property;
 10 | import javafx.event.EventHandler;
 11 | import javafx.scene.Node;
 12 | 
 13 | import java.util.function.Function;
 14 | 
 15 | /**
 16 |  * The base implementation of {@link AnimationProperty} that plays a timeline-based animation
 17 |  * whenever the value of the wrapped property changes.
 18 |  * @param <T> type of the wrapped value
 19 |  * @author Giorgio Garofalo
 20 |  */
 21 | public class SimpleAnimationProperty<T> extends AnimationProperty<T> {
 22 | 
 23 |     // Animation timeline
 24 |     private final Timeline timeline;
 25 | 
 26 |     // Last time an animation frame was played (in millis)
 27 |     private double lastUpdate;
 28 | 
 29 |     // Last value the timeline changed
 30 |     private T lastValue;
 31 | 
 32 |     // Whether the changes should be handled (internally handled)
 33 |     private boolean handleChanges = false;
 34 | 
 35 |     /**
 36 |      * Instantiates an implicitly animated property
 37 |      * @param property target property
 38 |      * @param settings animation settings
 39 |      */
 40 |     public SimpleAnimationProperty(PropertyWrapper<T> property, AnimationSettings settings) {
 41 |         super(property, settings);
 42 |         this.timeline = new Timeline();
 43 | 
 44 |         timeline.currentTimeProperty().addListener(o -> {
 45 |             lastUpdate = timeline.getCurrentTime().toMillis();
 46 |             lastValue = property.getValue();
 47 |         });
 48 | 
 49 |         timeline.setOnFinished(e -> fireEvent(onAnimationEndedProperty(), new AnimationEvent(false)));
 50 |     }
 51 | 
 52 |     /**
 53 |      * Instantiates an implicitly animated property
 54 |      * @param property target property
 55 |      */
 56 |     public SimpleAnimationProperty(PropertyWrapper<T> property) {
 57 |         this(property, new AnimationSettings());
 58 |     }
 59 | 
 60 |     /**
 61 |      * Plays the animation
 62 |      * @param value new property value
 63 |      * @param interrupted whether the animation was interrupted before it could finish as expected
 64 |      */
 65 |     private void handleChanges(T value, boolean interrupted) {
 66 |         // Temporarily stop the timeline in case it is currently running
 67 |         if (interrupted) {
 68 |             timeline.stop();
 69 |             this.fireEvent(onAnimationEndedProperty(), new AnimationEvent(true));
 70 |         }
 71 | 
 72 |         final AnimationSettings settings = getSettings();
 73 |         Interpolator interpolator = settings.getCurve().toInterpolator();
 74 | 
 75 |         // Set keyframes
 76 |         timeline.getKeyFrames().setAll(
 77 |                 new KeyFrame(settings.getDuration(), new KeyValue(getProperty().getProperty(), value, interpolator))
 78 |         );
 79 | 
 80 |         // Play the animation
 81 |         timeline.play();
 82 | 
 83 |         this.fireEvent(onAnimationStartedProperty(), new AnimationEvent(interrupted));
 84 |     }
 85 | 
 86 |     private boolean isRunning() {
 87 |         return timeline.getStatus() == Animation.Status.RUNNING;
 88 |     }
 89 | 
 90 |     /**
 91 |      * @return whether the current property change was fired by the animation or by an external source
 92 |      */
 93 |     private boolean isAnimationFrame(T oldPropertyValue, T newPropertyValue) {
 94 |         return timeline.getCurrentTime().toMillis() == lastUpdate && (newPropertyValue.equals(lastValue) || oldPropertyValue.equals(lastValue));
 95 |     }
 96 | 
 97 |     /**
 98 |      * {@inheritDoc}
 99 |      */
100 |     public void register(Node target) {
101 |         getProperty().addListener(((observable, oldValue, newValue) -> {
102 |             if (isPaused() || (target != null && target.getScene() == null)) {
103 |                 return;
104 |             }
105 | 
106 |             boolean running = isRunning();
107 |             if (!running || !isAnimationFrame(oldValue, newValue)) {
108 |                 if (handleChanges ^= true) {
109 |                     getProperty().set(oldValue);
110 |                     handleChanges(newValue, running);
111 |                 }
112 |             }
113 |         }));
114 |     }
115 | 
116 |     /**
117 |      * {@inheritDoc}
118 |      */
119 |     @Override
120 |     public void attachTo(Animated animated) {
121 |         this.register(animated.getChild());
122 |     }
123 | 
124 |     /**
125 |      * {@inheritDoc}
126 |      */
127 |     @Override
128 |     public <V> AnimationProperty<T> addBinding(Property<V> targetProperty, Function<T, V> mapper) {
129 |         getProperty().bindMapped(targetProperty, mapper);
130 |         return this;
131 |     }
132 | 
133 |     private void fireEvent(ObjectProperty<EventHandler<AnimationEvent>> handlerProperty, AnimationEvent event) {
134 |         EventHandler<? super AnimationEvent> handler = handlerProperty.get();
135 |         if (handler != null) {
136 |             handler.handle(event);
137 |         }
138 |     }
139 | }
140 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/AnimatedSwitcher.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition;
  2 | 
  3 | import animatefx.animation.AnimationFX;
  4 | import eu.iamgio.animated.common.Pausable;
  5 | import javafx.beans.property.BooleanProperty;
  6 | import javafx.beans.property.ObjectProperty;
  7 | import javafx.beans.property.SimpleBooleanProperty;
  8 | import javafx.beans.property.SimpleObjectProperty;
  9 | import javafx.scene.Node;
 10 | import javafx.scene.Parent;
 11 | 
 12 | /**
 13 |  * This node plays a transition when its child node changes.
 14 |  * @author Giorgio Garofalo
 15 |  */
 16 | public class AnimatedSwitcher extends Parent implements Pausable, EntranceAndExitAnimationCompatible {
 17 | 
 18 |     private final ObjectProperty<Animation> in;
 19 |     private final ObjectProperty<Animation> out;
 20 | 
 21 |     private final ObjectProperty<Node> child = new SimpleObjectProperty<>();
 22 |     private final BooleanProperty pausedProperty = new SimpleBooleanProperty(false);
 23 | 
 24 |     // Whether the handler has been set
 25 |     private boolean isHandlerRegistered;
 26 | 
 27 |     private void handleChanges(Node oldChild, Node newChild) {
 28 |         if (isPaused()) {
 29 |             getChildren().setAll(newChild);
 30 |             return;
 31 |         }
 32 |         if (newChild != null) {
 33 |             in.get().playIn(newChild, getChildren());
 34 |         }
 35 |         if (oldChild != null) {
 36 |             out.get().playOut(oldChild, getChildren());
 37 |         }
 38 |     }
 39 | 
 40 |     /**
 41 |      * Registers the listener
 42 |      */
 43 |     private void registerHandler() {
 44 |         isHandlerRegistered = true;
 45 |         child.addListener((observable, oldChild, newChild) -> handleChanges(oldChild, newChild));
 46 |     }
 47 | 
 48 |     /**
 49 |      * Instantiates an {@link AnimatedSwitcher}. {@link Animation} wraps an {@link AnimationFX} allowing customization.
 50 |      * @param animationIn non-null entrance animation
 51 |      * @param animationOut non-null exit animation
 52 |      */
 53 |     public AnimatedSwitcher(Animation animationIn, Animation animationOut) {
 54 |         this.in = new SimpleObjectProperty<>(Animation.requireNonNull(animationIn));
 55 |         this.out = new SimpleObjectProperty<>(Animation.requireNonNull(animationOut));
 56 |     }
 57 | 
 58 |     /**
 59 |      * Instantiates an {@link AnimatedSwitcher}.
 60 |      * @param animation a pair of in and out animations
 61 |      */
 62 |     public AnimatedSwitcher(AnimationPair animation) {
 63 |         this(animation.getIn(), animation.getOut());
 64 |     }
 65 | 
 66 |     /**
 67 |      * Instantiates an {@link AnimatedSwitcher}.
 68 |      * @param animationIn non-null raw entrance animation
 69 |      * @param animationOut non-null raw exit animation
 70 |      */
 71 |     public AnimatedSwitcher(AnimationFX animationIn, AnimationFX animationOut) {
 72 |         this(new Animation(animationIn), new Animation(animationOut));
 73 |     }
 74 | 
 75 |     /**
 76 |      * Instantiates an {@link AnimatedSwitcher} with default animations.
 77 |      */
 78 |     public AnimatedSwitcher() {
 79 |         this(AnimationPair.fade());
 80 |     }
 81 | 
 82 |     /**
 83 |      * Sets the initial child without playing the animation.
 84 |      * @param child initial child
 85 |      * @return this for concatenation
 86 |      * @throws IllegalStateException if child is already set
 87 |      */
 88 |     public AnimatedSwitcher of(Node child) {
 89 |         if (getChild() != null) {
 90 |             throw new IllegalStateException("Cannot use AnimatedSwitcher#of: child is already set. Use setChild instead.");
 91 |         }
 92 |         if (child != null) {
 93 |             getChildren().add(child);
 94 |         }
 95 | 
 96 |         this.child.set(child);
 97 |         if (!isHandlerRegistered) {
 98 |             registerHandler();
 99 |         }
100 | 
101 |         return this;
102 |     }
103 | 
104 |     /**
105 |      * @return current child
106 |      */
107 |     public ObjectProperty<Node> childProperty() {
108 |         return this.child;
109 |     }
110 | 
111 |     /**
112 |      * @return current child
113 |      */
114 |     public Node getChild() {
115 |         return child.get();
116 |     }
117 | 
118 |     /**
119 |      * @param child child to set
120 |      */
121 |     public void setChild(Node child) {
122 |         if (!isHandlerRegistered) {
123 |             registerHandler();
124 |         }
125 |         this.child.set(child);
126 |     }
127 | 
128 |     /**
129 |      * {@inheritDoc}
130 |      */
131 |     @Override
132 |     public ObjectProperty<Animation> animationInProperty() {
133 |         return this.in;
134 |     }
135 | 
136 |     /**
137 |      * {@inheritDoc}
138 |      */
139 |     @Override
140 |     public Animation getIn() {
141 |         // This overriden method is required for FXML compatibility.
142 |         return EntranceAndExitAnimationCompatible.super.getIn();
143 |     }
144 | 
145 |     /**
146 |      * {@inheritDoc}
147 |      */
148 |     @Override
149 |     public void setIn(Animation in) {
150 |         // This overriden method is required for FXML compatibility.
151 |         EntranceAndExitAnimationCompatible.super.setIn(in);
152 |     }
153 | 
154 |     /**
155 |      * {@inheritDoc}
156 |      */
157 |     @Override
158 |     public ObjectProperty<Animation> animationOutProperty() {
159 |         return this.out;
160 |     }
161 | 
162 |     /**
163 |      * {@inheritDoc}
164 |      */
165 |     @Override
166 |     public Animation getOut() {
167 |         // This overriden method is required for FXML compatibility.
168 |         return EntranceAndExitAnimationCompatible.super.getOut();
169 |     }
170 | 
171 |     /**
172 |      * {@inheritDoc}
173 |      */
174 |     @Override
175 |     public void setOut(Animation out) {
176 |         // This overriden method is required for FXML compatibility.
177 |         EntranceAndExitAnimationCompatible.super.setOut(out);
178 |     }
179 | 
180 |     /**
181 |      * {@inheritDoc}
182 |      */
183 |     @Override
184 |     public BooleanProperty pausedProperty() {
185 |         return pausedProperty;
186 |     }
187 | }
188 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/AnimationPair.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition;
  2 | 
  3 | import animatefx.animation.*;
  4 | 
  5 | /**
  6 |  * Class that takes two {@link Animation}s: one for in, one for out.
  7 |  * @author Giorgio Garofalo
  8 |  */
  9 | public class AnimationPair {
 10 | 
 11 |     private final Animation animationIn;
 12 |     private final Animation animationOut;
 13 | 
 14 |     /**
 15 |      * Instantiates a {@link AnimationPair} and passes its two required animations.
 16 |      * @param animationIn non-null entrance animation
 17 |      * @param animationOut non-null exit animation
 18 |      */
 19 |     public AnimationPair(Animation animationIn, Animation animationOut) {
 20 |         this.animationIn = Animation.requireNonNull(animationIn);
 21 |         this.animationOut = Animation.requireNonNull(animationOut);
 22 |     }
 23 | 
 24 |     /**
 25 |      * Instantiates a {@link AnimationPair} and passes its two required animations.
 26 |      * @param animationIn non-null entrance animation
 27 |      * @param animationOut non-null exit animation
 28 |      */
 29 |     public AnimationPair(AnimationFX animationIn, AnimationFX animationOut) {
 30 |         this(new Animation(animationIn), new Animation(animationOut));
 31 |     }
 32 | 
 33 |     /**
 34 |      * Instantiates a {@link AnimationPair} and passes its two required animations.
 35 |      * @param animationIn non-null entrance (wrapped) animation
 36 |      * @param animationOut non-null exit (unwrapped) animation
 37 |      */
 38 |     public AnimationPair(Animation animationIn, AnimationFX animationOut) {
 39 |         this(animationIn, new Animation(animationOut));
 40 |     }
 41 | 
 42 |     /**
 43 |      * Instantiates a {@link AnimationPair} and passes its two required animations.
 44 |      * @param animationIn non-null entrance (unwrapped) animation
 45 |      * @param animationOut non-null exit (wrapped) animation
 46 |      */
 47 |     public AnimationPair(AnimationFX animationIn, Animation animationOut) {
 48 |         this(new Animation(animationIn), animationOut);
 49 |     }
 50 | 
 51 |     /**
 52 |      * @return entrance animation
 53 |      */
 54 |     public Animation getIn() {
 55 |         return animationIn;
 56 |     }
 57 | 
 58 |     /**
 59 |      * @return exit animation
 60 |      */
 61 |     public Animation getOut() {
 62 |         return animationOut;
 63 |     }
 64 | 
 65 |     /**
 66 |      * @param speedIn speed multiplier to set to the entrance animation
 67 |      * @param speedOut speed multiplier to set to the exit animation
 68 |      * @return this for concatenation
 69 |      */
 70 |     public AnimationPair setSpeed(double speedIn, double speedOut) {
 71 |         animationIn.setSpeed(speedIn);
 72 |         animationOut.setSpeed(speedOut);
 73 |         return this;
 74 |     }
 75 | 
 76 |     /**
 77 |      * @return fade-in / fade-out animation
 78 |      * @see FadeIn
 79 |      * @see FadeIn
 80 |      */
 81 |     public static AnimationPair fade() {
 82 |         return new AnimationPair(new FadeIn(), new FadeOut());
 83 |     }
 84 | 
 85 |     /**
 86 |      * @return fade-in-up / fade-out-up animation
 87 |      * @see FadeInUp
 88 |      * @see FadeOutUp
 89 |      */
 90 |     public static AnimationPair fadeUp() {
 91 |         return new AnimationPair(new FadeInUp(), new FadeOutUp());
 92 |     }
 93 | 
 94 |     /**
 95 |      * @return fade-in-down / fade-out-down animation
 96 |      * @see FadeInDown
 97 |      * @see FadeOutDown
 98 |      */
 99 |     public static AnimationPair fadeDown() {
100 |         return new AnimationPair(new FadeInDown(), new FadeOutDown());
101 |     }
102 | 
103 |     /**
104 |      * @return fade-in-left / fade-out-left animation
105 |      * @see FadeInLeft
106 |      * @see FadeOutLeft
107 |      */
108 |     public static AnimationPair fadeLeft() {
109 |         return new AnimationPair(new FadeInLeft(), new FadeOutLeft());
110 |     }
111 | 
112 |     /**
113 |      * @return fade-in-right / fade-out-right animation
114 |      * @see FadeInRight
115 |      * @see FadeOutRight
116 |      */
117 |     public static AnimationPair fadeRight() {
118 |         return new AnimationPair(new FadeInRight(), new FadeOutRight());
119 |     }
120 | 
121 |     /**
122 |      * @return zoom-in / zoom-out animation
123 |      * @see ZoomIn
124 |      * @see ZoomOut
125 |      */
126 |     public static AnimationPair zoom() {
127 |         return new AnimationPair(new ZoomIn(), new ZoomOut());
128 |     }
129 | 
130 |     /**
131 |      * @return rotate-in / rotate-out animation
132 |      * @see RotateIn
133 |      * @see RotateOut
134 |      */
135 |     public static AnimationPair rotate() {
136 |         return new AnimationPair(new RotateIn(), new RotateOut());
137 |     }
138 | 
139 |     /**
140 |      * @return bounce-in / bounce-out animation
141 |      * @see BounceIn
142 |      * @see BounceOut
143 |      */
144 |     public static AnimationPair bounce() {
145 |         return new AnimationPair(new BounceIn(), new BounceOut());
146 |     }
147 | 
148 |     /**
149 |      * @return roll-in / roll-out animation
150 |      * @see RollIn
151 |      * @see RollOut
152 |      */
153 |     public static AnimationPair roll() {
154 |         return new AnimationPair(new RollIn(), new RollOut());
155 |     }
156 | 
157 |     /**
158 |      * @return slide-in-up / slide-out-up animation
159 |      * @see SlideInUp
160 |      * @see SlideOutUp
161 |      */
162 |     public static AnimationPair slideUp() {
163 |         return new AnimationPair(new SlideInUp(), new SlideOutUp());
164 |     }
165 | 
166 |     /**
167 |      * @return slide-in-down / slide-out-down animation
168 |      * @see SlideInDown
169 |      * @see SlideOutDown
170 |      */
171 |     public static AnimationPair slideDown() {
172 |         return new AnimationPair(new SlideInDown(), new SlideOutDown());
173 |     }
174 | 
175 |     /**
176 |      * @return slide-in-left / slide-out-left animation
177 |      * @see SlideInLeft
178 |      * @see SlideOutLeft
179 |      */
180 |     public static AnimationPair slideLeft() {
181 |         return new AnimationPair(new SlideInLeft(), new SlideOutLeft());
182 |     }
183 | 
184 |     /**
185 |      * @return slide-in-right / slide-out-right animation
186 |      * @see SlideInRight
187 |      * @see SlideOutRight
188 |      */
189 |     public static AnimationPair slideRight() {
190 |         return new AnimationPair(new SlideInRight(), new SlideOutRight());
191 |     }
192 | }
193 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/common/Curve.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.common;
  2 | 
  3 | import eu.iamgio.animated.binding.AnimationSettings;
  4 | import javafx.animation.Interpolator;
  5 | 
  6 | import java.util.function.Function;
  7 | 
  8 | import static java.lang.Math.*;
  9 | 
 10 | /**
 11 |  * A group of curves that affect the interpolation of an animation.
 12 |  * @author Giorgio Garofalo
 13 |  * @see AnimationSettings#withCurve(Curve)
 14 |  */
 15 | public enum Curve {
 16 | 
 17 |     /**
 18 |      * A curve that keeps the same value throughout its execution.
 19 |      */
 20 |     LINEAR(t -> t),
 21 | 
 22 | 
 23 |     //
 24 |     // EASE OUT CURVES
 25 |     //
 26 | 
 27 | 
 28 |     /**
 29 |      * @see <a href="https://easings.net/#easeOutCubic">on easings.net</a>
 30 |      */
 31 |     EASE_OUT(t -> 1 - (1 - t) * (1 - t) * (1 - t)),
 32 | 
 33 |     /**
 34 |      * @see <a href="https://easings.net/#easeOutSine">on easings.net</a>
 35 |      */
 36 |     EASE_OUT_SINE(t -> sin((t * PI) / 2)),
 37 | 
 38 |     /**
 39 |      * @see <a href="https://easings.net/#easeOutExpo">on easings.net</a>
 40 |      */
 41 |     EASE_OUT_EXPO(t -> t == 1 ? 1 : 1 - pow(2, -10 * t)),
 42 | 
 43 |     /**
 44 |      * @see <a href="https://easings.net/#easeOutBack">on easings.net</a>
 45 |      */
 46 |     EASE_OUT_BACK(t -> {
 47 |         double c1 = 1.70158;
 48 |         double c3 = c1 + 1;
 49 | 
 50 |         return 1 + c3 * pow(t - 1, 3) + c1 * pow(t - 1, 2);
 51 |     }),
 52 | 
 53 |     /**
 54 |      * @see <a href="https://easings.net/#easeOutBounce">on easings.net</a>
 55 |      */
 56 |     EASE_OUT_BOUNCE(t -> {
 57 |         double n = 7.5625;
 58 |         double d = 2.75;
 59 |         if (t < 1 / d) {
 60 |             return n * t * t;
 61 |         } else if (t < 2 / d) {
 62 |             return n * (t -= 1.5 / d) * t + 0.75;
 63 |         } else if (t < 2.5 / d) {
 64 |             return n * (t -= 2.25 / d) * t + 0.9375;
 65 |         } else {
 66 |             return n * (t -= 2.625 / d) * t + 0.984375;
 67 |         }
 68 |     }),
 69 | 
 70 |     /**
 71 |      * @see <a href="https://easings.net/#easeOutElastic">on easings.net</a>
 72 |      */
 73 |     EASE_OUT_ELASTIC(t -> {
 74 |         double c = (2 * Math.PI) / 3;
 75 | 
 76 |         return t == 0
 77 |                 ? 0
 78 |                 : t == 1
 79 |                 ? 1
 80 |                 : pow(2, -10 * t) * sin((t * 10 - 0.75) * c) + 1;
 81 |     }),
 82 | 
 83 | 
 84 |     //
 85 |     // EASE IN CURVES
 86 |     //
 87 | 
 88 | 
 89 |     /**
 90 |      * @see <a href="https://easings.net/#easeInCubic">on easings.net</a>
 91 |      */
 92 |     EASE_IN(t -> t * t * t),
 93 | 
 94 |     /**
 95 |      * @see <a href="https://easings.net/#easeInSine">on easings.net</a>
 96 |      */
 97 |     EASE_IN_SINE(t -> 1 - cos((t * PI) / 2)),
 98 | 
 99 |     /**
100 |      * @see <a href="https://easings.net/#easeInExpo">on easings.net</a>
101 |      */
102 |     EASE_IN_EXPO(t -> t == 0 ? 0 : pow(2, 10 * t - 10)),
103 | 
104 |     /**
105 |      * @see <a href="https://easings.net/#easeInBack">on easings.net</a>
106 |      */
107 |     EASE_IN_BACK(t -> {
108 |         double c1 = 1.70158;
109 |         double c3 = c1 + 1;
110 | 
111 |         return c3 * t * t * t - c1 * t * t;
112 |     }),
113 | 
114 |     /**
115 |      * @see <a href="https://easings.net/#easeInBounce">on easings.net</a>
116 |      */
117 |     EASE_IN_BOUNCE(t -> 1 - EASE_OUT_BOUNCE.curve.apply(1 - t)),
118 | 
119 |     /**
120 |      * @see <a href="https://easings.net/#easeInElastic">on easings.net</a>
121 |      */
122 |     EASE_IN_ELASTIC(t -> {
123 |         double c = (2 * PI) / 3;
124 | 
125 |         return t == 0
126 |                 ? 0
127 |                 : t == 1
128 |                 ? 1
129 |                 : -pow(2, 10 * t - 10) * sin((t * 10 - 10.75) * c);
130 |     }),
131 | 
132 | 
133 |     //
134 |     // EASE IN OUT CURVES
135 |     //
136 | 
137 | 
138 |     /**
139 |      * @see <a href="https://easings.net/#easeInOutCubic">on easings.net</a>
140 |      */
141 |     EASE_IN_OUT(t -> t < 0.5 ? 4 * t * t * t : 1 - pow(-2 * t + 2, 3) / 2),
142 | 
143 |     /**
144 |      * @see <a href="https://easings.net/#easeInOutSine">on easings.net</a>
145 |      */
146 |     EASE_IN_OUT_SINE(t -> -(cos(PI * t) - 1) / 2),
147 | 
148 |     /**
149 |      * @see <a href="https://easings.net/#easeInOutExpo">on easings.net</a>
150 |      */
151 |     EASE_IN_OUT_EXPO(t -> t == 0 ? 0 : t == 1 ? 1 : t < 0.5 ? pow(2, 20 * t - 10) / 2 : (2 - pow(2, -20 * t + 10)) / 2),
152 | 
153 |     /**
154 |      * @see <a href="https://easings.net/#easeInOutBack">on easings.net</a>
155 |      */
156 |     EASE_IN_OUT_BACK(t -> {
157 |         double c1 = 1.70158;
158 |         double c2 = c1 * 1.525;
159 | 
160 |         return t < 0.5 ? (pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2)) / 2 : (pow(2 * t - 2,
161 |                 2) * ((c2 + 1) * (t * 2 - 2) + c2) + 2) / 2;
162 |     }),
163 | 
164 |     /**
165 |      * @see <a href="https://easings.net/#easeInOutBounce">on easings.net</a>
166 |      */
167 |     EASE_IN_OUT_BOUNCE(t -> t < 0.5
168 |             ? (1 - EASE_OUT_BOUNCE.curve.apply(1 - 2 * t)) / 2
169 |             : (1 + EASE_IN_BOUNCE.curve.apply(2 * t - 1)) / 2),
170 | 
171 |     /**
172 |      * @see <a href="https://easings.net/#easeInOutElastic">on easings.net</a>
173 |      */
174 |     EASE_IN_OUT_ELASTIC(t -> {
175 |         double c = (2 * PI) / 4.5;
176 |         double sin = sin((20 * t - 11.125) * c);
177 | 
178 |         return t == 0
179 |                 ? 0
180 |                 : t == 1
181 |                 ? 1
182 |                 : t < 0.5
183 |                 ? -(pow(2, 20 * t - 10) * sin) / 2
184 |                 : (pow(2, -20 * t + 10) * sin) / 2 + 1;
185 |     });
186 | 
187 | 
188 |     //
189 |     // END OF CURVES
190 |     //
191 | 
192 |     private final Function<Double, Double> curve;
193 | 
194 |     Curve(Function<Double, Double> curve) {
195 |         this.curve = curve;
196 |     }
197 | 
198 |     /**
199 |      * @return the function that describes this curve
200 |      */
201 |     public Function<Double, Double> getCurveFunction() {
202 |         return curve;
203 |     }
204 | 
205 |     /**
206 |      * @return this curve to a JavaFX timeline interpolator
207 |      */
208 |     public Interpolator toInterpolator() {
209 |         return new Interpolator() {
210 |             @Override
211 |             protected double curve(double t) {
212 |                 return curve.apply(t);
213 |             }
214 |         };
215 |     }
216 | }
217 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/container/AnimatedContainerHandler.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition.container;
  2 | 
  3 | import eu.iamgio.animated.common.Curve;
  4 | import eu.iamgio.animated.transition.Animation;
  5 | import javafx.animation.KeyFrame;
  6 | import javafx.animation.KeyValue;
  7 | import javafx.animation.Timeline;
  8 | import javafx.application.Platform;
  9 | import javafx.beans.property.DoubleProperty;
 10 | import javafx.collections.ListChangeListener;
 11 | import javafx.collections.ObservableList;
 12 | import javafx.geometry.Bounds;
 13 | import javafx.scene.Node;
 14 | import javafx.util.Duration;
 15 | 
 16 | import java.util.ArrayList;
 17 | import java.util.HashSet;
 18 | import java.util.List;
 19 | import java.util.Set;
 20 | 
 21 | /**
 22 |  * Utility class that handles {@link AnimatedContainer}'s features.
 23 |  */
 24 | class AnimatedContainerHandler {
 25 | 
 26 |     // Nodes whose animation should be temporarily skipped.
 27 |     private static final Set<Node> skipped = new HashSet<>();
 28 | 
 29 |     /**
 30 |      * Registers the listener.
 31 |      * @param container container to animate
 32 |      */
 33 |     static void register(AnimatedContainer container) {
 34 |         container.getChildren().addListener((ListChangeListener<? super Node>) change -> {
 35 |             while(!container.isPaused() && change.next()) {
 36 |                 // Animate inserted nodes
 37 |                 if(container.getIn().getAnimationFX() != null) {
 38 |                     playIn(change, container);
 39 |                 }
 40 |                 // Animate removed nodes
 41 |                 if(container.getOut().getAnimationFX() != null) {
 42 |                     playOut(change, container);
 43 |                 }
 44 |             }
 45 |         });
 46 |     }
 47 | 
 48 |     /**
 49 |      * Plays the entrance animation for each added node.
 50 |      * @param change change that affected the children
 51 |      * @param container animated container to handle
 52 |      */
 53 |     private static void playIn(ListChangeListener.Change<? extends Node> change, AnimatedContainer container) {
 54 |         for(Node child : change.getAddedSubList()) {
 55 |             if(skipped.contains(child)) {
 56 |                 skipped.remove(child);
 57 |                 continue;
 58 |             }
 59 | 
 60 |             container.getIn().playIn(child, null);
 61 |             Platform.runLater(() -> relocate(
 62 |                     container,
 63 |                     container.getIn(),
 64 |                     change.getFrom(),
 65 |                     false
 66 |             ));
 67 |         }
 68 |     }
 69 | 
 70 |     /**
 71 |      * Plays the exit animation for each removed node.
 72 |      * @param change change that affected the children
 73 |      * @param container animated container to handle
 74 |      */
 75 |     private static void playOut(ListChangeListener.Change<? extends Node> change, AnimatedContainer container) {
 76 |         for (Node child : change.getRemoved()) {
 77 |             if (skipped.contains(child)) {
 78 |                 skipped.remove(child);
 79 |                 continue;
 80 |             }
 81 | 
 82 |             skipped.add(child);
 83 |             Platform.runLater(() -> {
 84 |                 container.getChildren().add(change.getFrom(), child);
 85 |                 skipped.add(child);
 86 |                 container.getOut().playOut(child, container.getChildren());
 87 |                 relocate(
 88 |                         container,
 89 |                         container.getOut(),
 90 |                         change.getFrom(),
 91 |                         true
 92 |                 );
 93 |             });
 94 |         }
 95 |     }
 96 | 
 97 |     /**
 98 |      * Updates the node's translate X or Y depending on the direction of the container.
 99 |      * @param node target node
100 |      * @param direction direction of the container
101 |      * @param translate new translation value
102 |      */
103 |     private static void setTranslate(Node node, AnimatedContainer.Direction direction, double translate) {
104 |         switch(direction) {
105 |             case HORIZONTAL:
106 |                 node.setTranslateX(translate);
107 |                 break;
108 |             case VERTICAL:
109 |                 node.setTranslateY(translate);
110 |                 break;
111 |         }
112 |     }
113 | 
114 |     /**
115 |      * Animates next nodes' position in order to have a smooth animation.
116 |      * @param container animated container to handle
117 |      * @param animation last animation to relocate from
118 |      * @param index start index
119 |      * @param reverse whether the animation should be reversed (exit) or not (entrance)
120 |      */
121 |     private static void relocate(AnimatedContainer container, Animation animation, int index, boolean reverse) {
122 |         final ObservableList<Node> children = container.getChildren();
123 |         final double spacing = container.getSpacing();
124 |         final AnimatedContainer.Direction direction = container.getDirection();
125 |         final Curve relocationCurve = container.getRelocationCurve();
126 | 
127 |         final Timeline timeline = new Timeline();
128 | 
129 |         // Affected nodes
130 |         final List<Node> toReset = new ArrayList<>();
131 | 
132 |         // Iterate next nodes
133 |         for (int i = index + 1; i < children.size(); i++) {
134 |             // Target node
135 |             final Node next = children.get(i);
136 |             // Bounds of the affected node
137 |             final Bounds affectedBounds = children.get(index).getBoundsInLocal();
138 | 
139 |             // Determine start (or end if reverse is true) value, based off direction and spacing
140 |             final double start = -((direction == AnimatedContainer.Direction.HORIZONTAL ? affectedBounds.getWidth() : affectedBounds.getHeight()) + spacing);
141 |             setTranslate(next, direction, reverse ? 0 : start);
142 | 
143 |             // Animate translate X/Y
144 |             final Duration duration = animation.getAnimationFX().getTimeline().getCycleDuration().divide(animation.getSpeed());
145 |             final DoubleProperty targetProperty = direction == AnimatedContainer.Direction.HORIZONTAL ? next.translateXProperty() : next.translateYProperty();
146 |             timeline.getKeyFrames().add(
147 |                     new KeyFrame(duration, new KeyValue(targetProperty, reverse ? start : 0, relocationCurve.toInterpolator()))
148 |             );
149 | 
150 |             // This node position will be reset after the animation is complete
151 |             toReset.add(next);
152 |         }
153 | 
154 |         // Reset positions
155 |         timeline.setOnFinished(e -> {
156 |             for (Node node : toReset) {
157 |                 setTranslate(node, direction, 0);
158 |             }
159 |         });
160 | 
161 |         timeline.playFromStart();
162 |     }
163 | }
164 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/AnimatedThemeSwitcher.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition;
  2 | 
  3 | import animatefx.animation.AnimationFX;
  4 | import animatefx.animation.FadeOut;
  5 | import eu.iamgio.animated.common.Pausable;
  6 | import javafx.beans.property.BooleanProperty;
  7 | import javafx.beans.property.ObjectProperty;
  8 | import javafx.beans.property.SimpleBooleanProperty;
  9 | import javafx.beans.property.SimpleObjectProperty;
 10 | import javafx.collections.ListChangeListener;
 11 | import javafx.collections.ObservableList;
 12 | import javafx.geometry.Bounds;
 13 | import javafx.scene.Parent;
 14 | import javafx.scene.Scene;
 15 | import javafx.scene.SnapshotParameters;
 16 | import javafx.scene.image.Image;
 17 | import javafx.scene.image.ImageView;
 18 | import javafx.scene.layout.HBox;
 19 | import javafx.scene.layout.Pane;
 20 | import javafx.scene.layout.VBox;
 21 | import javafx.scene.transform.Scale;
 22 | 
 23 | import java.util.LinkedList;
 24 | import java.util.List;
 25 | 
 26 | /**
 27 |  * An {@link AnimatedThemeSwitcher} provides animated transitions that are played when changing the stylesheets of a {@link Scene}.
 28 |  * @author Giorgio Garofalo
 29 |  */
 30 | public class AnimatedThemeSwitcher implements Pausable, ExitAnimationCompatible {
 31 | 
 32 |     // Defines how bigger the snapshot should be, relatively to scene size.
 33 |     // This avoids blurry images on high DPI screens.
 34 |     private static final double SNAPSHOT_SCALE = 2;
 35 | 
 36 |     private final Scene scene;
 37 | 
 38 |     private final ObjectProperty<Animation> out;
 39 |     private final BooleanProperty pausedProperty = new SimpleBooleanProperty(false);
 40 | 
 41 |     // Whether this switcher has been initialized via init()
 42 |     private boolean initialized;
 43 | 
 44 |     // Whether the changes to the stylesheets should be handled
 45 |     private boolean handleChanges = true;
 46 | 
 47 |     /**
 48 |      * Instantiates an {@link AnimatedThemeSwitcher}.
 49 |      * In order for this switcher to work, {@link #init()} has to be called.
 50 |      * @param scene JavaFX scene to register the hook onto
 51 |      * @param animationOut non-null exit animation
 52 |      */
 53 |     public AnimatedThemeSwitcher(Scene scene, Animation animationOut) {
 54 |         this.scene = scene;
 55 |         this.out = new SimpleObjectProperty<>(Animation.requireNonNull(animationOut));
 56 |     }
 57 | 
 58 |     /**
 59 |      * Instantiates an {@link AnimatedThemeSwitcher}.
 60 |      * In order for this switcher to work, {@link #init()} has to be called.
 61 |      * @param scene JavaFX scene to register the hook onto
 62 |      * @param animationOut non-null raw exit animation
 63 |      */
 64 |     public AnimatedThemeSwitcher(Scene scene, AnimationFX animationOut) {
 65 |         this(scene, new Animation(animationOut));
 66 |     }
 67 | 
 68 |     /**
 69 |      * Instantiates an {@link AnimatedThemeSwitcher} with a default animation.
 70 |      * In order for this switcher to work, {@link #init()} has to be called.
 71 |      * @param scene JavaFX scene to register the hook onto
 72 |      */
 73 |     public AnimatedThemeSwitcher(Scene scene) {
 74 |         this(scene, new Animation(new FadeOut()));
 75 |     }
 76 | 
 77 |     /**
 78 |      * Registers the stylesheets hook on the wrapped scene.
 79 |      *
 80 |      * @throws IllegalStateException if the root of the scene is not suitable for the transition
 81 |      *                               (i.e. containers like <tt>VBox</tt> and <tt>HBox</tt> are not supported)
 82 |      *                               or if this switcher has already been initialized before.
 83 |      */
 84 |     public void init() throws IllegalStateException {
 85 |         final Parent root = scene.getRoot();
 86 | 
 87 |         if (root == null) {
 88 |             throw new IllegalStateException("The given scene does not have a root node.");
 89 |         }
 90 |         if (!(root instanceof Pane)) {
 91 |             throw new IllegalStateException("The root node is not a Pane (or subclass).");
 92 |         }
 93 |         if (root instanceof VBox || root instanceof HBox) {
 94 |             throw new IllegalStateException("The root node cannot be a VBox or HBox.");
 95 |         }
 96 | 
 97 |         if (this.initialized) {
 98 |             throw new IllegalStateException("This AnimatedThemeSwitcher has already been initialized.");
 99 |         }
100 | 
101 |         this.initialized = true;
102 |         this.register();
103 |     }
104 | 
105 |     /**
106 |      * Registers the listener that watches the stylesheets of the scene.
107 |      * Every time they change, an image of the 'old' scene is put on top and disappears via an animation.
108 |      */
109 |     private void register() {
110 |         // Set-up stylesheets listener
111 |         scene.getStylesheets().addListener((ListChangeListener<? super String>) change -> {
112 |             final ObservableList<String> stylesheets = scene.getStylesheets();
113 |             while (change.next() && handleChanges && !isPaused()) {
114 |                 // Copy changes (to avoid ConcurrentModificationException)
115 |                 final List<? extends String> added = new LinkedList<>(change.getAddedSubList());
116 |                 final List<? extends String> removed = new LinkedList<>(change.getRemoved());
117 | 
118 |                 handleChanges = false; // Puts the listener on hold
119 | 
120 |                 // Revert changes
121 |                 stylesheets.removeAll(added);
122 |                 stylesheets.addAll(change.getFrom(), removed);
123 | 
124 |                 // Screenshot the scene with the old theme applied and play the out animation
125 |                 overlapSnapshot();
126 | 
127 |                 // Reapply changes
128 |                 stylesheets.addAll(change.getFrom(), added);
129 |                 stylesheets.removeAll(removed);
130 | 
131 |                 handleChanges = true; // Resumes the listener
132 |             }
133 |         });
134 |     }
135 | 
136 |     /**
137 |      * Takes a snapshot/screenshot of the scene, puts it on top and plays the exit animation on it.
138 |      */
139 |     private void overlapSnapshot() {
140 |         // Prepares the screenshot of the scene.
141 |         // The scale avoids blurry images on high DPI screens.
142 |         final SnapshotParameters params = new SnapshotParameters();
143 |         params.setTransform(new Scale(SNAPSHOT_SCALE, SNAPSHOT_SCALE));
144 | 
145 |         // Takes a screenshot.
146 |         final Pane root = (Pane) scene.getRoot();
147 |         final Image snapshot = root.snapshot(params, null);
148 | 
149 |         // Adds the image on top of the root.
150 |         final ImageView imageView = new ImageView(snapshot);
151 |         final Bounds bounds = root.getLayoutBounds();
152 |         imageView.setFitWidth(bounds.getWidth());
153 |         imageView.setFitHeight(bounds.getHeight());
154 | 
155 |         root.getChildren().add(imageView);
156 | 
157 |         // Plays the exit animation and removes the image after the transition ends.
158 |         getOut().playOut(imageView, root.getChildren());
159 |     }
160 | 
161 |     /**
162 |      * {@inheritDoc}
163 |      */
164 |     @Override
165 |     public ObjectProperty<Animation> animationOutProperty() {
166 |         return this.out;
167 |     }
168 | 
169 |     /**
170 |      * {@inheritDoc}
171 |      */
172 |     @Override
173 |     public BooleanProperty pausedProperty() {
174 |         return this.pausedProperty;
175 |     }
176 | }
177 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/Animation.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition;
  2 | 
  3 | import animatefx.animation.AnimationFX;
  4 | import eu.iamgio.animated.transition.animations.None;
  5 | import eu.iamgio.animated.transition.animations.RequiresScene;
  6 | import eu.iamgio.animated.util.ReflectionUtils;
  7 | import javafx.application.Platform;
  8 | import javafx.beans.NamedArg;
  9 | import javafx.collections.ObservableList;
 10 | import javafx.event.ActionEvent;
 11 | import javafx.event.EventHandler;
 12 | import javafx.scene.Node;
 13 | import javafx.util.Duration;
 14 | 
 15 | import java.util.Objects;
 16 | 
 17 | /**
 18 |  * Wrapper for {@link AnimationFX} with several properties.
 19 |  */
 20 | public class Animation {
 21 | 
 22 |     private final AnimationFX animationFX;
 23 | 
 24 |     private double speed = 1;
 25 |     private Duration delay = Duration.ZERO;
 26 |     private int cycleCount = 1;
 27 |     private EventHandler<ActionEvent> onFinished;
 28 | 
 29 |     /**
 30 |      * Instantiates a new {@link Animation} that wraps the given {@link AnimationFX}.
 31 |      * @param animationFX non-null raw {@link AnimationFX} to wrap
 32 |      */
 33 |     public Animation(AnimationFX animationFX) {
 34 |         this.animationFX = Objects.requireNonNull(animationFX);
 35 |     }
 36 | 
 37 |     /**
 38 |      * Instantiates a new {@link Animation} that wraps the given {@link AnimationFX}.
 39 |      * @param type name (case-sensitive) of the raw {@link AnimationFX} to wrap
 40 |      * @param speed speed multiplier of the animation
 41 |      * @param delay delay duration before the animation is played
 42 |      * @throws IllegalArgumentException if the type does not match any AnimateFX animation
 43 |      * @deprecated this method uses unnecessary reflection, hence it should be avoided.
 44 |      *             This was intended for FXML compatibility only
 45 |      */
 46 |     @Deprecated
 47 |     public Animation(@NamedArg("type") String type,
 48 |                      @NamedArg(value = "speed", defaultValue = "1.0") double speed,
 49 |                      @NamedArg(value = "delay", defaultValue = "0ms") Duration delay) {
 50 |         this.speed = speed;
 51 |         this.delay = delay;
 52 | 
 53 |         try {
 54 |             this.animationFX = (AnimationFX) ReflectionUtils.findClassInPackages(
 55 |                     type,
 56 |                     "animatefx.animation",
 57 |                     "eu.iamgio.animated.transition.animations",
 58 |                     "eu.iamgio.animated.transition.animations.clip"
 59 |             ).newInstance();
 60 |         } catch (ReflectiveOperationException e) {
 61 |             throw new IllegalArgumentException(e);
 62 |         }
 63 |     }
 64 | 
 65 |     private void applyProperties() {
 66 |         animationFX.setSpeed(speed);
 67 |         animationFX.setDelay(delay);
 68 |         animationFX.setCycleCount(cycleCount);
 69 |         if (onFinished != null) {
 70 |             animationFX.setOnFinished(onFinished);
 71 |         }
 72 |     }
 73 | 
 74 |     /**
 75 |      * Plays the animation while adding the <tt>target</tt> node to <tt>children</tt>
 76 |      * @param target node to animate
 77 |      * @param children observable list to add the node to (if not <tt>null</tt>)
 78 |      */
 79 |     public void playIn(Node target, ObservableList<Node> children) {
 80 |         if (children != null) {
 81 |             // If the animation has this tag,
 82 |             // the node must be added to the scene before playing the animation.
 83 |             if (animationFX instanceof RequiresScene) {
 84 |                 children.add(target);
 85 |             } else {
 86 |                 Platform.runLater(() -> children.add(target));
 87 |             }
 88 |         }
 89 | 
 90 |         animationFX.setNode(target);
 91 |         applyProperties();
 92 |         animationFX.play();
 93 |     }
 94 | 
 95 |     /**
 96 |      * Plays the animation before removing the <tt>target</tt> node from <tt>children</tt>
 97 |      * @param target node to animate
 98 |      * @param children observable list to remove the node from (if not <tt>null</tt>)
 99 |      */
100 |     public void playOut(Node target, ObservableList<Node> children) {
101 |         animationFX.setNode(target);
102 |         applyProperties();
103 | 
104 |         if (children != null) {
105 |             animationFX.setOnFinished(e -> {
106 |                 if (this.onFinished != null) {
107 |                     this.onFinished.handle(e);
108 |                 }
109 |                 children.remove(target);
110 |             });
111 |         }
112 | 
113 |         animationFX.play();
114 |     }
115 | 
116 |     /**
117 |      * @return status of the animation
118 |      */
119 |     public javafx.animation.Animation.Status getStatus() {
120 |         if (animationFX != null && animationFX.getTimeline() != null) {
121 |             return animationFX.getTimeline().getStatus();
122 |         }
123 |         return javafx.animation.Animation.Status.STOPPED;
124 |     }
125 | 
126 |     /**
127 |      * @return whether this animation is playing or not
128 |      */
129 |     public boolean isPlaying() {
130 |         return getStatus() == javafx.animation.Animation.Status.RUNNING;
131 |     }
132 | 
133 |     /**
134 |      * @return non-null AnimateFX animation
135 |      */
136 |     public AnimationFX getAnimationFX() {
137 |         return animationFX;
138 |     }
139 | 
140 |     /**
141 |      * @return speed multiplier (1 = normal speed)
142 |      */
143 |     public double getSpeed() {
144 |         return speed;
145 |     }
146 | 
147 |     /**
148 |      * @param speed speed multiplier to set
149 |      * @return this for concatenation
150 |      */
151 |     public Animation setSpeed(double speed) {
152 |         this.speed = speed;
153 |         return this;
154 |     }
155 | 
156 |     /**
157 |      * @return delay before the animation is played
158 |      */
159 |     public Duration getDelay() {
160 |         return delay;
161 |     }
162 | 
163 |     /**
164 |      * @param delay delay to set
165 |      * @return this for concatenation
166 |      */
167 |     public Animation setDelay(Duration delay) {
168 |         this.delay = delay;
169 |         return this;
170 |     }
171 | 
172 |     /**
173 |      * @return times the animation should be played. Defaults to 1
174 |      */
175 |     public int getCycleCount() {
176 |         return cycleCount;
177 |     }
178 | 
179 |     /**
180 |      * @param cycleCount cycles count to set
181 |      * @return this for concatenation
182 |      */
183 |     public Animation setCycleCount(int cycleCount) {
184 |         this.cycleCount = cycleCount;
185 |         return this;
186 |     }
187 | 
188 |     /**
189 |      * @param handler action to run when the animation finishes
190 |      */
191 |     public void setOnFinished(EventHandler<ActionEvent> handler) {
192 |         this.onFinished = handler;
193 |     }
194 | 
195 |     /**
196 |      * Fluent setter for {@link #setOnFinished(EventHandler)}.
197 |      * @param handler action to run when the animation finishes
198 |      * @return this for concatenation
199 |      */
200 |     public Animation onFinished(EventHandler<ActionEvent> handler) {
201 |         this.setOnFinished(handler);
202 |         return this;
203 |     }
204 | 
205 |     /**
206 |      * @return a valid non-null playable {@link Animation} that does not perform any actual animation
207 |      *         and is also affected by {@link #getDelay()}.
208 |      * @see None
209 |      */
210 |     public static Animation none() {
211 |         return new Animation(new None());
212 |     }
213 | 
214 |     /**
215 |      * Checks that the given animation is not <tt>null</tt>, or throws a {@link NullPointerException} otherwise.
216 |      * @param animation animation to check
217 |      * @return the given animation if not <tt>null</tt>
218 |      */
219 |     public static Animation requireNonNull(Animation animation) {
220 |         return Objects.requireNonNull(animation, "An animation cannot be null.");
221 |     }
222 | }
223 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/presets/AnimatedLayout.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.binding.presets;
  2 | 
  3 | import eu.iamgio.animated.binding.property.animation.OnDemandAnimationPropertyGroup;
  4 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
  5 | import javafx.beans.property.BooleanProperty;
  6 | import javafx.beans.property.SimpleBooleanProperty;
  7 | import javafx.geometry.Bounds;
  8 | import javafx.geometry.HPos;
  9 | import javafx.geometry.Pos;
 10 | import javafx.geometry.VPos;
 11 | import javafx.scene.Node;
 12 | import javafx.scene.layout.Region;
 13 | 
 14 | import java.util.Arrays;
 15 | 
 16 | /**
 17 |  * Node that animates its child's position based on an alignment relative to an anchor root.
 18 |  *
 19 |  * @author Giorgio Garofalo
 20 |  */
 21 | public class AnimatedLayout extends OnDemandAnimationPropertyGroup<Node, Double> {
 22 | 
 23 |     private final Node child;
 24 |     private final Region root;
 25 |     private final Pos alignment;
 26 | 
 27 |     private final BooleanProperty animateShrinking = new SimpleBooleanProperty();
 28 | 
 29 |     // The latest registered child size
 30 |     private Bounds bounds;
 31 | 
 32 |     /**
 33 |      * Instantiates an {@link AnimatedLayout} node.
 34 |      * @param child the node to wrap, whose layout should be animated
 35 |      * @param root root to rely relayouts on
 36 |      * @param alignment position of the node relative to its root
 37 |      * @param animateShrinking whether the animation should be played when the root is shrunk
 38 |      */
 39 |     public AnimatedLayout(Node child, Region root, Pos alignment, boolean animateShrinking) {
 40 |         super(Arrays.asList(
 41 |                 node -> PropertyWrapper.of(node.layoutXProperty()),
 42 |                 node -> PropertyWrapper.of(node.layoutYProperty())
 43 |         ));
 44 | 
 45 |         targetNodeProperty().set(child);
 46 | 
 47 |         this.child = child;
 48 |         this.root = root;
 49 |         this.alignment = alignment;
 50 |         this.bounds = child.getLayoutBounds();
 51 |         this.animateShrinking.set(animateShrinking);
 52 | 
 53 |         HPos hPos = alignment.getHpos();
 54 |         VPos vPos = alignment.getVpos();
 55 | 
 56 |         // Update the coordinates whenever the root gets resized
 57 |         bindX(hPos);
 58 |         bindY(vPos);
 59 | 
 60 |         // Register child size
 61 |         registerBoundsListener(hPos, vPos);
 62 |     }
 63 | 
 64 |     /**
 65 |      * Instantiates an {@link AnimatedLayout} node.
 66 |      * @param child the node to wrap, whose layout should be animated
 67 |      * @param root root to rely relayouts on
 68 |      * @param alignment position of the node relative to its root
 69 |      */
 70 |     public AnimatedLayout(Node child, Region root, Pos alignment) {
 71 |         this(child, root, alignment, false);
 72 |     }
 73 | 
 74 |     /**
 75 |      * @return alignment of the child relative to the root
 76 |      */
 77 |     public Pos getAlignment() {
 78 |         return alignment;
 79 |     }
 80 | 
 81 |     /**
 82 |      * @return whether the animation should be played when the root is shrunk
 83 |      */
 84 |     public BooleanProperty animateShrinkingProperty() {
 85 |         return animateShrinking;
 86 |     }
 87 | 
 88 |     /**
 89 |      * @return whether the animation should be played when the root is shrunk. Does not affect centered alignments
 90 |      */
 91 |     public boolean isAnimateShrinking() {
 92 |         return animateShrinking.get();
 93 |     }
 94 | 
 95 |     /**
 96 |      * Enables or disables shrinking animation.
 97 |      * @param animateShrinking whether the animation should be played when the root is shrunk
 98 |      */
 99 |     public void setAnimateShrinking(boolean animateShrinking) {
100 |         this.animateShrinking.set(animateShrinking);
101 |     }
102 | 
103 |     /**
104 |      * Whenever the size of the node changes, it gets saved to a local variable
105 |      * @param hPos horizontal position of the alignment
106 |      * @param vPos vertical position of the alignment
107 |      */
108 |     private void registerBoundsListener(HPos hPos, VPos vPos) {
109 |         child.layoutBoundsProperty().addListener((o, oldValue, newValue) -> {
110 |             if (oldValue != newValue || newValue != bounds) {
111 |                 bounds = newValue;
112 | 
113 |                 // Don't animate if this is the first update
114 |                 boolean wasEmpty = oldValue.getWidth() == 0 && oldValue.getHeight() == 0;
115 |                 if (wasEmpty) {
116 |                     pause();
117 |                 }
118 | 
119 |                 // Update coordinates
120 |                 if (requiresBinding(hPos)) {
121 |                     updateX(isCenter(hPos));
122 |                 }
123 |                 if (requiresBinding(vPos)) {
124 |                     updateY(isCenter(vPos));
125 |                 }
126 | 
127 |                 if (wasEmpty) {
128 |                     resume();
129 |                 }
130 |             }
131 |         });
132 |     }
133 | 
134 |     /**
135 |      * Updates the layout X coordinate of the node: either to the end of the root or to its center.
136 |      * @param center whether the node should be centered to the root
137 |      */
138 |     private void updateX(boolean center) {
139 |         if (bounds == null) {
140 |             return;
141 |         }
142 | 
143 |         double x = root.getPrefWidth() - bounds.getWidth();
144 |         child.setLayoutX(center ? x / 2 : x);
145 |     }
146 | 
147 |     /**
148 |      * Updates the layout Y coordinate of the node: either to the end of the root or to its center.
149 |      * @param center whether the node should be centered to the root
150 |      */
151 |     private void updateY(boolean center) {
152 |         if (bounds == null) {
153 |             return;
154 |         }
155 | 
156 |         double y = root.getPrefHeight() - bounds.getHeight();
157 |         child.setLayoutY(center ? y / 2 : y);
158 |     }
159 | 
160 |     /**
161 |      * Updates the layout X coordinate of the node whenever the width of the root changes.
162 |      * @param hPos horizontal position of the alignment
163 |      */
164 |     private void bindX(HPos hPos) {
165 |         if (requiresBinding(hPos)) {
166 |             root.prefWidthProperty().addListener((observable, oldValue, newValue) -> {
167 |                 boolean isShrunk = !isAnimateShrinking() && (double) newValue < (double) oldValue && !isCenter(hPos);
168 | 
169 |                 if (isShrunk) {
170 |                     pause();
171 |                 }
172 | 
173 |                 updateX(isCenter(hPos));
174 | 
175 |                 if (isShrunk) {
176 |                     resume();
177 |                 }
178 |             });
179 |         }
180 |     }
181 | 
182 |     /**
183 |      * Updates the layout Y coordinate of the node whenever the height of the root changes.
184 |      * @param vPos vertical position of the alignment
185 |      */
186 |     private void bindY(VPos vPos) {
187 |         if (requiresBinding(vPos)) {
188 |             boolean center = vPos == VPos.CENTER;
189 |             root.prefHeightProperty().addListener((observable, oldValue, newValue) -> {
190 |                 boolean isShrunk = !isAnimateShrinking() && (double) newValue < (double) oldValue && !isCenter(vPos);
191 |                 if (isShrunk) {
192 |                     pause();
193 |                 }
194 | 
195 |                 updateY(isCenter(vPos));
196 | 
197 |                 if (isShrunk) {
198 |                     resume();
199 |                 }
200 |             });
201 |         }
202 |     }
203 | 
204 |     private boolean requiresBinding(HPos hPos) {
205 |         return child != null && root != null && hPos != HPos.LEFT;
206 |     }
207 | 
208 |     private boolean requiresBinding(VPos vPos) {
209 |         return child != null && root != null && vPos != VPos.TOP;
210 |     }
211 | 
212 |     private boolean isCenter(HPos hPos) {
213 |         return hPos == HPos.CENTER;
214 |     }
215 | 
216 |     private boolean isCenter(VPos vPos) {
217 |         return vPos == VPos.CENTER;
218 |     }
219 | }
220 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <project xmlns="http://maven.apache.org/POM/4.0.0"
  3 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5 |     <modelVersion>4.0.0</modelVersion>
  6 | 
  7 |     <groupId>eu.iamgio</groupId>
  8 |     <artifactId>animated</artifactId>
  9 |     <version>1.3.0</version>
 10 | 
 11 |     <name>animated</name>
 12 |     <description>Modern animation library for JavaFX.</description>
 13 |     <url>https://github.com/iamgio/animated</url>
 14 | 
 15 |     <licenses>
 16 |         <license>
 17 |             <name>MIT License</name>
 18 |             <url>https://www.opensource.org/licenses/mit-license.php</url>
 19 |         </license>
 20 |     </licenses>
 21 | 
 22 |     <developers>
 23 |         <developer>
 24 |             <name>Giorgio Garofalo</name>
 25 |             <email>giorgiogarofalo02@gmail.com</email>
 26 |             <organization>com.github.iamgio</organization>
 27 |             <organizationUrl>https://iamgio.eu</organizationUrl>
 28 |         </developer>
 29 |     </developers>
 30 | 
 31 |     <scm>
 32 |         <connection>scm:git:git://github.com/iamgio/animated.git</connection>
 33 |         <developerConnection>scm:git:ssh://github.com:iamgio/animated.git</developerConnection>
 34 |         <url>https://github.com/iamgio/animated</url>
 35 |     </scm>
 36 | 
 37 |     <properties>
 38 |         <kotlin.version>1.4.31</kotlin.version>
 39 |         <maven.compiler.target>8</maven.compiler.target>
 40 |         <maven.compiler.source>8</maven.compiler.source>
 41 |     </properties>
 42 | 
 43 |     <distributionManagement>
 44 |         <snapshotRepository>
 45 |             <id>ossrh</id>
 46 |             <url>https://s01.oss.sonatype.org/content/repositories/snapshots</url>
 47 |         </snapshotRepository>
 48 |         <repository>
 49 |             <id>ossrh</id>
 50 |             <url>https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/</url>
 51 |         </repository>
 52 |     </distributionManagement>
 53 | 
 54 |     <build>
 55 |         <plugins>
 56 |             <plugin>
 57 |                 <groupId>org.sonatype.plugins</groupId>
 58 |                 <artifactId>nexus-staging-maven-plugin</artifactId>
 59 |                 <version>1.6.8</version>
 60 |                 <extensions>true</extensions>
 61 |                 <configuration>
 62 |                     <serverId>ossrh</serverId>
 63 |                     <nexusUrl>https://s01.oss.sonatype.org/</nexusUrl>
 64 |                     <autoReleaseAfterClose>true</autoReleaseAfterClose>
 65 |                 </configuration>
 66 |             </plugin>
 67 |             <plugin>
 68 |                 <groupId>org.apache.maven.plugins</groupId>
 69 |                 <artifactId>maven-source-plugin</artifactId>
 70 |                 <version>2.2.1</version>
 71 |                 <executions>
 72 |                     <execution>
 73 |                         <id>attach-sources</id>
 74 |                         <goals>
 75 |                             <goal>jar-no-fork</goal>
 76 |                         </goals>
 77 |                     </execution>
 78 |                 </executions>
 79 |             </plugin>
 80 |             <plugin>
 81 |                 <groupId>org.apache.maven.plugins</groupId>
 82 |                 <artifactId>maven-jar-plugin</artifactId>
 83 |                 <configuration>
 84 |                     <archive>
 85 |                         <manifestEntries>
 86 |                             <Automatic-Module-Name>eu.iamgio.animated</Automatic-Module-Name>
 87 |                         </manifestEntries>
 88 |                     </archive>
 89 |                 </configuration>
 90 |             </plugin>
 91 |             <plugin>
 92 |                 <groupId>org.apache.maven.plugins</groupId>
 93 |                 <artifactId>maven-javadoc-plugin</artifactId>
 94 |                 <version>2.9.1</version>
 95 |                 <executions>
 96 |                     <execution>
 97 |                         <id>attach-javadocs</id>
 98 |                         <goals>
 99 |                             <goal>jar</goal>
100 |                         </goals>
101 |                     </execution>
102 |                 </executions>
103 |             </plugin>
104 |             <plugin>
105 |                 <groupId>org.apache.maven.plugins</groupId>
106 |                 <artifactId>maven-gpg-plugin</artifactId>
107 |                 <version>1.5</version>
108 |                 <executions>
109 |                     <execution>
110 |                         <id>sign-artifacts</id>
111 |                         <phase>verify</phase>
112 |                         <goals>
113 |                             <goal>sign</goal>
114 |                         </goals>
115 |                     </execution>
116 |                 </executions>
117 |             </plugin>
118 |             <plugin>
119 |                 <groupId>org.jetbrains.kotlin</groupId>
120 |                 <artifactId>kotlin-maven-plugin</artifactId>
121 |                 <version>${kotlin.version}</version>
122 |                 <executions>
123 |                     <execution>
124 |                         <id>compile</id>
125 |                         <phase>compile</phase>
126 |                         <goals>
127 |                             <goal>compile</goal>
128 |                         </goals>
129 |                         <configuration>
130 |                             <sourceDirs>
131 |                                 <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
132 |                             </sourceDirs>
133 |                         </configuration>
134 |                     </execution>
135 |                     <execution>
136 |                         <id>test-compile</id>
137 |                         <phase>test-compile</phase>
138 |                         <goals>
139 |                             <goal>test-compile</goal>
140 |                         </goals>
141 |                     </execution>
142 |                 </executions>
143 |                 <configuration>
144 |                     <jvmTarget>1.8</jvmTarget>
145 |                 </configuration>
146 |             </plugin>
147 |             <plugin>
148 |                 <groupId>org.apache.maven.plugins</groupId>
149 |                 <artifactId>maven-compiler-plugin</artifactId>
150 |                 <version>3.8.1</version>
151 |                 <executions>
152 |                     <execution>
153 |                         <id>compile</id>
154 |                         <phase>compile</phase>
155 |                         <goals>
156 |                             <goal>compile</goal>
157 |                         </goals>
158 |                     </execution>
159 |                     <execution>
160 |                         <id>testCompile</id>
161 |                         <phase>test-compile</phase>
162 |                         <goals>
163 |                             <goal>testCompile</goal>
164 |                         </goals>
165 |                     </execution>
166 |                 </executions>
167 |                 <configuration>
168 |                     <source>8</source>
169 |                     <target>8</target>
170 |                 </configuration>
171 |             </plugin>
172 |         </plugins>
173 |     </build>
174 | 
175 |     <dependencies>
176 |         <dependency>
177 |             <groupId>org.openjfx</groupId>
178 |             <artifactId>javafx-controls</artifactId>
179 |             <version>11</version>
180 |             <scope>provided</scope>
181 |         </dependency>
182 |         <dependency>
183 |             <groupId>io.github.typhon0</groupId>
184 |             <artifactId>AnimateFX</artifactId>
185 |             <version>1.2.4</version>
186 |         </dependency>
187 |         <dependency>
188 |             <groupId>org.jetbrains.kotlin</groupId>
189 |             <artifactId>kotlin-stdlib-jdk8</artifactId>
190 |             <version>${kotlin.version}</version>
191 |             <scope>provided</scope>
192 |         </dependency>
193 |         <dependency>
194 |             <groupId>org.jetbrains.kotlin</groupId>
195 |             <artifactId>kotlin-test</artifactId>
196 |             <version>${kotlin.version}</version>
197 |             <scope>test</scope>
198 |         </dependency>
199 |     </dependencies>
200 | </project>


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/binding/property/animation/AnimationProperty.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.binding.property.animation;
  2 | 
  3 | import eu.iamgio.animated.binding.Animated;
  4 | import eu.iamgio.animated.binding.AnimationSettings;
  5 | import eu.iamgio.animated.binding.CustomizableAnimation;
  6 | import eu.iamgio.animated.binding.event.AnimationEvent;
  7 | import eu.iamgio.animated.binding.event.ListenableAnimation;
  8 | import eu.iamgio.animated.binding.property.wrapper.PropertyWrapper;
  9 | import eu.iamgio.animated.common.Pausable;
 10 | import javafx.beans.property.*;
 11 | import javafx.event.EventHandler;
 12 | import javafx.scene.Node;
 13 | 
 14 | import java.util.function.Function;
 15 | 
 16 | /**
 17 |  * An animation property wraps a JavaFX property and describes its behavior when it is affected by a change.
 18 |  * The property has to be wrapped inside a {@link PropertyWrapper}.
 19 |  * @param <T> type of the wrapped value
 20 |  * @author Giorgio Garofalo
 21 |  */
 22 | public abstract class AnimationProperty<T> implements CustomizableAnimation<AnimationProperty<T>>, ListenableAnimation, Pausable {
 23 | 
 24 |     // The target property
 25 |     private final PropertyWrapper<T> property;
 26 | 
 27 |     // Whether the property should be animated
 28 |     private final BooleanProperty paused = new SimpleBooleanProperty(false);
 29 | 
 30 |     // Animation settings
 31 |     private final ObjectProperty<AnimationSettings> settings;
 32 | 
 33 |     // Event handlers
 34 |     private final ObjectProperty<EventHandler<AnimationEvent>> onAnimationStarted = new SimpleObjectProperty<>();
 35 |     private final ObjectProperty<EventHandler<AnimationEvent>> onAnimationEnded = new SimpleObjectProperty<>();
 36 | 
 37 |     /**
 38 |      * Instantiates an implicitly animated property
 39 |      * @param property target property
 40 |      * @param settings animation settings
 41 |      */
 42 |     public AnimationProperty(PropertyWrapper<T> property, AnimationSettings settings) {
 43 |         this.property = property;
 44 |         this.settings = new SimpleObjectProperty<>(settings);
 45 |     }
 46 | 
 47 |     /**
 48 |      * Instantiates an implicitly animated property with default settings.
 49 |      * @param property target property
 50 |      */
 51 |     public AnimationProperty(PropertyWrapper<T> property) {
 52 |         this(property, new AnimationSettings());
 53 |     }
 54 | 
 55 |     /**
 56 |      * @return the current animation settings
 57 |      */
 58 |     public ObjectProperty<AnimationSettings> settingsProperty() {
 59 |         return this.settings;
 60 |     }
 61 | 
 62 |     /**
 63 |      * @return the current animation settings
 64 |      */
 65 |     public AnimationSettings getSettings() {
 66 |         return this.settings.get();
 67 |     }
 68 | 
 69 |     /**
 70 |      * {@inheritDoc}
 71 |      */
 72 |     @Override
 73 |     public void setSettings(AnimationSettings settings) {
 74 |         this.settings.set(settings);
 75 |     }
 76 | 
 77 |     /**
 78 |      * {@inheritDoc}
 79 |      */
 80 |     @Override
 81 |     public AnimationProperty<T> custom(Function<AnimationSettings, AnimationSettings> settings) {
 82 |         return withSettings(settings.apply(getSettings()));
 83 |     }
 84 | 
 85 |     /**
 86 |      * Registers the listener
 87 |      * @param target nullable target {@link Node}. If present, the animation is not played when it is not in scene.
 88 |      */
 89 |     public abstract void register(Node target);
 90 | 
 91 |     /**
 92 |      * Registers the listener
 93 |      */
 94 |     public void register() {
 95 |         register(null);
 96 |     }
 97 | 
 98 |     /**
 99 |      * Attaches this property to an {@link Animated} node.
100 |      * @param animated animated node to link this property to
101 |      */
102 |     public abstract void attachTo(Animated animated);
103 | 
104 |     /**
105 |      * Adds a binding to a target property: when the value of the wrapped property changes,
106 |      * the target property is updated too, based on a mapper function.
107 |      * The following example binds a label text to this property, converted to a string:
108 |      * <pre>
109 |      *     property.addBinding(label.textProperty(), String::valueOf);
110 |      * </pre>
111 |      *
112 |      * @param targetProperty property to bind
113 |      * @param mapper function that takes the value of the wrapped property as input,
114 |      *               and returns the value the target property should get
115 |      * @return this for concatenation
116 |      * @param <V> type of the target property
117 |      */
118 |     public abstract <V> AnimationProperty<T> addBinding(Property<V> targetProperty, Function<T, V> mapper);
119 | 
120 |     /**
121 |      * Adds a binding to a target property: when the value of the wrapped property changes,
122 |      * the target property is updated too.
123 |      * @param targetProperty property to bind
124 |      * @return this for concatenation
125 |      */
126 |     public AnimationProperty<T> addBinding(Property<T> targetProperty) {
127 |         return this.addBinding(targetProperty, Function.identity());
128 |     }
129 | 
130 |     /**
131 |      * @return target property
132 |      */
133 |     public PropertyWrapper<T> getProperty() {
134 |         return this.property;
135 |     }
136 | 
137 |     /**
138 |      * Fluent setter for {@link ListenableAnimation#setOnAnimationStarted(EventHandler)}
139 |      * @param handler the action to run when an animation begins
140 |      * @return this for concatenation
141 |      */
142 |     public AnimationProperty<T> onAnimationStarted(EventHandler<AnimationEvent> handler) {
143 |         setOnAnimationStarted(handler);
144 |         return this;
145 |     }
146 | 
147 |     /**
148 |      * Fluent setter for {@link ListenableAnimation#setOnAnimationEnded(EventHandler)}
149 |      * @param handler the action to run when an animation finishes
150 |      * @return this for concatenation
151 |      */
152 |     public AnimationProperty<T> onAnimationEnded(EventHandler<AnimationEvent> handler) {
153 |         setOnAnimationEnded(handler);
154 |         return this;
155 |     }
156 | 
157 |     /**
158 |      * {@inheritDoc}
159 |      */
160 |     @Override
161 |     public BooleanProperty pausedProperty() {
162 |         return this.paused;
163 |     }
164 | 
165 |     /**
166 |      * {@inheritDoc}
167 |      */
168 |     @Override
169 |     public ObjectProperty<EventHandler<AnimationEvent>> onAnimationStartedProperty() {
170 |         return this.onAnimationStarted;
171 |     }
172 | 
173 |     /**
174 |      * {@inheritDoc}
175 |      */
176 |     @Override
177 |     public ObjectProperty<EventHandler<AnimationEvent>> onAnimationEndedProperty() {
178 |         return this.onAnimationEnded;
179 |     }
180 | 
181 |     /**
182 |      * Copies settings and other attributes (pause status) from this property to another (and overrides existing values).
183 |      * @param to property to copy attributes to
184 |      */
185 |     void copyAttributesTo(AnimationProperty<?> to) {
186 |         to.pausedProperty().bindBidirectional(pausedProperty());
187 | 
188 |         to.onAnimationStartedProperty().bindBidirectional(onAnimationStartedProperty());
189 |         to.onAnimationEndedProperty().bindBidirectional(onAnimationEndedProperty());
190 | 
191 |         to.withSettings(this.getSettings());
192 |     }
193 | 
194 |     /**
195 |      * Creates an {@link AnimationProperty} that wraps the given {@link ObjectProperty}.
196 |      * @see eu.iamgio.animated.binding.property.wrapper.ObjectPropertyWrapper
197 |      * @param property JavaFX property to wrap
198 |      * @param <T> property type
199 |      * @return instance of a new animation property that wraps <tt>property</tt>.
200 |      */
201 |     public static <T> AnimationProperty<T> of(ObjectProperty<T> property) {
202 |         return new SimpleAnimationProperty<>(PropertyWrapper.of(property));
203 |     }
204 | 
205 |     /**
206 |      * Creates an {@link AnimationProperty} that wraps the given {@link DoubleProperty}.
207 |      * @see eu.iamgio.animated.binding.property.wrapper.DoublePropertyWrapper
208 |      * @param property JavaFX property to wrap
209 |      * @return instance of a new animation property that wraps <tt>property</tt>.
210 |      */
211 |     public static AnimationProperty<Double> of(DoubleProperty property) {
212 |         return new SimpleAnimationProperty<>(PropertyWrapper.of(property));
213 |     }
214 | 
215 |     /**
216 |      * Creates an {@link AnimationProperty} that wraps the given {@link IntegerProperty}.
217 |      * @see eu.iamgio.animated.binding.property.wrapper.IntegerPropertyWrapper
218 |      * @param property JavaFX property to wrap
219 |      * @return instance of a new animation property that wraps <tt>property</tt>.
220 |      */
221 |     public static AnimationProperty<Integer> of(IntegerProperty property) {
222 |         return new SimpleAnimationProperty<>(PropertyWrapper.of(property));
223 |     }
224 | }
225 | 


--------------------------------------------------------------------------------
/src/main/java/eu/iamgio/animated/transition/AnimatedLabel.java:
--------------------------------------------------------------------------------
  1 | package eu.iamgio.animated.transition;
  2 | 
  3 | import animatefx.animation.AnimationFX;
  4 | import eu.iamgio.animated.common.Pausable;
  5 | import javafx.beans.property.*;
  6 | import javafx.scene.Parent;
  7 | import javafx.scene.control.Label;
  8 | 
  9 | /**
 10 |  * A node that wraps a text string that, whenever changed, plays an animation between the old and current state.
 11 |  *
 12 |  * @author Giorgio Garofalo
 13 |  */
 14 | public class AnimatedLabel extends Parent implements Pausable, EntranceAndExitAnimationCompatible {
 15 | 
 16 |     private final ObjectProperty<Animation> in;
 17 |     private final ObjectProperty<Animation> out;
 18 | 
 19 |     private final StringProperty textProperty = new SimpleStringProperty();
 20 | 
 21 |     private final ObjectProperty<LabelFactory> labelFactory = new SimpleObjectProperty<>(LabelFactory.DEFAULT);
 22 |     private final ObjectProperty<Label> currentLabel = new SimpleObjectProperty<>();
 23 | 
 24 |     private final SimpleBooleanProperty pausedProperty = new SimpleBooleanProperty();
 25 | 
 26 |     /**
 27 |      * Instantiates an {@link AnimatedLabel}.
 28 |      * @param text initial text, displayed without animations
 29 |      * @param animationIn non-null entrance animation
 30 |      * @param animationOut non-null exit animation
 31 |      */
 32 |     public AnimatedLabel(String text, Animation animationIn, Animation animationOut) {
 33 |         this.textProperty.set(text);
 34 |         this.in = new SimpleObjectProperty<>(Animation.requireNonNull(animationIn));
 35 |         this.out = new SimpleObjectProperty<>(Animation.requireNonNull(animationOut));
 36 |         register();
 37 |     }
 38 | 
 39 |     /**
 40 |      * Instantiates an initially empty {@link AnimatedLabel}.
 41 |      * @param animationIn non-null entrance animation
 42 |      * @param animationOut non-null exit animation
 43 |      */
 44 |     public AnimatedLabel(Animation animationIn, Animation animationOut) {
 45 |         this("", animationIn, animationOut);
 46 |     }
 47 | 
 48 |     /**
 49 |      * Instantiates an {@link AnimatedLabel}.
 50 |      * @param text initial text, displayed without animations
 51 |      * @param animation pair of non-null in and out animations
 52 |      */
 53 |     public AnimatedLabel(String text, AnimationPair animation) {
 54 |         this(text, animation.getIn(), animation.getOut());
 55 |     }
 56 | 
 57 |     /**
 58 |      * Instantiates an initially empty {@link AnimatedLabel}.
 59 |      * @param animation pair of non-null in and out animations
 60 |      */
 61 |     public AnimatedLabel(AnimationPair animation) {
 62 |         this("", animation.getIn(), animation.getOut());
 63 |     }
 64 | 
 65 |     /**
 66 |      * Instantiates an {@link AnimatedLabel}.
 67 |      * @param text initial text, displayed without animations
 68 |      * @param animationIn raw entrance animation
 69 |      * @param animationOut raw exit animation
 70 |      */
 71 |     public AnimatedLabel(String text, AnimationFX animationIn, AnimationFX animationOut) {
 72 |         this(text, new Animation(animationIn), new Animation(animationOut));
 73 |     }
 74 | 
 75 |     /**
 76 |      * Instantiates an initially empty {@link AnimatedLabel}.
 77 |      * @param animationIn raw entrance animation
 78 |      * @param animationOut raw exit animation
 79 |      */
 80 |     public AnimatedLabel(AnimationFX animationIn, AnimationFX animationOut) {
 81 |         this("", new Animation(animationIn), new Animation(animationOut));
 82 |     }
 83 | 
 84 |     /**
 85 |      * Instantiates an initially empty {@link AnimatedLabel} with default animations.
 86 |      */
 87 |     public AnimatedLabel() {
 88 |         this("", AnimationPair.fade());
 89 |     }
 90 | 
 91 |     /**
 92 |      * Registers the text listener.
 93 |      */
 94 |     private void register() {
 95 |         // Initialization
 96 |         final Label initialLabel = labelFactory.get().newLabel(getText());
 97 |         currentLabel.set(initialLabel);
 98 | 
 99 |         // AnimatedLabel works via this AnimatedSwitcher,
100 |         // which simply overlaps the old and new labels.
101 |         final AnimatedSwitcher switcher = new AnimatedSwitcher().of(initialLabel);
102 |         switcher.animationInProperty().bindBidirectional(this.in);
103 |         switcher.animationOutProperty().bindBidirectional(this.out);
104 |         switcher.pausedProperty().bindBidirectional(this.pausedProperty);
105 |         getChildren().add(switcher);
106 | 
107 |         // Every time the text changes, a new label is placed on top and the switch is animated.
108 |         textProperty.addListener(((observable, oldValue, newValue) -> {
109 |             final Label newLabel = labelFactory.get().newLabel(newValue);
110 |             currentLabel.set(newLabel);
111 |             switcher.setChild(newLabel);
112 |         }));
113 |     }
114 | 
115 |     /**
116 |      * @return the displayed text
117 |      */
118 |     public StringProperty textProperty() {
119 |         return textProperty;
120 |     }
121 | 
122 |     /**
123 |      * @return the displayed text
124 |      */
125 |     public String getText() {
126 |         return textProperty.get();
127 |     }
128 | 
129 |     /**
130 |      * Sets the displayed text.
131 |      * @param text text to display
132 |      */
133 |     public void setText(String text) {
134 |         this.textProperty.set(text);
135 |     }
136 | 
137 |     /**
138 |      * @return the latest {@link Label} initialized
139 |      */
140 |     public ReadOnlyObjectProperty<Label> currentLabelProperty() {
141 |         return this.currentLabel;
142 |     }
143 | 
144 |     /**
145 |      * @return the latest {@link Label} initialized
146 |      */
147 |     public Label getCurrentLabel() {
148 |         return this.currentLabel.get();
149 |     }
150 | 
151 |     /**
152 |      * {@inheritDoc}
153 |      */
154 |     @Override
155 |     public ObjectProperty<Animation> animationInProperty() {
156 |         return this.in;
157 |     }
158 | 
159 |     /**
160 |      * {@inheritDoc}
161 |      */
162 |     @Override
163 |     public Animation getIn() {
164 |         // This overriden method is required for FXML compatibility.
165 |         return EntranceAndExitAnimationCompatible.super.getIn();
166 |     }
167 | 
168 |     /**
169 |      * {@inheritDoc}
170 |      */
171 |     @Override
172 |     public void setIn(Animation in) {
173 |         // This overriden method is required for FXML compatibility.
174 |         EntranceAndExitAnimationCompatible.super.setIn(in);
175 |     }
176 | 
177 |     /**
178 |      * {@inheritDoc}
179 |      */
180 |     @Override
181 |     public ObjectProperty<Animation> animationOutProperty() {
182 |         return this.out;
183 |     }
184 | 
185 |     /**
186 |      * {@inheritDoc}
187 |      */
188 |     @Override
189 |     public Animation getOut() {
190 |         // This overriden method is required for FXML compatibility.
191 |         return EntranceAndExitAnimationCompatible.super.getOut();
192 |     }
193 | 
194 |     /**
195 |      * {@inheritDoc}
196 |      */
197 |     @Override
198 |     public void setOut(Animation out) {
199 |         // This overriden method is required for FXML compatibility.
200 |         EntranceAndExitAnimationCompatible.super.setOut(out);
201 |     }
202 | 
203 |     /**
204 |      * @return the non-null active label generator
205 |      */
206 |     public ObjectProperty<LabelFactory> labelFactoryProperty() {
207 |         return this.labelFactory;
208 |     }
209 | 
210 |     /**
211 |      * @return the non-null active label generator
212 |      */
213 |     public LabelFactory getLabelFactory() {
214 |         return this.labelFactory.get();
215 |     }
216 | 
217 |     /**
218 |      * {@inheritDoc}
219 |      */
220 |     @Override
221 |     public SimpleBooleanProperty pausedProperty() {
222 |         return pausedProperty;
223 |     }
224 | 
225 |     /**
226 |      * Sets the active label generator.
227 |      * Example:
228 |      * <pre>
229 |      *     animatedLabel.setLabelFactory(text{@literal ->} {
230 |      *        Label label = new Label(text);
231 |      *        // Apply label properties...
232 |      *        return label;
233 |      *     });
234 |      * </pre>
235 |      *
236 |      * @param labelFactory the way new labels will be generated. If <tt>null</tt>, the default one will be used
237 |      */
238 |     public void setLabelFactory(LabelFactory labelFactory) {
239 |         this.labelFactory.set(labelFactory != null ? labelFactory : LabelFactory.DEFAULT);
240 |     }
241 | 
242 |     /**
243 |      * A factory that generates new {@link Label}s every time the {@link AnimatedLabel}'s text is updated.
244 |      */
245 |     @FunctionalInterface
246 |     public interface LabelFactory {
247 | 
248 |         /**
249 |          * The default factory used, which returns a standard {@link Label} with the given text.
250 |          */
251 |         LabelFactory DEFAULT = Label::new;
252 | 
253 |         /**
254 |          * @param text the updated text
255 |          * @return a new label
256 |          */
257 |         Label newLabel(String text);
258 |     }
259 | }
260 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # animated
  2 | 
  3 | **animated** introduces **implicit animations**, a completely new concept in JavaFX strongly inspired by [Flutter's animations and motion widgets](https://flutter.dev/docs/development/ui/widgets/animation).
  4 | 
  5 | ### Index
  6 | 1. [Getting started](#getting-started)
  7 | 2. [Implicit animations](#implicit-animations)
  8 | 3. [Animated containers](#animated-containers)
  9 | 4. [Animated switchers](#animated-switchers)
 10 | 5. [Animated theme switch](#animated-theme-switch)
 11 | 6. [Animated values](#animated-values)
 12 | 7. [Other examples](#other-examples)
 13 | 8. [FXML](#fxml)
 14 | 9. [Kotlin extensions](#kotlin-extensions)
 15 | 
 16 | ## Getting started
 17 | 
 18 | Maven:
 19 | ```xml
 20 | <dependency>
 21 |     <groupId>eu.iamgio</groupId>
 22 |     <artifactId>animated</artifactId>
 23 |     <version>1.3.0</version>
 24 | </dependency>
 25 | ```
 26 | 
 27 | Gradle:
 28 | ```gradle
 29 | allprojects {
 30 |     repositories {
 31 |         mavenCentral()
 32 |     }
 33 | }
 34 | dependencies {
 35 |     implementation 'eu.iamgio:animated:1.3.0'
 36 | }
 37 | ```
 38 | 
 39 | > **Note**: v1.0.0 brought several important changes, including a different project structure,
 40 | > that may cause compilation errors when upgrading from 0.x versions.  
 41 | > Please check the [migration guide](https://github.com/iamgio/animated/releases/tag/v1.0.0) to see what changed and quickly learn how to fix those errors.
 42 | 
 43 | <br/>
 44 | 
 45 | ---
 46 | 
 47 | <br/>
 48 | 
 49 | ## Implicit animations
 50 | 
 51 | Forget about timelines, explicit animations and other stuff that pollutes your code. This animation system will provide versatility to your code and interface.
 52 | 
 53 | ![Demo](https://i.imgur.com/TKXA8de.gif)  
 54 | **[Code](src/test/java/eu/iamgio/animatedtest/AnimatedTest.java)**
 55 | 
 56 | ```java
 57 | Animated animated = new Animated(child, AnimationProperty.of(child.opacityProperty()));
 58 | root.getChildren().add(animated);
 59 | 
 60 | // Later...
 61 | child.setOpacity(0.5); // Plays the transition
 62 | ```  
 63 | 
 64 | This approach instantiates an `Animated` node that contains one child and is bound to a property.  
 65 | Now that we have set an animated bound, we can see that `child.setOpacity(someValue)` creates a transition between the initial and final value.
 66 | 
 67 | A single `Animated` object can take multiple properties at once,
 68 | and they can also be added later by accessing `Animated#getTargetProperties`. 
 69 | 
 70 | ### Presets
 71 | [Pre-made animation properties](src/main/java/eu/iamgio/animated/binding/presets) represent a concise and efficient
 72 | way to create animated bindings, rather than manually referencing to the
 73 | raw JavaFX property as we previously did.
 74 | 
 75 | - `AnimatedBlur`
 76 | - `AnimatedColor`
 77 | - `AnimatedDropShadow.Color`
 78 | - `AnimatedDropShadow.Radius`
 79 | - `AnimatedLayout`
 80 | - `AnimatedOpacity`
 81 | - `AnimatedPrefSize`
 82 | - `AnimatedRotation`
 83 | - `AnimatedScale`
 84 | - `AnimatedTranslatePosition`
 85 | 
 86 | When these properties are instantiated via their zero-arguments constructor,
 87 | the target node references to the `Animated`'s child. 
 88 | 
 89 | ```java
 90 | // Before
 91 | new Animated(child,
 92 |         AnimationProperty.of(child.prefWidthProperty()),
 93 |         AnimationProperty.of(child.prefHeightProperty())
 94 | );
 95 | 
 96 | // After: better!
 97 | new Animated(child, new AnimatedPrefSize());
 98 | ```
 99 | 
100 | ### Independent animations
101 | 
102 | `Animated` is a node that has to be added to the scene in order to work.  
103 | Here is a different approach that is independent from the scene:
104 | 
105 | ```java
106 | AnimationProperty.of(node.opacityProperty()).register();
107 | // or
108 | new AnimatedOpacity(node).register();
109 | 
110 | // Later...
111 | node.setOpacity(0.5); // Plays the transition
112 | ```
113 | 
114 | > Animations are not only visual:
115 | > you can also animate other changes such as audio volume!
116 | 
117 | ### Custom animations
118 | 
119 | The default animation is linear and lasts 1 second.
120 | It can be customized by calling `withSettings(AnimationSettings settings)` or `custom(Function<AnimationSettings, AnimationSettings> settings)`,
121 | both methods available on animated nodes and animation properties.
122 | 
123 | Examples:
124 | ```java
125 | Animated animated = new Animated(child, AnimationProperty.of(child.opacityProperty()));
126 |     .custom(settings -> settings.withDuration(Duration.seconds(.5)).withCurve(Curve.EASE_IN_OUT));
127 | ```  
128 | 
129 | ```java
130 | Animated animated = new Animated(child,
131 |     new AnimatedOpacity()
132 |         .custom(settings -> settings.withDuration(Duration.seconds(.8))),
133 |     new AnimatedRotation()
134 |         .custom(settings -> settings.withDuration(Duration.seconds(.5))),
135 | ).custom(settings -> settings.withCurve(Curve.EASE_OUT));
136 | ```
137 | 
138 | <br/>
139 | 
140 | ---
141 | 
142 | <br/>
143 | 
144 | ## Animated containers
145 | 
146 | **animated** provides custom implementations of `VBox` and `HBox` that animate their content whenever their children are affected by a change.  
147 | This feature is based on animations from [AnimateFX](https://github.com/Typhon0/AnimateFX).
148 | 
149 | ![Demo](https://i.imgur.com/jqm9KDA.gif)  
150 | **[Code](src/test/java/eu/iamgio/animatedtest/AnimatedContainerTest.java)**
151 | 
152 | **Constructors**:
153 | - `Animation in, Animation out` wraps two `AnimateFX` objects into customizable `animated` objects;
154 | - `AnimationFX in, AnimationFX out` takes two raw AnimateFX animations that cannot be customized;
155 | - `AnimationPair animation` takes a pair of animations, mostly used with pre-made pairs (e.g. `AnimationPair.fade()`).
156 | 
157 | `pause()` and `resume()` allow disabling/enabling animations so that you can switch back to the regular implementation and forth.
158 | 
159 | Example:
160 | ```java
161 | AnimatedVBox vBox = new AnimatedVBox(AnimationPair.fade());
162 | 
163 | // Later...
164 | vBox.getChildren().add(someNode);    // someNode fades in
165 | vBox.getChildren().remove(someNode); // someNode fades out
166 | ```
167 | 
168 | <br/>
169 | 
170 | ---
171 | 
172 | <br/>
173 | 
174 | ## Animated switchers
175 | 
176 | The library also provides an `AnimatedSwitcher` node that creates a transition whenever its child changes.  
177 | As for animated containers, this feature relies on AnimateFX.
178 | 
179 | ![Demo](https://i.imgur.com/8v2Wn0a.gif)  
180 | **[Code](src/test/java/eu/iamgio/animatedtest/AnimatedSwitcherTest.java)**
181 | 
182 | See [animated containers](#animated-containers) for information about constructors.  
183 | Right after the instantiation, calling `of(Node child)` will set the initial child without any animation played.
184 | 
185 | Example:
186 | ```java
187 | AnimatedSwitcher switcher = new AnimatedSwitcher(
188 |     new Animation(new FadeInDown()).setSpeed(2), 
189 |     new Animation(new FadeOutDown()).setSpeed(1.5)
190 | ).of(firstChild);
191 | root.getChildren().add(switcher);
192 | 
193 | // Later...
194 | switcher.setChild(secondChild); // Plays the transition
195 | ```
196 | 
197 | ### Related: animated text
198 | 
199 | `AnimatedLabel` uses a switcher to animate text.
200 | 
201 | Example:
202 | ```java
203 | AnimatedLabel label = new AnimatedLabel("Text", AnimationPair.fade());
204 | 
205 | // Later...
206 | label.setText("New text"); // Plays the transition
207 | ```
208 | 
209 | <br/>
210 | 
211 | ---
212 | 
213 | <br/>
214 | 
215 | ## Animated theme switch
216 | 
217 | It is possible to create a transition whenever the stylesheets of the scene change via `AnimatedThemeSwitcher`, based on AnimateFX.
218 | 
219 | 
220 | ![Theme](https://i.imgur.com/Wwma43y.gif)  
221 | **[Code](src/test/java/eu/iamgio/animatedtest/AnimatedThemeTest.java)**
222 | 
223 | ```java
224 | scene.getStylesheets().setAll("/light.css"); // Initial theme
225 | AnimatedThemeSwitcher themeSwitcher = new AnimatedThemeSwitcher(scene, new CircleClipOut());
226 | themeSwitcher.init(); // Required!
227 | 
228 | // Later...
229 | scene.getStylesheets().setAll("/dark.css"); // Plays the transition
230 | 
231 | // This also works with add, set, remove and other List methods.
232 | ```
233 | 
234 | > **Note** that not every type of root can be animated properly, such as `VBox` and `HBox`.
235 | > Parents that allow overlapping children, i.e. `Pane`, are suggested. 
236 | 
237 | <br/>
238 | 
239 | ---
240 | 
241 | <br/>
242 | 
243 | ## Animated values
244 | 
245 | The animated binding API provides a way to animate the content of a `Label`
246 | every time its associated value changes.  
247 | 
248 | 
249 | ![Currency](https://i.imgur.com/9TZmEzl.gif)  
250 | **[Code](src/test/java/eu/iamgio/animatedtest/AnimatedCurrencyTest.java)**
251 | 
252 | ```java
253 | AnimatedValueLabel<Integer> label = new AnimatedValueLabel<>(0)
254 |                 .custom(settings -> settings.withCurve(Curve.EASE_IN_OUT));
255 | 
256 | // We can also customize the displayed text
257 | label.setTextMapper(value -> "The value is " + value);
258 | 
259 | // Later...
260 | label.setValue(10); // Plays the transition
261 | ```
262 | 
263 | <br/>
264 | 
265 | ---
266 | 
267 | <br/>
268 | 
269 | ## Other examples
270 | 
271 | ![Button](https://i.imgur.com/mVGkKcx.gif)  
272 | **[Button color and border](src/test/java/eu/iamgio/animatedtest/AnimatedButtonTest.java)**
273 | 
274 | ![Shadow](https://i.imgur.com/jd8Bbr4.gif)  
275 | **[Drop shadows + label](src/test/java/eu/iamgio/animatedtest/AnimatedShadowTest.java)**
276 | 
277 | ![Root switch](https://i.imgur.com/cYkSu9z.gif)  
278 | **[Root switch](src/test/java/eu/iamgio/animatedtest/AnimatedRootSwitchTest.java)**
279 | 
280 | ![Layout alignment](https://i.imgur.com/xNRltwq.gif)  
281 | **[Layout alignment](src/test/java/eu/iamgio/animatedtest/AnimatedLayoutTest.java)** (inspired by the Edge home page)
282 | 
283 | <br/>
284 | 
285 | ---
286 | 
287 | <br/>
288 | 
289 | ## FXML
290 | 
291 | - **Animated**
292 |   ```xml
293 |   <?import eu.iamgio.animated.binding.Animated?>
294 |   <?import eu.iamgio.animated.binding.AnimationSettings?>
295 |   <?import eu.iamgio.animated.binding.presets.AnimatedOpacity?>
296 |   
297 |   <Animated>
298 |         <child>
299 |             <MyNode/>
300 |         </child>
301 |         <targetProperties>
302 |             <!-- Properties to animate, related to the current child -->
303 |             <AnimatedOpacity>
304 |                 <settings>
305 |                     <AnimationSettings duration="1500ms" curve="EASE_IN_OUT"/>
306 |                 </settings>
307 |             </AnimatedOpacity>
308 |             <!-- Multiple properties are supported -->
309 |         </targetProperties>
310 |     </Animated>
311 |   ```
312 | 
313 | - **AnimatedContainer**
314 |   ```xml
315 |   <?import eu.iamgio.animated.transition.container.AnimatedHBox?>
316 |   <?import eu.iamgio.animated.transition.Animation?>
317 | 
318 |   <AnimatedHBox>
319 |       <!-- Optional: defaults to FadeIn -->
320 |       <in>
321 |           <Animation type="ZoomIn"/>
322 |       </in>
323 |       <!-- Optional: defaults to FadeOut -->
324 |       <out>
325 |           <Animation type="ZoomOut"/>
326 |       </out>
327 |       <!-- Optional initial children -->
328 |       <MyNode1/>      
329 |       <MyNode2/>
330 |       <!-- ... -->      
331 |   </AnimatedHBox>
332 |   ```
333 | 
334 | - **AnimatedSwitcher**  
335 |   ```xml
336 |   <?import eu.iamgio.animated.transition.AnimatedSwitcher?>
337 |   <?import eu.iamgio.animated.transition.Animation?>
338 |   
339 |   <AnimatedSwitcher>
340 |       <!-- Optional: defaults to FadeIn -->
341 |       <in>
342 |           <Animation type="RectangleClipIn"/>
343 |       </in>
344 |       <!-- Optional: defaults to FadeOut -->
345 |       <out>
346 |           <Animation type="SlideOutUp" speed="0.5"/>
347 |       </out>
348 |       <!-- Optional initial child -->
349 |       <child>
350 |           <InitialChild/>
351 |       </child>
352 |   </AnimatedSwitcher>
353 |   ```
354 |   
355 | - **AnimatedLabel**  
356 |   ```xml
357 |   <?import eu.iamgio.animated.transition.AnimatedLabel?>
358 |   <?import eu.iamgio.animated.transition.Animation?>
359 |   
360 |   <AnimatedLabel text="Initial text">
361 |       <!-- Optional: defaults to FadeIn -->
362 |       <in>
363 |           <Animation type="BounceIn" delay="300ms"/>
364 |       </in>
365 |       <!-- Optional: defaults to FadeOut -->
366 |       <in>
367 |           <Animation type="BounceOut"/>
368 |       </in>
369 |   </AnimatedLabel>
370 |   ```  
371 | 
372 | - **AnimatedValueLabel**  
373 |   FXML has issues with generic types, so you will need to instantiate an
374 |   `AnimatedIntValueLabel` or `AnimatedDoubleValueLabel`.  
375 |   ```xml
376 |   <?import eu.iamgio.animated.binding.AnimationSettings?>
377 |   <?import eu.iamgio.animated.binding.value.AnimatedIntValueLabel?>
378 |   
379 |   <AnimatedIntValueLabel value="0">
380 |       <!-- Optional customization -->
381 |       <settings>
382 |           <AnimationSettings duration="1500ms" curve="EASE_IN_OUT"/>
383 |       </settings>
384 |   </AnimatedIntValueLabel>
385 |   ```
386 | 
387 | <br>
388 | 
389 | > When instantiating an `<Animation type="..."/>`,
390 | > the class name (case sensitive) is searched in the following packages:
391 | > - [`animatefx.animation`](https://github.com/Typhon0/AnimateFX/tree/master/animatefx/src/main/java/animatefx/animation)
392 | > - [`eu.iamgio.animated.transition.animations`](src/main/java/eu/iamgio/animated/transition/animations) and sub-packages
393 | 
394 | 
395 | <br/>
396 | 
397 | ---
398 | 
399 | <br/>
400 | 
401 | ## Kotlin extensions
402 | 
403 | [Extension functions](src/main/kotlin/eu/iamgio/animated/AnimatedExtensions.kt) make the library less verbose with Kotlin.  
404 | Example:
405 | ```kotlin
406 | val animated: Animated = Animated(child, child.someProperty().animated())
407 | val pair: AnimationPair = FadeIn().options(speed = 1.5) outTo FadeOut()
408 | ```


--------------------------------------------------------------------------------