FAQ JavaFXConsultez toutes les FAQ

Les animations sont construites � partir de la classe javafx.animation.Animation et de ses classes filles pr�sentes dans le package javafx.animation.

Il existe deux mani�res de faire des animations en JavaFX :

• Timeline - une ligne de temps ou ligne temporelle constitu�e d��tapes-cl�s (key frames). L'animation doit �tre construite ici de mani�re manuelle ;
• Transition - une animation pr�te � l'emploi qui peut utiliser directement les propri�t�s d'un n�ud.
  

Nous devons utiliser la classe javafx.util.Duration pour sp�cifier des dur�es ou des instants/moments dans le temps qui serviront � d�finir des �tapes-cl�s dans les animations.

La classe Duration dispose de constantes statiques pr�tes � l'emploi ainsi que de m�thodes de fabriques statiques qui permettent de convertir des valeurs num�riques en dur�es. Des m�thodes utilitaires d'instance sont �galement disponibles pour convertir une dur�e en valeur num�rique ou effectuer des op�rations arithm�tiques entre dur�es. Ce type n'a pas d'�quivalent dans le langage Java�7 ou moins et s'apparente � la classe java.time.Duration disponible en Java�8 ou ult�rieure.

1
2
3
final Duration d100ms = Duration.millis(100); // Une dur�e de 100 millisecondes. 
final Duration d5m = Duration.minutes(5); // Une dur�e de 5 minutes. 
System.out.printf("%f s", d100ms.toSeconds()).println(); // Imprime la valeur de 100ms en secondes.

Il suffit d'appeler la m�thode playFromStart() de l'animation. L'animation d�marrera � partir de son temps initial (Duration.ZERO) et s'effectuera dans le sens positif (sens de temps croissant) tout en conservant le rythme pr�c�demment d�fini.

animation.playFromStart()

1
2
3
4
animation.stop(); 
animation.setRate = setRate(Math.abs(animation.getRate()));  
animation.jumpTo(Duration.ZERO); 
animation.play();

Il suffit d'utiliser la m�thode playFrom() de l'animation en sp�cifiant le temps de d�part.

animation.playFrom(Duration.millis(750));

Il suffit d'appeler la m�thode stop() de l'animation. Cette m�thode positionne le curseur de temps de l'animation � sa position initiale. Appeler cette m�thode n'a aucun effet si l'animation n'est pas en train d��tre jou�e.

animation.stop();

Il suffit d'appeler la m�thode pause() de l'animation. Cette m�thode conserve le curseur de temps de l'animation � sa position actuelle. Appeler cette m�thode n'a aucun effet si l'animation n'est pas en train d��tre jou�e.

animation.pause();

Il suffit d'appeler sa m�thode play() de l'animation. L'animation reprendra � partir du point o� elle s'est pr�c�demment arr�t�e. Si elle n'a jamais �t� lanc�e pr�c�demment, elle d�marrera au temps initial de la ligne temporelle (Duration.ZERO).

animation.play()

Il est possible de modifier la vitesse d'une animation en modifiant sa propri�t� rate.

animation.setRate(2);

animation.setRate(0.5);

Pour inverser une animation, il suffit de lui donner une valeur n�gative pour sa propri�t� rate. L'animation ira alors � rebours depuis son emplacement actuel dans la ligne temporelle.

animation.setRate(-1);

Il faut utiliser la m�thode jumpTo() de l�animation en sp�cifiant une Duration en param�tre.

animation.jumpTo(Duration.seconds(5));

Pour sp�cifier le nombre de r�p�titions d'une animation, il faut modifier la valeur de la propri�t� cycleCount de l'animation en sp�cifiant le nombre de boucles d�sir�es par un nombre entier. Si la valeur est �gale � 1, l'animation s'ex�cutera une seule et unique fois. Pour r�p�ter l'animation ind�finiment, il faut utiliser la valeur Timeline.INDEFINITE.

animation.setCycleCount(10);

Pour inverser une animation automatiquement quand elle se r�p�te, il faut modifier la valeur de sa propri�t� autoReverse et la mettre � la valeur true. Si l'animation se r�p�te plus d'une fois, la vitesse de lecture se verra invers�e � chaque fois qu'elle arrive � une extr�mit� de sa ligne temporelle.

animation.setAutoReverse(true);

Un interpolateur est un objet de type javafx.animation.Interpolator qui permet de modifier l��volution d'une valeur entre deux �tapes-cl�s. Pour �tre plus pr�cis, il permet de modifier la vitesse � la laquelle la valeur part de la valeur initiale pour arriver � la valeur finale. Graphiquement, cela peut se traduire par exemple lorsque la vitesse de d�placement, de rotation ou d'agrandissement du n�ud en train d��tre anim� varie au cours du temps.

Par d�faut, l'API d'animation JavaFX fournit cinq types d'interpolateurs :

• Interpolator.DISCRETE - la valeur conserve sa valeur initiale durant toute l'animation. � la fin de l'animation, elle passe � la valeur finale
  
• Interpolator.LINEAR - durant toute l'animation, la valeur �volue � vitesse constante depuis la valeur initiale jusqu�� la valeur finale
  
• Interpolator.EASE_IN - l'animation d�marre lentement, puis gagne en vitesse, et, au bout d'un certain temps, la valeur �volue � vitesse constante jusqu�� la valeur finale
  
