MCL/sf/mw/qt: comparison src/corelib/animation/qabstractanimation.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 The class defines the functions for the functionality shared by
 all animations. By inheriting this class, you can create custom
 animations that plug into the rest of the animation framework.
 The progress of an animation is given by its current time
-(currentTime()), which is measured in milliseconds from the start
+(currentLoopTime()), which is measured in milliseconds from the start
 of the animation (0) to its end (duration()). The value is updated
 automatically while the animation is running. It can also be set
 directly with setCurrentTime().
 At any point an animation is in one of three states:
 \sa stateChanged()
 */
 /*!
-\fn QAbstractAnimation::stateChanged(QAbstractAnimation::State oldState, QAbstractAnimation::State newState)
+\fn QAbstractAnimation::stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
 QAbstractAnimation emits this signal whenever the state of the animation has
 changed from \a oldState to \a newState. This signal is emitted after the virtual
 updateState() function is called.
 #include <QtCore/qpointer.h>
 #ifndef QT_NO_ANIMATION
 #define DEFAULT_TIMER_INTERVAL 16
-#ifdef Q_WS_WIN
-/// Fix for Qt 4.7
-//on windows if you're currently dragging a widget an inner eventloop was started by the system
-//to make sure that this timer is getting fired, we need to make sure to use the system timers
-//that will send a WM_TIMER event. We do that by settings the timer interval to 11
-//It is 16 because QEventDispatcherWin32Private::registerTimer specifically checks if the interval
-//is greater than 11 to determine if it should use a system timer (or the multimedia timer).
-#define STARTSTOP_TIMER_DELAY 16
-#else
 #define STARTSTOP_TIMER_DELAY 0
-#endif
 QT_BEGIN_NAMESPACE
 Q_GLOBAL_STATIC(QThreadStorage<QUnifiedTimer *>, unifiedTimer)
 QUnifiedTimer::QUnifiedTimer() :
 QObject(), lastTick(0), timingInterval(DEFAULT_TIMER_INTERVAL),
-currentAnimationIdx(0), consistentTiming(false), isPauseTimerActive(false),
+currentAnimationIdx(0), consistentTiming(false), slowMode(false),
-runningLeafAnimations(0)
+isPauseTimerActive(false), runningLeafAnimations(0)
 {
 }
 QUnifiedTimer *QUnifiedTimer::instance()
 {
 inst = unifiedTimer()->localData();
 }
 return inst;
 }
-void QUnifiedTimer::ensureTimerUpdate(QAbstractAnimation *animation)
+void QUnifiedTimer::ensureTimerUpdate()
 {
-if (isPauseTimerActive) {
+if (isPauseTimerActive)
 updateAnimationsTime();
-} else {
-// this code is needed when ensureTimerUpdate is called from setState because we update
-// the currentTime when an animation starts running (otherwise we could remove it)
-animation->setCurrentTime(animation->currentTime());
-}
 }
 void QUnifiedTimer::updateAnimationsTime()
 {
 // ignore consistentTiming in case the pause timer is active
-const int delta = (consistentTiming && !isPauseTimerActive) ?
+int delta = (consistentTiming && !isPauseTimerActive) ?
 timingInterval : time.elapsed() - lastTick;
+if (slowMode)
+delta /= 5;
 lastTick = time.elapsed();
 //we make sure we only call update time if the time has actually changed
 //it might happen in some cases that the time doesn't change because events are delayed
 //when the CPU load is high
 void QUnifiedTimer::restartAnimationTimer()
 {
 if (runningLeafAnimations == 0 && !runningPauseAnimations.isEmpty()) {
 int closestTimeToFinish = closestPauseAnimationTimeToFinish();
+if (closestTimeToFinish < 0) {
+qDebug() << runningPauseAnimations;
+qDebug() << closestPauseAnimationTimeToFinish();
+}
 animationTimer.start(closestTimeToFinish, this);
 isPauseTimerActive = true;
 } else if (!animationTimer.isActive() || isPauseTimerActive) {
 animationTimer.start(timingInterval, this);
 isPauseTimerActive = false;
 }
 }
 void QUnifiedTimer::timerEvent(QTimerEvent *event)
 {
-if (event->timerId() == startStopAnimationTimer.timerId()) {
+//in the case of consistent timing we make sure the orders in which events come is always the same
+//for that purpose we do as if the startstoptimer would always fire before the animation timer
+if ((consistentTiming && startStopAnimationTimer.isActive()) ||
+event->timerId() == startStopAnimationTimer.timerId()) {
 startStopAnimationTimer.stop();
 //we transfer the waiting animations into the "really running" state
 animations += animationsToStart;
 animationsToStart.clear();
 if (!time.isValid()) {
 lastTick = 0;
 time.start();
 }
 }
-} else if (event->timerId() == animationTimer.timerId()) {
+}
+if (event->timerId() == animationTimer.timerId()) {
 // update current time on all top level animations
 updateAnimationsTime();
 restartAnimationTimer();
 }
 }
 void QUnifiedTimer::registerRunningAnimation(QAbstractAnimation *animation)
 {
 if (QAbstractAnimationPrivate::get(animation)->isGroup)
 return;
-if (QAbstractAnimationPrivate::get(animation)->isPause)
+if (QAbstractAnimationPrivate::get(animation)->isPause) {
+if (animation->duration() == -1)
+qDebug() << "toto";
 runningPauseAnimations << animation;
-else
+} else
 runningLeafAnimations++;
 }
 void QUnifiedTimer::unregisterRunningAnimation(QAbstractAnimation *animation)
 {
 for (int i = 0; i < runningPauseAnimations.size(); ++i) {
 QAbstractAnimation *animation = runningPauseAnimations.at(i);
 int timeToFinish;
 if (animation->direction() == QAbstractAnimation::Forward)
-timeToFinish = animation->duration() - animation->currentTime();
+timeToFinish = animation->duration() - animation->currentLoopTime();
 else
-timeToFinish = animation->currentTime();
+timeToFinish = animation->currentLoopTime();
 if (timeToFinish < closestTimeToFinish)
 closestTimeToFinish = timeToFinish;
 }
 return closestTimeToFinish;
 }
 state = newState;
 QWeakPointer<QAbstractAnimation> guard(q);
-q->updateState(oldState, newState);
+//(un)registration of the animation must always happen before calls to
-if (!guard)
+//virtual function (updateState) to ensure a correct state of the timer
-return;
+bool isTopLevel = !group || group->state() == QAbstractAnimation::Stopped;
+if (oldState == QAbstractAnimation::Running) {
-//this is to be safe if updateState changes the state
+if (newState == QAbstractAnimation::Paused && hasRegisteredTimer)
-if (state == oldState)
+QUnifiedTimer::instance()->ensureTimerUpdate();
+//the animation, is not running any more
+QUnifiedTimer::instance()->unregisterAnimation(q);
+} else if (newState == QAbstractAnimation::Running) {
+QUnifiedTimer::instance()->registerAnimation(q, isTopLevel);
+}
+q->updateState(newState, oldState);
+if (!guard || newState != state) //this is to be safe if updateState changes the state
 return;
 // Notify state change
-emit q->stateChanged(oldState, newState);
+emit q->stateChanged(newState, oldState);
-if (!guard)
+if (!guard || newState != state) //this is to be safe if updateState changes the state
 return;
 switch (state) {
 case QAbstractAnimation::Paused:
-if (hasRegisteredTimer)
-// currentTime needs to be updated if pauseTimer is active
-QUnifiedTimer::instance()->ensureTimerUpdate(q);
-if (!guard)
-return;
-//here we're sure that we were in running state before and that the
-//animation is currently registered
-QUnifiedTimer::instance()->unregisterAnimation(q);
 break;
 case QAbstractAnimation::Running:
 {
-bool isTopLevel = !group || group->state() == QAbstractAnimation::Stopped;
-QUnifiedTimer::instance()->registerAnimation(q, isTopLevel);
 // this ensures that the value is updated now that the animation is running
 if (oldState == QAbstractAnimation::Stopped) {
-if (isTopLevel)
+if (isTopLevel) {
 // currentTime needs to be updated if pauseTimer is active
-QUnifiedTimer::instance()->ensureTimerUpdate(q);
+QUnifiedTimer::instance()->ensureTimerUpdate();
+q->setCurrentTime(totalCurrentTime);
+}
 }
 }
 break;
 case QAbstractAnimation::Stopped:
 // Leave running state.
 int dura = q->duration();
-if (!guard)
-return;
 if (deleteWhenStopped)
 q->deleteLater();
-if (oldState == QAbstractAnimation::Running)
-QUnifiedTimer::instance()->unregisterAnimation(q);
 if (dura == -1 || loopCount < 0
 || (oldDirection == QAbstractAnimation::Forward && (oldCurrentTime * (oldCurrentLoop + 1)) == (dura * loopCount))
 || (oldDirection == QAbstractAnimation::Backward && oldCurrentTime == 0)) {
 emit q->finished();
 }
 // the commands order below is important: first we need to setCurrentTime with the old direction,
 // then update the direction on this and all children and finally restart the pauseTimer if needed
 if (d->hasRegisteredTimer)
-QUnifiedTimer::instance()->ensureTimerUpdate(this);
+QUnifiedTimer::instance()->ensureTimerUpdate();
 d->direction = direction;
 updateDirection(direction);
 if (d->hasRegisteredTimer)
 return -1;
 return dura * loopcount;
 }
 /*!
+Returns the current time inside the current loop. It can go from 0 to duration().
+\sa duration(), currentTime
+*/
+int QAbstractAnimation::currentLoopTime() const
+{
+Q_D(const QAbstractAnimation);
+return d->currentTime;
+}
+/*!
 \property QAbstractAnimation::currentTime
 \brief the current time and progress of the animation
 This property describes the animation's current time. You can change the
 current time by calling setCurrentTime, or you can call start() and let
 the animation run, setting the current time automatically as the animation
 progresses.
-The animation's current time starts at 0, and ends at duration(). If the
+The animation's current time starts at 0, and ends at totalDuration().
-animation's loopCount is larger than 1, the current time will rewind and
-start at 0 again for the consecutive loops. If the animation has a pause.
+\sa loopCount, currentLoopTime()
-currentTime will also include the duration of the pause.
-\sa loopCount
 */
 int QAbstractAnimation::currentTime() const
 {
 Q_D(const QAbstractAnimation);
-return d->currentTime;
+return d->totalCurrentTime;
 }
 void QAbstractAnimation::setCurrentTime(int msecs)
 {
 Q_D(QAbstractAnimation);
 msecs = qMax(msecs, 0);
 /*!
 Stops the animation. When the animation is stopped, it emits the stateChanged()
 signal, and state() returns Stopped. The current time is not changed.
 If the animation stops by itself after reaching the end (i.e.,
-currentTime() == duration() and currentLoop() > loopCount() - 1), the
+currentLoopTime() == duration() and currentLoop() > loopCount() - 1), the
 finished() signal is emitted.
 \sa start(), state()
 */
 void QAbstractAnimation::stop()
 d->setState(Running);
 }
 /*!
+If \a paused is true, the animation is paused.
+If \a paused is false, the animation is resumed.
+\sa state(), pause(), resume()
+*/
+void QAbstractAnimation::setPaused(bool paused)
+{
+if (paused)
+pause();
+else
+resume();
+}
+/*!
 \reimp
 */
 bool QAbstractAnimation::event(QEvent *event)
 {
 return QObject::event(event);
 This virtual function is called by QAbstractAnimation when the state
 of the animation is changed from \a oldState to \a newState.
 \sa start(), stop(), pause(), resume()
 */
-void QAbstractAnimation::updateState(QAbstractAnimation::State oldState,
+void QAbstractAnimation::updateState(QAbstractAnimation::State newState,
-QAbstractAnimation::State newState)
+QAbstractAnimation::State oldState)
 {
 Q_UNUSED(oldState);
 Q_UNUSED(newState);
 }

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7