QAbstractAnimation

La classe QAbstractAnimation est la base de toutes les animations. Plus d'informations...

#include <QAbstractAnimation>

Voir la position dans l'arbre des classes.

Héritage

Hérite de QObject.

Hérité par QAnimationGroup, QPauseAnimation et QVariantAnimation.

Classe introduite dans Qt 4.6.

Description détaillée

La classe QAbstractAnimation est la base de toutes les animations.

Cette classe définit les fonctions qui peuvent être partagées par toutes les animations. En héritant de cette classe, vous pouvez créer des animations personnalisées qui s'adaptent au reste du framework animation.

La progression d'une animation est donnée par son temps courant (currentLoopTime()), qui est mesurée en millisecondes à partir du début de l'animation (0) jusqu'à la fin (duration()). La valeur est mise à jour automatiquement pendant le déroulement de l'animation. Elle peut également être modifiée directement avec setCurrentTime().

À tout moment une animation est dans l'un des trois états : Running, Stopped ou Paused -- comme défini par l'énumération State. L'état courant peut être modifié en appelant start(), stop(), pause() ou resume(). Une animation verra toujours son temps courant remis à zéro quand elle est démarrée. Si elle est mise en pause, elle continuera avec le même temps courant quand elle sera reprise. Quand une animation est arrêtée, elle ne peut pas être reprise, mais gardera son temps courant (jusqu'à ce qu'elle soit redémarrée). QAbstractAnimation émettra stateChanged() chaque fois qu'elle changera d'état.

Une animation peut boucler un certain nombre de fois en définissant la propriété loopCount. Quand le temps courant d'une animation atteindra sa duration(), il remettra à zéro le temps courant et continuera de s'exécuter. Un compte de boucle de 1 (la valeur par défaut) signifie que l'animation sera exécutée une seule fois. Notez qu'une durée de -1 signifie que l'animation sera exécutée jusqu'à ce qu'elle soit arrêtée ; le temps courant augmentera indéfiniment. Quand le temps courant est égal à duration() et que l'animation est dans sa dernière boucle, elle entre dans l'état Stopped 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 (telle que discutée ci-dessus). Le framework animation appelle updateCurrentTime() quand le temps courant a changé. En réimplémentant cette fonction, vous pouvez suivre la progression de l'animation. Notez que ni l'intervalle entre deux appels, ni le nombre d'appels à cette fonction ne sont définis ; cependant, elle doit normalement être de 60 mises à jour par seconde.

En réimplémentant updateState(), vous pouvez suivre les changements d'états de l'animation, ce qui est particulièrement utile pour celles qui ne sont pas temporelles.

Voir aussi QVariantAnimation, QPropertyAnimation, QAnimationGroup et animation-overview.

Type

enum QAbstractAnimation::DeletionPolicy

enum QAbstractAnimation::Direction

Cette énumération décrit la direction de l'animation lorsqu'elle est dans l'état Running.

Voir aussi direction.

enum QAbstractAnimation::State

Cette énumération décrit l'état de l'animation.

Voir aussi state() et stateChanged().

Propriétés

currentLoop : const int

Cette propriété contient et décrit la boucle courante de l'animation. Par défaut, le compte de boucle de l'animation est de 1, et ainsi la boucle courante sera toujours 0. Si le compte de boucle est 2 et que l'animation s'exécute au-delà de sa durée, il rembobine automatiquement et redémarre au temps courant 0, puis la boucle courante 1 et ainsi de suite.

Quand la boucle courante change, QAbstractAnimation émet le signal currentLoopChanged().

Fonction d'accès

int currentLoop () const

Signal de notification

void currentLoopChanged() ( int currentLoop )

currentTime : int

Cette propriété contient le temps courant et la progression de l'animation.

Cette propriété décrit le temps courant de l'animation. Vous pouvez changer le temps courant en appelant setCurrentTime ou vous pouvez appeler start() et laisser l'animation s'exécuter, mettant à jour automatiquement le temps courant au fur et à mesure de la progression de l'animation.

Le temps courant de l'animation commence à 0 et se termine à totalDuration().

Fonctions d'accès

int currentTime () const
void setCurrentTime ( int msecs )

Voir aussi loopCount et currentLoopTime.

direction : Direction

Cette propriété contient la direction de l'animation quand elle est dans l'état Running.

La direction indique soit que le temps se déplace de 0 vers la durée de l'animation ou de la valeur de la durée vers 0 après l'appel de start().

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

Fonctions d'accès

Direction direction () const
void setDirection ( Direction direction )

Signal de notification

void directionChanged ( QAbstractAnimation::Direction newDirection )

duration : const int

Cette propriété contient la durée de l'animation.

Si la durée est -1, cela signifie qu'elle est indéfinie. Dans ce cas, loopCount est ignorée.

Fonctions d'accès

virtual int duration () const = 0

loopCount : int

Cette propriété contient le compte de boucles de l'animation et le décrit sous la forme d'un entier. Par défaut, cette valeur est 1, indiquant que l'animation devra s'exécuter une seule fois, puis s'arrêter. En le changeant, vous pouvez laisser l'animation boucler plusieurs fois. Avec une valeur de 0, l'animation ne s'exécutera pas du tout ; avec une valeur de -1, l'animation s'exécutera indéfiniment jusqu'à ce qu'elle soit stoppée. Il n'est pas supporté d'avoir une boucle sur une animation qui a une durée indéfinie. Elle sera lancée uniquement une fois.

