===== QAbstractAnimation ===== La classe QAbstractAnimation est la base de toutes les animations. [[#Description détaillée|Plus d'informations...]] ==== 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 ([[qabstractanimation#currentLoopTime|currentLoopTime()]]), qui est mesurée en millisecondes à partir du début de l'animation (0) jusqu'à la fin ([[qabstractanimation#duration-prop|duration()]]). La valeur est mise à jour automatiquement pendant le déroulement de l'animation. Elle peut également être modifiée directement avec [[qabstractanimation#currentTime-prop|setCurrentTime()]]. À tout moment une animation est dans l'un des trois états : [[qabstractanimation#State-enum|Running]], [[qabstractanimation#State-enum|Stopped]] ou [[qabstractanimation#State-enum|Paused]] -- comme défini par l'énumération [[qabstractanimation#State-enum|State]]. L'état courant peut être modifié en appelant [[qabstractanimation#start|start()]], [[qabstractanimation#stop|stop()]], [[qabstractanimation#pause|pause()]] ou [[qabstractanimation#resume|resume()]]. Une animation verra toujours son [[qabstractanimation#currentTime-prop|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 [[qabstractanimation#stateChanged|stateChanged()]] chaque fois qu'elle changera d'état. Une animation peut boucler un certain nombre de fois en définissant la propriété [[qabstractanimation#loopCount-prop|loopCount]]. Quand le temps courant d'une animation atteindra sa [[qabstractanimation#duration-prop|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 à [[qabstractanimation#duration-prop|duration()]] et que l'animation est dans sa dernière boucle, elle entre dans l'état [[qabstractanimation#State-enum|Stopped]] et le signal [[qabstractanimation#finished|finished()]] est émis. QAbstractAnimation fournit des fonctions virtuelles pures utilisées par les sous-classes pour suivre la progression de l'animation : [[qabstractanimation#duration-prop|duration()]] et [[qabstractanimation#updateCurrentTime|updateCurrentTime()]]. La fonction [[qabstractanimation#duration-prop|duration()]] vous permet de signaler une durée pour l'animation (telle que discutée ci-dessus). Le framework animation appelle [[qabstractanimation#updateCurrentTime|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 [[qabstractanimation#updateState|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 ==== === DeletionPolicy-enum === ''enum QAbstractAnimation::DeletionPolicy'' ^ Constante ^ Valeur ^ Description ^ | ''QAbstractAnimation::KeepWhenStopped'' | 0 | L'animation ne sera pas supprimée quand elle sera arrêtée. | | ''QAbstractAnimation::DeleteWhenStopped'' | 1 | L'animation sera automatiquement supprimée quand elle sera arrêtée. | === Direction-enum === ''enum QAbstractAnimation::Direction'' Cette énumération décrit la direction de l'animation lorsqu'elle est dans l'état [[qabstractanimation#State-enum|Running]]. ^ Constante ^ Valeur ^ Description ^ | ''QAbstractAnimation::Forward'' | 0 | Le temps courant de l'animation augmente avec le temps (i.e., se déplace de 0 vers la fin / durée). | | ''QAbstractAnimation::Backward'' | 1 | Le temps courant de l'animation diminue avec le temps (i.e., se déplace de la fin / durée vers 0). | Voir aussi [[qabstractanimation#direction-prop|direction]]. === State-enum === ''enum QAbstractAnimation::State'' Cette énumération décrit l'état de l'animation. ^ Constante ^ Valeur ^ Description ^ | ''QAbstractAnimation::Stopped'' | 0 | L'animation n'est pas exécutée. C'est l'état initial de [[QAbstractAnimation]], et c'est l'état de [[QAbstractAnimation]] dans lequel on retourne quand elle est terminée. Le temps courant reste inchangé jusqu'à ce que [[qabstractanimation#currentTime-prop|setCurrentTime()]] soit appelée, ou que l'animation est démarrée en appelant [[qabstractanimation#start|start()]]. | | ''QAbstractAnimation::Paused'' | 1 | L'animation est mise en pause (c'est-à-dire, temporairement suspendue). L'appel de [[qabstractanimation#resume|resume()]] relancera l'activité de l'animation. | | ''QAbstractAnimation::Running'' | 2 | L'animation est en cours d'exécution. Alors que le contrôle est dans la boucle d'événement, [[QAbstractAnimation]] mettra à jour son temps courant à intervalles réguliers, en appelant [[qabstractanimation#updateCurrentTime|updateCurrentTime()]] lorsque cela est approprié. | Voir aussi [[qabstractanimation#state-prop|state()]] et [[qabstractanimation#stateChanged|stateChanged()]]. ==== Propriétés ==== === currentLoop-prop === ''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 [[qabstractanimation#currentLoopChanged|currentLoopChanged()]]. == Fonction d'accès == ''int currentLoop () const'' == Signal de notification == ''void [[qabstractanimation#currentLoopChanged|currentLoopChanged()]] ( int currentLoop )'' === currentTime-prop === ''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 [[qabstractanimation#start|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 à [[qabstractanimation#totalDuration|totalDuration()]]. == Fonctions d'accès == ''int currentTime () const''\\ ''void setCurrentTime ( int msecs )'' Voir aussi [[qabstractanimation#loopCount-prop|loopCount]] et currentLoopTime. === direction-prop === ''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 [[qabstractanimation#start|start()]]. Par défaut, cette propriété est définie à [[qabstractanimation#Direction-enum|Forward]]. == Fonctions d'accès == ''Direction direction () const''\\ ''void setDirection ( Direction direction )'' == Signal de notification == ''void [[qabstractanimation#directionChanged|directionChanged]] ( QAbstractAnimation::Direction newDirection )'' === duration-prop === ''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, [[qabstractanimation#loopCount-prop|loopCount]] est ignorée. == Fonctions d'accès == ''virtual int duration () const = 0'' === loopCount-prop === ''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-prop === ''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 [[qabstractanimation#stateChanged|stateChanged()]]. == Fonctions d'accès == ''State state () const'' == Signal de notification == ''void stateChanged ( QAbstractAnimation::State newState, QAbstractAnimation::State oldState )'' ==== Fonctions membres ==== === QAbstractAnimation() === ''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::~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. === currentLoopChanged() === ''void QAbstractAnimation::currentLoopChanged ( int currentLoop ) [signal]'' [[QAbstractAnimation]] émet ce signal chaque fois que la boucle courante change. ''currentLoop'' est la boucle courante. Voir aussi [[qabstractanimation#currentLoop-prop|currentLoop()]] et [[qabstractanimation#loopCount-prop|loopCount()]]. === currentLoopTime() === ''int QAbstractAnimation::currentLoopTime () const'' Retourne le temps courant à l'intérieur de la boucle courante. Il peut aller de 0 à [[qabstractanimation#duration-prop|duration()]]. Voir aussi [[qabstractanimation#duration-prop|duration()]] et [[qabstractanimation#currentTime-prop|currentTime]]. === directionChanged() === ''void QAbstractAnimation::directionChanged ( [[qabstractanimation#Direction-enum|QAbstractAnimation::Direction]] newDirection ) [signal]'' [[QAbstractAnimation]] émet le signal chaque fois que la direction a été changée. ''newDirection'' est la nouvelle direction. Voir aussi [[qabstractanimation#direction-prop|direction]]. === event() === ''bool QAbstractAnimation::event ( [[QEvent]] * event ) [virtual protected]'' Réimplémentation de [[qobject#event|QObject::event()]]. === finished() === ''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 [[qabstractanimation#stateChanged|stateChanged()]]. Voir aussi [[qabstractanimation#stateChanged|stateChanged()]]. === group() === ''[[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|QAnimationGroup::addAnimation()]]. === pause() === ''void QAbstractAnimation::pause () [slot]'' Met en pause l'animation. Lorsque l'animation est en pause, [[qabstractanimation#state-prop|state()]] retourne ''Paused''. La valeur de [[qabstractanimation#currentTime-prop|currentTime]] restera inchangée jusqu'à ce que [[qabstractanimation#resume|resume()]] ou [[qabstractanimation#start|start()]] soient appelées. Si vous voulez continuer au temps courant, appelez [[qabstractanimation#resume|resume()]]. Voir aussi [[qabstractanimation#start|start()]], [[qabstractanimation#state-prop|state()]] et [[qabstractanimation#resume|resume()]]. === 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 [[qabstractanimation#stateChanged|stateChanged()]]. Le currenttime est inchangé. Voir aussi [[qabstractanimation#start|start()]], [[qabstractanimation#pause|pause()]] et [[qabstractanimation#state-prop|state()]]. === setPaused() === ''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 [[qabstractanimation#state-prop|state()]], [[qabstractanimation#pause|pause()]] et [[qabstractanimation#resume|resume()]]. === start() === ''void QAbstractAnimation::start ( [[qabstractanimation#DeletionPolicy-enum|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 [[qabstractanimation#stateChanged|stateChanged()]] est émis et [[qabstractanimation#state-prop|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 [[qabstractanimation#updateCurrentTime|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 [[qabstractanimation#stop|stop()]] et [[qabstractanimation#state-prop|state()]]. === stateChanged() === ''void QAbstractAnimation::stateChanged ( [[qabstractanimation#State-enum|QAbstractAnimation::State]] newState, [[qabstractanimation#State-enum|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 [[qabstractanimation#updateState|updateState()]]. Voir aussi [[qabstractanimation#updateState|updateState()]]. === stop() === ''void QAbstractAnimation::stop () [slot]'' Arrête l'animation. Quand l'animation est arrêtée, elle émet le signal [[qabstractanimation#stateChanged|stateChanged()]] et [[qabstractanimation#state-prop|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 [[qabstractanimation#currentLoopTime|currentLoopTime()]] vaut [[qabstractanimation#duration-prop|duration()]] et [[qabstractanimation#currentLoop-prop|currentLoop()]] est plus grand que ''[[qabstractanimation#loopCount-prop|loopCount()]] - 1''), le signal [[qabstractanimation#finished|finished()]] est émis. Voir aussi [[qabstractanimation#start|start()]] et [[qabstractanimation#state-prop|state()]]. === totalDuration() === ''int QAbstractAnimation::totalDuration () const'' Retourne la durée totale et effective de l'animation, incluant le compte de boucles. Voir aussi [[qabstractanimation#duration-prop|duration()]] et [[qabstractanimation#currentTime-prop|currentTime]]. === updateCurrentTime() === ''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 [[qabstractanimation#updateState|updateState()]]. === updateDirection() === ''void QAbstractAnimation::updateDirection ( [[qabstractanimation#Direction-enum|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 [[qabstractanimation#direction-prop|setDirection()]] et [[qabstractanimation#direction-prop|direction()]]. === updateState() === ''void QAbstractAnimation::updateState ( [[qabstractanimation#State-enum|QAbstractAnimation::State]] newState, [[qabstractanimation#State-enum|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 [[qabstractanimation#start|start()]], [[qabstractanimation#stop|stop()]], [[qabstractanimation#pause|pause()]] et [[qabstractanimation#resume|resume()]]. ==== Remerciements ==== Merci à pour la traduction ainsi qu'à et à pour la relecture !