• Interpolator.EASE_OUT - durant l'animation, la valeur �volue � vitesse constante depuis la valeur initiale jusqu�� un certain point. Pass� cet instant, la vitesse d��volution ralentit jusqu�� atteindre la valeur finale de l'animation
  
• Interpolator.EASE_BOTH - une combinaison de EASE_IN et EASE_OUT. L'animation d�marre et se termine lentement tandis que la partie centrale se d�roule � vitesse constante
  
  

Vous pouvez directement �tendre la classe javafx.animation.Interpolator et surcharger la m�thode curve() pour cr�er de nouveaux types d'interpolateurs.

Prenons par exemple le code suivant :

1
2
3
4
5
6
new Interpolator() { 
    @Override 
    protected double curve(double t) { 
        return (1 - Math.sin(Math.PI / 2d + t * Math.PI)) / 2d; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
new Interpolator() { 
    private double factor = 1.25; 
    private final double min = 0; 
    private final double max = (1 - Math.sin(Math.PI / 2d + factor * Math.PI)) / 2d; 
  
    @Override 
    protected double curve(double t) { 
        double sin = Math.sin(Math.PI / 2d + t * factor * Math.PI); 
        sin = (1 - sin) / 2d; 
        sin = sin / (max - min); 
        return sin; 
    } 
}

• initialement l'image est � sa (petite) taille d'origine ;
• l'image commence � s'agrandir lentement, puis le changement de taille s�acc�l�re ;
• le changement de taille commence � ralentir, l'image approche de sa taille finale ;
• la taille de l'image d�passe la taille finale escompt�e tout en continuant � ralentir ;
• puis elle finit par marquer un palier � une taille qui est un peu plus grande que celle que nous voulions atteindre ;
• le changement de taille s'inverse et l'image commence � r�tr�cir, d'abord lentement puis en acc�l�rant ;
• l'animation s�arr�te lorsque l'image atteint une seconde fois sa taille de destination.
  

La classe javafx.animation.AnimationTimer (litt�ralement � minuteur d'animation�) permet d'utiliser un timer de granularit� fine qui tourne sur le thread des animations et donc aux alentours de 60 fps (60 images par seconde. Ici, image = pulsation ou impulsion du timer ; on dit �galement un pulse).

Ce genre de minuteur peut �tre utilis� pour g�rer des animations sans passer par des instances des classes Timeline ou Transition, par exemple pour g�rer une fontaine � particules pour laquelle utiliser une classe d'animation classique ne serait pas efficace.

Ce minuteur peut �galement �tre utilis� pour des travaux sans rapport direct avec un affichage : un timer qui met � jour le ��monde�� d'un jeu c�t� serveur (ind�pendamment de la sortie graphique donc).

Pour utiliser la classe AnimationTimer, vous devez en cr�er une nouvelle instance et surcharger sa m�thode handle(). Cette m�thode est invoqu�e � chaque pulsation du timer et re�oit en param�tre, le temps actuel en nanosecondes. Vous pouvez alors effectuer vos travaux graphiques ou non dans le corps de cette m�thode.

Vous pouvez ensuite invoquer la m�thode start() de la classe AnimationTimer pour d�marrer le minuteur et il vous suffira d'invoquer sa m�thode stop() pour l�arr�ter.

Par exemple, le code suivant permet de v�rifier que le timer tourne aux alentours de 60 fps en calculant le temps moyen entre deux pulsations et en affichant le r�sultat dans un label dans la sc�ne :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
public class Main extends Application { 
  
    private Label label; 
    private ToggleButton button; 
    private AnimationTimer timer; 
  
    @Override 
    public void start(Stage primaryStage) { 
        label = new Label(); 
        StackPane.setAlignment(label, Pos.TOP_LEFT); 
        button = new ToggleButton("Lancement"); 
        button.setOnAction(actionEvent -> toggleTimer()); 
        final StackPane root = new StackPane(); 
        root.getChildren().setAll(button, label); 
        final Scene scene = new Scene(root, 350, 300); 
        primaryStage.setTitle("Test du minuteur d'animation"); 
        primaryStage.setScene(scene); 
        primaryStage.show(); 
    } 
  
    private void toggleTimer() { 
        if (timer == null) { 
            timer = new AnimationTimer() { 
                private final int MAXSAMPPLES = 100; 
                private long[] diffs = new long[MAXSAMPPLES]; 
                private long previousTime = -1; 
                private int currentIndex = 0; 
  
                @Override 
                public void handle(long now) { 
                    if (previousTime != -1) { 
                        diffs[currentIndex] = now - previousTime; 
                        currentIndex++; 
                    } 
                    if (currentIndex == MAXSAMPPLES) { 
                        long sum = 0; 
                        for (int index = 0; index < MAXSAMPPLES; index++) { 
                            sum += diffs[index]; 
                        } 
                        double average = sum / (double) MAXSAMPPLES; 
                        average /= (1000.0 * 1000.0 * 1000.0); 
                        average = 1 / average; 
                        label.setText(String.format("%.1f", average)); 
                        currentIndex = 0; 
                    } 
                    previousTime = now; 
                } 
            }; 
            timer.start(); 
            button.setText("Arr�t"); 
        } else { 
            timer.stop(); 
            timer = null; 
            button.setText("Lancement"); 
        } 
    } 
  
    public static void main(String[] args) { 
        launch(args); 
    } 
}