Result API review with Jasmin

QAbstractAnimation:
currentTime returns the "complete" current time
currentLoopTime() returns the time inside the current loop
add setPaused(bool) for consistency with QTimeLine
stateChanged: newState passed as first paramater (before oldState)
              for consistency with the reset of Qt

QAnimationGroup:
rename clearAnimations to clear
rename insertAnimationAt to insertAnimation
rename takeAnimationAt to takeAnimation

QSequentialAnimationGroup:
rename insertPauseAt to insertPause

20 files changed, 416 insertions, 396 deletions

diff --git a/demos/sub-attaq/boat.cpp b/demos/sub-attaq/boat.cpp
index cb40329..0ad31b1 100644
--- a/demos/sub-attaq/boat.cpp
+++ b/demos/sub-attaq/boat.cpp
@@ -68,7 +68,7 @@ static QAbstractAnimation *setupDestroyAnimation(Boat *boat)
         QPropertyAnimation *anim = new QPropertyAnimation(step, "opacity");
         anim->setEndValue(1);
         anim->setDuration(100);
-        group->insertAnimationAt(i-1, anim);
+        group->insertAnimation(i-1, anim);
 
         //and then fade-out
         QPropertyAnimation *anim2 = new QPropertyAnimation(step, "opacity");
diff --git a/src/corelib/animation/qabstractanimation.cpp b/src/corelib/animation/qabstractanimation.cpp
index 4f93c1e..0cdc40c 100644
--- a/src/corelib/animation/qabstractanimation.cpp
+++ b/src/corelib/animation/qabstractanimation.cpp
@@ -115,7 +115,7 @@
 */
 
 /*!
-    \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
@@ -357,12 +357,12 @@ void QAbstractAnimationPrivate::setState(QAbstractAnimation::State newState)
         QUnifiedTimer::instance()->unregisterAnimation(q);
     }
 
-    q->updateState(oldState, newState);
+    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 || newState != state) //this is to be safe if updateState changes the state
         return;
 
@@ -635,6 +635,18 @@ int QAbstractAnimation::totalDuration() const
 }
 
 /*!
+    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
 
@@ -643,17 +655,14 @@ int QAbstractAnimation::totalDuration() const
     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
-    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.
-    currentTime will also include the duration of the pause.
+    The animation's current time starts at 0, and ends at totalDuration().
 
-    \sa loopCount
+    \sa loopCount, currentLoopTime
  */
 int QAbstractAnimation::currentTime() const
 {
     Q_D(const QAbstractAnimation);
-    return d->currentTime;
+    return d->totalCurrentTime;
 }
 void QAbstractAnimation::setCurrentTime(int msecs)
 {
@@ -777,6 +786,21 @@ void QAbstractAnimation::resume()
 }
 
 /*!
+    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)
@@ -799,8 +823,8 @@ bool QAbstractAnimation::event(QEvent *event)
 
     \sa start(), stop(), pause(), resume()
 */
