Sur cette page

QTimeLine Class

La classe QTimeLine fournit une chronologie permettant de contrôler les animations. En savoir plus...

En-tête : #include <QTimeLine>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core
Hérite de : QObject

Types publics

enum Direction { Forward, Backward }
enum State { NotRunning, Paused, Running }

Propriétés

Fonctions publiques

QTimeLine(int duration = 1000, QObject *parent = nullptr)
virtual ~QTimeLine()
QBindable<int> bindableCurrentTime()
QBindable<QTimeLine::Direction> bindableDirection()
QBindable<int> bindableDuration()
QBindable<QEasingCurve> bindableEasingCurve()
QBindable<int> bindableLoopCount()
QBindable<int> bindableUpdateInterval()
int currentFrame() const
int currentTime() const
qreal currentValue() const
QTimeLine::Direction direction() const
int duration() const
QEasingCurve easingCurve() const
int endFrame() const
int frameForTime(int msec) const
int loopCount() const
void setDirection(QTimeLine::Direction direction)
void setDuration(int duration)
void setEasingCurve(const QEasingCurve &curve)
void setEndFrame(int frame)
void setFrameRange(int startFrame, int endFrame)
void setLoopCount(int count)
void setStartFrame(int frame)
void setUpdateInterval(int interval)
int startFrame() const
QTimeLine::State state() const
int updateInterval() const
virtual qreal valueForTime(int msec) const

Emplacements publics

void resume()
void setCurrentTime(int msec)
void setPaused(bool paused)
void start()
void stop()
void toggleDirection()

Signaux

void finished()
void frameChanged(int frame)
void stateChanged(QTimeLine::State newState)
void valueChanged(qreal value)

Fonctions protégées réimplémentées

virtual void timerEvent(QTimerEvent *event) override

Description détaillée

Elle est le plus souvent utilisée pour animer un contrôle d'interface graphique en appelant périodiquement un slot. Vous pouvez créer une ligne de temps en passant sa durée en millisecondes au constructeur de QTimeLine. La durée de la ligne de temps détermine la durée de l’animation. Vous définissez ensuite une plage d’images appropriée en appelant la fonction setFrameRange(). Enfin, connectez le signal frameChanged() à une fonction de traitement appropriée du widget que vous souhaitez animer (par exemple, setValue() dans QProgressBar). Lorsque vous appelez start(), QTimeLine passe à l’état « Running » et commence à émettre des signaux frameChanged() à intervalles réguliers, ce qui fait évoluer la valeur de la propriété connectée de votre widget de la limite inférieure vers la limite supérieure de votre plage d’images, à un rythme constant. Vous pouvez spécifier l’intervalle de mise à jour en appelant la méthode ` setUpdateInterval()`. Une fois cette opération terminée, QTimeLine passe à l’état « NotRunning » et émet l’événement ` finished()`.

Exemple :

//...
auto progressBar = new QProgressBar(this);
progressBar->setRange(0, 100);

// Construct a 1-second timeline with a frame range of 0 - 100
QTimeLine *timeLine = new QTimeLine(1000, this);
timeLine->setFrameRange(0, 100);
connect(timeLine, &QTimeLine::frameChanged, progressBar, &QProgressBar::setValue);

// Clicking the push button will start the progress bar animation
auto pushButton = new QPushButton(tr("Start animation"), this);
connect(pushButton, &QPushButton::clicked, timeLine, &QTimeLine::start);
//...

Par défaut, la timeline s’exécute une seule fois, du début à la fin, après quoi vous devez appeler à nouveau start() pour la relancer depuis le début. Pour que la timeline boucle, vous pouvez appeler setLoopCount(), en passant le nombre de fois où la timeline doit s’exécuter avant de s’arrêter. Il est également possible de modifier le sens de défilement, afin que la timeline défile à l’envers, en appelant setDirection(). Vous pouvez également mettre en pause et reprendre la lecture de la chronologie pendant son exécution en appelant setPaused(). Pour un contrôle interactif, la fonction setCurrentTime() est fournie ; elle permet de définir directement la position temporelle de la chronologie. Bien qu’elle soit particulièrement utile en mode « NotRunning » (par exemple, lorsqu’elle est connectée à un signal valueChanged() dans un QSlider), cette fonction peut être appelée à tout moment.

