===== QTimeLine ===== La classe QTimeLine fournit une ligne temporelle pour contrôler les animations. [[#Description détaillée|Plus d'informations...]] ==== 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 à [[qprogressbar#setValue|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 [[#updateInterval-prop|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 [[graphicsview|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 [[#loopCount-prop|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 [[#direction-prop|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 [[#currentTime-prop|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 [[qslider#valueChanged|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 [[#curveShape-prop|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-prop|curveShape]] de QTimeLine est ignorée. Voir aussi [[QProgressBar]], [[QProgressDialog]] et [[QGraphicsItemAnimation]]. ==== Type ==== === CurveShape-enum === ''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. ^ Constante ^ Valeur ^ Description ^ | ''QTimeLine::EaseInCurve'' | 0 | La valeur commence par grandir doucement, puis augmente en vitesse. | | ''QTimeLine::EaseOutCurve'' | 1 | La valeur commence par grandir régulièrement, puis termine doucement. | | ''QTimeLine::EaseInOutCurve'' | 2 | La valeur commence par grandir doucement, puis s'exécute régulièrement, puis grandit de nouveau doucement. | | ''QTimeLine::LinearCurve'' | 3 | La valeur grandit linéairement (par exemple, si la durée est de 1000 ms, la valeur à 500 ms est 0.5). | | ''QTimeLine::SineCurve'' | 4 | La valeur grandit sinusoïdalement. | | ''QTimeLine::CosineCurve'' | 5 | La valeur grandit cosinusoïdalement. | Voir aussi [[#curveShape-prop|setCurveShape()]]. === Direction-enum === ''enum QTimeLine::Direction'' Cette énumération décrit la direction de la ligne temporelle quand elle est dans l'état ''Running''. ^ Constante ^ Valeur ^ Description ^ | ''QTimeLine::Forward'' | 0 | Le temps courant de la ligne temporelle augmente avec le temps (c'est-à-dire qu'il se déplace de 0 vers la fin / durée). | | ''QTimeLine::Backward'' | 1 | Le temps courant de la ligne temporelle diminue avec le temps (c'est-à-dire qu'il se déplace de la fin / durée vers 0). | Voir aussi [[#direction-prop|setDirection()]]. === State-enum === ''enum QTimeLine::State'' Cette énumération décrit l'état de la ligne temporelle. ^ Constante ^ Valeur ^ Description ^ | ''QTimeLine::NotRunning'' | 0 | La ligne temporelle n'est pas exécutée. C'est l'état initial de [[QTimeLine]] et c'est l'état de [[QTimeLine]] dans lequel on retourne quand elle est terminée. Le temps courant, la valeur et la frame restent inchangés jusqu'à ce que [[#currentTime-prop|setCurrentTime()]] soit appelée ou que la ligne temporelle est démarrée en appelant [[#start()]]. | | | ''QTimeLine::Paused'' | 1 | La ligne temporelle est mise en pause (c'est-à-dire, temporairement suspendue). L'appel de [[#setPaused|setPaused(false)]] relancera son activité. | | ''QTimeLine::Running'' | 2 | La ligne temporelle est en cours d'exécution. Alors que le contrôle est dans la boucle d'événement, [[QTimeLine]] mettra à jour son temps courant à intervalles réguliers, en émettant [[q#valueChanged()]] et [[#frameChanged()]] lorsque cela est approprié. | | Voir aussi [[#state()]] et [[#stateChanged()]]. ==== Propriétés ==== === currentTime-prop === ''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-prop === ''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-prop === ''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-prop === ''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 [[#duration-prop|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 [[#currentTime-prop|setCurrentTime()]] avec la valeur désirée. == Fonctions d'accès == ''int duration () const''\\ ''void setDuration ( int duration )'' === easingCurve-prop === ''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-prop === ''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-prop === ''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::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::~QTimeLine () [virtual]'' Détruit la ligne temporelle. === currentFrame() === ''int QTimeLine::currentFrame () const'' Retourne la frame correspondant au temps courant. Voir aussi [[#currentTime-prop|currentTime()]], [[#frameForTime()]] et [[#setFrameRange()]]. === currentValue() === ''[[qtglobal#qreal-typedef|qreal]] QTimeLine::currentValue () const'' Retourne la valeur correspondante du temps courant. Voir aussi [[#valueForTime()]] et [[#currentFrame()]]. === endFrame() === ''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()]]. === finished() === ''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. === frameChanged() === ''void QTimeLine::frameChanged ( int frame ) [signal]'' [[QTimeLine]] émet ce signal à intervalle régulier lorsqu'elle se trouve dans l'état [[#State-enum|Running]], mais seulement si la frame courante change. ''frame'' est le numéro de la frame courante. Voir aussi [[#setFrameRange()]] et [[#updateInterval-prop|updateInterval]]. === frameForTime() === ''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()]]. === resume() === ''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-prop|updateInterval()]], [[#frameChanged()]] et [[#valueChanged()]]. === setEndFrame() === ''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()]]. === 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()]]. === setPaused() === ''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|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()]]. === setStartFrame() === ''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()]]. === start() === ''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 [[#updateInterval-prop|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-prop|updateInterval()]], [[#frameChanged()]] et [[#valueChanged()]]. === startFrame() === ''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() === ''[[#State-enum|State]] QTimeLine::state () const'' Retourne l'état de la ligne temporelle. Voir aussi [[#start()]], [[#setPaused()]] et [[#stop()]]. === stateChanged() === ''void QTimeLine::stateChanged ( QTimeLine::State newState ) [signal]'' Ce signal est émis quand l'état de QTimeLine change. Le nouvel état est ''newState''. === stop() === ''void QTimeLine::stop () [slot]'' Arrête la ligne temporelle, faisant entrer QTimeLine dans l'état ''[[#State-enum|NotRunning]]''. Voir aussi [[#start()]]. === timerEvent() === ''void QTimeLine::timerEvent ( QTimerEvent * event ) [virtual protected]'' Réimplémentation de [[qobject#timerEvent|QObject::timerEvent()]]. === toggleDirection() === ''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 [[#direction-prop|setDirection()]]. === valueChanged() === ''void QTimeLine::valueChanged ( qreal value ) [signal]'' [[QTimeLine]] émet ce signal à intervalle régulier lorsqu'elle est dans l'état [[#State-enum|Running]], mais seulement si la valeur courante change. ''value'' est la valeur courante, un nombre entre 0.0 et 1.0. Voir aussi [[#duration-prop|setDuration()]], [[#valueForTime()]] et [[#updateInterval-prop|updateInterval]]. === valueForTime() === ''[[qtglobal#qreal-typedef|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-enum|CurveShape]] et [[#frameForTime()]]. ==== Remerciements ==== Merci à pour la traduction et à et à pour la relecture !