-void QAbstractAnimation::updateState(QAbstractAnimation::State oldState,
-                                     QAbstractAnimation::State newState)
+void QAbstractAnimation::updateState(QAbstractAnimation::State newState,
+                                     QAbstractAnimation::State oldState)
 {
     Q_UNUSED(oldState);
     Q_UNUSED(newState);
diff --git a/src/corelib/animation/qabstractanimation.h b/src/corelib/animation/qabstractanimation.h
index 3d608b6..3c6e12f 100644
--- a/src/corelib/animation/qabstractanimation.h
+++ b/src/corelib/animation/qabstractanimation.h
@@ -95,6 +95,9 @@ public:
     Direction direction() const;
     void setDirection(Direction direction);
 
+    int currentTime() const;
+    int currentLoopTime() const;
+
     int loopCount() const;
     void setLoopCount(int loopCount);
     int currentLoop() const;
@@ -102,11 +105,9 @@ public:
     virtual int duration() const = 0;
     int totalDuration() const;
 
-    int currentTime() const;
-
 Q_SIGNALS:
     void finished();
-    void stateChanged(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
     void currentLoopChanged(int currentLoop);
     void directionChanged(QAbstractAnimation::Direction);
 
@@ -114,6 +115,7 @@ public Q_SLOTS:
     void start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped);
     void pause();
     void resume();
+    void setPaused(bool);
     void stop();
     void setCurrentTime(int msecs);
 
@@ -122,7 +124,7 @@ protected:
     bool event(QEvent *event);
 
     virtual void updateCurrentTime(int currentTime) = 0;
-    virtual void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
     virtual void updateDirection(QAbstractAnimation::Direction direction);
 
 private:
diff --git a/src/corelib/animation/qanimationgroup.cpp b/src/corelib/animation/qanimationgroup.cpp
index 40f5936..64282ea 100644
--- a/src/corelib/animation/qanimationgroup.cpp
+++ b/src/corelib/animation/qanimationgroup.cpp
@@ -70,7 +70,7 @@
     QAnimationGroup provides methods for adding and retrieving
     animations. Besides that, you can remove animations by calling
     remove(), and clear the animation group by calling
-    clearAnimations(). You may keep track of changes in the group's
+    clear(). You may keep track of changes in the group's
     animations by listening to QEvent::ChildAdded and
     QEvent::ChildRemoved events.
 
@@ -151,7 +151,7 @@ int QAnimationGroup::animationCount() const
     Returns the index of \a animation. The returned index can be passed
     to the other functions that take an index as an argument.
 
-    \sa insertAnimationAt(), animationAt(), takeAnimationAt()
+    \sa insertAnimation(), animationAt(), takeAnimation()
 */
 int QAnimationGroup::indexOfAnimation(QAbstractAnimation *animation) const
 {
@@ -160,7 +160,7 @@ int QAnimationGroup::indexOfAnimation(QAbstractAnimation *animation) const
 }
 
 /*!
-    Adds \a animation to this group. This will call insertAnimationAt with
+    Adds \a animation to this group. This will call insertAnimation with
     index equals to animationCount().
 
     \note The group takes ownership of the animation.
@@ -170,7 +170,7 @@ int QAnimationGroup::indexOfAnimation(QAbstractAnimation *animation) const
 void QAnimationGroup::addAnimation(QAbstractAnimation *animation)
 {
     Q_D(QAnimationGroup);
-    insertAnimationAt(d->animations.count(), animation);
+    insertAnimation(d->animations.count(), animation);
 }
 
 /*!
@@ -180,14 +180,14 @@ void QAnimationGroup::addAnimation(QAbstractAnimation *animation)
 
     \note The group takes ownership of the animation.
 
-    \sa takeAnimationAt(), addAnimation(), indexOfAnimation(), removeAnimation()
+    \sa takeAnimation(), addAnimation(), indexOfAnimation(), removeAnimation()
 */
-void QAnimationGroup::insertAnimationAt(int index, QAbstractAnimation *animation)
+void QAnimationGroup::insertAnimation(int index, QAbstractAnimation *animation)
 {
     Q_D(QAnimationGroup);
 
     if (index < 0 || index > d->animations.size()) {
-        qWarning("QAnimationGroup::insertAnimationAt: index is out of bounds");
+        qWarning("QAnimationGroup::insertAnimation: index is out of bounds");
         return;
     }
 
@@ -205,7 +205,7 @@ void QAnimationGroup::insertAnimationAt(int index, QAbstractAnimation *animation
     Removes \a animation from this group. The ownership of \a animation is
     transferred to the caller.
 
-    \sa takeAnimationAt(), insertAnimationAt(), addAnimation()
+    \sa takeAnimation(), insertAnimation(), addAnimation()
 */
 void QAnimationGroup::removeAnimation(QAbstractAnimation *animation)
 {
@@ -221,7 +221,7 @@ void QAnimationGroup::removeAnimation(QAbstractAnimation *animation)
         return;
     }
 
-    takeAnimationAt(index);
+    takeAnimation(index);
 }
 
 /*!
@@ -229,13 +229,13 @@ void QAnimationGroup::removeAnimation(QAbstractAnimation *animation)
 
     \note The ownership of the animation is transferred to the caller.
 
-    \sa removeAnimation(), addAnimation(), insertAnimationAt(), indexOfAnimation()
+    \sa removeAnimation(), addAnimation(), insertAnimation(), indexOfAnimation()
 */
-QAbstractAnimation *QAnimationGroup::takeAnimationAt(int index)
+QAbstractAnimation *QAnimationGroup::takeAnimation(int index)
 {
     Q_D(QAnimationGroup);
     if (index < 0 || index >= d->animations.size()) {
-        qWarning("QAnimationGroup::takeAnimationAt: no animation at index %d", index);
+        qWarning("QAnimationGroup::takeAnimation: no animation at index %d", index);
         return 0;
     }
     QAbstractAnimation *animation = d->animations.at(index);
@@ -254,7 +254,7 @@ QAbstractAnimation *QAnimationGroup::takeAnimationAt(int index)
 
     \sa addAnimation(), removeAnimation()
 */
-void QAnimationGroup::clearAnimations()
+void QAnimationGroup::clear()
 {
     Q_D(QAnimationGroup);
     qDeleteAll(d->animations);
@@ -279,7 +279,7 @@ bool QAnimationGroup::event(QEvent *event)
         // case it might be called from the destructor.
         int index = d->animations.indexOf(a);
         if (index != -1)
-            takeAnimationAt(index);
+            takeAnimation(index);
     }
     return QAbstractAnimation::event(event);
 }
diff --git a/src/corelib/animation/qanimationgroup.h b/src/corelib/animation/qanimationgroup.h
index 86368a3..416ce3f 100644
--- a/src/corelib/animation/qanimationgroup.h
+++ b/src/corelib/animation/qanimationgroup.h
@@ -65,10 +65,10 @@ public:
     int animationCount() const;
     int indexOfAnimation(QAbstractAnimation *animation) const;
     void addAnimation(QAbstractAnimation *animation);
-    void insertAnimationAt(int index, QAbstractAnimation *animation);
+    void insertAnimation(int index, QAbstractAnimation *animation);
     void removeAnimation(QAbstractAnimation *animation);
-    QAbstractAnimation *takeAnimationAt(int index);
-    void clearAnimations();
+    QAbstractAnimation *takeAnimation(int index);
+    void clear();
 
 protected:
     QAnimationGroup(QAnimationGroupPrivate &dd, QObject *parent);
diff --git a/src/corelib/animation/qparallelanimationgroup.cpp b/src/corelib/animation/qparallelanimationgroup.cpp
index 0a04c14..2d37d10 100644
--- a/src/corelib/animation/qparallelanimationgroup.cpp
+++ b/src/corelib/animation/qparallelanimationgroup.cpp
@@ -182,11 +182,11 @@ void QParallelAnimationGroup::updateCurrentTime(int currentTime)
 /*!
     \reimp
 */
-void QParallelAnimationGroup::updateState(QAbstractAnimation::State oldState,
-                                          QAbstractAnimation::State newState)
+void QParallelAnimationGroup::updateState(QAbstractAnimation::State newState,
+                                          QAbstractAnimation::State oldState)
 {
     Q_D(QParallelAnimationGroup);
-    QAnimationGroup::updateState(oldState, newState);
+    QAnimationGroup::updateState(newState, oldState);
 
     switch (newState) {
     case Stopped:
diff --git a/src/corelib/animation/qparallelanimationgroup.h b/src/corelib/animation/qparallelanimationgroup.h
index 1cab91e..18ec885 100644
--- a/src/corelib/animation/qparallelanimationgroup.h
+++ b/src/corelib/animation/qparallelanimationgroup.h
@@ -68,7 +68,7 @@ protected:
     bool event(QEvent *event);
 
     void updateCurrentTime(int currentTime);
-    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
     void updateDirection(QAbstractAnimation::Direction direction);
 
 private:
diff --git a/src/corelib/animation/qpauseanimation.cpp b/src/corelib/animation/qpauseanimation.cpp
index 21e5b08..1b3b654 100644
--- a/src/corelib/animation/qpauseanimation.cpp
+++ b/src/corelib/animation/qpauseanimation.cpp
@@ -56,7 +56,7 @@
     It is not necessary to construct a QPauseAnimation yourself.
     QSequentialAnimationGroup provides the convenience functions
     \l{QSequentialAnimationGroup::}{addPause()} and
-    \l{QSequentialAnimationGroup::}{insertPauseAt()}. These functions
+    \l{QSequentialAnimationGroup::}{insertPause()}. These functions
     simply take the number of milliseconds the pause should last.
 
     \sa QSequentialAnimationGroup
diff --git a/src/corelib/animation/qpropertyanimation.cpp b/src/corelib/animation/qpropertyanimation.cpp
index 4742e54..3065083 100644
--- a/src/corelib/animation/qpropertyanimation.cpp
+++ b/src/corelib/animation/qpropertyanimation.cpp
@@ -250,8 +250,8 @@ void QPropertyAnimation::updateCurrentValue(const QVariant &value)
     If the startValue is not defined when the state of the animation changes from Stopped to Running,
     the current property value is used as the initial value for the animation.
 */
-void QPropertyAnimation::updateState(QAbstractAnimation::State oldState,
-                                     QAbstractAnimation::State newState)
+void QPropertyAnimation::updateState(QAbstractAnimation::State newState,
+                                     QAbstractAnimation::State oldState)
 {
     Q_D(QPropertyAnimation);
 
@@ -260,7 +260,7 @@ void QPropertyAnimation::updateState(QAbstractAnimation::State oldState,
         return;
     }
 
-    QVariantAnimation::updateState(oldState, newState);
+    QVariantAnimation::updateState(newState, oldState);
 
     QPropertyAnimation *animToStop = 0;
     {
diff --git a/src/corelib/animation/qpropertyanimation.h b/src/corelib/animation/qpropertyanimation.h
index 2e2ca3a..61efed9 100644
--- a/src/corelib/animation/qpropertyanimation.h
+++ b/src/corelib/animation/qpropertyanimation.h
@@ -73,7 +73,7 @@ public:
 protected:
     bool event(QEvent *event);
     void updateCurrentValue(const QVariant &value);
-    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
 
 private:
     Q_DISABLE_COPY(QPropertyAnimation)
diff --git a/src/corelib/animation/qsequentialanimationgroup.cpp b/src/corelib/animation/qsequentialanimationgroup.cpp
index 5ca560a..861e26e 100644
--- a/src/corelib/animation/qsequentialanimationgroup.cpp
+++ b/src/corelib/animation/qsequentialanimationgroup.cpp
@@ -50,7 +50,7 @@
     another has finished playing. The animations are played in the
     order they are added to the group (using
     \l{QAnimationGroup::}{addAnimation()} or
-    \l{QAnimationGroup::}{insertAnimationAt()}). The animation group
+    \l{QAnimationGroup::}{insertAnimation()}). The animation group
     finishes when its last animation has finished.
 
     At each moment there is at most one animation that is active in
@@ -59,7 +59,7 @@
 
     A sequential animation group can be treated as any other
     animation, i.e., it can be started, stopped, and added to other
-    groups. You can also call addPause() or insertPauseAt() to add a
+    groups. You can also call addPause() or insertPause() to add a
     pause to a sequential animation group.
 
     \code
@@ -269,7 +269,7 @@ QSequentialAnimationGroup::~QSequentialAnimationGroup()
     \l{QAnimationGroup::animationCount()}{animationCount} will be 
     increased by one.
 
-    \sa insertPauseAt(), QAnimationGroup::addAnimation()
+    \sa insertPause(), QAnimationGroup::addAnimation()
 */
 QPauseAnimation *QSequentialAnimationGroup::addPause(int msecs)
 {
@@ -282,19 +282,19 @@ QPauseAnimation *QSequentialAnimationGroup::addPause(int msecs)
     Inserts a pause of \a msecs milliseconds at \a index in this animation
     group.
 
-    \sa addPause(), QAnimationGroup::insertAnimationAt()
+    \sa addPause(), QAnimationGroup::insertAnimation()
 */
-QPauseAnimation *QSequentialAnimationGroup::insertPauseAt(int index, int msecs)
+QPauseAnimation *QSequentialAnimationGroup::insertPause(int index, int msecs)
 {
     Q_D(const QSequentialAnimationGroup);
 
     if (index < 0 || index > d->animations.size()) {
-        qWarning("QSequentialAnimationGroup::insertPauseAt: index is out of bounds");
+        qWarning("QSequentialAnimationGroup::insertPause: index is out of bounds");
         return 0;
     }
 
     QPauseAnimation *pause = new QPauseAnimation(msecs);
-    insertAnimationAt(index, pause);
+    insertAnimation(index, pause);
     return pause;
 }
 
@@ -382,11 +382,11 @@ void QSequentialAnimationGroup::updateCurrentTime(int currentTime)
 /*!
     \reimp
 */
-void QSequentialAnimationGroup::updateState(QAbstractAnimation::State oldState,
-                                            QAbstractAnimation::State newState)
+void QSequentialAnimationGroup::updateState(QAbstractAnimation::State newState,
+                                            QAbstractAnimation::State oldState)
 {
     Q_D(QSequentialAnimationGroup);
-    QAnimationGroup::updateState(oldState, newState);
+    QAnimationGroup::updateState(newState, oldState);
 
     if (!d->currentAnimation)
         return;
@@ -532,7 +532,7 @@ void QSequentialAnimationGroupPrivate::animationInsertedAt(int index)
     currentAnimationIndex = animations.indexOf(currentAnimation);
 
     if (index < currentAnimationIndex || currentLoop != 0) {
-        qWarning("QSequentialGroup::insertAnimationAt only supports to add animations after the current one.");
+        qWarning("QSequentialGroup::insertAnimation only supports to add animations after the current one.");
         return; //we're not affected because it is added after the current one
     }
 }
diff --git a/src/corelib/animation/qsequentialanimationgroup.h b/src/corelib/animation/qsequentialanimationgroup.h
index f30f851..97e7e01 100644
--- a/src/corelib/animation/qsequentialanimationgroup.h
+++ b/src/corelib/animation/qsequentialanimationgroup.h
@@ -65,7 +65,7 @@ public:
     ~QSequentialAnimationGroup();
 
     QPauseAnimation *addPause(int msecs);
-    QPauseAnimation *insertPauseAt(int index, int msecs);
+    QPauseAnimation *insertPause(int index, int msecs);
 
     QAbstractAnimation *currentAnimation() const;
     int duration() const;
@@ -78,7 +78,7 @@ protected:
     bool event(QEvent *event);
 
     void updateCurrentTime(int);
-    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
     void updateDirection(QAbstractAnimation::Direction direction);
 
 private:
diff --git a/src/corelib/animation/qvariantanimation.cpp b/src/corelib/animation/qvariantanimation.cpp
index de8185b..c735778 100644
--- a/src/corelib/animation/qvariantanimation.cpp
+++ b/src/corelib/animation/qvariantanimation.cpp
@@ -621,8 +621,8 @@ bool QVariantAnimation::event(QEvent *event)
 /*!
     \reimp
 */
-void QVariantAnimation::updateState(QAbstractAnimation::State oldState,
-                                    QAbstractAnimation::State newState)
+void QVariantAnimation::updateState(QAbstractAnimation::State newState,
+                                    QAbstractAnimation::State oldState)
 {
     Q_UNUSED(oldState);
     Q_UNUSED(newState);
diff --git a/src/corelib/animation/qvariantanimation.h b/src/corelib/animation/qvariantanimation.h
index bc57b1c..89d9b34 100644
--- a/src/corelib/animation/qvariantanimation.h
+++ b/src/corelib/animation/qvariantanimation.h
@@ -103,7 +103,7 @@ protected:
     bool event(QEvent *event);
 
     void updateCurrentTime(int);
-    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
 
     virtual void updateCurrentValue(const QVariant &value) = 0;
     virtual QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const;
diff --git a/src/gui/itemviews/qtreeview_p.h b/src/gui/itemviews/qtreeview_p.h
index aad5837..d58dea3 100644
--- a/src/gui/itemviews/qtreeview_p.h
+++ b/src/gui/itemviews/qtreeview_p.h
@@ -105,7 +105,7 @@ public:
         int top() const { return startValue().toInt(); }
         QRect rect() const { QRect rect = viewport->rect(); rect.moveTop(top()); return rect; }
         void updateCurrentValue(const QVariant &) { viewport->update(rect()); }
-        void updateState(State, State state) { if (state == Stopped) before = after = QPixmap(); }
+        void updateState(State state, State) { if (state == Stopped) before = after = QPixmap(); }
     } animatedOperation;
     void prepareAnimatedOperation(int item, QVariantAnimation::Direction d);
     void beginAnimatedOperation();
diff --git a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
index 8d937e9..a26e0eb 100644
--- a/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
+++ b/tests/auto/qparallelanimationgroup/tst_qparallelanimationgroup.cpp
@@ -119,8 +119,8 @@ class TestAnimation : public QVariantAnimation
     Q_OBJECT
 public:
     virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
-    virtual void updateState(QAbstractAnimation::State oldState,
-                             QAbstractAnimation::State newState)
+    virtual void updateState(QAbstractAnimation::State newState,
+                             QAbstractAnimation::State oldState)
     {
         Q_UNUSED(oldState)
         Q_UNUSED(newState)
@@ -135,8 +135,8 @@ public:
     TestAnimation2(int duration, QAbstractAnimation *animation) : QVariantAnimation(animation), m_duration(duration) {}
 
     virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
-    virtual void updateState(QAbstractAnimation::State oldState,
-                             QAbstractAnimation::State newState)
+    virtual void updateState(QAbstractAnimation::State newState,
+                             QAbstractAnimation::State oldState)
     {
         Q_UNUSED(oldState)
         Q_UNUSED(newState)
@@ -223,33 +223,33 @@ void tst_QParallelAnimationGroup::setCurrentTime()
     QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
     QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(a1_p_o1->currentTime(), 1);
-    QCOMPARE(a1_p_o2->currentTime(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 1);
-    QCOMPARE(notTimeDriven->currentTime(), 1);
-    QCOMPARE(loopsForever->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 1);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 1);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 1);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 1);
+    QCOMPARE(loopsForever->currentLoopTime(), 1);
 
     // Current time = 250
     group.setCurrentTime(250);
-    QCOMPARE(group.currentTime(), 250);
-    QCOMPARE(a1_p_o1->currentTime(), 250);
-    QCOMPARE(a1_p_o2->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 250);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 0);
     QCOMPARE(a1_p_o2->currentLoop(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 250);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 250);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(loopsForever->currentLoop(), 1);
 
     // Current time = 251
     group.setCurrentTime(251);
-    QCOMPARE(group.currentTime(), 251);
-    QCOMPARE(a1_p_o1->currentTime(), 250);
-    QCOMPARE(a1_p_o2->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 251);
+    QCOMPARE(a1_p_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_p_o2->currentLoopTime(), 1);
     QCOMPARE(a1_p_o2->currentLoop(), 1);
-    QCOMPARE(a1_p_o3->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 251);
-    QCOMPARE(loopsForever->currentTime(), 1);
+    QCOMPARE(a1_p_o3->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 251);
+    QCOMPARE(loopsForever->currentLoopTime(), 1);
 }
 
 void tst_QParallelAnimationGroup::stateChanged()
@@ -278,18 +278,18 @@ void tst_QParallelAnimationGroup::stateChanged()
     group.start();
     //all the animations should be started
     QCOMPARE(spy1.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Running);
     QCOMPARE(spy2.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Running);
     QCOMPARE(spy3.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Running);
     QCOMPARE(spy4.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Running);
 
     group.setCurrentTime(1500); //anim1 should be finished
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(spy1.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy2.count(), 1); //no change
     QCOMPARE(spy3.count(), 1); //no change
     QCOMPARE(spy4.count(), 1); //no change
@@ -298,7 +298,7 @@ void tst_QParallelAnimationGroup::stateChanged()
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(spy1.count(), 2); //no change
     QCOMPARE(spy2.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy3.count(), 1); //no change
     QCOMPARE(spy4.count(), 1); //no change
 
@@ -307,9 +307,9 @@ void tst_QParallelAnimationGroup::stateChanged()
     QCOMPARE(spy1.count(), 2); //no change
     QCOMPARE(spy2.count(), 2); //no change
     QCOMPARE(spy3.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy4.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
 
     //cleanup
     spy1.clear();
@@ -326,22 +326,22 @@ void tst_QParallelAnimationGroup::stateChanged()
     QCOMPARE(spy1.count(), 0);
     QCOMPARE(spy2.count(), 0);
     QCOMPARE(spy3.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Running);
     QCOMPARE(spy4.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Running);
 
     group.setCurrentTime(1500); //anim2 should be started
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(spy1.count(), 0); //no change
     QCOMPARE(spy2.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Running);
     QCOMPARE(spy3.count(), 1); //no change
     QCOMPARE(spy4.count(), 1); //no change
 
     group.setCurrentTime(500); //anim1 is finally also started
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(spy1.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Running);
     QCOMPARE(spy2.count(), 1); //no change
     QCOMPARE(spy3.count(), 1); //no change
     QCOMPARE(spy4.count(), 1); //no change
@@ -349,13 +349,13 @@ void tst_QParallelAnimationGroup::stateChanged()
     group.setCurrentTime(0); //everything should be stopped
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
     QCOMPARE(spy1.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy1.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy2.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy2.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy3.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy3.last().first()), TestAnimation::Stopped);
     QCOMPARE(spy4.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy4.last().first()), TestAnimation::Stopped);
 }
 
 void tst_QParallelAnimationGroup::clearGroup()
@@ -375,9 +375,9 @@ void tst_QParallelAnimationGroup::clearGroup()
         children[i] = group.animationAt(i);
     }
 
-    group.clearAnimations();
+    group.clear();
     QCOMPARE(group.animationCount(), 0);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     for (int i = 0; i < animationCount; ++i)
         QVERIFY(children[i].isNull());
 }
