Sur cette page

QVariantAnimation Class

La classe QVariantAnimation sert de classe de base pour les animations. En savoir plus...

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

QPropertyAnimation

Types publics

Propriétés

Fonctions publiques

QVariantAnimation(QObject *parent = nullptr)
virtual ~QVariantAnimation()
QBindable<int> bindableDuration()
QBindable<QEasingCurve> bindableEasingCurve()
QVariant currentValue() const
QEasingCurve easingCurve() const
QVariant endValue() const
QVariant keyValueAt(qreal step) const
QVariantAnimation::KeyValues keyValues() const
void setDuration(int msecs)
void setEasingCurve(const QEasingCurve &easing)
void setEndValue(const QVariant &value)
void setKeyValueAt(qreal step, const QVariant &value)
void setKeyValues(const QVariantAnimation::KeyValues &keyValues)
void setStartValue(const QVariant &value)
QVariant startValue() const

Fonctions publiques réimplémentées

virtual int duration() const override

Signaux

void valueChanged(const QVariant &value)

Fonctions protégées

virtual QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const
virtual void updateCurrentValue(const QVariant &value)

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

virtual bool event(QEvent *event) override
virtual void updateCurrentTime(int) override
virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) override
void qRegisterAnimationInterpolator(QVariant (*func)(const T &, const T &, qreal))

Description détaillée

Cette classe fait partie du framework d'animation. Elle sert de classe de base pour les animations de propriétés et d'éléments, et propose des fonctions permettant de partager des fonctionnalités.

La classe effectue une interpolation sur les é QVariants, mais laisse à ses sous-classes le soin d’utiliser les valeurs interpolées. Actuellement, Qt fournit la classe ` QPropertyAnimation`, qui permet d’animer les propriétés Qt. Consultez la description de la classe ` QPropertyAnimation ` si vous souhaitez animer ce type de propriétés.

Vous pouvez ensuite définir les valeurs de départ et de fin de la propriété en appelant ` setStartValue()` et ` setEndValue()`, puis appeler ` start()` pour lancer l’animation. `QVariantAnimation` effectuera l’interpolation de la propriété de l’objet cible et émettra le signal ` valueChanged()`. Pour réagir à une modification de la valeur actuelle, vous devez réimplémenter la fonction virtuelle ` updateCurrentValue()` ou vous connecter à ce signal.

Il est également possible de définir des valeurs à des pas spécifiés situés entre la valeur de départ et la valeur finale. L’interpolation passera alors par ces points aux pas spécifiés. Notez que les valeurs de départ et finale sont définies comme les valeurs clés à 0,0 et 1,0.

Il existe deux façons d’influencer la manière dont QVariantAnimation interpole les valeurs. Vous pouvez définir une courbe d’accélération en appelant setEasingCurve(), et configurer la durée en appelant setDuration(). Vous pouvez modifier la manière dont les « QVariants » sont interpolées en créant une sous-classe de QVariantAnimation et en réimplémentant la fonction virtuelle interpolated().

La création d’une sous-classe de QVariantAnimation peut constituer une alternative si vous disposez d’ QVariantque vous ne souhaitez pas déclarer en tant que propriétés Qt. Notez toutefois que, dans la plupart des cas, il est préférable de déclarer vos QVariant en tant que propriétés.

Tous les types d’ QVariant s ne sont pas pris en charge. Vous trouverez ci-dessous une liste des types d’ QVariant s actuellement pris en charge :

Si vous avez besoin d’interpoler d’autres types de variantes, y compris des types personnalisés, vous devez implémenter vous-même l’interpolation pour ceux-ci. Pour ce faire, vous pouvez enregistrer une fonction d’interpolation pour un type donné. Cette fonction prend 3 paramètres : la valeur de départ, la valeur finale et la progression actuelle.

Exemple :

