QTimeLine

La classe QTimeLine fournit une ligne temporelle pour contrôler les animations. Plus d'informations...

#include <QTimeLine>

Héritage

Hérite de QObject.

Description détaillée

La classe QTimeLine fournit une ligne temporelle pour contrôler les animations.

Cela est plus généralement utilisé pour animer un contrôleur d'interface graphique en appelant un slot périodiquement. Vous pouvez construire une ligne temporelle en passant sa durée en millisecondes au constructeur de QTimeLine. La durée de la ligne temporelle décrit pour combien de temps l'animation sera exécutée. Ensuite vous modifiez la longueur de fenêtre suivante (une distance de frame appropriée) en appelant setFrameRange(). Pour terminer, connectez le signal frameChanged() à un slot adapté dans le widget que vous voulez animer (c'est-à-dire à setValue() dans QProgressBar). Lorsque vous procédez en appelant start(), QTimeLine entre dans l'état Running et commence à émettre frameChanged() à intervalles réguliers, (entraînant l'augmentation de la valeur de la propriété de votre widget connecté, de l'extrémité inférieure à la partie supérieure de votre frame, à un taux constant). Vous pouvez spécifier l'intervalle de mise à jour en appelant setUpdateInterval(). Lorsqu'il a terminé, QTimeLine entre dans l'état NotRunning et émet finished().

Exemple :

...
progressBar = new QProgressBar(this);
progressBar->setRange(0, 100);
 
// Constuit une ligne d'une seconde, allant de 0 à 100
QTimeLine *timeLine = new QTimeLine(1000, this);
timeLine->setFrameRange(0, 100);
connect(timeLine, SIGNAL(frameChanged(int)), progressBar, SLOT(setValue(int)));
 
// Cliquer sur le bouton poussoir démarrera l'animation de la barre de progression
pushButton = new QPushButton(tr("Start animation"), this);
connect(pushButton, SIGNAL(clicked()), timeLine, SLOT(start()));
...

Vous pouvez également utiliser QTimeLine avec le framework Graphics View pour réaliser des animations. La classe QGraphicsItemAnimation implémente l'animation des QGraphicsItems avec une ligne temporelle.

Par défaut, la ligne temporelle ne s'exécute qu'une seule fois, du début et en avant jusqu'à la fin. Vous devez appeler à nouveau start pour recommencer au début. Pour faire boucler la ligne temporelle, vous pouvez appeler setLoopCount(), en passant en paramètre le nombre de répétitions de la ligne temporelle. La direction peut également être changée, c'est-à-dire aller en l'arrière, en appelant setDirection(). Vous pouvez également mettre en pause et retirer la pause de la ligne temporelle pendant son exécution en appelant setPaused(). Pour un contrôle interactif, la fonction setCurrentTime() est fournie, qui modifie directement la position du temps dans la ligne temporelle. Bien que ce soit dans l'état NotRunning qu'elle est la plus utile (c'est-à-dire connectée à un signal valueChanged() dans un QSlider), cette fonction peut être appelée à n'importe quel moment.

L'interface de frame est utile pour des widgets standards, mais QTimeLine peut être utilisé pour contrôler tout type d'animation. Le coeur de QTimeLine réside dans la fonction valueForTime(), qui génère une valeur entre 0 et 1 pour un temps donné. Cette valeur est typiquement utilisée pour décrire les étapes d'un animation, où 0 en est la première étape, et 1 la dernière. Quand elle est en cours d'exécution, QTimeLine génère des valeurs entre 0 et 1 en appelant valueForTime() et en émettant valueChanged(). Par défaut, valueForTime() applique une interpolation algorithmique pour générer ces valeurs. Vous pouvez choisir à partir d'un ensemble d'algorithmes prédéfini de ligne temporelle en appelant setCurveShape().

Notez que, par défaut, QTimeLine utilise la forme de la courbe EaseInOut, qui fournit une valeur qui grandit lentement, puis grandit régulièrement et, finalement, grandit lentement. Pour une ligne temporelle personnalisée, vous pouvez réimplémenter valueForTime(), dans ce cas, la propriété curveShape de QTimeLine est ignorée.

Voir aussi QProgressBar, QProgressDialog et QGraphicsItemAnimation.

Type

enum QTimeLine::CurveShape