@@ -460,9 +460,9 @@ void tst_QParallelAnimationGroup::updateChildrenWithRunningGroup()
     QCOMPARE(groupStateChangedSpy.count(), 1);
     QCOMPARE(childStateChangedSpy.count(), 1);
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
 
     // starting directly a running child will not have any effect
@@ -501,13 +501,13 @@ void tst_QParallelAnimationGroup::deleteChildrenWithRunningGroup()
     QCOMPARE(anim1->state(), QAnimationGroup::Running);
 
     QTest::qWait(80);
-    QVERIFY(group.currentTime() > 0);
+    QVERIFY(group.currentLoopTime() > 0);
 
     delete anim1;
     QVERIFY(group.animationCount() == 0);
     QCOMPARE(group.duration(), 0);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
-    QCOMPARE(group.currentTime(), 0); //that's the invariant
+    QCOMPARE(group.currentLoopTime(), 0); //that's the invariant
 }
 
 void tst_QParallelAnimationGroup::startChildrenWithStoppedGroup()
@@ -622,11 +622,11 @@ void tst_QParallelAnimationGroup::startGroupWithRunningChild()
     anim2.start();
     anim2.pause();
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(1).first()),
              QAnimationGroup::Paused);
 
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
@@ -636,15 +636,15 @@ void tst_QParallelAnimationGroup::startGroupWithRunningChild()
     group.start();
 
     QCOMPARE(stateChangedSpy1.count(), 3);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
              QAnimationGroup::Stopped);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(2).first()),
              QAnimationGroup::Running);
 
     QCOMPARE(stateChangedSpy2.count(), 4);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
              QAnimationGroup::Stopped);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
              QAnimationGroup::Running);
 
     QCOMPARE(group.state(), QAnimationGroup::Running);
