QAbstractAnimation Class
La classe `QAbstractAnimation` constitue la base de toutes les animations. En savoir plus...
| En-tête : | #include <QAbstractAnimation> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake : | QT += core |
| Hérite de : | QObject |
| Hérité par : |
- Liste de tous les membres, y compris les membres hérités
- QAbstractAnimation fait partie du framework d'animation.
Types publics
| enum | DeletionPolicy { KeepWhenStopped, DeleteWhenStopped } |
| enum | Direction { Forward, Backward } |
| enum | State { Stopped, Paused, Running } |
Propriétés
|
Fonctions publiques
| QAbstractAnimation(QObject *parent = nullptr) | |
| virtual | ~QAbstractAnimation() |
| QBindable<int> | bindableCurrentLoop() const |
| QBindable<int> | bindableCurrentTime() |
| QBindable<QAbstractAnimation::Direction> | bindableDirection() |
| QBindable<int> | bindableLoopCount() |
| QBindable<QAbstractAnimation::State> | bindableState() const |
| int | currentLoop() const |
| int | currentLoopTime() const |
| int | currentTime() const |
| QAbstractAnimation::Direction | direction() const |
| virtual int | duration() const = 0 |
| QAnimationGroup * | group() const |
| int | loopCount() const |
| void | setDirection(QAbstractAnimation::Direction direction) |
| void | setLoopCount(int loopCount) |
| QAbstractAnimation::State | state() const |
| int | totalDuration() const |
Emplacements publics
| void | pause() |
| void | resume() |
| void | setCurrentTime(int msecs) |
| void | setPaused(bool paused) |
| void | start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped) |
| void | stop() |
Signaux
| void | currentLoopChanged(int currentLoop) |
| void | directionChanged(QAbstractAnimation::Direction newDirection) |
| void | finished() |
| void | stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) |
Fonctions protégées
| virtual void | updateCurrentTime(int currentTime) = 0 |
| virtual void | updateDirection(QAbstractAnimation::Direction direction) |
| virtual void | updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) |
Fonctions protégées réimplémentées
| virtual bool | event(QEvent *event) override |
Description détaillée
Cette classe définit les fonctions communes à toutes les animations. En héritant de cette classe, vous pouvez créer des animations personnalisées qui s'intègrent au reste du framework d'animation.
La progression d’une animation est indiquée par son temps actuel (currentLoopTime()), qui est mesuré en millisecondes depuis le début de l’animation (0) jusqu’à sa fin (duration()). Cette valeur est mise à jour automatiquement pendant l’exécution de l’animation. Elle peut également être définie directement à l’aide de la fonction setCurrentTime().
À tout moment, une animation se trouve dans l’un des trois états suivants : Running, Stopped ou Paused– tels que définis par l’énumération State. L’état actuel peut être modifié en appelant start(), stop(), pause() ou resume(). Une animation réinitialise toujours son « current time » lorsqu’elle est lancée. Si elle est mise en pause, elle reprend à la même durée actuelle lorsqu’elle est relancée. Lorsqu’une animation est arrêtée, elle ne peut pas être relancée, mais conserve sa durée actuelle (jusqu’à ce qu’elle soit relancée). QAbstractAnimation émet un événement « stateChanged() » chaque fois que son état change.
Une animation peut être répétée un nombre illimité de fois en définissant la propriété « loopCount ». Lorsque l’heure actuelle d’une animation atteint sa valeur « duration » (), celle-ci réinitialise l’heure actuelle et continue de s’exécuter. Un nombre de boucles égal à 1 (valeur par défaut) signifie que l’animation s’exécutera une seule fois. Notez qu’une durée de -1 signifie que l’animation s’exécutera jusqu’à ce qu’elle soit arrêtée ; l’instant courant augmentera indéfiniment. Lorsque l’instant courant est égal à duration() et que l’animation en est à sa dernière boucle, l’état « Stopped » est activé et le signal finished() est émis.
QAbstractAnimation fournit des fonctions virtuelles pures utilisées par les sous-classes pour suivre la progression de l’animation : duration() et updateCurrentTime(). La fonction duration() vous permet de signaler une durée pour l’animation (comme indiqué ci-dessus). Le framework d’animation appelle updateCurrentTime() lorsque l’heure actuelle a changé. En réimplémentant cette fonction, vous pouvez suivre la progression de l’animation. Notez que ni l’intervalle entre les appels, ni le nombre d’appels à cette fonction ne sont définis ; toutefois, on compte généralement 60 mises à jour par seconde.
En réimplémentant updateState(), vous pouvez suivre les changements d’état de l’animation, ce qui est particulièrement utile pour les animations qui ne sont pas pilotées par le temps.
Voir également QVariantAnimation, QPropertyAnimation, QAnimationGroup et Le framework d’animation.
Documentation sur les types de membres
enum QAbstractAnimation::DeletionPolicy
| Constante | Valeur | Description |
|---|---|---|
QAbstractAnimation::KeepWhenStopped | 0 | L'animation ne sera pas supprimée lorsqu'elle sera arrêtée. |
QAbstractAnimation::DeleteWhenStopped | 1 | L'animation sera automatiquement supprimée lorsqu'elle sera arrêtée. |
enum QAbstractAnimation::Direction
Cette énumération décrit la direction de l'animation lorsqu'elle se trouve dans l'état « Running ».
| Constante | Valeur | Description |
|---|---|---|
QAbstractAnimation::Forward | 0 | Le temps actuel de l’animation augmente avec le temps (c’est-à-dire qu’il évolue de 0 vers la fin / la durée). |
QAbstractAnimation::Backward | 1 | Le temps actuel de l'animation diminue au fil du temps (c'est-à-dire qu'il évolue de la fin / durée vers 0). |
Voir aussi direction.
enum QAbstractAnimation::State
Cette énumération décrit l'état de l'animation.
| Constante | Valeur | Description |
|---|---|---|
QAbstractAnimation::Stopped | 0 | L'animation n'est pas en cours d'exécution. Il s'agit de l'état initial de la fonction QAbstractAnimation, et de l'état dans lequel la fonction QAbstractAnimation revient une fois terminée. L'heure actuelle reste inchangée jusqu'à ce que la fonction setCurrentTime() soit appelée, ou que l'animation soit lancée en appelant la fonction start(). |
QAbstractAnimation::Paused | 1 | L’animation est mise en pause (c’est-à-dire temporairement suspendue). L’appel de resume() relancera l’animation. |
QAbstractAnimation::Running | 2 | L’animation est en cours d’exécution. Tant que le contrôle se trouve dans la boucle d’événements, QAbstractAnimation mettra à jour son heure actuelle à intervalles réguliers, en appelant updateCurrentTime() le cas échéant. |
Voir également state() et stateChanged().
Documentation sur les propriétés
[bindable read-only] currentLoop : int
Remarque : cette propriété prend en charge les liaisons « QProperty ».
Cette propriété indique la boucle actuelle de l'animation
Cette propriété décrit la boucle actuelle de l’animation. Par défaut, le nombre de boucles de l’animation est égal à 1 ; la boucle actuelle est donc toujours égale à 0. Si le nombre de boucles est égal à 2 et que l’animation dépasse sa durée, elle revient automatiquement en arrière et redémarre à l’instant courant 0, avec la boucle actuelle égale à 1, et ainsi de suite.
Lorsque la boucle actuelle change, QAbstractAnimation émet le signal currentLoopChanged().
Fonctions d’accès :
| int | currentLoop() const |
Signal du notificateur :
| void | currentLoopChanged(int currentLoop) |
[bindable] currentTime : int
Remarque : cette propriété prend en charge les liaisons de type « QProperty ».
Cette propriété contient l'instant actuel et la progression de l'animation
Cette propriété indique l'instant actuel de l'animation. Vous pouvez modifier l'instant actuel en appelant la méthode setCurrentTime(), ou bien appeler la méthode start() et laisser l'animation s'exécuter, ce qui définira automatiquement l'instant actuel au fur et à mesure que l'animation progresse.
La durée actuelle de l'animation commence à 0 et se termine à totalDuration().
Remarque : vous pouvez lier d’autres propriétés à currentTime, mais il n’est pas recommandé de définir des liaisons vers celle-ci. À mesure que l’animation progresse, currentTime est mise à jour automatiquement, ce qui annule ses liaisons.
Fonctions d'accès :
| int | currentTime() const |
| void | setCurrentTime(int msecs) |
Voir également loopCount et currentLoopTime().
[bindable] direction : Direction
Remarque : cette propriété prend en charge les liaisons de type « QProperty ».
Cette propriété indique la direction de l'animation lorsqu'elle est dans l'état « Running ».
Cette direction indique si le temps évolue de 0 vers la durée de l'animation, ou si, après l'appel de la méthode ` start()`, il évolue de la valeur de la durée vers 0.
Par défaut, cette propriété est définie sur ` Forward`.
Fonctions d'accès :
| QAbstractAnimation::Direction | direction() const |
| void | setDirection(QAbstractAnimation::Direction direction) |
Signal de notification :
| void | directionChanged(QAbstractAnimation::Direction newDirection) |
[read-only] duration : int
Cette propriété indique la durée de l'animation.
Si la durée est égale à -1, cela signifie qu'elle n'est pas définie. Dans ce cas, la propriété « loopCount » est ignorée.
Fonctions d'accès :
| virtual int | duration() const = 0 |
[bindable] loopCount : int
Remarque : cette propriété prend en charge les liaisons de type « QProperty ».
Cette propriété contient le nombre de boucles de l'animation
Cette propriété décrit le nombre de boucles de l'animation sous forme d'entier. Par défaut, cette valeur est égale à 1, ce qui indique que l'animation ne doit s'exécuter qu'une seule fois, puis s'arrêter. En modifiant cette valeur, vous pouvez faire en sorte que l’animation soit lue en boucle plusieurs fois. Avec une valeur de 0, l’animation ne sera pas lue du tout, et avec une valeur de -1, elle sera lue en boucle indéfiniment jusqu’à ce qu’on l’arrête. La boucle n’est pas prise en charge pour une animation dont la durée n’est pas définie. Elle ne sera lue qu’une seule fois.
Fonctions d'accès :
| int | loopCount() const |
| void | setLoopCount(int loopCount) |
[bindable read-only] state : State
Remarque : cette propriété prend en charge les liaisons « QProperty ».
État de l'animation.
Cette propriété décrit l'état actuel de l'animation. Lorsque l'état de l'animation change, QAbstractAnimation émet le signal stateChanged().
Remarque : les mises à jourd’état peuvent entraîner des mises à jour de la propriété currentTime, ce qui peut à son tour annuler ses liaisons. Soyez donc prudent lorsque vous définissez des liaisons sur la propriété currentTime, si vous vous attendez à ce que l’état de l’animation change.
Fonctions d’accès :
| QAbstractAnimation::State | state() const |
Signal de notification :
| void | stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) |
Documentation des fonctions membres
QAbstractAnimation::QAbstractAnimation(QObject *parent = nullptr)
Crée l'instance de la classe de base `QAbstractAnimation` et transmet ` parent ` au constructeur de ` QObject`.
Voir également QVariantAnimation et QAnimationGroup.
[virtual noexcept] QAbstractAnimation::~QAbstractAnimation()
Arrête l'animation si elle est en cours, puis détruit l'QAbstractAnimation. Si l'animation fait partie d'un QAnimationGroup, elle est automatiquement supprimée avant la destruction de ce dernier.
[signal] void QAbstractAnimation::currentLoopChanged(int currentLoop)
QAbstractAnimation émet ce signal chaque fois que la boucle de courant change. currentLoop correspond à la boucle de courant.
Remarque : signalde notification pour la propriété currentLoop.
Voir également currentLoop() et loopCount().
int QAbstractAnimation::currentLoopTime() const
Renvoie l'heure actuelle à l'intérieur de la boucle en cours. Elle peut aller de 0 à duration().
Voir également duration() et currentTime.
[signal] void QAbstractAnimation::directionChanged(QAbstractAnimation::Direction newDirection)
QAbstractAnimation émet ce signal chaque fois que la direction a été modifiée. newDirection correspond à la nouvelle direction.
Remarque : signalde notification pour la propriété direction.
Voir également direction.
[pure virtual] int QAbstractAnimation::duration() const
Cette fonction purement virtuelle renvoie la durée de l'animation et définit pendant combien de temps ` QAbstractAnimation ` doit mettre à jour l'heure actuelle. Cette durée est locale et n'inclut pas le nombre de boucles.
Une valeur de retour égale à -1 indique que l'animation n'a pas de durée définie ; l'animation doit alors s'exécuter indéfiniment jusqu'à ce qu'elle soit arrêtée. Cela est utile pour les animations qui ne sont pas pilotées par le temps, ou dont la durée est difficile à prévoir (par exemple, la lecture audio déclenchée par des événements dans un jeu).
Si l’animation est une animation parallèle ( QAnimationGroup), la durée correspondra à la plus longue durée de toutes ses animations. Si l’animation est une animation séquentielle ( QAnimationGroup), la durée correspondra à la somme des durées de toutes ses animations.
Remarque : fonctiongetter pour la propriété duration.
Voir également loopCount.
[override virtual protected] bool QAbstractAnimation::event(QEvent *event)
Réimplémente : QObject::event(QEvent *e).
[signal] void QAbstractAnimation::finished()
QAbstractAnimation émet ce signal une fois que l'animation s'est arrêtée et qu'elle est arrivée à la fin.
Ce signal est émis après l'appel de la fonction ` stateChanged()`.
Voir également stateChanged().
QAnimationGroup *QAbstractAnimation::group() const
Si cette animation fait partie d'un groupe ( QAnimationGroup), cette fonction renvoie un pointeur vers ce groupe ; sinon, elle renvoie « nullptr ».
Voir également QAnimationGroup::addAnimation().
[slot] void QAbstractAnimation::pause()
Met l'animation en pause. Lorsque l'animation est en pause, la méthode state() renvoie la valeur « Paused ». La valeur de currentTime restera inchangée jusqu'à ce que la méthode resume() ou start() soit appelée. Si vous souhaitez reprendre l'animation à partir du moment actuel, appelez la méthode resume().
Voir également start(), state() et resume().
[slot] void QAbstractAnimation::resume()
Reprend l'animation après une mise en pause. Lorsque l'animation reprend, elle émet le signal stateChanged(). La propriété currentTime n'est pas modifiée.
Voir également start(), pause() et state().
[slot] void QAbstractAnimation::setPaused(bool paused)
Si paused est vrai, l'animation est mise en pause. Si paused est faux, l'animation reprend.
Voir également state(), pause() et resume().
[slot] void QAbstractAnimation::start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped)
Lance l’animation. L’argument ` policy ` indique si l’animation doit être supprimée ou non une fois terminée. Lorsque l’animation démarre, le signal ` stateChanged()` est émis, et ` state()` renvoie la valeur « Running ». Lorsque le contrôle revient à la boucle d’événements, l’animation s’exécute de manière autonome, en appelant périodiquement ` updateCurrentTime()` au fur et à mesure de sa progression.
Si l’animation est actuellement arrêtée ou a déjà atteint sa fin, l’appel à start() la rembobinera et la relancera depuis le début. Lorsque l’animation atteint sa fin, elle s’arrête, ou si le niveau de boucle est supérieur à 1, elle est rembobinée et reprend depuis le début.
Si l’animation est déjà en cours d’exécution, cette fonction ne fait rien.
Voir également stop() et state().
[signal] void QAbstractAnimation::stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
QAbstractAnimation émet ce signal chaque fois que l'état de l'animation passe de « oldState » à « newState ». Ce signal est émis après l'appel de la fonction virtuelle updateState().
Remarque : signalde notification pour la propriété state.
Voir également updateState().
[slot] void QAbstractAnimation::stop()
Arrête l'animation. Lorsque l'animation est arrêtée, elle émet le signal ` stateChanged()`, et la méthode ` state()` renvoie la valeur « Stopped ». L'heure actuelle n'est pas modifiée.
Si l'animation s'arrête d'elle-même après avoir atteint la fin (c'est-à-dire lorsque currentLoopTime() == duration() et currentLoop() > loopCount() - 1), le signal finished() est émis.
Voir également start() et state().
int QAbstractAnimation::totalDuration() const
Renvoie la durée totale et la durée effective de l'animation, y compris le nombre de boucles.
Remarque : si le nombre de boucles est très élevé, ou si la durée d’une seule boucle est trop longue, la durée totale peut être trop importante pour tenir dans un entier de type ` int`. Dans ce cas, la valeur est saturée à ` INT_MAX`.
Voir également ` duration()` et ` currentTime`.
[pure virtual protected] void QAbstractAnimation::updateCurrentTime(int currentTime)
Cette fonction purement virtuelle est appelée chaque fois que l'currentTime de l'animation change.
Voir également updateState().
[virtual protected] void QAbstractAnimation::updateDirection(QAbstractAnimation::Direction direction)
Cette fonction virtuelle est appelée par QAbstractAnimation lorsque la direction de l'animation est modifiée. L'argument direction correspond à la nouvelle direction.
Voir également setDirection() et direction().
[virtual protected] void QAbstractAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
Cette fonction virtuelle est appelée par QAbstractAnimation lorsque l'état de l'animation passe de oldState à newState.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.