L’interface « frame » est utile pour les widgets standard, mais QTimeLine peut être utilisé pour contrôler tout type d’animation. Le cœur de QTimeLine réside dans la fonction valueForTime(), qui génère une valeur comprise entre 0 et 1 pour un moment donné. Cette valeur est généralement utilisée pour décrire les étapes d’une animation, où 0 correspond à la première étape et 1 à la dernière. Lors de son exécution, QTimeLine génère des valeurs comprises entre 0 et 1 en appelant ` valueForTime()` et en émettant ` valueChanged()`. Par défaut, ` valueForTime()` applique un algorithme d’interpolation pour générer ces valeurs. Vous pouvez choisir parmi un ensemble d’algorithmes de timeline prédéfinis en appelant ` setEasingCurve()`.

Notez que, par défaut, QTimeLine utilise QEasingCurve::InOutSine, qui fournit une valeur qui augmente lentement, puis de manière régulière, et enfin à nouveau lentement. Pour une chronologie personnalisée, vous pouvez réimplémenter valueForTime(), auquel cas la propriété easingCurve de QTimeLine est ignorée.

Voir également QProgressBar et QProgressDialog.

Documentation sur les types de membres

enum QTimeLine::Direction

Cette énumération décrit le sens de la chronologie lorsque celle-ci est à l'état « Running ».

ConstanteValeurDescription
QTimeLine::Forward0L'instant actuel de la timeline augmente avec le temps (c'est-à-dire qu'il évolue de 0 vers la fin / la durée).
QTimeLine::Backward1L'instant courant de la timeline diminue au fil du temps (c'est-à-dire qu'il s'éloigne de la fin / de la durée et se rapproche de 0).

Voir également setDirection().

enum QTimeLine::State

Cette énumération décrit l'état de la chronologie.

ConstanteValeurDescription
QTimeLine::NotRunning0La timeline n'est pas en cours d'exécution. Il s'agit de l'état initial de ` QTimeLine`, et de l'état dans lequel ` QTimeLine ` revient une fois l'opération terminée. L'heure, l'image et la valeur actuelles restent inchangées jusqu'à ce que la méthode ` setCurrentTime()` soit appelée, ou que la timeline soit lancée en appelant ` start()`.
QTimeLine::Paused1La timeline est mise en pause (c’est-à-dire temporairement suspendue). L’appel de ` setPaused(false)` reprendra l’activité de la timeline.
QTimeLine::Running2La timeline est en cours d’exécution. Tant que le contrôle se trouve dans la boucle d’événements, QTimeLine met à jour son heure courante à intervalles réguliers, en émettant valueChanged() et frameChanged() le cas échéant.

Voir également state() et stateChanged().

Documentation sur les propriétés

[bindable] currentTime : int

Remarque : cette propriété prend en charge les liaisons de type « QProperty ».

Cette propriété contient l'instant actuel de la chronologie.

Lorsque « QTimeLine » est à l’état « Running », cette valeur est mise à jour en continu en fonction de la durée et du sens de la timeline. Sinon, il s’agit de la valeur qui était actuelle lors du dernier appel de « stop() », ou de la valeur définie par « setCurrentTime() ».

Remarque : vous pouvez lier d’autres propriétés à currentTime, mais il n’est pas recommandé de définir des liaisons vers celle-ci. Au fur et à mesure que l’animation progresse, currentTime est mise à jour automatiquement, ce qui annule ses liaisons.

Par défaut, cette propriété contient la valeur 0.

Fonctions d'accès :

int currentTime() const
void setCurrentTime(int msec)

[bindable] direction : Direction

Remarque : cette propriété prend en charge les liaisons de type « QProperty ».

Cette propriété contient la direction de la timeline lorsque la méthode QTimeLine est dans l'état « Running ».

Cette direction indique si le temps évolue de 0 vers la durée de la timeline, ou si, après l’appel de la méthode start(), il évolue de la valeur de la durée vers 0.

Toute liaison de direction sera supprimée non seulement par setDirection(), mais également par toggleDirection().

Par défaut, cette propriété est définie sur Forward.

Fonctions d'accès :

QTimeLine::Direction direction() const
void setDirection(QTimeLine::Direction direction)

[bindable] duration : int

Remarque : cette propriété prend en charge les liaisons de type « QProperty ».

Cette propriété contient la durée totale de la timeline en millisecondes.

Par défaut, cette valeur est de 1 000 (soit 1 seconde), mais vous pouvez la modifier soit en transmettant une durée au constructeur de ` QTimeLine`, soit en appelant la méthode `setDuration()`. La durée doit être supérieure à 0.