Fonctions d'accès

int loopCount () const
void setLoopCount ( int loopCount )

state : const State

Cette propriété contient l'état de l'animation.

Cette propriété décrit l'état courant de l'animation. Quand l'état de l'animation change, QAbstractAnimation émet le signal stateChanged().

Fonctions d'accès

State state () const

Signal de notification

void stateChanged ( QAbstractAnimation::State newState, QAbstractAnimation::State oldState )

Fonctions membres

QAbstractAnimation::QAbstractAnimation ( QObject * parent = 0 )

Construit la base de la classe QAbstractAnimation et passe parent au constructeur de QObject.

Voir aussi QVariantAnimation et QAnimationGroup.

QAbstractAnimation::~QAbstractAnimation () [virtual]

Arrête l'animation si elle est en cours d'exécution, puis détruit la QAbstractAnimation. Si l'animation fait partie d'un QAnimationGroup, celui-ci est automatiquement supprimé avant d'être détruit.

void QAbstractAnimation::currentLoopChanged ( int currentLoop ) [signal]

QAbstractAnimation émet ce signal chaque fois que la boucle courante change. currentLoop est la boucle courante.

Voir aussi currentLoop() et loopCount().

int QAbstractAnimation::currentLoopTime () const

Retourne le temps courant à l'intérieur de la boucle courante. Il peut aller de 0 à duration().

Voir aussi duration() et currentTime.

void QAbstractAnimation::directionChanged ( QAbstractAnimation::Direction newDirection ) [signal]

QAbstractAnimation émet le signal chaque fois que la direction a été changée. newDirection est la nouvelle direction.

Voir aussi direction.

bool QAbstractAnimation::event ( QEvent * event ) [virtual protected]

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

void QAbstractAnimation::finished () [signal]

QAbstractAnimation émet le signal après que l'animation se soit arrêtée et qu'elle ait atteint la fin.

Ce signal est émis après stateChanged().

Voir aussi stateChanged().

QAnimationGroup * QAbstractAnimation::group () const

Si l'animation fait partie d'un QAnimationGroup, cette fonction retourne un pointeur sur le groupe ; autrement, elle retourne 0.

Voir aussi QAnimationGroup::addAnimation().

void QAbstractAnimation::pause () [slot]

Met en pause l'animation. Lorsque l'animation est en pause, state() retourne Paused. La valeur de currentTime restera inchangée jusqu'à ce que resume() ou start() soient appelées. Si vous voulez continuer au temps courant, appelez resume().

Voir aussi start(), state() et resume().

void QAbstractAnimation::resume () [slot]

Reprend l'animation après qu'elle ait été mise en pause. Lorsque l'animation est rétablie, elle émet les signaux resume() et stateChanged(). Le currenttime est inchangé.

Voir aussi start(), pause() et state().

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

Si paused est vrai, l'animation est en pause. Si paused est faux, l'animation est reprise.

Voir aussi state(), pause() et resume().

void QAbstractAnimation::start ( QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped ) [slot]

Démarre l'animation. L'argument policy indique si oui ou non l'animation doit être supprimée lorsqu'elle est terminée. Lorsque l'animation démarre, le signal stateChanged() est émis et state() retourne Running. Lorsque le contrôle atteint la boucle d'événements, l'animation s'exécutera par elle-même, appelant périodiquement updateCurrentTime() au fur et à mesure de la progression de l'animation.

Si l'animation est actuellement arrêtée ou a déjà atteint la fin, appeler start() rembobinera l'animation et la redémarrera du début. Quand l'animation atteint la fin, elle s'arrête ou, si le niveau de la boucle est supérieur à 1, elle se rembobine et redémarre au début.

Si l'animation est déjà en cours d'exécution, cette fonction ne fait rien.

Voir aussi stop() et state().

void QAbstractAnimation::stateChanged ( QAbstractAnimation::State newState, QAbstractAnimation::State oldState ) [signal]

QAbstractAnimation émet le signal chaque fois que l'état de l'animation a changé de oldState à newState. Ce signal est émis après l'appel de la fonction virtuelle updateState().

Voir aussi updateState().

void QAbstractAnimation::stop () [slot]

Arrête l'animation. Quand l'animation est arrêtée, elle émet le signal stateChanged() et state() retourne Stopped. Le temps courant est inchangé.

Si l'animation s'arrête d'elle-même après avoir atteint la fin (c'est-à-dire que currentLoopTime() vaut duration() et currentLoop() est plus grand que loopCount() - 1), le signal finished() est émis.

Voir aussi start() et state().

int QAbstractAnimation::totalDuration () const

Retourne la durée totale et effective de l'animation, incluant le compte de boucles.

Voir aussi duration() et currentTime.

void QAbstractAnimation::updateCurrentTime ( int currentTime ) [pure virtual protected]

Cette fonction virtuelle pure est appelée chaque fois que le currentTime de l'animation change.

Voir aussi updateState().

void QAbstractAnimation::updateDirection ( QAbstractAnimation::Direction direction ) [virtual protected]

Cette fonction virtuelle est appelée par QAbstractAnimation quand la direction de l'animation a changé. L'argument direction est la nouvelle direction.

Voir aussi setDirection() et direction().

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

Cette fonction virtuelle est appelée par QAbstractAnimation quand l'état de l'animation a changé de oldState à newState.

Voir aussi start(), stop(), pause() et resume().

Remerciements

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