@@ -687,19 +687,19 @@ void tst_QParallelAnimationGroup::zeroDurationAnimation()
     group.start();
     QCOMPARE(stateChangedSpy1.count(), 2);
     QCOMPARE(finishedSpy1.count(), 1);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(stateChangedSpy2.count(), 1);
     QCOMPARE(finishedSpy2.count(), 0);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy1.at(0).first()),
              QAnimationGroup::Running);
 
     QCOMPARE(stateChangedSpy3.count(), 1);
     QCOMPARE(finishedSpy3.count(), 0);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy3.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy3.at(0).first()),
              QAnimationGroup::Running);
 
 
@@ -762,9 +762,9 @@ void tst_QParallelAnimationGroup::stopUncontrolledAnimations()
     group.start();
 
     QCOMPARE(stateChangedSpy.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(group.state(), QAnimationGroup::Running);
@@ -915,9 +915,9 @@ void tst_QParallelAnimationGroup::loopCount()
 
     group.setCurrentTime(currentGroupTime);
 
-    QCOMPARE(anim1.currentTime(), expected1.time);
-    QCOMPARE(anim2.currentTime(), expected2.time);
-    QCOMPARE(anim3.currentTime(), expected3.time);
+    QCOMPARE(anim1.currentLoopTime(), expected1.time);
+    QCOMPARE(anim2.currentLoopTime(), expected2.time);
+    QCOMPARE(anim3.currentLoopTime(), expected3.time);
 
     if (expected1.state >=0)
         QCOMPARE(int(anim1.state()), expected1.state);
@@ -968,22 +968,22 @@ void tst_QParallelAnimationGroup::pauseResume()
     QCOMPARE(anim->state(), QAnimationGroup::Running);
     QCOMPARE(spy.count(), 1);
     spy.clear();
-    const int currentTime = group.currentTime();
-    QCOMPARE(anim->currentTime(), currentTime);
+    const int currentTime = group.currentLoopTime();
+    QCOMPARE(anim->currentLoopTime(), currentTime);
 
     group.pause();
     QCOMPARE(group.state(), QAnimationGroup::Paused);
-    QCOMPARE(group.currentTime(), currentTime);
+    QCOMPARE(group.currentLoopTime(), currentTime);
     QCOMPARE(anim->state(), QAnimationGroup::Paused);
-    QCOMPARE(anim->currentTime(), currentTime);
+    QCOMPARE(anim->currentLoopTime(), currentTime);
     QCOMPARE(spy.count(), 1);
     spy.clear();
 
     group.resume();
     QCOMPARE(group.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentTime(), currentTime);
+    QCOMPARE(group.currentLoopTime(), currentTime);
     QCOMPARE(anim->state(), QAnimationGroup::Running);
-    QCOMPARE(anim->currentTime(), currentTime);
+    QCOMPARE(anim->currentLoopTime(), currentTime);
     QCOMPARE(spy.count(), 1);
 
     group.stop();
@@ -991,10 +991,10 @@ void tst_QParallelAnimationGroup::pauseResume()
     new TestAnimation2(500, &group);
     group.start();
     QCOMPARE(spy.count(), 1); //the animation should have been started
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().at(1)), TestAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().first()), TestAnimation::Running);
     group.setCurrentTime(250); //end of first animation
     QCOMPARE(spy.count(), 2); //the animation should have been stopped
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().at(1)), TestAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(spy.last().first()), TestAnimation::Stopped);
     group.pause();
     QCOMPARE(spy.count(), 2); //this shouldn't have changed
     group.resume();