QVariant myColorInterpolator(const QColor&start, const QColor&end, qreal progress)
{
    // ...
    return QColor(/*...*/);
}
// ...
void someFunc()
{
    // ...
    qRegisterAnimationInterpolator<QColor>(myColorInterpolator);
   // ...
}

Une autre option consiste à réimplémenter la fonction ` interpolated()`, qui renvoie des valeurs d'interpolation pour la valeur en cours d'interpolation.

Voir également QPropertyAnimation, QAbstractAnimation et Le framework d'animation.

Documentation sur les types de membres

[alias] QVariantAnimation::KeyValue

Il s'agit d'un typedef pour std::pair<qreal, QVariant>.

QVariantAnimation::KeyValues

Il s'agit d'un typedef pour QList<KeyValue>

Documentation sur les propriétés

[read-only] currentValue : QVariant

Cette propriété contient la valeur actuelle de l'animation.

Cette propriété décrit la valeur actuelle ; il s'agit d'une valeur interpolée entre start value et end value, calculée à partir du temps écoulé. La valeur elle-même est obtenue à partir de la méthode interpolated(), qui est appelée de manière répétée pendant l'exécution de l'animation.

QVariantAnimation appelle la fonction virtuelle updateCurrentValue() lorsque la valeur actuelle change. Ceci est particulièrement utile pour les sous-classes qui doivent suivre les mises à jour. Par exemple, QPropertyAnimation utilise cette fonction pour animer les propriétés Qt.

Fonctions d'accès :

QVariant currentValue() const

Signal Notifier :

void valueChanged(const QVariant &value)

Voir également startValue et endValue.

[bindable] duration : int

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

Cette propriété définit la durée de l'animation

Cette propriété indique la durée de l'animation en millisecondes. La durée par défaut est de 250 millisecondes.

Fonctions d'accès :

virtual int duration() const override
void setDuration(int msecs)

Voir également QAbstractAnimation::duration().

[bindable] easingCurve : QEasingCurve

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

Cette propriété définit la courbe d'accélération de l'animation

Cette propriété définit la courbe d'accélération de l'animation. Par défaut, une courbe d'accélération linéaire est utilisée, ce qui donne lieu à une interpolation linéaire. D'autres courbes sont disponibles, par exemple QEasingCurve::InCirc, qui fournit une courbe d'entrée circulaire. Un autre exemple est QEasingCurve::InOutElastic, qui produit un effet élastique sur les valeurs de la variante interpolée.

QVariantAnimation utilisera la fonction QEasingCurve::valueForProgress() pour transformer la « progression normalisée » (currentTime() / totalDuration()) de l’animation en progression effective réellement utilisée par l’animation. C’est cette progression effective qui sera prise en compte lorsque la fonction interpolated() sera appelée. De même, les étapes de la fonction keyValues se réfèrent à cette progression effective.

La courbe d’accélération est utilisée avec l’interpolateur, la fonction virtuelle interpolated() et la durée de l’animation pour contrôler la manière dont la valeur actuelle évolue au fur et à mesure que l’animation progresse.

Fonctions d’accès :

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

endValue : QVariant

Cette propriété contient la valeur finale de l'animation

Cette propriété décrit la valeur finale de l'animation.

Fonctions d'accès :

QVariant endValue() const
void setEndValue(const QVariant &value)

Voir également startValue.

startValue : QVariant

Cette propriété contient la valeur de départ facultative de l'animation

Cette propriété décrit la valeur de départ facultative de l'animation. Si elle est omise, ou si une valeur nulle QVariant est attribuée comme valeur de départ, l'animation utilisera la position actuelle de la fin au moment où l'animation démarre.

Fonctions d'accès :

QVariant startValue() const
void setStartValue(const QVariant &value)

Voir également endValue.

Documentation des fonctions membres

QVariantAnimation::QVariantAnimation(QObject *parent = nullptr)

Créer un objet `QVariantAnimation`. ` parent ` est transmis au constructeur de ` QAbstractAnimation`.