Cette énumération décrit la forme par défaut de la courbe de valeur de QTimeLine. La forme par défaut est EaseInOutCurve. La courbe définit la relation entre la valeur et la ligne temporelle.

Voir aussi setCurveShape().

enum QTimeLine::Direction

Cette énumération décrit la direction de la ligne temporelle quand elle est dans l'état Running.

Voir aussi setDirection().

enum QTimeLine::State

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

Voir aussi state() et stateChanged().

Propriétés

currentTime : int

Cette propriété contient le temps courant de la ligne temporelle.

Quand QTimeLine est dans l'état Running, cette valeur est mise à jour continuellement en fonction de la durée et de la direction de la ligne temporelle. Autrement, il s'agit de cette valeur qui était courante quand stop() a été appelé la dernière fois ou de la valeur définie par setCurrentTime().

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

Fonctions d'accès

int currentTime () const
void setCurrentTime ( int msec )

curveShape : CurveShape

Cette propriété contient la forme de la ligne temporelle.

La forme de la courbe décrit la relation entre le temps et la valeur pour l'implémentation de base de valueForTime().

Si vous avez réimplémenté valueForTime(), cette valeur est ignorée.

Par défaut, cette propriété est définie à EaseInOutCurve.

Fonctions d'accès

CurveShape curveShape () const
void setCurveShape ( CurveShape shape )

Voir aussi valueForTime().

direction : Direction

Cette propriété contient la direction de la ligne temporelle quand QTimeLine est dans l'état Running.

Cette direction indique si le temps se déplace de 0 vers la durée de la ligne temporelle ou de la durée jusqu'à 0, après que start() ait été appelée.

Par défaut, cette propriété est définit à Forward.

Fonctions d'accès

Direction direction () const
void setDirection ( Direction direction )

duration : int

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

Par défaut, cette valeur est 1000 (soit une seconde), mais vous pouvez la changer, soit en passant une durée au constructeur de QTimeLine, soit en appelant setDuration(). La durée doit être supérieure à 0.

Remarque : changer la durée ne remet pas le temps courant à 0 ou à la nouvelle durée. Vous devez également appeler setCurrentTime() avec la valeur désirée.

Fonctions d'accès

int duration () const
void setDuration ( int duration )

easingCurve : QEasingCurve

Spécifie l'assouplissement de la courbe que la ligne temporelle utilisera. Si, à la fois, l'assouplissement de la courbe et la forme de la courbe sont définis, la dernière propriété définie écrasera la précédente. (Si valueForTime() a été réimplementée, il écrasera les deux).

Cette propriété a été introduite dans Qt 4.6.

Fonctions d'accès

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

loopCount : int

Cette propriété contient le nombre de fois que la ligne temporelle doit boucler avant de se terminer.

Un compte de boucles de 0 signifie que la ligne temporelle bouclera indéfiniment.

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

Fonctions d'accès

int loopCount () const
void setLoopCount ( int count )

updateInterval : int

Cette propriété contient l'intervalle de temps en millisecondes entre chaque mise à jour du temps courant de QTimeLine.

Quand le temps courant est mis à jour, QTimeLine émet valueChanged() si la valeur courante a changé et frameChanged() si la frame a changé.

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

Fonctions d'accès

int updateInterval () const
void setUpdateInterval ( int interval )

Fonctions membres

QTimeLine::QTimeLine ( int duration = 1000, QObject * parent = 0 )

Construit une ligne temporelle avec une durée de duration millisecondes. parent est passé au constructeur de QObject. La durée par défaut est de 1000 millisecondes.

QTimeLine::~QTimeLine () [virtual]

Détruit la ligne temporelle.

int QTimeLine::currentFrame () const

Retourne la frame correspondant au temps courant.

Voir aussi currentTime(), frameForTime() et setFrameRange().

qreal QTimeLine::currentValue () const

Retourne la valeur correspondante du temps courant.

Voir aussi valueForTime() et currentFrame().

int QTimeLine::endFrame () const

