/**************************************************************************** | |
** | |
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
** All rights reserved. | |
** Contact: Nokia Corporation (qt-info@nokia.com) | |
** | |
** This file is part of the QtCore module of the Qt Toolkit. | |
** | |
** $QT_BEGIN_LICENSE:LGPL$ | |
** GNU Lesser General Public License Usage | |
** This file may be used under the terms of the GNU Lesser General Public | |
** License version 2.1 as published by the Free Software Foundation and | |
** appearing in the file LICENSE.LGPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU Lesser | |
** General Public License version 2.1 requirements will be met: | |
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
** | |
** In addition, as a special exception, Nokia gives you certain additional | |
** rights. These rights are described in the Nokia Qt LGPL Exception | |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
** | |
** GNU General Public License Usage | |
** Alternatively, this file may be used under the terms of the GNU General | |
** Public License version 3.0 as published by the Free Software Foundation | |
** and appearing in the file LICENSE.GPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU General | |
** Public License version 3.0 requirements will be met: | |
** http://www.gnu.org/copyleft/gpl.html. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
#include "qtimeline.h" | |
#include <private/qobject_p.h> | |
#include <QtCore/qcoreevent.h> | |
#include <QtCore/qmath.h> | |
#include <QtCore/qelapsedtimer.h> | |
QT_BEGIN_NAMESPACE | |
class QTimeLinePrivate : public QObjectPrivate | |
{ | |
Q_DECLARE_PUBLIC(QTimeLine) | |
public: | |
inline QTimeLinePrivate() | |
: startTime(0), duration(1000), startFrame(0), endFrame(0), | |
updateInterval(1000 / 25), | |
totalLoopCount(1), currentLoopCount(0), currentTime(0), timerId(0), | |
direction(QTimeLine::Forward), easingCurve(QEasingCurve::InOutSine), | |
state(QTimeLine::NotRunning) | |
{ } | |
int startTime; | |
int duration; | |
int startFrame; | |
int endFrame; | |
int updateInterval; | |
int totalLoopCount; | |
int currentLoopCount; | |
int currentTime; | |
int timerId; | |
QElapsedTimer timer; | |
QTimeLine::Direction direction; | |
QEasingCurve easingCurve; | |
QTimeLine::State state; | |
inline void setState(QTimeLine::State newState) | |
{ | |
Q_Q(QTimeLine); | |
if (newState != state) | |
emit q->stateChanged(state = newState); | |
} | |
void setCurrentTime(int msecs); | |
}; | |
/*! | |
\internal | |
*/ | |
void QTimeLinePrivate::setCurrentTime(int msecs) | |
{ | |
Q_Q(QTimeLine); | |
qreal lastValue = q->currentValue(); | |
int lastFrame = q->currentFrame(); | |
// Determine if we are looping. | |
int elapsed = (direction == QTimeLine::Backward) ? (-msecs + duration) : msecs; | |
int loopCount = elapsed / duration; | |
bool looping = (loopCount != currentLoopCount); | |
#ifdef QTIMELINE_DEBUG | |
qDebug() << "QTimeLinePrivate::setCurrentTime:" << msecs << duration << "with loopCount" << loopCount | |
<< "currentLoopCount" << currentLoopCount | |
<< "looping" << looping; | |
#endif | |
if (looping) | |
currentLoopCount = loopCount; | |
// Normalize msecs to be between 0 and duration, inclusive. | |
currentTime = elapsed % duration; | |
if (direction == QTimeLine::Backward) | |
currentTime = duration - currentTime; | |
// Check if we have reached the end of loopcount. | |
bool finished = false; | |
if (totalLoopCount && currentLoopCount >= totalLoopCount) { | |
finished = true; | |
currentTime = (direction == QTimeLine::Backward) ? 0 : duration; | |
currentLoopCount = totalLoopCount - 1; | |
} | |
int currentFrame = q->frameForTime(currentTime); | |
#ifdef QTIMELINE_DEBUG | |
qDebug() << "QTimeLinePrivate::setCurrentTime: frameForTime" << currentTime << currentFrame; | |
#endif | |
if (!qFuzzyCompare(lastValue, q->currentValue())) | |
emit q->valueChanged(q->currentValue()); | |
if (lastFrame != currentFrame) { | |
const int transitionframe = (direction == QTimeLine::Forward ? endFrame : startFrame); | |
if (looping && !finished && transitionframe != currentFrame) { | |
#ifdef QTIMELINE_DEBUG | |
qDebug() << "QTimeLinePrivate::setCurrentTime: transitionframe"; | |
#endif | |
emit q->frameChanged(transitionframe); | |
} | |
#ifdef QTIMELINE_DEBUG | |
else { | |
QByteArray reason; | |
if (!looping) | |
reason += " not looping"; | |
if (finished) { | |
if (!reason.isEmpty()) | |
reason += " and"; | |
reason += " finished"; | |
} | |
if (transitionframe == currentFrame) { | |
if (!reason.isEmpty()) | |
reason += " and"; | |
reason += " transitionframe is equal to currentFrame: " + QByteArray::number(currentFrame); | |
} | |
qDebug("QTimeLinePrivate::setCurrentTime: not transitionframe because %s", reason.constData()); | |
} | |
#endif | |
emit q->frameChanged(currentFrame); | |
} | |
if (finished && state == QTimeLine::Running) { | |
q->stop(); | |
emit q->finished(); | |
} | |
} | |
/*! | |
\class QTimeLine | |
\brief The QTimeLine class provides a timeline for controlling animations. | |
\since 4.2 | |
\ingroup animation | |
It's most commonly used to animate a GUI control by calling a slot | |
periodically. You can construct a timeline by passing its duration in | |
milliseconds to QTimeLine's constructor. The timeline's duration describes | |
for how long the animation will run. Then you set a suitable frame range | |
by calling setFrameRange(). Finally connect the frameChanged() signal to a | |
suitable slot in the widget you wish to animate (e.g., setValue() in | |
QProgressBar). When you proceed to calling start(), QTimeLine will enter | |
Running state, and start emitting frameChanged() at regular intervals, | |
causing your widget's connected property's value to grow from the lower | |
end to the upper and of your frame range, at a steady rate. You can | |
specify the update interval by calling setUpdateInterval(). When done, | |
QTimeLine enters NotRunning state, and emits finished(). | |
Example: | |
\snippet doc/src/snippets/code/src_corelib_tools_qtimeline.cpp 0 | |
You can also use QTimeLine with the | |
\l{Graphics View}{Graphics View framework} for | |
animations. The QGraphicsItemAnimation class implements animation | |
of \l{QGraphicsItem}{QGraphicsItems} with a timeline. | |
By default the timeline runs once, from the beginning and towards the end, | |
upon which you must call start() again to restart from the beginning. To | |
make the timeline loop, you can call setLoopCount(), passing the number of | |
times the timeline should run before finishing. The direction can also be | |
changed, causing the timeline to run backward, by calling | |
setDirection(). You can also pause and unpause the timeline while it's | |
running by calling setPaused(). For interactive control, the | |
setCurrentTime() function is provided, which sets the time position of the | |
time line directly. Although most useful in NotRunning state, (e.g., | |
connected to a valueChanged() signal in a QSlider,) this function can be | |
called at any time. | |
The frame interface is useful for standard widgets, but QTimeLine can be | |
used to control any type of animation. The heart of QTimeLine lies in the | |
valueForTime() function, which generates a \e value between 0 and 1 for a | |
given time. This value is typically used to describe the steps of an | |
animation, where 0 is the first step of an animation, and 1 is the last | |
step. When running, QTimeLine generates values between 0 and 1 by calling | |
valueForTime() and emitting valueChanged(). By default, valueForTime() | |
applies an interpolation algorithm to generate these value. You can choose | |
from a set of predefined timeline algorithms by calling | |
setCurveShape(). | |
Note that by default, QTimeLine uses the EaseInOut curve shape, | |
which provides a value that grows slowly, then grows steadily, and | |
finally grows slowly. For a custom timeline, you can reimplement | |
valueForTime(), in which case QTimeLine's curveShape property is ignored. | |
\sa QProgressBar, QProgressDialog, QGraphicsItemAnimation | |
*/ | |
/*! | |
\enum QTimeLine::State | |
This enum describes the state of the timeline. | |
\value NotRunning The timeline is not running. This is the initial state | |
of QTimeLine, and the state QTimeLine reenters when finished. The current | |
time, frame and value remain unchanged until either setCurrentTime() is | |
called, or the timeline is started by calling start(). | |
\value Paused The timeline is paused (i.e., temporarily | |
suspended). Calling setPaused(false) will resume timeline activity. | |
\value Running The timeline is running. While control is in the event | |
loop, QTimeLine will update its current time at regular intervals, | |
emitting valueChanged() and frameChanged() when appropriate. | |
\sa state(), stateChanged() | |
*/ | |
/*! | |
\enum QTimeLine::Direction | |
This enum describes the direction of the timeline when in \l Running state. | |
\value Forward The current time of the timeline increases with time (i.e., | |
moves from 0 and towards the end / duration). | |
\value Backward The current time of the timeline decreases with time (i.e., | |
moves from the end / duration and towards 0). | |
\sa setDirection() | |
*/ | |
/*! | |
\enum QTimeLine::CurveShape | |
This enum describes the default shape of QTimeLine's value curve. The | |
default, shape is EaseInOutCurve. The curve defines the relation | |
between the value and the timeline. | |
\value EaseInCurve The value starts growing slowly, then increases in speed. | |
\value EaseOutCurve The value starts growing steadily, then ends slowly. | |
\value EaseInOutCurve The value starts growing slowly, then runs steadily, then grows slowly again. | |
\value LinearCurve The value grows linearly (e.g., if the duration is 1000 ms, | |
the value at time 500 ms is 0.5). | |
\value SineCurve The value grows sinusoidally. | |
\value CosineCurve The value grows cosinusoidally. | |
\sa setCurveShape() | |
*/ | |
/*! | |
\fn QTimeLine::valueChanged(qreal value) | |
QTimeLine emits this signal at regular intervals when in \l Running state, | |
but only if the current value changes. \a value is the current value. \a value is | |
a number between 0.0 and 1.0 | |
\sa QTimeLine::setDuration(), QTimeLine::valueForTime(), QTimeLine::updateInterval | |
*/ | |
/*! | |
\fn QTimeLine::frameChanged(int frame) | |
QTimeLine emits this signal at regular intervals when in \l Running state, | |
but only if the current frame changes. \a frame is the current frame number. | |
\sa QTimeLine::setFrameRange(), QTimeLine::updateInterval | |
*/ | |
/*! | |
\fn QTimeLine::stateChanged(QTimeLine::State newState) | |
This signal is emitted whenever QTimeLine's state changes. The new state | |
is \a newState. | |
*/ | |
/*! | |
\fn QTimeLine::finished() | |
This signal is emitted when QTimeLine finishes (i.e., reaches the end of | |
its time line), and does not loop. | |
*/ | |
/*! | |
Constructs a timeline with a duration of \a duration milliseconds. \a | |
parent is passed to QObject's constructor. The default duration is 1000 | |
milliseconds. | |
*/ | |
QTimeLine::QTimeLine(int duration, QObject *parent) | |
: QObject(*new QTimeLinePrivate, parent) | |
{ | |
setDuration(duration); | |
} | |
/*! | |
Destroys the timeline. | |
*/ | |
QTimeLine::~QTimeLine() | |
{ | |
Q_D(QTimeLine); | |
if (d->state == Running) | |
stop(); | |
} | |
/*! | |
Returns the state of the timeline. | |
\sa start(), setPaused(), stop() | |
*/ | |
QTimeLine::State QTimeLine::state() const | |
{ | |
Q_D(const QTimeLine); | |
return d->state; | |
} | |
/*! | |
\property QTimeLine::loopCount | |
\brief the number of times the timeline should loop before it's finished. | |
A loop count of of 0 means that the timeline will loop forever. | |
By default, this property contains a value of 1. | |
*/ | |
int QTimeLine::loopCount() const | |
{ | |
Q_D(const QTimeLine); | |
return d->totalLoopCount; | |
} | |
void QTimeLine::setLoopCount(int count) | |
{ | |
Q_D(QTimeLine); | |
d->totalLoopCount = count; | |
} | |
/*! | |
\property QTimeLine::direction | |
\brief the direction of the timeline when QTimeLine is in \l Running | |
state. | |
This direction indicates whether the time moves from 0 towards the | |
timeline duration, or from the value of the duration and towards 0 after | |
start() has been called. | |
By default, this property is set to \l Forward. | |
*/ | |
QTimeLine::Direction QTimeLine::direction() const | |
{ | |
Q_D(const QTimeLine); | |
return d->direction; | |
} | |
void QTimeLine::setDirection(Direction direction) | |
{ | |
Q_D(QTimeLine); | |
d->direction = direction; | |
d->startTime = d->currentTime; | |
d->timer.start(); | |
} | |
/*! | |
\property QTimeLine::duration | |
\brief the total duration of the timeline in milliseconds. | |
By default, this value is 1000 (i.e., 1 second), but you can change this | |
by either passing a duration to QTimeLine's constructor, or by calling | |
setDuration(). The duration must be larger than 0. | |
\note Changing the duration does not cause the current time to be reset | |
to zero or the new duration. You also need to call setCurrentTime() with | |
the desired value. | |
*/ | |
int QTimeLine::duration() const | |
{ | |
Q_D(const QTimeLine); | |
return d->duration; | |
} | |
void QTimeLine::setDuration(int duration) | |
{ | |
Q_D(QTimeLine); | |
if (duration <= 0) { | |
qWarning("QTimeLine::setDuration: cannot set duration <= 0"); | |
return; | |
} | |
d->duration = duration; | |
} | |
/*! | |
Returns the start frame, which is the frame corresponding to the start of | |
the timeline (i.e., the frame for which the current value is 0). | |
\sa setStartFrame(), setFrameRange() | |
*/ | |
int QTimeLine::startFrame() const | |
{ | |
Q_D(const QTimeLine); | |
return d->startFrame; | |
} | |
/*! | |
Sets the start frame, which is the frame corresponding to the start of the | |
timeline (i.e., the frame for which the current value is 0), to \a frame. | |
\sa startFrame(), endFrame(), setFrameRange() | |
*/ | |
void QTimeLine::setStartFrame(int frame) | |
{ | |
Q_D(QTimeLine); | |
d->startFrame = frame; | |
} | |
/*! | |
Returns the end frame, which is the frame corresponding to the end of the | |
timeline (i.e., the frame for which the current value is 1). | |
\sa setEndFrame(), setFrameRange() | |
*/ | |
int QTimeLine::endFrame() const | |
{ | |
Q_D(const QTimeLine); | |
return d->endFrame; | |
} | |
/*! | |
Sets the end frame, which is the frame corresponding to the end of the | |
timeline (i.e., the frame for which the current value is 1), to \a frame. | |
\sa endFrame(), startFrame(), setFrameRange() | |
*/ | |
void QTimeLine::setEndFrame(int frame) | |
{ | |
Q_D(QTimeLine); | |
d->endFrame = frame; | |
} | |
/*! | |
Sets the timeline's frame counter to start at \a startFrame, and end and | |
\a endFrame. For each time value, QTimeLine will find the corresponding | |
frame when you call currentFrame() or frameForTime() by interpolating, | |
using the return value of valueForTime(). | |
When in Running state, QTimeLine also emits the frameChanged() signal when | |
the frame changes. | |
\sa startFrame(), endFrame(), start(), currentFrame() | |
*/ | |
void QTimeLine::setFrameRange(int startFrame, int endFrame) | |
{ | |
Q_D(QTimeLine); | |
d->startFrame = startFrame; | |
d->endFrame = endFrame; | |
} | |
/*! | |
\property QTimeLine::updateInterval | |
\brief the time in milliseconds between each time QTimeLine updates its | |
current time. | |
When updating the current time, QTimeLine will emit valueChanged() if the | |
current value changed, and frameChanged() if the frame changed. | |
By default, the interval is 40 ms, which corresponds to a rate of 25 | |
updates per second. | |
*/ | |
int QTimeLine::updateInterval() const | |
{ | |
Q_D(const QTimeLine); | |
return d->updateInterval; | |
} | |
void QTimeLine::setUpdateInterval(int interval) | |
{ | |
Q_D(QTimeLine); | |
d->updateInterval = interval; | |
} | |
/*! | |
\property QTimeLine::curveShape | |
\brief the shape of the timeline curve. | |
The curve shape describes the relation between the time and value for the | |
base implementation of valueForTime(). | |
If you have reimplemented valueForTime(), this value is ignored. | |
By default, this property is set to \l EaseInOutCurve. | |
\sa valueForTime() | |
*/ | |
QTimeLine::CurveShape QTimeLine::curveShape() const | |
{ | |
Q_D(const QTimeLine); | |
switch (d->easingCurve.type()) { | |
default: | |
case QEasingCurve::InOutSine: | |
return EaseInOutCurve; | |
case QEasingCurve::InCurve: | |
return EaseInCurve; | |
case QEasingCurve::OutCurve: | |
return EaseOutCurve; | |
case QEasingCurve::Linear: | |
return LinearCurve; | |
case QEasingCurve::SineCurve: | |
return SineCurve; | |
case QEasingCurve::CosineCurve: | |
return CosineCurve; | |
} | |
return EaseInOutCurve; | |
} | |
void QTimeLine::setCurveShape(CurveShape shape) | |
{ | |
switch (shape) { | |
default: | |
case EaseInOutCurve: | |
setEasingCurve(QEasingCurve(QEasingCurve::InOutSine)); | |
break; | |
case EaseInCurve: | |
setEasingCurve(QEasingCurve(QEasingCurve::InCurve)); | |
break; | |
case EaseOutCurve: | |
setEasingCurve(QEasingCurve(QEasingCurve::OutCurve)); | |
break; | |
case LinearCurve: | |
setEasingCurve(QEasingCurve(QEasingCurve::Linear)); | |
break; | |
case SineCurve: | |
setEasingCurve(QEasingCurve(QEasingCurve::SineCurve)); | |
break; | |
case CosineCurve: | |
setEasingCurve(QEasingCurve(QEasingCurve::CosineCurve)); | |
break; | |
} | |
} | |
/*! | |
\property QTimeLine::easingCurve | |
\since 4.6 | |
Specifies the easing curve that the timeline will use. | |
If both easing curve and curveShape are set, the last set property will | |
override the previous one. (If valueForTime() is reimplemented it will | |
override both) | |
*/ | |
QEasingCurve QTimeLine::easingCurve() const | |
{ | |
Q_D(const QTimeLine); | |
return d->easingCurve; | |
} | |
void QTimeLine::setEasingCurve(const QEasingCurve& curve) | |
{ | |
Q_D(QTimeLine); | |
d->easingCurve = curve; | |
} | |
/*! | |
\property QTimeLine::currentTime | |
\brief the current time of the time line. | |
When QTimeLine is in Running state, this value is updated continuously as | |
a function of the duration and direction of the timeline. Otherwise, it is | |
value that was current when stop() was called last, or the value set by | |
setCurrentTime(). | |
By default, this property contains a value of 0. | |
*/ | |
int QTimeLine::currentTime() const | |
{ | |
Q_D(const QTimeLine); | |
return d->currentTime; | |
} | |
void QTimeLine::setCurrentTime(int msec) | |
{ | |
Q_D(QTimeLine); | |
d->startTime = 0; | |
d->currentLoopCount = 0; | |
d->timer.restart(); | |
d->setCurrentTime(msec); | |
} | |
/*! | |
Returns the frame corresponding to the current time. | |
\sa currentTime(), frameForTime(), setFrameRange() | |
*/ | |
int QTimeLine::currentFrame() const | |
{ | |
Q_D(const QTimeLine); | |
return frameForTime(d->currentTime); | |
} | |
/*! | |
Returns the value corresponding to the current time. | |
\sa valueForTime(), currentFrame() | |
*/ | |
qreal QTimeLine::currentValue() const | |
{ | |
Q_D(const QTimeLine); | |
return valueForTime(d->currentTime); | |
} | |
/*! | |
Returns the frame corresponding to the time \a msec. This value is | |
calculated using a linear interpolation of the start and end frame, based | |
on the value returned by valueForTime(). | |
\sa valueForTime(), setFrameRange() | |
*/ | |
int QTimeLine::frameForTime(int msec) const | |
{ | |
Q_D(const QTimeLine); | |
if (d->direction == Forward) | |
return d->startFrame + int((d->endFrame - d->startFrame) * valueForTime(msec)); | |
return d->startFrame + qCeil((d->endFrame - d->startFrame) * valueForTime(msec)); | |
} | |
/*! | |
Returns the timeline value for the time \a msec. The returned value, which | |
varies depending on the curve shape, is always between 0 and 1. If \a msec | |
is 0, the default implementation always returns 0. | |
Reimplement this function to provide a custom curve shape for your | |
timeline. | |
\sa CurveShape, frameForTime() | |
*/ | |
qreal QTimeLine::valueForTime(int msec) const | |
{ | |
Q_D(const QTimeLine); | |
msec = qMin(qMax(msec, 0), d->duration); | |
qreal value = msec / qreal(d->duration); | |
return d->easingCurve.valueForProgress(value); | |
} | |
/*! | |
Starts the timeline. QTimeLine will enter Running state, and once it | |
enters the event loop, it will update its current time, frame and value at | |
regular intervals. The default interval is 40 ms (i.e., 25 times per | |
second). You can change the update interval by calling | |
setUpdateInterval(). | |
The timeline will start from position 0, or the end if going backward. | |
If you want to resume a stopped timeline without restarting, you can call | |
resume() instead. | |
\sa resume(), updateInterval(), frameChanged(), valueChanged() | |
*/ | |
void QTimeLine::start() | |
{ | |
Q_D(QTimeLine); | |
if (d->timerId) { | |
qWarning("QTimeLine::start: already running"); | |
return; | |
} | |
int curTime = 0; | |
if (d->direction == Backward) | |
curTime = d->duration; | |
d->timerId = startTimer(d->updateInterval); | |
d->startTime = curTime; | |
d->currentLoopCount = 0; | |
d->timer.start(); | |
d->setState(Running); | |
d->setCurrentTime(curTime); | |
} | |
/*! | |
Resumes the timeline from the current time. QTimeLine will reenter Running | |
state, and once it enters the event loop, it will update its current time, | |
frame and value at regular intervals. | |
In contrast to start(), this function does not restart the timeline before | |
it resumes. | |
\sa start(), updateInterval(), frameChanged(), valueChanged() | |
*/ | |
void QTimeLine::resume() | |
{ | |
Q_D(QTimeLine); | |
if (d->timerId) { | |
qWarning("QTimeLine::resume: already running"); | |
return; | |
} | |
d->timerId = startTimer(d->updateInterval); | |
d->startTime = d->currentTime; | |
d->timer.start(); | |
d->setState(Running); | |
} | |
/*! | |
Stops the timeline, causing QTimeLine to enter NotRunning state. | |
\sa start() | |
*/ | |
void QTimeLine::stop() | |
{ | |
Q_D(QTimeLine); | |
if (d->timerId) | |
killTimer(d->timerId); | |
d->setState(NotRunning); | |
d->timerId = 0; | |
} | |
/*! | |
If \a paused is true, the timeline is paused, causing QTimeLine to enter | |
Paused state. No updates will be signaled until either start() or | |
setPaused(false) is called. If \a paused is false, the timeline is resumed | |
and continues where it left. | |
\sa state(), start() | |
*/ | |
void QTimeLine::setPaused(bool paused) | |
{ | |
Q_D(QTimeLine); | |
if (d->state == NotRunning) { | |
qWarning("QTimeLine::setPaused: Not running"); | |
return; | |
} | |
if (paused && d->state != Paused) { | |
d->startTime = d->currentTime; | |
killTimer(d->timerId); | |
d->timerId = 0; | |
d->setState(Paused); | |
} else if (!paused && d->state == Paused) { | |
d->timerId = startTimer(d->updateInterval); | |
d->setState(Running); | |
} | |
} | |
/*! | |
Toggles the direction of the timeline. If the direction was Forward, it | |
becomes Backward, and vice verca. | |
\sa setDirection() | |
*/ | |
void QTimeLine::toggleDirection() | |
{ | |
Q_D(QTimeLine); | |
setDirection(d->direction == Forward ? Backward : Forward); | |
} | |
/*! | |
\reimp | |
*/ | |
void QTimeLine::timerEvent(QTimerEvent *event) | |
{ | |
Q_D(QTimeLine); | |
if (event->timerId() != d->timerId) { | |
event->ignore(); | |
return; | |
} | |
event->accept(); | |
if (d->direction == Forward) { | |
d->setCurrentTime(d->startTime + d->timer.elapsed()); | |
} else { | |
d->setCurrentTime(d->startTime - d->timer.elapsed()); | |
} | |
} | |
QT_END_NAMESPACE |