[virtual noexcept] QVariantAnimation::~QVariantAnimation()

Supprime l'animation.

[override virtual protected] bool QVariantAnimation::event(QEvent *event)

Réimplémente : QAbstractAnimation::event(QEvent *event).

[virtual protected] QVariant QVariantAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const

Cette fonction virtuelle renvoie l'interpolation linéaire entre les variantes from et to, à l'adresse progress, généralement une valeur comprise entre 0 et 1. Vous pouvez réimplémenter cette fonction dans une sous-classe de QVariantAnimation afin de fournir votre propre algorithme d'interpolation.

Notez que pour que l’interpolation fonctionne avec une fonction ` QEasingCurve ` renvoyant une valeur inférieure à 0 ou supérieure à 1 (comme ` QEasingCurve::InBack`), vous devez vous assurer qu’elle permet l’extrapolation. Si la sémantique du type de données ne permet pas l’extrapolation, cette fonction doit gérer cela de manière élégante.

Vous devez appeler l’implémentation de cette fonction fournie par ` QVariantAnimation ` si vous souhaitez que votre classe gère les types déjà pris en charge par Qt (voir la description de la classe ` QVariantAnimation ` pour obtenir la liste des types pris en charge).

Voir également QEasingCurve.

QVariant QVariantAnimation::keyValueAt(qreal step) const

Renvoie la valeur de l'image clé pour l'step donné. L'step donné doit être compris entre 0 et 1. S'il n'existe aucune KeyValue pour step, la fonction renvoie une QVariant non valide.

Voir également keyValues() et setKeyValueAt().

QVariantAnimation::KeyValues QVariantAnimation::keyValues() const

Renvoie les images clés de cette animation.

Voir également keyValueAt() et setKeyValues().

void QVariantAnimation::setKeyValueAt(qreal step, const QVariant &value)

Crée une image clé à l'step indiquée avec l'value spécifiée. La step fournie doit être comprise entre 0 et 1.

Voir également setKeyValues() et keyValueAt().

void QVariantAnimation::setKeyValues(const QVariantAnimation::KeyValues &keyValues)

Remplace l'ensemble actuel d'images clés par celui spécifié à l'adresse keyValues. L'intervalle entre les images clés doit être compris entre 0 et 1.

Voir également keyValues() et keyValueAt().

[override virtual protected] void QVariantAnimation::updateCurrentTime(int)

Réimplémente : QAbstractAnimation::updateCurrentTime(int currentTime).

[virtual protected] void QVariantAnimation::updateCurrentValue(const QVariant &value)

Cette fonction virtuelle est appelée chaque fois que la valeur actuelle de l'animation change. L'argument ` value ` correspond à la nouvelle valeur actuelle.

L'implémentation de la classe parente ne fait rien.

Voir également currentValue.

[override virtual protected] void QVariantAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)

Réimplémente : QAbstractAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState).

[signal] void QVariantAnimation::valueChanged(const QVariant &value)

QVariantAnimation émet ce signal chaque fois que la propriété « value » change.

Remarque : signalde notification pour la propriété « currentValue ».

Voir également currentValue, startValue et endValue.

Éléments non membres associés

template <typename T> void qRegisterAnimationInterpolator(QVariant (*func)(const T &, const T &, qreal))

Enregistre un interpolateur personnalisé func pour le type de modèle T. L'interpolateur doit être enregistré avant la création de l'animation. Pour annuler l'enregistrement (et utiliser l'interpolateur par défaut), définissez func sur nullptr.

Avertissement : l'enregistrement d'un interpolateur personnalisé pour l'un des types intégrés de Qt (par exemple int) affectera toutes les animations de ce type qui seront créées par la suite. Ce comportement peut s'avérer indésirable. Il est donc recommandé de réinitialiser l'interpolateur à sa valeur par défaut une fois les animations souhaitées créées.

Remarque : cette fonction est thread-safe.

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