diff --git a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
index 56c1ced..f41fff1 100644
--- a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
+++ b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
@@ -225,7 +225,7 @@ void tst_QPropertyAnimation::setCurrentTime()
     animation.setLoopCount(loopCount);
     animation.setCurrentTime(currentTime);
 
-    QCOMPARE(animation.currentTime(), testCurrentTime);
+    QCOMPARE(animation.currentLoopTime(), testCurrentTime);
     QCOMPARE(animation.currentLoop(), testCurrentLoop);
 }
 
@@ -280,7 +280,7 @@ void tst_QPropertyAnimation::statesAndSignals()
     QCOMPARE(anim->state(), QAnimationGroup::Stopped);
     QCOMPARE(runningSpy.count(), 1); //anim must have stopped
     QCOMPARE(finishedSpy.count(), 0);
-    QCOMPARE(anim->currentTime(), 0);
+    QCOMPARE(anim->currentLoopTime(), 0);
     QCOMPARE(anim->currentLoop(), 0);
     QCOMPARE(currentLoopSpy.count(), 2);
     runningSpy.clear();
@@ -291,7 +291,7 @@ void tst_QPropertyAnimation::statesAndSignals()
     QCOMPARE(runningSpy.count(), 2); //started and stopped again
     runningSpy.clear();
     QCOMPARE(finishedSpy.count(), 1);
-    QCOMPARE(anim->currentTime(), 100);
+    QCOMPARE(anim->currentLoopTime(), 100);
     QCOMPARE(anim->currentLoop(), 2);
     QCOMPARE(currentLoopSpy.count(), 4);
 
@@ -312,7 +312,7 @@ void tst_QPropertyAnimation::statesAndSignals()
     QCOMPARE(anim->currentLoop(), 2);
     QCOMPARE(runningSpy.count(), 1); // anim has stopped
     QCOMPARE(finishedSpy.count(), 2);
-    QCOMPARE(anim->currentTime(), 100);
+    QCOMPARE(anim->currentLoopTime(), 100);
 
     delete anim;
 }
@@ -864,16 +864,16 @@ void tst_QPropertyAnimation::zeroDurationStart()
     //let's check the first state change
     const QVariantList firstChange = spy.first();
     //old state
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.first()), QAbstractAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Stopped);
     //new state
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.first()), QAbstractAnimation::Running);
 
     //let's check the first state change
     const QVariantList secondChange = spy.last();
     //old state
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Running);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Running);
     //new state
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Stopped);
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Stopped);
 }
 
 #define Pause 1
@@ -1171,9 +1171,9 @@ public:
         innerAnim->start();
     }
 
-    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState)
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
     {
-        QPropertyAnimation::updateState(oldState, newState);
+        QPropertyAnimation::updateState(newState, oldState);
         if (newState == QAbstractAnimation::Stopped)
             delete innerAnim;
     }
diff --git a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
index f6afc5b..28fccac 100644
--- a/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
+++ b/tests/auto/qsequentialanimationgroup/tst_qsequentialanimationgroup.cpp
@@ -87,7 +87,7 @@ private slots:
     void currentAnimation();
     void currentAnimationWithZeroDuration();
     void insertAnimation();
-    void clearAnimations();
+    void clear();
     void pauseResume();
 };
 
@@ -134,8 +134,8 @@ class TestAnimation : public QVariantAnimation
     Q_OBJECT
 public:
     virtual void updateCurrentValue(const QVariant &value) { Q_UNUSED(value)};
-    virtual void updateState(QAbstractAnimation::State oldState,
-                             QAbstractAnimation::State newState)
+    virtual void updateState(QAbstractAnimation::State newState,
+                             QAbstractAnimation::State oldState)
     {
         Q_UNUSED(oldState)
         Q_UNUSED(newState)
@@ -208,119 +208,119 @@ void tst_QSequentialAnimationGroup::setCurrentTime()
     QCOMPARE(sequence2->state(), QAnimationGroup::Stopped);
     QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 250
     group.setCurrentTime(250);
-    QCOMPARE(group.currentTime(), 250);
-    QCOMPARE(sequence->currentTime(), 250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 250);
+    QCOMPARE(sequence->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 251
     group.setCurrentTime(251);
-    QCOMPARE(group.currentTime(), 251);
-    QCOMPARE(sequence->currentTime(), 251);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 251);
+    QCOMPARE(sequence->currentLoopTime(), 251);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 1);
     QCOMPARE(a2_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 750
     group.setCurrentTime(750);
-    QCOMPARE(group.currentTime(), 750);
-    QCOMPARE(sequence->currentTime(), 750);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 750);
+    QCOMPARE(sequence->currentLoopTime(), 750);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1000
     group.setCurrentTime(1000);
-    QCOMPARE(group.currentTime(), 1000);
-    QCOMPARE(sequence->currentTime(), 1000);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1000);
+    QCOMPARE(sequence->currentLoopTime(), 1000);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1010
     group.setCurrentTime(1010);
-    QCOMPARE(group.currentTime(), 1010);
-    QCOMPARE(sequence->currentTime(), 1010);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1010);
+    QCOMPARE(sequence->currentLoopTime(), 1010);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 10);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 10);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1250
     group.setCurrentTime(1250);
-    QCOMPARE(group.currentTime(), 1250);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1250);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1500
     group.setCurrentTime(1500);
-    QCOMPARE(group.currentTime(), 1500);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1500);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1750
     group.setCurrentTime(1750);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 500);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 250);
 
     // Current time = 2000
     group.setCurrentTime(2000);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 500);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 250);
 }
 
 void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
@@ -357,40 +357,40 @@ void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
     QCOMPARE(notTimeDriven->state(), QAnimationGroup::Stopped);
     QCOMPARE(loopsForever->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(notTimeDriven->currentTime(), 0);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 0);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
 
     // Current time = 250
     group.setCurrentTime(250);
-    QCOMPARE(group.currentTime(), 250);
-    QCOMPARE(sequence->currentTime(), 250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(notTimeDriven->currentTime(), 0);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 250);
+    QCOMPARE(sequence->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 0);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
 
     // Current time = 500
     group.setCurrentTime(500);