Remarque : la modification de la durée n'entraîne pas la réinitialisation de l'heure actuelle à zéro ni à la nouvelle durée. Vous devez également appeler la méthode setCurrentTime() avec la valeur souhaitée.

Fonctions d'accès :

int duration() const
void setDuration(int duration)

[bindable] easingCurve : QEasingCurve

Remarque : cette propriété prend en charge les liaisons de type « QProperty ».

Spécifie la courbe d'accélération que la timeline utilisera. Si la méthode valueForTime() est réimplémentée, cette valeur est ignorée.

Fonctions d'accès :

QEasingCurve easingCurve() const
void setEasingCurve(const QEasingCurve &curve)

Voir également valueForTime().

[bindable] loopCount : int

Remarque : cette propriété prend en charge les liaisons de type « QProperty ».

Cette propriété indique le nombre de fois que la chronologie doit être lue en boucle avant d'arriver à la fin.

Un nombre de boucles égal à 0 signifie que la timeline sera lue en boucle indéfiniment.

Par défaut, cette propriété a pour valeur 1.

Fonctions d'accès :

int loopCount() const
void setLoopCount(int count)

[bindable] updateInterval : int

Remarque : cette propriété prend en charge les liaisons QProperty.

Cette propriété contient le temps, en millisecondes, écoulé entre chaque mise à jour de l'heure actuelle par QTimeLine.

Lors de la mise à jour de l'heure actuelle, QTimeLine émettra l'événement valueChanged() si la valeur actuelle a changé, et l'événement frameChanged() si l'image a changé.

Par défaut, l’intervalle est de 40 ms, ce qui correspond à une fréquence de 25 mises à jour par seconde.

Fonctions d’accès :

int updateInterval() const
void setUpdateInterval(int interval)

Documentation des fonctions membres

[explicit] QTimeLine::QTimeLine(int duration = 1000, QObject *parent = nullptr)

Crée une chronologie d'une durée de duration millisecondes. L'objet ` parent ` est transmis au constructeur de ` QObject`. La durée par défaut est de 1 000 millisecondes.

[virtual noexcept] QTimeLine::~QTimeLine()

Détruit la chronologie.

int QTimeLine::currentFrame() const

Renvoie l'image correspondant à l'instant présent.

Voir également currentTime(), frameForTime() et setFrameRange().

qreal QTimeLine::currentValue() const

Renvoie la valeur correspondant à l'heure actuelle.

Voir également valueForTime() et currentFrame().

int QTimeLine::endFrame() const

Renvoie l'image de fin, c'est-à-dire l'image correspondant à la fin de la timeline (c'est-à-dire l'image pour laquelle la valeur actuelle est égale à 1).

Voir également setEndFrame() et setFrameRange().

[private signal] void QTimeLine::finished()

Ce signal est émis lorsque « QTimeLine » se termine (c'est-à-dire lorsqu'il atteint la fin de sa chronologie) et ne se répète pas en boucle.

Remarque : il s'agit d'un signal privé. Il peut être utilisé dans des connexions de signaux, mais ne peut pas être émis par l'utilisateur.

[private signal] void QTimeLine::frameChanged(int frame)

QTimeLine émet ce signal à intervalles réguliers lorsqu'il est à l'Running, mais uniquement si la trame en cours change. frame correspond au numéro de la trame en cours.

Remarque : il s’agit d’un signal privé. Il peut être utilisé dans les connexions de signaux, mais ne peut pas être émis par l’utilisateur.

Voir également QTimeLine::setFrameRange() et QTimeLine::updateInterval.

int QTimeLine::frameForTime(int msec) const

Renvoie l'image correspondant à l'instant msec. Cette valeur est calculée à l'aide d'une interpolation linéaire entre l'image de départ et l'image finale, sur la base de la valeur renvoyée par la fonction valueForTime().

Voir également valueForTime() et setFrameRange().

[slot] void QTimeLine::resume()

Reprend la chronologie à partir de l'heure actuelle. ` QTimeLine ` repasse à l'état « Running » et, dès qu'il entre dans la boucle d'événements, met à jour son heure, son image et sa valeur actuelles à intervalles réguliers.

Contrairement à la fonction start(), cette fonction ne redémarre pas la chronologie avant de la reprendre.

Voir également start(), updateInterval(), frameChanged() et valueChanged().

void QTimeLine::setEndFrame(int frame)