Retourne la dernière frame, qui correspond à la frame de la fin de la ligne temporelle (c'est-à-dire la frame pour laquelle la valeur courante est 1).

Voir aussi setEndFrame() et setFrameRange().

void QTimeLine::finished () [signal]

Ce signal est émis quand QTimeLine se termine (c'est-à-dire quand elle atteint la fin de la ligne temporelle) et ne boucle pas.

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

QTimeLine émet ce signal à intervalle régulier lorsqu'elle se trouve dans l'état Running, mais seulement si la frame courante change. frame est le numéro de la frame courante.

Voir aussi setFrameRange() et updateInterval.

int QTimeLine::frameForTime ( int msec ) const

Retourne la frame correspondant au temps msec. Cette valeur est calculée en utilisant une interpolation linéaire entre la frame de début et la frame de fin, basée sur la valeur retournée par valueForTime().

Voir aussi valueForTime() et setFrameRange().

void QTimeLine::resume () [slot]

Reprend la ligne temporelle à partir du temps courant. QTimeLine retournera dans l'état Running et, une fois qu'elle entre dans la boucle d'événements, elle mettra à jour son temps courant, sa frame et sa valeur à intervalles réguliers.

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

Voir aussi start(), updateInterval(), frameChanged() et valueChanged().

void QTimeLine::setEndFrame ( int frame )

Définit la frame de fin, la frame correspondant à la fin de la ligne temporelle (c'est-à-dire la frame pour laquelle la valeur courante est 1), à frame.

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

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

Définit le compteur de frames de la ligne temporelle pour commencer à startFrame et terminer à endFrame. Pour chaque valeur de temps, QTimeLine trouvera la frame correspondante quand vous appelez currentFrame() ou frameForTime() par interpolation, en utilisant la valeur de retour de valueForTime().

Dans l'état Running, QTimeLine émet également le signal frameChanged() quand la frame change.

Voir aussi startFrame(), endFrame(), start() et currentFrame().

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

Si paused est vrai, la ligne temporelle est mise en pause, mettant QTimeLine dans l'état Paused. Aucune mise à jour ne sera signalée jusqu'à ce que start() ou setPaused(false) soit appelé. Si paused est faux, la ligne temporelle reprend et continue de là où elle s'était arrêtée.

Voir aussi state() et start().

void QTimeLine::setStartFrame ( int frame )

Définit la frame du début, la frame correspondant au début de la ligne temporelle (c'est-à-dire la frame pour laquelle la valeur courante est 0) à frame.

Voir aussi startFrame(), endFrame() et setFrameRange().

void QTimeLine::start () [slot]

Démarre la ligne temporelle. QTimeLine entrera dans l'état Running et, une fois qu'elle entre dans la boucle d'événements, elle mettra à jour son temps courant, sa frame et sa valeur à intervalles réguliers. L'intervalle par défaut est de 40 ms (soit 25 fois par seconde). Vous pouvez changer l'intervalle de mise à jour en appelant setUpdateInterval().

La ligne temporelle démarrera de la position 0 ou de la fin, si elle va dans le sens inverse. Si vous voulez reprendre une ligne temporelle arrêtée sans redémarrer, vous pouvez appeler resume() à la place.

Voir aussi resume(), updateInterval(), frameChanged() et valueChanged().

int QTimeLine::startFrame () const

Retourne la frame du début, la frame correspondant au début de la ligne temporelle (c'est-à-dire la frame pour laquelle la valeur courante est 0).

Voir aussi setStartFrame() et setFrameRange().

State QTimeLine::state () const

Retourne l'état de la ligne temporelle.

Voir aussi start(), setPaused() et stop().

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

Ce signal est émis quand l'état de QTimeLine change. Le nouvel état est newState.

void QTimeLine::stop () [slot]

Arrête la ligne temporelle, faisant entrer QTimeLine dans l'état NotRunning.

Voir aussi start().

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

Réimplémentation de QObject::timerEvent().

void QTimeLine::toggleDirection () [slot]

Inverse la direction de la ligne temporelle. Si la direction était en avant, elle devient en arrière, et vice versa.

Voir aussi setDirection().

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

QTimeLine émet ce signal à intervalle régulier lorsqu'elle est dans l'état Running, mais seulement si la valeur courante change. value est la valeur courante, un nombre entre 0.0 et 1.0.

Voir aussi setDuration(), valueForTime() et updateInterval.

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

Rétourne la valeur de la ligne temporelle pour le temps msec. La valeur retournée, qui dépend de la forme de la courbe, est toujours entre 0 et 1. Si msec est 0, l'implémentation par défaut retourne toujours 0.

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

Voir aussi CurveShape et frameForTime().

Remerciements

Merci à Jonathan Courtois pour la traduction et à Thibaut Cuvelier et à Jacques Thery pour la relecture !