-    QCOMPARE(group.currentTime(), 500);
-    QCOMPARE(sequence->currentTime(), 500);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 0);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 500);
+    QCOMPARE(sequence->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 0);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), notTimeDriven);
 
     // Current time = 505
     group.setCurrentTime(505);
-    QCOMPARE(group.currentTime(), 505);
-    QCOMPARE(sequence->currentTime(), 500);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 5);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 505);
+    QCOMPARE(sequence->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 5);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), notTimeDriven);
     QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
     QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
@@ -400,12 +400,12 @@ void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
 
     // Current time = 750 (end of notTimeDriven animation)
     group.setCurrentTime(750);
-    QCOMPARE(group.currentTime(), 750);
-    QCOMPARE(sequence->currentTime(), 500);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 250);
-    QCOMPARE(loopsForever->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 750);
+    QCOMPARE(sequence->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 250);
+    QCOMPARE(loopsForever->currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), loopsForever);
     QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
     QCOMPARE(a1_s_o1->state(), QAnimationGroup::Stopped);
@@ -415,13 +415,13 @@ void tst_QSequentialAnimationGroup::setCurrentTimeWithUncontrolledAnimation()
 
     // Current time = 800 (as notTimeDriven was finished at 750, loopsforever should still run)
     group.setCurrentTime(800);
-    QCOMPARE(group.currentTime(), 800);
+    QCOMPARE(group.currentLoopTime(), 800);
     QCOMPARE(group.currentAnimation(), loopsForever);
-    QCOMPARE(sequence->currentTime(), 500);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(notTimeDriven->currentTime(), 250);
-    QCOMPARE(loopsForever->currentTime(), 50);
+    QCOMPARE(sequence->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(notTimeDriven->currentLoopTime(), 250);
+    QCOMPARE(loopsForever->currentLoopTime(), 50);
 
     loopsForever->stop(); // this should stop the group
 
@@ -466,26 +466,26 @@ void tst_QSequentialAnimationGroup::seekingForwards()
     QCOMPARE(a1_s_o2->state(), QAnimationGroup::Stopped);
     QCOMPARE(a1_s_o3->state(), QAnimationGroup::Stopped);
 
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // Current time = 1500
     group.setCurrentTime(1500);
-    QCOMPARE(group.currentTime(), 1500);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1500);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 250);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     // this will restart the group
     group.start();
@@ -499,15 +499,15 @@ void tst_QSequentialAnimationGroup::seekingForwards()
 
     // Current time = 1750
     group.setCurrentTime(1750);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 500);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 250);
 }
 
 void tst_QSequentialAnimationGroup::seekingBackwards()
@@ -537,15 +537,15 @@ void tst_QSequentialAnimationGroup::seekingBackwards()
 
     // Current time = 1600
     group.setCurrentTime(1600);
-    QCOMPARE(group.currentTime(), 1600);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1600);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 350);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 100);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 350);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 100);
 
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
@@ -556,22 +556,22 @@ void tst_QSequentialAnimationGroup::seekingBackwards()
 
     // Seeking backwards, current time = 1
     group.setCurrentTime(1);
-    QCOMPARE(group.currentTime(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
 
     QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
         "hence they don't reset from their current animation", Continue);
-    QCOMPARE(a2_s_o1->currentTime(), 0);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 0);
     QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
         "hence they don't reset from their current animation", Continue);
     QCOMPARE(a2_s_o1->currentLoop(), 0);
     QEXPECT_FAIL("", "rewinding in nested groups is considered as a restart from the children,"
         "hence they don't reset from their current animation", Continue);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
-    QCOMPARE(sequence2->currentTime(), 0);
-    QCOMPARE(a1_s_o2->currentTime(), 0);
-    QCOMPARE(a1_s_o3->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
+    QCOMPARE(sequence2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 0);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 0);
 
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(sequence->state(), QAnimationGroup::Running);
@@ -582,15 +582,15 @@ void tst_QSequentialAnimationGroup::seekingBackwards()
 
     // Current time = 2000
     group.setCurrentTime(2000);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 1250);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 1250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 2);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
-    QCOMPARE(sequence2->currentTime(), 500);
-    QCOMPARE(a1_s_o2->currentTime(), 250);
-    QCOMPARE(a1_s_o3->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
+    QCOMPARE(sequence2->currentLoopTime(), 500);
+    QCOMPARE(a1_s_o2->currentLoopTime(), 250);
+    QCOMPARE(a1_s_o3->currentLoopTime(), 250);
 
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
     QCOMPARE(sequence->state(), QAnimationGroup::Stopped);
@@ -612,7 +612,7 @@ static bool compareStates(const QSignalSpy& spy, const StateList &expectedStates
         }
         QList<QVariant> args = spy.at(i);
         QAbstractAnimation::State st = expectedStates.at(i);
-        QAbstractAnimation::State actual = qVariantValue<QAbstractAnimation::State>(args.value(1));
+        QAbstractAnimation::State actual = qVariantValue<QAbstractAnimation::State>(args.first());
         if (equals && actual != st) {
             equals = false;
             break;
@@ -672,14 +672,14 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
 
     // Current time = 1751
     group.setCurrentTime(1751);
-    QCOMPARE(group.currentTime(), 1751);
-    QCOMPARE(sequence->currentTime(), 751);
+    QCOMPARE(group.currentLoopTime(), 1751);
+    QCOMPARE(sequence->currentLoopTime(), 751);
     QCOMPARE(sequence->currentLoop(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 1);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 1);
 
     QCOMPARE(group.state(), QAnimationGroup::Paused);
     QCOMPARE(sequence->state(), QAnimationGroup::Paused);
@@ -696,20 +696,20 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
                                               << QAbstractAnimation::Running
                                               << QAbstractAnimation::Stopped)));
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(1).first()),
              QAnimationGroup::Paused);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(2).first()),
              QAnimationGroup::Stopped);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(3).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(4).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(a1StateChangedSpy.at(4).first()),
              QAnimationGroup::Stopped);
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
              QAnimationGroup::Paused);
 
     group.resume();
@@ -720,17 +720,17 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
     QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
     QCOMPARE(a3_s_o1->state(), QAnimationGroup::Running);
 
-    QVERIFY(group.currentTime() >= 1751);
-    QVERIFY(sequence->currentTime() >= 751);
+    QVERIFY(group.currentLoopTime() >= 1751);
+    QVERIFY(sequence->currentLoopTime() >= 751);
     QCOMPARE(sequence->currentLoop(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QVERIFY(a3_s_o1->currentTime() >= 1);
+    QVERIFY(a3_s_o1->currentLoopTime() >= 1);
 
     QCOMPARE(seqStateChangedSpy.count(), 3);    // Running,Paused,Running
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(2).first()),
              QAnimationGroup::Running);
 
     group.pause();
@@ -741,23 +741,23 @@ void tst_QSequentialAnimationGroup::pauseAndResume()
     QCOMPARE(a2_s_o1->state(), QAnimationGroup::Stopped);
     QCOMPARE(a3_s_o1->state(), QAnimationGroup::Paused);
 
-    QVERIFY(group.currentTime() >= 1751);
-    QVERIFY(sequence->currentTime() >= 751);
+    QVERIFY(group.currentLoopTime() >= 1751);
+    QVERIFY(sequence->currentLoopTime() >= 751);
     QCOMPARE(sequence->currentLoop(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QVERIFY(a3_s_o1->currentTime() >= 1);
+    QVERIFY(a3_s_o1->currentLoopTime() >= 1);
 
     QCOMPARE(seqStateChangedSpy.count(), 4);    // Running,Paused,Running,Paused
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(3).first()),
              QAnimationGroup::Paused);
 
     group.stop();
 
     QCOMPARE(seqStateChangedSpy.count(), 5);    // Running,Paused,Running,Paused,Stopped
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(4).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(4).first()),
              QAnimationGroup::Stopped);
 }
 