Définit l'image de fin, c'est-à-dire l'image correspondant à la fin de la timeline (c'est-à-dire l'image pour laquelle la valeur actuelle est 1), sur frame.

Voir également endFrame(), startFrame() et setFrameRange().

void QTimeLine::setFrameRange(int startFrame, int endFrame)

Définit le compteur d'images de la timeline pour qu'il commence à startFrame et se termine à endFrame. Pour chaque valeur temporelle, QTimeLine trouvera l'image correspondante lorsque vous appellerez currentFrame() ou frameForTime() par interpolation, en utilisant la valeur renvoyée par valueForTime().

Lorsqu’il est à l’état « Running », QTimeLine émet également le signal frameChanged() à chaque changement d’image.

Voir également startFrame(), endFrame(), start() et currentFrame().

[slot] void QTimeLine::setPaused(bool paused)

Si paused est vrai, la timeline est mise en pause, ce qui fait passer QTimeLine à l’état « Paused ». Aucune mise à jour ne sera signalée tant que la méthode start() ou setPaused(false) n’aura pas été appelée. Si paused est faux, la timeline reprend et continue là où elle s’était arrêtée.

Voir également state() et start().

void QTimeLine::setStartFrame(int frame)

Définit l'image de départ, c'est-à-dire l'image correspondant au début de la timeline (c'est-à-dire l'image pour laquelle la valeur actuelle est 0), sur frame.

Voir également startFrame(), endFrame() et setFrameRange().

[slot] void QTimeLine::start()

Lance la timeline. ` QTimeLine ` passe à l'état « Running » et, une fois qu'elle entre dans la boucle d'événements, elle met à jour son heure, son image et sa valeur actuelles à intervalles réguliers. L'intervalle par défaut est de 40 ms (soit 25 fois par seconde). Vous pouvez modifier l'intervalle de mise à jour en appelant ` setUpdateInterval()`.

La timeline démarrera à la position 0, ou à la fin si le défilement s'effectue en arrière. Si vous souhaitez reprendre une timeline arrêtée sans la redémarrer, vous pouvez appeler resume() à la place.

Voir également resume(), updateInterval(), frameChanged() et valueChanged().

int QTimeLine::startFrame() const

Renvoie l'image de départ, c'est-à-dire l'image correspondant au début de la timeline (c'est-à-dire l'image pour laquelle la valeur actuelle est égale à 0).

Voir également setStartFrame() et setFrameRange().

QTimeLine::State QTimeLine::state() const

Renvoie l'état de la chronologie.

Voir également start(), setPaused() et stop().

[private signal] void QTimeLine::stateChanged(QTimeLine::State newState)

Ce signal est émis chaque fois que l'état de ` QTimeLine` change. Le nouvel état est ` newState`.

Remarque : il s'agit d'un signal privé. Il peut être utilisé dans les connexions de signaux, mais ne peut pas être émis par l'utilisateur.

[slot] void QTimeLine::stop()

Arrête la timeline, ce qui fait passer « QTimeLine » à l'état « NotRunning ».

Voir également start().

[override virtual protected] void QTimeLine::timerEvent(QTimerEvent *event)

Réimplémente : QObject::timerEvent(QTimerEvent *event).

[slot] void QTimeLine::toggleDirection()

Permet de basculer entre les sens de la chronologie. Si le sens était « En avant », il passe à « En arrière », et inversement.

Les liaisons existantes de ` direction ` sont supprimées.

Voir aussi setDirection().

[private signal] void QTimeLine::valueChanged(qreal value)

QTimeLine émet ce signal à intervalles réguliers lorsqu'il est à l'Running, mais uniquement si la valeur actuelle change. value correspond à la valeur actuelle. value est un nombre compris entre 0,0 et 1,0

Remarque : il s’agit d’un signal privé. Il peut être utilisé dans des connexions de signaux, mais ne peut pas être émis par l’utilisateur.

Voir également QTimeLine::setDuration(), QTimeLine::valueForTime() et QTimeLine::updateInterval.

[virtual] qreal QTimeLine::valueForTime(int msec) const

Renvoie la valeur de la timeline correspondant à l'msec. La valeur renvoyée, qui varie en fonction de la forme de la courbe, est toujours comprise entre 0 et 1. Si msec est égal à 0, l'implémentation par défaut renvoie toujours 0.

Réimplémentez cette fonction pour fournir une forme de courbe personnalisée à votre timeline.

Voir également easingCurve et frameForTime().

© 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.