@@ -797,20 +797,20 @@ void tst_QSequentialAnimationGroup::restart()
 
     for (int i = 0; i < 3; i++) {
         QCOMPARE(animsStateChanged[i]->count(), 4);
-        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(0).at(1)),
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(0).first()),
                  QAnimationGroup::Running);
-        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(1).at(1)),
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(1).first()),
                  QAnimationGroup::Stopped);
-        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(2).at(1)),
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(2).first()),
                  QAnimationGroup::Running);
-        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(3).at(1)),
+        QCOMPARE(qVariantValue<QAbstractAnimation::State>(animsStateChanged[i]->at(3).first()),
                  QAnimationGroup::Stopped);
     }
 
     QCOMPARE(seqStateChangedSpy.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(seqStateChangedSpy.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(seqCurrentAnimChangedSpy.count(), 6);
@@ -855,15 +855,15 @@ void tst_QSequentialAnimationGroup::looping()
 
     // Current time = 1750
     group.setCurrentTime(1750);
-    QCOMPARE(group.currentTime(), 1750);
-    QCOMPARE(sequence->currentTime(), 750);
+    QCOMPARE(group.currentLoopTime(), 1750);
+    QCOMPARE(sequence->currentLoopTime(), 750);
     QCOMPARE(sequence->currentLoop(), 1);
-    QCOMPARE(a1_s_o1->currentTime(), 250);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 250);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     // this animation is at the beginning because it is the current one inside sequence
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 0);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 0);
     QCOMPARE(sequence->currentAnimation(), a3_s_o1);
 
     QCOMPARE(group.state(), QAnimationGroup::Paused);
@@ -890,16 +890,16 @@ void tst_QSequentialAnimationGroup::looping()
 
     // Looping, current time = duration + 1
     group.setCurrentTime(group.duration() + 1);
-    QCOMPARE(group.currentTime(), 1);
+    QCOMPARE(group.currentLoopTime(), 1);
     QCOMPARE(group.currentLoop(), 1);
-    QCOMPARE(sequence->currentTime(), 1);
+    QCOMPARE(sequence->currentLoopTime(), 1);
     QCOMPARE(sequence->currentLoop(), 0);
-    QCOMPARE(a1_s_o1->currentTime(), 1);
-    QCOMPARE(a2_s_o1->currentTime(), 250);
+    QCOMPARE(a1_s_o1->currentLoopTime(), 1);
+    QCOMPARE(a2_s_o1->currentLoopTime(), 250);
     QCOMPARE(a2_s_o1->currentLoop(), 1);
     // this animation is at the end because it was run on the previous loop
     QCOMPARE(a3_s_o1->currentLoop(), 0);
-    QCOMPARE(a3_s_o1->currentTime(), 250);
+    QCOMPARE(a3_s_o1->currentLoopTime(), 250);
 
     QCOMPARE(group.state(), QAnimationGroup::Paused);
     QCOMPARE(sequence->state(), QAnimationGroup::Paused);
@@ -934,7 +934,7 @@ void tst_QSequentialAnimationGroup::startDelay()
 
     QTest::qWait(500);
 
-    QVERIFY(group.currentTime() == 375);
+    QVERIFY(group.currentLoopTime() == 375);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
 }
 
@@ -958,9 +958,9 @@ void tst_QSequentialAnimationGroup::clearGroup()
         children[i] = group.animationAt(i);
     }
 
-    group.clearAnimations();
+    group.clear();
     QCOMPARE(group.animationCount(), 0);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     for (int i = 0; i < animationCount; ++i)
         QVERIFY(children[i].isNull());
 }
@@ -1130,9 +1130,9 @@ void tst_QSequentialAnimationGroup::updateChildrenWithRunningGroup()
     QCOMPARE(groupStateChangedSpy.count(), 1);
     QCOMPARE(childStateChangedSpy.count(), 1);
 
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(groupStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(childStateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
 
     // starting directly a running child will not have any effect
@@ -1171,13 +1171,13 @@ void tst_QSequentialAnimationGroup::deleteChildrenWithRunningGroup()
     QCOMPARE(anim1->state(), QAnimationGroup::Running);
 
     QTest::qWait(100);
-    QVERIFY(group.currentTime() > 0);
+    QVERIFY(group.currentLoopTime() > 0);
 
     delete anim1;
     QCOMPARE(group.animationCount(), 0);
     QCOMPARE(group.duration(), 0);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
-    QCOMPARE(group.currentTime(), 0); //that's the invariant
+    QCOMPARE(group.currentLoopTime(), 0); //that's the invariant
 }
 
 void tst_QSequentialAnimationGroup::startChildrenWithStoppedGroup()
@@ -1320,9 +1320,9 @@ void tst_QSequentialAnimationGroup::startGroupWithRunningChild()
     QCOMPARE(anim2->state(), QAnimationGroup::Running);
 
     QCOMPARE(stateChangedSpy2.count(), 4);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(2).first()),
              QAnimationGroup::Stopped);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy2.at(3).first()),
              QAnimationGroup::Running);
 
     group.stop();
@@ -1359,9 +1359,9 @@ void tst_QSequentialAnimationGroup::zeroDurationAnimation()
     group.start();
 
     QCOMPARE(stateChangedSpy.count(), 2);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(0).first()),
              QAnimationGroup::Running);
-    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).at(1)),
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(stateChangedSpy.at(1).first()),
              QAnimationGroup::Stopped);
 
     QCOMPARE(anim1->state(), QAnimationGroup::Stopped);
@@ -1426,14 +1426,14 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
     group.start();
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(notTimeDriven.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentTime(), 0);
-    QCOMPARE(notTimeDriven.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
+    QCOMPARE(notTimeDriven.currentLoopTime(), 0);
 
     QTest::qWait(300); //wait for the end of notTimeDriven
     QCOMPARE(notTimeDriven.state(), QAnimationGroup::Stopped);
-    const int actualDuration = notTimeDriven.currentTime();
+    const int actualDuration = notTimeDriven.currentLoopTime();
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
-    QCOMPARE(group.currentTime(), actualDuration);
+    QCOMPARE(group.currentLoopTime(), actualDuration);
     QCOMPARE(spy.count(), 1);
 
     //2nd case:
@@ -1444,7 +1444,7 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
 
     group.setCurrentTime(300);
     QCOMPARE(group.state(), QAnimationGroup::Stopped);
-    QCOMPARE(notTimeDriven.currentTime(), actualDuration);
+    QCOMPARE(notTimeDriven.currentLoopTime(), actualDuration);
     QCOMPARE(group.currentAnimation(), static_cast<QAbstractAnimation*>(&anim));
 
     //3rd case:
@@ -1453,8 +1453,8 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
     group.start();
     QCOMPARE(group.state(), QAnimationGroup::Running);
     QCOMPARE(notTimeDriven.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentTime(), 0);
-    QCOMPARE(notTimeDriven.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
+    QCOMPARE(notTimeDriven.currentLoopTime(), 0);
 
     QCOMPARE(animStateChangedSpy.count(), 0);
 
@@ -1467,12 +1467,12 @@ void tst_QSequentialAnimationGroup::finishWithUncontrolledAnimation()
     QTest::qWait(300); //wait for the end of anim
 
     QCOMPARE(anim.state(), QAnimationGroup::Stopped);
-    QCOMPARE(anim.currentTime(), anim.duration());
+    QCOMPARE(anim.currentLoopTime(), anim.duration());
 
     //we should simply be at the end
     QCOMPARE(spy.count(), 1);
     QCOMPARE(animStateChangedSpy.count(), 2);
-    QCOMPARE(group.currentTime(), notTimeDriven.currentTime() + anim.currentTime());
+    QCOMPARE(group.currentLoopTime(), notTimeDriven.currentLoopTime() + anim.currentLoopTime());
 }
 
 void tst_QSequentialAnimationGroup::addRemoveAnimation()
@@ -1481,48 +1481,48 @@ void tst_QSequentialAnimationGroup::addRemoveAnimation()
     QSequentialAnimationGroup group;
 
     QCOMPARE(group.duration(), 0);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     QAbstractAnimation *anim1 = new QPropertyAnimation;
     group.addAnimation(anim1);
     QCOMPARE(group.duration(), 250);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), anim1);
 
     //let's append an animation
     QAbstractAnimation *anim2 = new QPropertyAnimation;
     group.addAnimation(anim2);
     QCOMPARE(group.duration(), 500);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), anim1);
 
     //let's prepend an animation
     QAbstractAnimation *anim0 = new QPropertyAnimation;
-    group.insertAnimationAt(0, anim0);
+    group.insertAnimation(0, anim0);
     QCOMPARE(group.duration(), 750);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
     QCOMPARE(group.currentAnimation(), anim0); //anim0 has become the new currentAnimation
 
     group.setCurrentTime(300); //anim0 | anim1 | anim2
-    QCOMPARE(group.currentTime(), 300);
+    QCOMPARE(group.currentLoopTime(), 300);
     QCOMPARE(group.currentAnimation(), anim1);
-    QCOMPARE(anim1->currentTime(), 50);
+    QCOMPARE(anim1->currentLoopTime(), 50);
 
     group.removeAnimation(anim0); //anim1 | anim2
-    QCOMPARE(group.currentTime(), 50);
+    QCOMPARE(group.currentLoopTime(), 50);
     QCOMPARE(group.currentAnimation(), anim1);
-    QCOMPARE(anim1->currentTime(), 50);
+    QCOMPARE(anim1->currentLoopTime(), 50);
 
     group.setCurrentTime(0);
-    group.insertAnimationAt(0, anim0); //anim0 | anim1 | anim2
+    group.insertAnimation(0, anim0); //anim0 | anim1 | anim2
     group.setCurrentTime(300);
-    QCOMPARE(group.currentTime(), 300);
+    QCOMPARE(group.currentLoopTime(), 300);
     QCOMPARE(group.currentAnimation(), anim1);
-    QCOMPARE(anim1->currentTime(), 50);
+    QCOMPARE(anim1->currentLoopTime(), 50);
 
     group.removeAnimation(anim1); //anim0 | anim2
-    QCOMPARE(group.currentTime(), 250);
+    QCOMPARE(group.currentLoopTime(), 250);
     QCOMPARE(group.currentAnimation(), anim2);
-    QCOMPARE(anim0->currentTime(), 250);
+    QCOMPARE(anim0->currentLoopTime(), 250);
 }
 
 void tst_QSequentialAnimationGroup::currentAnimation()
@@ -1595,15 +1595,15 @@ class SequentialAnimationGroup : public QSequentialAnimationGroup
 {
     Q_OBJECT
 public slots:
-    void clearAnimations()
+    void clear()
     {
-        QSequentialAnimationGroup::clearAnimations();
+        QSequentialAnimationGroup::clear();
     }
 
     void refill()
     {
         stop();
-        clearAnimations();
+        clear();
         new DummyPropertyAnimation(this);
         start();
     }
@@ -1611,11 +1611,11 @@ public slots:
 };
 
 
-void tst_QSequentialAnimationGroup::clearAnimations()
+void tst_QSequentialAnimationGroup::clear()
 {
     SequentialAnimationGroup group;
     QPointer<QAbstractAnimation> anim1 = new DummyPropertyAnimation(&group);
-    group.connect(anim1, SIGNAL(finished()), SLOT(clearAnimations()));
+    group.connect(anim1, SIGNAL(finished()), SLOT(clear()));
     new DummyPropertyAnimation(&group);
     QCOMPARE(group.animationCount(), 2);
 
@@ -1623,7 +1623,7 @@ void tst_QSequentialAnimationGroup::clearAnimations()
     QTest::qWait(anim1->duration() + 100);
     QCOMPARE(group.animationCount(), 0);
     QCOMPARE(group.state(), QAbstractAnimation::Stopped);
-    QCOMPARE(group.currentTime(), 0);
+    QCOMPARE(group.currentLoopTime(), 0);
 
     anim1 = new DummyPropertyAnimation(&group);
     group.connect(anim1, SIGNAL(finished()), SLOT(refill()));
@@ -1649,22 +1649,22 @@ void tst_QSequentialAnimationGroup::pauseResume()
     QCOMPARE(anim->state(), QAnimationGroup::Running);
     QCOMPARE(spy.count(), 1);
     spy.clear();
-    const int currentTime = group.currentTime();
-    QCOMPARE(anim->currentTime(), currentTime);
+    const int currentTime = group.currentLoopTime();
+    QCOMPARE(anim->currentLoopTime(), currentTime);
 
     group.pause();
     QCOMPARE(group.state(), QAnimationGroup::Paused);
-    QCOMPARE(group.currentTime(), currentTime);
+    QCOMPARE(group.currentLoopTime(), currentTime);
     QCOMPARE(anim->state(), QAnimationGroup::Paused);
-    QCOMPARE(anim->currentTime(), currentTime);
+    QCOMPARE(anim->currentLoopTime(), currentTime);
     QCOMPARE(spy.count(), 1);
     spy.clear();
 
     group.resume();
     QCOMPARE(group.state(), QAnimationGroup::Running);
-    QCOMPARE(group.currentTime(), currentTime);
+    QCOMPARE(group.currentLoopTime(), currentTime);
     QCOMPARE(anim->state(), QAnimationGroup::Running);
-    QCOMPARE(anim->currentTime(), currentTime);
+    QCOMPARE(anim->currentLoopTime(), currentTime);
     QCOMPARE(spy.count(), 1);
 }
 
diff --git a/tests/benchmarks/qanimation/rectanimation.cpp b/tests/benchmarks/qanimation/rectanimation.cpp
index ab381f4..88eec4d 100644
--- a/tests/benchmarks/qanimation/rectanimation.cpp
+++ b/tests/benchmarks/qanimation/rectanimation.cpp
@@ -92,8 +92,3 @@ void RectAnimation::updateCurrentTime(int currentTime)
     if (m_object)
         m_object->setRect(m_current);
 }
-
-void RectAnimation::updateState(QAbstractAnimation::State state)
-{
-    Q_UNUSED(state);
-}
diff --git a/tests/benchmarks/qanimation/rectanimation.h b/tests/benchmarks/qanimation/rectanimation.h
index ea1f804..38a6f48 100644
--- a/tests/benchmarks/qanimation/rectanimation.h
+++ b/tests/benchmarks/qanimation/rectanimation.h
@@ -59,7 +59,6 @@ public:
     int duration() const;
 
     virtual void updateCurrentTime(int currentTime);
-    virtual void updateState(QAbstractAnimation::State state);
 
 private:
     DummyObject *m_object;