Merge branch 'master' into graphics-master

70 files changed, 11816 insertions, 244 deletions

diff --git a/src/corelib/animation/animation.pri b/src/corelib/animation/animation.pri
new file mode 100644
index 0000000..cb7850c
--- /dev/null
+++ b/src/corelib/animation/animation.pri
@@ -0,0 +1,25 @@
+# Qt core animation module
+
+HEADERS += \
+        animation/qabstractanimation.h \
+        animation/qabstractanimation_p.h \
+        animation/qvariantanimation.h \
+        animation/qvariantanimation_p.h \
+        animation/qpropertyanimation.h \
+        animation/qpropertyanimation_p.h \
+        animation/qanimationgroup.h \
+        animation/qanimationgroup_p.h \
+        animation/qsequentialanimationgroup.h \
+        animation/qsequentialanimationgroup_p.h \
+        animation/qparallelanimationgroup.h \
+        animation/qparallelanimationgroup_p.h \
+        animation/qpauseanimation.h
+
+SOURCES += \
+        animation/qabstractanimation.cpp \
+        animation/qvariantanimation.cpp \
+        animation/qpropertyanimation.cpp \
+        animation/qanimationgroup.cpp \
+        animation/qsequentialanimationgroup.cpp \
+        animation/qparallelanimationgroup.cpp \
+        animation/qpauseanimation.cpp
diff --git a/src/corelib/animation/qabstractanimation.cpp b/src/corelib/animation/qabstractanimation.cpp
new file mode 100644
index 0000000..94a94d1
--- /dev/null
+++ b/src/corelib/animation/qabstractanimation.cpp
@@ -0,0 +1,759 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QAbstractAnimation
+    \ingroup animation
+    \brief The QAbstractAnimation class is the base of all animations.
+    \since 4.6
+
+    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
+    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:
+    \l{QAbstractAnimation::}{Running},
+    \l{QAbstractAnimation::}{Stopped}, or
+    \l{QAbstractAnimation::}{Paused}--as defined by the
+    \l{QAbstractAnimation::}{State} enum. The current state can be
+    changed by calling start(), stop(), pause(), or resume(). An
+    animation will always reset its \l{currentTime()}{current time}
+    when it is started. If paused, it will continue with the same
+    current time when resumed. When an animation is stopped, it cannot
+    be resumed, but will keep its current time (until started again).
+    QAbstractAnimation will emit stateChanged() whenever its state
+    changes.
+
+    An animation can loop any number of times by setting the loopCount
+    property. When an animation's current time reaches its duration(),
+    it will reset the current time and keep running. A loop count of 1
+    (the default value) means that the animation will run one time.
+    Note that a duration of -1 means that the animation will run until
+    stopped; the current time will increase indefinitely. When the
+    current time equals duration() and the animation is in its
+    final loop, the \l{QAbstractAnimation::}{Stopped} state is
+    entered, and the finished() signal is emitted.
+
+    QAbstractAnimation provides pure virtual functions used by
+    subclasses to track the progress of the animation: duration() and
+    updateCurrentTime(). The duration() function lets you report a
+    duration for the animation (as discussed above). The current time
+    is delivered by the animation framework through calls to
+    updateCurrentTime(). By reimplementing this function, you can
+    track the animation progress. Note that neither the interval
+    between calls nor the number of calls to this function are
+    defined; though, it will normally be 60 updates per second.
+
+    By reimplementing updateState(), you can track the animation's
+    state changes, which is particularly useful for animations that
+    are not driven by time.
+
+    \sa QVariantAnimation, QPropertyAnimation, QAnimationGroup, {The Animation Framework}
+*/
+
+/*!
+    \enum QAbstractAnimation::DeletionPolicy
+
+    \value KeepWhenStopped The animation will not be deleted when stopped.
+    \value DeleteWhenStopped The animation will be automatically deleted when
+    stopped.
+*/
+
+/*!
+    \fn QAbstractAnimation::finished()
+
+    QAbstractAnimation emits this signal after the animation has stopped and
+    has reached the end.
+
+    This signal is emitted after stateChanged().
+
+    \sa stateChanged()
+*/
+
+/*!
+    \fn QAbstractAnimation::stateChanged(QAbstractAnimation::State oldState, QAbstractAnimation::State newState)
+
+    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.
+
+    \sa updateState()
+*/
+
+/*!
+    \fn QAbstractAnimation::currentLoopChanged(int currentLoop)
+
+    QAbstractAnimation emits this signal whenever the current loop
+    changes. \a currentLoop is the current loop.
+
+    \sa currentLoop(), loopCount()
+*/
+
+/*!
+    \fn QAbstractAnimation::directionChanged(QAbstractAnimation::Direction newDirection);
+
+    QAbstractAnimation emits this signal whenever the direction has been
+    changed. \a newDirection is the new direction.
+
+    \sa direction
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qabstractanimation.h"
+#include "qanimationgroup.h"
+#include <QtCore/qdebug.h>
+
+#include "qabstractanimation_p.h"
+
+#include <QtCore/qmath.h>
+#include <QtCore/qthreadstorage.h>
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qpointer.h>
+
+#define DEFAULT_TIMER_INTERVAL 16
+
+QT_BEGIN_NAMESPACE
+
+Q_GLOBAL_STATIC(QThreadStorage<QUnifiedTimer *>, unifiedTimer);
+
+QUnifiedTimer::QUnifiedTimer() : QObject(), lastTick(0), timingInterval(DEFAULT_TIMER_INTERVAL), consistentTiming(false)
+{
+}
+
+QUnifiedTimer *QUnifiedTimer::instance()
+{
+    QUnifiedTimer *inst;
+    if (!unifiedTimer()->hasLocalData()) {
+        inst = new QUnifiedTimer;
+        unifiedTimer()->setLocalData(inst);
+    } else {
+        inst = unifiedTimer()->localData();
+    }
+    return inst;
+}
+
+void QUnifiedTimer::updateRecentlyStartedAnimations()
+{
+    if (animationsToStart.isEmpty())
+        return;
+
+    animations += animationsToStart;
+    updateTimer(); //we make sure we start the timer there
+
+    animationsToStart.clear();
+}
+
+/*
+  defines the timing interval. Default is DEFAULT_TIMER_INTERVAL
+*/
+void QUnifiedTimer::setTimingInterval(int interval)
+{
+    timingInterval = interval;
+    if (animationTimer.isActive()) {
+        //we changed the timing interval
+        animationTimer.start(timingInterval, this);
+    }
+}
+
+/*
+   this allows to have a consistent timer interval at each tick from the timer
+   not taking the real time that passed into account.
+*/
+void QUnifiedTimer::setConsistentTiming(bool b)
+{
+    consistentTiming = b;
+}
+
+int QUnifiedTimer::elapsedTime() const
+{
+    return lastTick;
+}
+
+void QUnifiedTimer::timerEvent(QTimerEvent *event)
+{
+    //this is simply the time we last received a tick
+    const int oldLastTick = lastTick;
+    if (time.isValid())
+        lastTick = consistentTiming ? oldLastTick + timingInterval : time.elapsed();
+
+    //we transfer the waiting animations into the "really running" state
+    updateRecentlyStartedAnimations();
+
+    if (event->timerId() == startStopAnimationTimer.timerId()) {
+        startStopAnimationTimer.stop();
+        if (animations.isEmpty()) {
+            animationTimer.stop();
+            time = QTime();
+        } else {
+            animationTimer.start(timingInterval, this);
+            lastTick = 0;
+            time.start();
+        }
+    } else if (event->timerId() == animationTimer.timerId()) {
+        const int delta = lastTick - oldLastTick;
+        for (int i = 0; i < animations.count(); ++i) {
+            QAbstractAnimation *animation = animations.at(i);
+            int elapsed = QAbstractAnimationPrivate::get(animation)->totalCurrentTime
+                + (animation->direction() == QAbstractAnimation::Forward ? delta : -delta);
+            animation->setCurrentTime(elapsed);
+        }
+    }
+}
+
+void QUnifiedTimer::updateTimer()
+{
+    //we delay the call to start and stop for the animation timer so that if you
+    //stop and start animations in batch you don't stop/start the timer too often.
+    if (!startStopAnimationTimer.isActive())
+        startStopAnimationTimer.start(0, this); // we delay the actual start of the animation
+}
+
+void QUnifiedTimer::registerAnimation(QAbstractAnimation *animation)
+{
+    if (animations.contains(animation) ||animationsToStart.contains(animation))
+        return;
+    animationsToStart << animation;
+    updateTimer();
+}
+
+void QUnifiedTimer::unregisterAnimation(QAbstractAnimation *animation)
+{
+    animations.removeAll(animation);
+    animationsToStart.removeAll(animation);
+    updateTimer();
+}
+
+
+void QAbstractAnimationPrivate::setState(QAbstractAnimation::State newState)
+{
+    Q_Q(QAbstractAnimation);
+    if (state == newState)
+        return;
+
+    QAbstractAnimation::State oldState = state;
+    int oldCurrentTime = currentTime;
+    int oldCurrentLoop = currentLoop;
+    QAbstractAnimation::Direction oldDirection = direction;
+
+    state = newState;
+
+    QPointer<QAbstractAnimation> guard(q);
+
+    guard->updateState(oldState, newState);
+
+    //this is to be safe if updateState changes the state
+    if (state == oldState)
+        return;
+
+    // Notify state change
+    if (guard)
+        emit guard->stateChanged(oldState, newState);
+
+    // Enter running state.
+    switch (state)
+    {
+    case QAbstractAnimation::Paused:
+    case QAbstractAnimation::Running:
+        {
+            // Rewind
+            if (oldState == QAbstractAnimation::Stopped) {
+                if (guard) {
+                    if (direction == QAbstractAnimation::Forward)
+                        q->setCurrentTime(0);
+                    else
+                        q->setCurrentTime(loopCount == -1 ? q->duration() : q->totalDuration());
+                }
+
+                // Check if the setCurrentTime() function called stop().
+                // This can happen for a 0-duration animation
+                if (state == QAbstractAnimation::Stopped)
+                    return;
+            }
+
+            // Register timer if our parent is not running.
+            if (state == QAbstractAnimation::Running && guard) {
+                if (!group || group->state() == QAbstractAnimation::Stopped) {
+                    QUnifiedTimer::instance()->registerAnimation(q);
+                }
+            } else {
+                //new state is paused
+                QUnifiedTimer::instance()->unregisterAnimation(q);
+            }
+        }
+        break;
+    case QAbstractAnimation::Stopped:
+        // Leave running state.
+        int dura = q->duration();
+        if (deleteWhenStopped && guard)
+            q->deleteLater();
+
+        QUnifiedTimer::instance()->unregisterAnimation(q);
+
+        if (dura == -1 || loopCount < 0
+            || (oldDirection == QAbstractAnimation::Forward && (oldCurrentTime * (oldCurrentLoop + 1)) == (dura * loopCount))
+            || (oldDirection == QAbstractAnimation::Backward && oldCurrentTime == 0)) {
+                if (guard)
+                    emit q->finished();
+        }
+        break;
+    }
+
+}
+
+/*!
+    Constructs the QAbstractAnimation base class, and passes \a parent to
+    QObject's constructor.
+
+    \sa QVariantAnimation, QAnimationGroup
+*/
+QAbstractAnimation::QAbstractAnimation(QObject *parent)
+    : QObject(*new QAbstractAnimationPrivate, 0)
+{
+    // Allow auto-add on reparent
+    setParent(parent);
+}
+
+/*!
+    \internal
+*/
+QAbstractAnimation::QAbstractAnimation(QAbstractAnimationPrivate &dd, QObject *parent)
+    : QObject(dd, 0)
+{
+    // Allow auto-add on reparent
+   setParent(parent);
+}
+
+/*!
+    Stops the animation if it's running, then destroys the
+    QAbstractAnimation. If the animation is part of a QAnimationGroup, it is
+    automatically removed before it's destroyed.
+*/
+QAbstractAnimation::~QAbstractAnimation()
+{
+    Q_D(QAbstractAnimation);
+    //we can't call stop here. Otherwise we get pure virtual calls
+    if (d->state != Stopped) {
+        QAbstractAnimation::State oldState = d->state;
+        d->state = Stopped;
+        emit stateChanged(oldState, d->state);
+        QUnifiedTimer::instance()->unregisterAnimation(this);
+    }
+}
+
+/*!
+    \property QAbstractAnimation::state
+    \brief state of the animation.
+
+    This property describes the current state of the animation. When the
+    animation state changes, QAbstractAnimation emits the stateChanged()
+    signal.
+*/
+QAbstractAnimation::State QAbstractAnimation::state() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->state;
+}
+
+/*!
+    If this animation is part of a QAnimationGroup, this function returns a
+    pointer to the group; otherwise, it returns 0.
+
+    \sa QAnimationGroup::addAnimation()
+*/
+QAnimationGroup *QAbstractAnimation::group() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->group;
+}
+
+/*!
+    \enum QAbstractAnimation::State
+
+    This enum describes the state of the animation.
+
+    \value Stopped The animation is not running. This is the initial state
+    of QAbstractAnimation, and the state QAbstractAnimation reenters when finished. The current
+    time remain unchanged until either setCurrentTime() is
+    called, or the animation is started by calling start().
+
+    \value Paused The animation is paused (i.e., temporarily
+    suspended). Calling resume() will resume animation activity.
+
+    \value Running The animation is running. While control is in the event
+    loop, QAbstractAnimation will update its current time at regular intervals,
+    calling updateCurrentTime() when appropriate.
+
+    \sa state(), stateChanged()
+*/
+
+/*!
+    \enum QAbstractAnimation::Direction
+
+    This enum describes the direction of the animation when in \l Running state.
+
+    \value Forward The current time of the animation increases with time (i.e.,
+    moves from 0 and towards the end / duration).
+
+    \value Backward The current time of the animation decreases with time (i.e.,
+    moves from the end / duration and towards 0).
+
+    \sa direction
+*/
+
+/*!
+    \property QAbstractAnimation::direction
+    \brief the direction of the animation when it is in \l Running
+    state.
+
+    This direction indicates whether the time moves from 0 towards the
+    animation duration, or from the value of the duration and towards 0 after
+    start() has been called.
+
+    By default, this property is set to \l Forward.
+*/
+QAbstractAnimation::Direction QAbstractAnimation::direction() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->direction;
+}
+void QAbstractAnimation::setDirection(Direction direction)
+{
+    Q_D(QAbstractAnimation);
+    if (d->direction == direction)
+        return;
+
+    d->direction = direction;
+    if (state() == Stopped) {
+        if (direction == Backward) {
+            d->currentTime = duration();
+            d->currentLoop = d->loopCount - 1;
+        } else {
+            d->currentTime = 0;
+            d->currentLoop = 0;
+        }
+    }
+    updateDirection(direction);
+    emit directionChanged(direction);
+}
+
+/*!
+    \property QAbstractAnimation::duration
+    \brief the duration of the animation.
+
+    If the duration is -1, it means that the duration is undefined.
+    In this case, loopCount is ignored.
+*/
+
+/*!
+    \property QAbstractAnimation::loopCount
+    \brief the loop count of the animation
+
+    This property describes the loop count of the animation as an integer.
+    By default this value is 1, indicating that the animation
+    should run once only, and then stop. By changing it you can let the
+    animation loop several times. With a value of 0, the animation will not
+    run at all, and with a value of -1, the animation will loop forever
+    until stopped.
+    It is not supported to have loop on an animation that has an undefined
+    duration. It will only run once.
+*/
+int QAbstractAnimation::loopCount() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->loopCount;
+}
+void QAbstractAnimation::setLoopCount(int loopCount)
+{
+    Q_D(QAbstractAnimation);
+    d->loopCount = loopCount;
+}
+
+/*!
+    \property QAbstractAnimation::currentLoop
+    \brief the current loop of the animation
+
+    This property describes the current loop of the animation. By default,
+    the animation's loop count is 1, and so the current loop will
+    always be 0. If the loop count is 2 and the animation runs past its
+    duration, it will automatically rewind and restart at current time 0, and
+    current loop 1, and so on.
+
+    When the current loop changes, QAbstractAnimation emits the
+    currentLoopChanged() signal.
+*/
+int QAbstractAnimation::currentLoop() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->currentLoop;
+}
+
+/*!
+    \fn virtual int QAbstractAnimation::duration() const = 0
+
+    This pure virtual function returns the duration of the animation, and
+    defines for how long QAbstractAnimation should update the current
+    time. This duration is local, and does not include the loop count.
+
+    A return value of -1 indicates that the animation has no defined duration;
+    the animation should run forever until stopped. This is useful for
+    animations that are not time driven, or where you cannot easily predict
+    its duration (e.g., event driven audio playback in a game).
+
+    If the animation is a parallel QAnimationGroup, the duration will be the longest
+    duration of all its animations. If the animation is a sequential QAnimationGroup,
+    the duration will be the sum of the duration of all its animations.
+    \sa loopCount
+*/
+
+/*!
+    Returns the total and effective duration of the animation, including the
+    loop count.
+
+    \sa duration(), currentTime
+*/
+int QAbstractAnimation::totalDuration() const
+{
+    Q_D(const QAbstractAnimation);
+    if (d->loopCount < 0)
+        return -1;
+    int dura = duration();
+    if (dura == -1)
+        return -1;
+    return dura * d->loopCount;
+}
+
+/*!
+    \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
+    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.
+
+    \sa loopCount
+ */
+int QAbstractAnimation::currentTime() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->currentTime;
+}
+void QAbstractAnimation::setCurrentTime(int msecs)
+{
+    Q_D(QAbstractAnimation);
+    msecs = qMax(msecs, 0);
+
+    // Calculate new time and loop.
+    int dura = duration();
+    int totalDura = (d->loopCount < 0 || dura == -1) ? -1 : dura * d->loopCount;
+    if (totalDura != -1)
+        msecs = qMin(totalDura, msecs);
+    d->totalCurrentTime = msecs;
+
+    // Update new values.
+    int oldLoop = d->currentLoop;
+    d->currentLoop = ((dura <= 0) ? 0 : (msecs / dura));
+    if (d->currentLoop == d->loopCount) {
+        //we're at the end
+        d->currentTime = qMax(0, dura);
+        d->currentLoop = qMax(0, d->loopCount - 1);
+    } else {
+        if (d->direction == Forward) {
+            d->currentTime = (dura <= 0) ? msecs : (msecs % dura);
+        } else {
+            d->currentTime = (dura <= 0) ? msecs : ((msecs - 1) % dura) + 1;
+            if (d->currentTime == dura)
+                --d->currentLoop;
+        }
+    }
+
+    updateCurrentTime(msecs);
+    if (d->currentLoop != oldLoop)
+        emit currentLoopChanged(d->currentLoop);
+
+    // All animations are responsible for stopping the animation when their
+    // own end state is reached; in this case the animation is time driven,
+    // and has reached the end.
+    if ((d->direction == Forward && d->totalCurrentTime == totalDura)
+        || (d->direction == Backward && d->totalCurrentTime == 0)) {
+        stop();
+    }
+}
+
+/*!
+    Starts the animation. The \a policy argument says whether or not the
+    animation should be deleted when it's done. When the animation starts, the
+    stateChanged() signal is emitted, and state() returns Running. When control
+    reaches the event loop, the animation will run by itself, periodically
+    calling updateCurrentTime() as the animation progresses.
+
+    If the animation is currently stopped or has already reached the end,
+    calling start() will rewind the animation and start again from the beginning.
+    When the animation reaches the end, the animation will either stop, or
+    if the loop level is more than 1, it will rewind and continue from the beginning.
+
+    If the animation is already running, this function does nothing.
+
+    \sa stop(), state()
+*/
+void QAbstractAnimation::start(DeletionPolicy policy)
+{
+    Q_D(QAbstractAnimation);
+    if (d->state == Running)
+        return;
+    d->setState(Running);
+    d->deleteWhenStopped = policy;
+}
+
+/*!
+    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
+    finished() signal is emitted.
+
+    \sa start(), state()
+ */
+void QAbstractAnimation::stop()
+{
+    Q_D(QAbstractAnimation);
+
+    d->setState(Stopped);
+}
+
+/*!
+    Pauses the animation. When the animation is paused, state() returns Paused.
+    The currenttime will remain unchanged until resume() or start() is called.
+    If you want to continue from the current time, call resume().
+
+
+    \sa start(), state(), resume()
+ */
+void QAbstractAnimation::pause()
+{
+    Q_D(QAbstractAnimation);
+    if (d->state == Stopped) {
+        qWarning("QAbstractAnimation::pause: Cannot pause a stopped animation");
+        return;
+    }
+
+    d->setState(Paused);
+}
+
+/*!
+    Resumes the animation after it was paused. When the animation is resumed,
+    it emits the resumed() and stateChanged() signals. The currenttime is not
+    changed.
+
+    \sa start(), pause(), state()
+ */
+void QAbstractAnimation::resume()
+{
+    Q_D(QAbstractAnimation);
+    if (d->state != Paused) {
+        qWarning("QAbstractAnimation::resume: "
+                 "Cannot resume an animation that is not paused");
+        return;
+    }
+
+    d->setState(Running);
+}
+
+/*!
+    \reimp
+*/
+bool QAbstractAnimation::event(QEvent *event)
+{
+    return QObject::event(event);
+}
+
+/*!
+    \fn virtual void QAbstractAnimation::updateCurrentTime(int msecs) = 0;
+
+    This pure virtual function is called every time the animation's current
+    time changes. The \a msecs argument is the current time.
+
+    \sa updateState()
+*/
+
+/*!
+    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,
+                                     QAbstractAnimation::State newState)
+{
+    Q_UNUSED(oldState);
+    Q_UNUSED(newState);
+}
+
+/*!
+    This virtual function is called by QAbstractAnimation when the direction
+    of the animation is changed. The \a direction argument is the new direction.
+
+    \sa setDirection(), direction()
+*/
+void QAbstractAnimation::updateDirection(QAbstractAnimation::Direction direction)
+{
+    Q_UNUSED(direction);
+}
+
+
+QT_END_NAMESPACE
+
+#include "moc_qabstractanimation.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qabstractanimation.h b/src/corelib/animation/qabstractanimation.h
new file mode 100644
index 0000000..d6d50dc
--- /dev/null
+++ b/src/corelib/animation/qabstractanimation.h
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTANIMATION_H
+#define QABSTRACTANIMATION_H
+
+#include <QtCore/qobject.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QAnimationGroup;
+class QSequentialAnimationGroup;
+
+class QAbstractAnimationPrivate;
+class Q_CORE_EXPORT QAbstractAnimation : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(State state READ state NOTIFY stateChanged)
+    Q_PROPERTY(int loopCount READ loopCount WRITE setLoopCount)
+    Q_PROPERTY(int currentTime READ currentTime WRITE setCurrentTime)
+    Q_PROPERTY(int currentLoop READ currentLoop NOTIFY currentLoopChanged)
+    Q_PROPERTY(Direction direction READ direction WRITE setDirection NOTIFY directionChanged)
+    Q_PROPERTY(int duration READ duration)
+
+public:
+    enum Direction {
+        Forward,
+        Backward
+    };
+
+    enum State {
+        Stopped,
+        Paused,
+        Running
+    };
+
+    enum DeletionPolicy {
+        KeepWhenStopped = 0,
+        DeleteWhenStopped
+    };
+
+    QAbstractAnimation(QObject *parent = 0);
+    virtual ~QAbstractAnimation();
+
+    State state() const;
+
+    QAnimationGroup *group() const;
+
+    Direction direction() const;
+    void setDirection(Direction direction);
+
+    int loopCount() const;
+    void setLoopCount(int loopCount);
+    int currentLoop() const;
+
+    virtual int duration() const = 0;
+    int totalDuration() const;
+
+    int currentTime() const;
+
+Q_SIGNALS:
+    void finished();
+    void stateChanged(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void currentLoopChanged(int currentLoop);
+    void directionChanged(QAbstractAnimation::Direction);
+
+public Q_SLOTS:
+    void start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped);
+    void pause();
+    void resume();
+    void stop();
+    void setCurrentTime(int msecs);
+
+protected:
+    QAbstractAnimation(QAbstractAnimationPrivate &dd, QObject *parent = 0);
+    bool event(QEvent *event);
+
+    virtual void updateCurrentTime(int msecs) = 0;
+    virtual void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    virtual void updateDirection(QAbstractAnimation::Direction direction);
+
+private:
+    Q_DISABLE_COPY(QAbstractAnimation)
+    Q_DECLARE_PRIVATE(QAbstractAnimation)
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QABSTRACTANIMATION_H
diff --git a/src/corelib/animation/qabstractanimation_p.h b/src/corelib/animation/qabstractanimation_p.h
new file mode 100644
index 0000000..e64554c
--- /dev/null
+++ b/src/corelib/animation/qabstractanimation_p.h
@@ -0,0 +1,136 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTANIMATION_P_H
+#define QABSTRACTANIMATION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qbasictimer.h>
+#include <QtCore/qdatetime.h>
+#include <QtCore/qtimer.h>
+#include <private/qobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QAnimationGroup;
+class QAbstractAnimation;
+class QAbstractAnimationPrivate : public QObjectPrivate
+{
+public:
+    QAbstractAnimationPrivate()
+        : state(QAbstractAnimation::Stopped),
+          direction(QAbstractAnimation::Forward),
+          deleteWhenStopped(false),
+          totalCurrentTime(0),
+          currentTime(0),
+          loopCount(1),
+          currentLoop(0),
+          group(0)
+    {
+    }
+
+    virtual ~QAbstractAnimationPrivate() {}
+
+    static QAbstractAnimationPrivate *get(QAbstractAnimation *q)
+    {
+        return q->d_func();
+    }
+
+    QAbstractAnimation::State state;
+    QAbstractAnimation::Direction direction;
+    bool deleteWhenStopped;
+    void setState(QAbstractAnimation::State state);
+
+    int totalCurrentTime;
+    int currentTime;
+    int loopCount;
+    int currentLoop;
+
+    QAnimationGroup *group;
+
+private:
+    Q_DECLARE_PUBLIC(QAbstractAnimation)
+};
+
+
+class Q_CORE_EXPORT QUnifiedTimer : public QObject
+{
+private:
+    QUnifiedTimer();
+
+public:
+    static QUnifiedTimer *instance();
+
+    void registerAnimation(QAbstractAnimation *animation);
+    void unregisterAnimation(QAbstractAnimation *animation);
+
+    void setTimingInterval(int interval);
+    void setConsistentTiming(bool consistent);
+
+    int elapsedTime() const;
+
+protected:
+    void timerEvent(QTimerEvent *);
+    void updateTimer();
+
+private:
+    void updateRecentlyStartedAnimations();
+
+    QBasicTimer animationTimer, startStopAnimationTimer;
+    QTime time;
+    int lastTick;
+    int timingInterval;
+    bool consistentTiming;
+    QList<QAbstractAnimation*> animations, animationsToStart;
+};
+
+QT_END_NAMESPACE
+#endif
diff --git a/src/corelib/animation/qanimationgroup.cpp b/src/corelib/animation/qanimationgroup.cpp
new file mode 100644
index 0000000..ed06eff
--- /dev/null
+++ b/src/corelib/animation/qanimationgroup.cpp
@@ -0,0 +1,309 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QAnimationGroup
+    \brief The QAnimationGroup class is an abstract base class for groups of animations.
+    \since 4.6
+    \ingroup animation
+
+    An animation group is a container for animations (subclasses of
+    QAbstractAnimation). A group is usually responsible for managing
+    the \l{QAbstractAnimation::State}{state} of its animations, i.e.,
+    it decides when to start, stop, resume, and pause them. Currently,
+    Qt provides two such groups: QParallelAnimationGroup and
+    QSequentialAnimationGroup. Look up their class descriptions for
+    details.
+
+    Since QAnimationGroup inherits from QAbstractAnimation, you can
+    combine groups, and easily construct complex animation graphs.
+    You can query QAbstractAnimation for the group it belongs to
+    (using the \l{QAbstractAnimation::}{group()} function).
+
+    To start a top-level animation group, you simply use the
+    \l{QAbstractAnimation::}{start()} function from
+    QAbstractAnimation. By a top-level animation group, we think of a
+    group that itself is not contained within another group. Starting
+    sub groups directly is not supported, and may lead to unexpected
+    behavior.
+
+    \omit OK, we'll put in a snippet on this here \endomit
+
+    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
+    animations by listening to QEvent::ChildAdded and
+    QEvent::ChildRemoved events.
+
+    \omit OK, let's find a snippet here as well. \endomit
+
+    QAnimationGroup takes ownership of the animations it manages, and
+    ensures that they are deleted when the animation group is deleted.
+
+    You can also use a \l{The State Machine Framework}{state machine}
+    to create complex animations. The framework provides a special
+    state, QAnimationState, that plays an animation upon entry and
+    transitions to a new state when the animation has finished
+    playing. This technique can also be combined with using animation
+    groups.
+
+    \sa QAbstractAnimation, QVariantAnimation, {The Animation Framework}
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qanimationgroup.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qcoreevent.h>
+#include "qanimationgroup_p.h"
+
+QT_BEGIN_NAMESPACE
+
+
+/*!
+    Constructs a QAnimationGroup.
+    \a parent is passed to QObject's constructor.
+*/
+QAnimationGroup::QAnimationGroup(QObject *parent)
+    : QAbstractAnimation(*new QAnimationGroupPrivate, parent)
+{
+}
+
+/*!
+    \internal
+*/
+QAnimationGroup::QAnimationGroup(QAnimationGroupPrivate &dd, QObject *parent)
+    : QAbstractAnimation(dd, parent)
+{
+}
+
+/*!
+    Destroys the animation group. It will also destroy all its animations.
+*/
+QAnimationGroup::~QAnimationGroup()
+{
+}
+
+/*!
+    Returns a pointer to the animation at \a index in this group. This
+    function is useful when you need access to a particular animation.  \a
+    index is between 0 and animationCount() - 1.
+
+    \sa animationCount(), indexOfAnimation()
+*/
+QAbstractAnimation *QAnimationGroup::animationAt(int index) const
+{
+    Q_D(const QAnimationGroup);
+
+    if (index < 0 || index >= d->animations.size()) {
+        qWarning("QAnimationGroup::animationAt: index is out of bounds");
+        return 0;
+    }
+
+    return d->animations.at(index);
+}
+
+
+/*!
+    Returns the number of animations managed by this group.
+
+    \sa indexOfAnimation(), addAnimation(), animationAt()
+*/
+int QAnimationGroup::animationCount() const
+{
+    Q_D(const QAnimationGroup);
+    return d->animations.size();
+}
+
+/*!
+    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()
+*/
+int QAnimationGroup::indexOfAnimation(QAbstractAnimation *animation) const
+{
+    Q_D(const QAnimationGroup);
+    return d->animations.indexOf(animation);
+}
+
+/*!
+    Adds \a animation to this group. This will call insertAnimationAt with
+    index equals to animationCount().
+
+    \note The group takes ownership of the animation.
+
+    \sa removeAnimation()
+*/
+void QAnimationGroup::addAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QAnimationGroup);
+    insertAnimationAt(d->animations.count(), animation);
+}
+
+/*!
+    Inserts \a animation into this animation group at \a index.
+    If \a index is 0 the animation is inserted at the beginning.
+    If \a index is animationCount(), the animation is inserted at the end.
+
+    \note The group takes ownership of the animation.
+
+    \sa takeAnimationAt(), addAnimation(), indexOfAnimation(), removeAnimation()
+*/
+void QAnimationGroup::insertAnimationAt(int index, QAbstractAnimation *animation)
+{
+    Q_D(QAnimationGroup);
+
+    if (index < 0 || index > d->animations.size()) {
+        qWarning("QAnimationGroup::insertAnimationAt: index is out of bounds");
+        return;
+    }
+
+    if (QAnimationGroup *oldGroup = animation->group())
+        oldGroup->removeAnimation(animation);
+
+    d->animations.insert(index, animation);
+    QAbstractAnimationPrivate::get(animation)->group = this;
+    // this will make sure that ChildAdded event is sent to 'this'
+    animation->setParent(this);
+    d->animationInsertedAt(index);
+}
+
+/*!
+    Removes \a animation from this group. The ownership of \a animation is
+    transferred to the caller.
+
+    \sa takeAnimationAt(), insertAnimationAt(), addAnimation()
+*/
+void QAnimationGroup::removeAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QAnimationGroup);
+
+    if (!animation) {
+        qWarning("QAnimationGroup::remove: cannot remove null animation");
+        return;
+    }
+    int index = d->animations.indexOf(animation);
+    if (index == -1) {
+        qWarning("QAnimationGroup::remove: animation is not part of this group");
+        return;
+    }
+
+    takeAnimationAt(index);
+}
+
+/*!
+    Returns the animation at \a index and removes it from the animation group.
+
+    \note The ownership of the animation is transferred to the caller.
+
+    \sa removeAnimation(), addAnimation(), insertAnimation(), indexOfAnimation()
+*/
+QAbstractAnimation *QAnimationGroup::takeAnimationAt(int index)
+{
+    Q_D(QAnimationGroup);
+    if (index < 0 || index >= d->animations.size()) {
+        qWarning("QAnimationGroup::takeAnimationAt: no animation at index %d", index);
+        return 0;
+    }
+    QAbstractAnimation *animation = d->animations.at(index);
+    QAbstractAnimationPrivate::get(animation)->group = 0;
+    // ### removing from list before doing setParent to avoid inifinite recursion
+    // in ChildRemoved event
+    d->animations.removeAt(index);
+    animation->setParent(0);
+    d->animationRemovedAt(index);
+    return animation;
+}
+
+/*!
+    Removes and deletes all animations in this animation group, and resets the current
+    time to 0.
+
+    \sa addAnimation(), removeAnimation()
+*/
+void QAnimationGroup::clearAnimations()
+{
+    Q_D(QAnimationGroup);
+    qDeleteAll(d->animations);
+}
+
+/*!
+    \reimp
+*/
+bool QAnimationGroup::event(QEvent *event)
+{
+    Q_D(QAnimationGroup);
+    if (event->type() == QEvent::ChildAdded) {
+        QChildEvent *childEvent = static_cast<QChildEvent *>(event);
+        if (QAbstractAnimation *a = qobject_cast<QAbstractAnimation *>(childEvent->child())) {
+            if (a->group() != this)
+                addAnimation(a);
+        }
+    } else if (event->type() == QEvent::ChildRemoved) {
+        QChildEvent *childEvent = static_cast<QChildEvent *>(event);
+        QAbstractAnimation *a = static_cast<QAbstractAnimation *>(childEvent->child());
+        // You can only rely on the child being a QObject because in the QEvent::ChildRemoved
+        // case it might be called from the destructor.
+        int index = d->animations.indexOf(a);
+        if (index != -1)
+            takeAnimationAt(index);
+    }
+    return QAbstractAnimation::event(event);
+}
+
+
+void QAnimationGroupPrivate::animationRemovedAt(int index)
+{
+    Q_Q(QAnimationGroup);
+    Q_UNUSED(index);
+    if (animations.isEmpty()) {
+        currentTime = 0;
+        q->stop();
+    }
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qanimationgroup.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qanimationgroup.h b/src/corelib/animation/qanimationgroup.h
new file mode 100644
index 0000000..263bc38
--- /dev/null
+++ b/src/corelib/animation/qanimationgroup.h
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANIMATIONGROUP_H
+#define QANIMATIONGROUP_H
+
+#include <QtCore/qabstractanimation.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QAnimationGroupPrivate;
+class Q_CORE_EXPORT QAnimationGroup : public QAbstractAnimation
+{
+    Q_OBJECT
+
+public:
+    QAnimationGroup(QObject *parent = 0);
+    ~QAnimationGroup();
+
+    QAbstractAnimation *animationAt(int index) const;
+    int animationCount() const;
+    int indexOfAnimation(QAbstractAnimation *animation) const;
+    void addAnimation(QAbstractAnimation *animation);
+    void insertAnimationAt(int index, QAbstractAnimation *animation);
+    void removeAnimation(QAbstractAnimation *animation);
+    QAbstractAnimation *takeAnimationAt(int index);
+    void clearAnimations();
+
+protected:
+    QAnimationGroup(QAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+
+private:
+    Q_DISABLE_COPY(QAnimationGroup)
+    Q_DECLARE_PRIVATE(QAnimationGroup)
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif //QANIMATIONGROUP_H
diff --git a/src/corelib/animation/qanimationgroup_p.h b/src/corelib/animation/qanimationgroup_p.h
new file mode 100644
index 0000000..a7bd0fa
--- /dev/null
+++ b/src/corelib/animation/qanimationgroup_p.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANIMATIONGROUP_P_H
+#define QANIMATIONGROUP_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qanimationgroup.h"
+
+#include <QtCore/qlist.h>
+
+#include "qabstractanimation_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QAnimationGroupPrivate : public QAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QAnimationGroup)
+public:
+    QAnimationGroupPrivate()
+    { }
+
+    virtual void animationInsertedAt(int index) { Q_UNUSED(index) };
+    virtual void animationRemovedAt(int index);
+
+    QList<QAbstractAnimation *> animations;
+};
+
+QT_END_NAMESPACE
+
+#endif //QANIMATIONGROUP_P_H
diff --git a/src/corelib/animation/qparallelanimationgroup.cpp b/src/corelib/animation/qparallelanimationgroup.cpp
new file mode 100644
index 0000000..13f6073
--- /dev/null
+++ b/src/corelib/animation/qparallelanimationgroup.cpp
@@ -0,0 +1,316 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QParallelAnimationGroup
+    \brief The QParallelAnimationGroup class provides a parallel group of animations.
+    \since 4.6
+    \ingroup animation
+
+    QParallelAnimationGroup--a \l{QAnimationGroup}{container for
+    animations}--starts all its animations when it is
+    \l{QAbstractAnimation::start()}{started} itself, i.e., runs all
+    animations in parallel. The animation group finishes when the
+    longest lasting animation has finished.
+
+    You can treat QParallelAnimation as any other QAbstractAnimation,
+    e.g., pause, resume, or add it to other animation groups.
+
+    \code
+        QParallelAnimationGroup *group = new QParallelAnimationGroup;
+        group->addAnimation(anim1);
+        group->addAnimation(anim2);
+
+        group->start();
+    \endcode
+
+    In this example, \c anim1 and \c anim2 are two
+    \l{QPropertyAnimation}s that have already been set up.
+
+    \sa QAnimationGroup, QPropertyAnimation, {The Animation Framework}
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qparallelanimationgroup.h"
+#include "qparallelanimationgroup_p.h"
+//#define QANIMATION_DEBUG
+QT_BEGIN_NAMESPACE
+
+/*!
+    Constructs a QParallelAnimationGroup.
+    \a parent is passed to QObject's constructor.
+*/
+QParallelAnimationGroup::QParallelAnimationGroup(QObject *parent)
+    : QAnimationGroup(*new QParallelAnimationGroupPrivate, parent)
+{
+}
+
+/*!
+    \internal
+*/
+QParallelAnimationGroup::QParallelAnimationGroup(QParallelAnimationGroupPrivate &dd,
+                                                 QObject *parent)
+    : QAnimationGroup(dd, parent)
+{
+}
+
+/*!
+    Destroys the animation group. It will also destroy all its animations.
+*/
+QParallelAnimationGroup::~QParallelAnimationGroup()
+{
+}
+
+/*!
+    \reimp
+*/
+int QParallelAnimationGroup::duration() const
+{
+    Q_D(const QParallelAnimationGroup);
+    int ret = 0;
+
+    for (int i = 0; i < d->animations.size(); ++i) {
+        QAbstractAnimation *animation = d->animations.at(i);
+        const int currentDuration = animation->totalDuration();
+        if (currentDuration == -1)
+            return -1; // Undetermined length
+
+        ret = qMax(ret, currentDuration);
+    }
+
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+void QParallelAnimationGroup::updateCurrentTime(int)
+{
+    Q_D(QParallelAnimationGroup);
+    if (d->animations.isEmpty())
+        return;
+
+    if (d->currentLoop > d->lastLoop) {
+        // simulate completion of the loop
+        int dura = duration();
+        if (dura > 0) {
+            foreach (QAbstractAnimation *animation, d->animations) {
+                animation->setCurrentTime(dura);   // will stop
+            }
+        }
+    } else if (d->currentLoop < d->lastLoop) {
+        // simulate completion of the loop seeking backwards
+        foreach (QAbstractAnimation *animation, d->animations) {
+            animation->setCurrentTime(0);
+            animation->stop();
+        }
+    }
+
+    bool timeFwd = ((d->currentLoop == d->lastLoop && d->currentTime >= d->lastCurrentTime)
+                   || d->currentLoop > d->lastLoop);
+#ifdef QANIMATION_DEBUG
+    qDebug("QParallellAnimationGroup %5d: setCurrentTime(%d), loop:%d, last:%d, timeFwd:%d, lastcurrent:%d, %d",
+        __LINE__, d->currentTime, d->currentLoop, d->lastLoop, timeFwd, d->lastCurrentTime, state());
+#endif
+    // finally move into the actual time of the current loop
+    foreach (QAbstractAnimation *animation, d->animations) {
+        const int dura = animation->totalDuration();
+        if (dura == -1 && d->isUncontrolledAnimationFinished(animation))
+            continue;
+        if (dura == -1 || (d->currentTime <= dura && dura != 0)
+            || (dura == 0 && d->currentLoop != d->lastLoop)) {
+            switch (state()) {
+            case Running:
+                animation->start();
+                break;
+            case Paused:
+                animation->pause();
+                break;
+            case Stopped:
+            default:
+                break;
+            }
+        }
+
+        if (dura <= 0) {
+            if (dura == -1)
+                animation->setCurrentTime(d->currentTime);
+            continue;
+        }
+
+        if ((timeFwd && d->lastCurrentTime <= dura)
+            || (!timeFwd && d->currentTime <= dura))
+                animation->setCurrentTime(d->currentTime);
+        if (d->currentTime > dura)
+            animation->stop();
+    }
+    d->lastLoop = d->currentLoop;
+    d->lastCurrentTime = d->currentTime;
+}
+
+/*!
+    \reimp
+*/
+void QParallelAnimationGroup::updateState(QAbstractAnimation::State oldState,
+                                          QAbstractAnimation::State newState)
+{
+    Q_D(QParallelAnimationGroup);
+    QAnimationGroup::updateState(oldState, newState);
+
+    switch (newState) {
+    case Stopped:
+        foreach (QAbstractAnimation *animation, d->animations)
+            animation->stop();
+        d->disconnectUncontrolledAnimations();
+        break;
+    case Paused:
+        foreach (QAbstractAnimation *animation, d->animations)
+            animation->pause();
+        break;
+    case Running:
+        d->connectUncontrolledAnimations();
+        foreach (QAbstractAnimation *animation, d->animations) {
+            animation->stop();
+            animation->setDirection(d->direction);
+            animation->start();
+        }
+        break;
+    }
+}
+
+void QParallelAnimationGroupPrivate::_q_uncontrolledAnimationFinished()
+{
+    Q_Q(QParallelAnimationGroup);
+
+    QAbstractAnimation *animation = qobject_cast<QAbstractAnimation *>(q->sender());
+    Q_ASSERT(animation);
+
+    int uncontrolledRunningCount = 0;
+    if (animation->duration() == -1 || animation->loopCount() < 0) {
+        QHash<QAbstractAnimation *, int>::iterator it = uncontrolledFinishTime.begin();
+        while (it != uncontrolledFinishTime.end()) {
+            if (it.key() == animation) {
+                *it = animation->currentTime();
+            }
+            if (it.value() == -1)
+                ++uncontrolledRunningCount;
+            ++it;
+        }
+    }
+
+    if (uncontrolledRunningCount > 0)
+        return;
+
+    int maxDuration = 0;
+    foreach (QAbstractAnimation *a, animations)
+        maxDuration = qMax(maxDuration, a->totalDuration());
+
+    if (currentTime >= maxDuration)
+        q->stop();
+}
+
+void QParallelAnimationGroupPrivate::disconnectUncontrolledAnimations()
+{
+    Q_Q(QParallelAnimationGroup);
+
+    QHash<QAbstractAnimation *, int>::iterator it = uncontrolledFinishTime.begin();
+    while (it != uncontrolledFinishTime.end()) {
+        QObject::disconnect(it.key(), SIGNAL(finished()), q, SLOT(_q_uncontrolledAnimationFinished()));
+        ++it;
+    }
+
+    uncontrolledFinishTime.clear();
+}
+
+void QParallelAnimationGroupPrivate::connectUncontrolledAnimations()
+{
+    Q_Q(QParallelAnimationGroup);
+
+    foreach (QAbstractAnimation *animation, animations) {
+        if (animation->duration() == -1 || animation->loopCount() < 0) {
+            uncontrolledFinishTime[animation] = -1;
+            QObject::connect(animation, SIGNAL(finished()), q, SLOT(_q_uncontrolledAnimationFinished()));
+        }
+    }
+}
+
+bool QParallelAnimationGroupPrivate::isUncontrolledAnimationFinished(QAbstractAnimation *anim) const
+{
+    return uncontrolledFinishTime.value(anim, -1) >= 0;
+}
+
+/*!
+    \reimp
+*/
+void QParallelAnimationGroup::updateDirection(QAbstractAnimation::Direction direction)
+{
+    Q_D(QParallelAnimationGroup);
+    //we need to update the direction of the current animation
+    if (state() != Stopped) {
+        foreach(QAbstractAnimation *anim, d->animations) {
+            anim->setDirection(direction);
+        }
+    } else {
+        if (direction == Forward) {
+            d->lastLoop = 0;
+            d->lastCurrentTime = 0;
+        } else {
+            // Looping backwards with loopCount == -1 does not really work well...
+            d->lastLoop = (d->loopCount == -1 ? 0 : d->loopCount - 1);
+            d->lastCurrentTime = duration();
+        }
+    }
+}
+
+/*!
+    \reimp
+*/
+bool QParallelAnimationGroup::event(QEvent *event)
+{
+    return QAnimationGroup::event(event);
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qparallelanimationgroup.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qparallelanimationgroup.h b/src/corelib/animation/qparallelanimationgroup.h
new file mode 100644
index 0000000..57a8146
--- /dev/null
+++ b/src/corelib/animation/qparallelanimationgroup.h
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPARALLELANIMATIONGROUP_H
+#define QPARALLELANIMATIONGROUP_H
+
+#include <QtCore/qanimationgroup.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QParallelAnimationGroupPrivate;
+class Q_CORE_EXPORT QParallelAnimationGroup : public QAnimationGroup
+{
+    Q_OBJECT
+
+public:
+    QParallelAnimationGroup(QObject *parent = 0);
+    ~QParallelAnimationGroup();
+
+    int duration() const;
+
+protected:
+    QParallelAnimationGroup(QParallelAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+
+    void updateCurrentTime(int msecs);
+    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void updateDirection(QAbstractAnimation::Direction direction);
+
+private:
+    Q_DISABLE_COPY(QParallelAnimationGroup)
+    Q_DECLARE_PRIVATE(QParallelAnimationGroup)
+    Q_PRIVATE_SLOT(d_func(), void _q_uncontrolledAnimationFinished())
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPARALLELANIMATIONGROUP
diff --git a/src/corelib/animation/qparallelanimationgroup_p.h b/src/corelib/animation/qparallelanimationgroup_p.h
new file mode 100644
index 0000000..f36d972
--- /dev/null
+++ b/src/corelib/animation/qparallelanimationgroup_p.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPARALLELANIMATIONGROUP_P_H
+#define QPARALLELANIMATIONGROUP_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qparallelanimationgroup.h"
+#include "qanimationgroup_p.h"
+#include <QtCore/QHash>
+
+QT_BEGIN_NAMESPACE
+
+class QParallelAnimationGroupPrivate : public QAnimationGroupPrivate
+{
+    Q_DECLARE_PUBLIC(QParallelAnimationGroup)
+public:
+    QParallelAnimationGroupPrivate()
+        : lastLoop(0), lastCurrentTime(0)
+    {
+    }
+
+    QHash<QAbstractAnimation*, int> uncontrolledFinishTime;
+    int lastLoop;
+    int lastCurrentTime;
+
+    bool isUncontrolledAnimationFinished(QAbstractAnimation *anim) const;
+    void connectUncontrolledAnimations();
+    void disconnectUncontrolledAnimations();
+
+    // private slot
+    void _q_uncontrolledAnimationFinished();
+};
+
+QT_END_NAMESPACE
+
+#endif //QPARALLELANIMATIONGROUP_P_H
diff --git a/src/corelib/animation/qpauseanimation.cpp b/src/corelib/animation/qpauseanimation.cpp
new file mode 100644
index 0000000..b175f0c
--- /dev/null
+++ b/src/corelib/animation/qpauseanimation.cpp
@@ -0,0 +1,154 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QPauseAnimation
+    \brief The QPauseAnimation class provides a pause for QSequentialAnimationGroup.
+    \since 4.6
+    \ingroup animation
+
+    If you wish to introduce a delay between animations in a
+    QSequentialAnimationGroup, you can insert a QPauseAnimation. This
+    class does not animate anything, but does not
+    \l{QAbstractAnimation::finished()}{finish} before a specified
+    number of milliseconds have elapsed from when it was started. You
+    specify the duration of the pause in the constructor. It can also
+    be set directly with setDuration().
+
+    It is not necessary to construct a QPauseAnimation yourself.
+    QSequentialAnimationGroup provides the convenience functions
+    \l{QSequentialAnimationGroup::}{addPause()} and
+    \l{QSequentialAnimationGroup::}{insertPauseAt()}. These functions
+    simply take the number of milliseconds the pause should last.
+
+    \sa QSequentialAnimationGroup
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qpauseanimation.h"
+#include "qabstractanimation_p.h"
+
+
+QT_BEGIN_NAMESPACE
+
+class QPauseAnimationPrivate : public QAbstractAnimationPrivate
+{
+public:
+    QPauseAnimationPrivate() : QAbstractAnimationPrivate(), duration(0)
+    {
+    }
+
+    int duration;
+};
+
+/*!
+    Constructs a QPauseAnimation.
+    \a parent is passed to QObject's constructor.
+    The default duration is 0.
+*/
+
+QPauseAnimation::QPauseAnimation(QObject *parent) : QAbstractAnimation(*new QPauseAnimationPrivate, parent)
+{
+}
+
+/*!
+    Constructs a QPauseAnimation.
+    \a msecs is the duration of the pause.
+    \a parent is passed to QObject's constructor.
+*/
+
+QPauseAnimation::QPauseAnimation(int msecs, QObject *parent) : QAbstractAnimation(*new QPauseAnimationPrivate, parent)
+{
+    setDuration(msecs);
+}
+
+/*!
+    Destroys the pause animation.
+*/
+QPauseAnimation::~QPauseAnimation()
+{
+}
+
+/*!
+    \property QPauseAnimation::duration
+    \brief the duration of the pause.
+
+    The duration of the pause. The duration should not be negative.
+*/
+int QPauseAnimation::duration() const
+{
+    Q_D(const QPauseAnimation);
+    return d->duration;
+}
+
+void QPauseAnimation::setDuration(int msecs)
+{
+    if (msecs < 0) {
+        qWarning("QPauseAnimation::setDuration: cannot set a negative duration");
+        return;
+    }
+    Q_D(QPauseAnimation);
+    d->duration = msecs;
+}
+
+/*!
+    \reimp
+ */
+bool QPauseAnimation::event(QEvent *e)
+{
+    return QAbstractAnimation::event(e);
+}
+
+/*!
+    \reimp
+ */
+void QPauseAnimation::updateCurrentTime(int msecs)
+{
+    Q_UNUSED(msecs);
+}
+
+
+QT_END_NAMESPACE
+
+#include "moc_qpauseanimation.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qpauseanimation.h b/src/corelib/animation/qpauseanimation.h
new file mode 100644
index 0000000..cb6e041
--- /dev/null
+++ b/src/corelib/animation/qpauseanimation.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAUSEANIMATION_P_H
+#define QPAUSEANIMATION_P_H
+
+#include <QtCore/qanimationgroup.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QPauseAnimationPrivate;
+
+class Q_CORE_EXPORT QPauseAnimation : public QAbstractAnimation
+{
+    Q_OBJECT
+    Q_PROPERTY(int duration READ duration WRITE setDuration)
+public:
+    QPauseAnimation(QObject *parent = 0);
+    QPauseAnimation(int msecs, QObject *parent = 0);
+    ~QPauseAnimation();
+
+    int duration() const;
+    void setDuration(int msecs);
+
+protected:
+    bool event(QEvent *e);
+    void updateCurrentTime(int msecs);
+
+private:
+    Q_DISABLE_COPY(QPauseAnimation)
+    Q_DECLARE_PRIVATE(QPauseAnimation)
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPAUSEANIMATION_P_H
diff --git a/src/corelib/animation/qpropertyanimation.cpp b/src/corelib/animation/qpropertyanimation.cpp
new file mode 100644
index 0000000..9a17049
--- /dev/null
+++ b/src/corelib/animation/qpropertyanimation.cpp
@@ -0,0 +1,316 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QPropertyAnimation
+    \brief The QPropertyAnimation class animates Qt properties
+    \since 4.6
+    \ingroup animation
+
+    QPropertyAnimation interpolates over \l{Qt's Property System}{Qt
+    properties}. As property values are stored in \l{QVariant}s, the
+    class inherits QVariantAnimation, and supports animation of the
+    same \l{QVariant::Type}{variant types} as its super class.
+
+    A class declaring properties must be a QObject. To make it
+    possible to animate a property, it must provide a setter (so that
+    QPropertyAnimation can set the property's value). Note that this
+    makes it possible to animate many of Qt's widgets. Let's look at
+    an example:
+
+    \code
+        QPropertyAnimation animation(myWidget, "geometry");
+        animation.setDuration(10000);
+        animation.setStartValue(QRect(0, 0, 100, 30));
+        animation.setEndValue(QRect(250, 250, 100, 30));
+
+        animation.start();
+    \endcode
+
+    The property name and the QObject instance of which property
+    should be animated are passed to the constructor. You can then
+    specify the start and end value of the property. The procedure is
+    equal for properties in classes you have implemented
+    yourself--just check with QVariantAnimation that your QVariant
+    type is supported.
+
+    The QVariantAnimation class description explains how to set up the
+    animation in detail. Note, however, that if a start value is not
+    set, the property will start at the value it had when the
+    QPropertyAnimation instance was created.
+
+    QPropertyAnimation works like a charm on its own. For complex
+    animations that, for instance, contain several objects,
+    QAnimationGroup is provided. An animation group is an animation
+    that can contain other animations, and that can manage when its
+    animations are played. Look at QParallelAnimationGroup for an
+    example.
+
+    \sa QVariantAnimation, QAnimationGroup, {The Animation Framework}
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qpropertyanimation.h"
+#include "qanimationgroup.h"
+#include <QtCore/qdebug.h>
+
+#include "qpropertyanimation_p.h"
+
+#include <QtCore/qmath.h>
+#include <QtCore/qmutex.h>
+
+QT_BEGIN_NAMESPACE
+
+typedef QPair<QObject *, QByteArray> QPropertyAnimationPair;
+typedef QHash<QPropertyAnimationPair, QPropertyAnimation*> QPropertyAnimationHash;
+Q_GLOBAL_STATIC(QPropertyAnimationHash, _q_runningAnimations);
+Q_GLOBAL_STATIC_WITH_ARGS(QMutex, guardHashLock, (QMutex::Recursive) )
+
+void QPropertyAnimationPrivate::updateMetaProperty()
+{
+    if (!target || propertyName.isEmpty())
+        return;
+
+    if (hasMetaProperty == 0 && !property.isValid()) {
+        const QMetaObject *mo = target->metaObject();
+        propertyIndex = mo->indexOfProperty(propertyName);
+        if (propertyIndex != -1) {
+            hasMetaProperty = 1;
+            property = mo->property(propertyIndex);
+            propertyType = property.userType();
+        } else {
+            if (!target->dynamicPropertyNames().contains(propertyName))
+                qWarning("QPropertyAnimation: you're trying to animate a non-existing property %s of your QObject", propertyName.constData());
+            hasMetaProperty = 2;
+        }
+    }
+
+    if (property.isValid())
+        convertValues(propertyType);
+}
+
+void QPropertyAnimationPrivate::updateProperty(const QVariant &newValue)
+{
+    if (!target || state == QAbstractAnimation::Stopped)
+        return;
+
+    if (hasMetaProperty == 1) {
+        if (newValue.userType() == propertyType) {
+          //no conversion is needed, we directly call the QObject::qt_metacall
+          void *data = const_cast<void*>(newValue.constData());
+          target->qt_metacall(QMetaObject::WriteProperty, propertyIndex, &data);
+        } else {
+          property.write(target, newValue);
+        }
+    } else {
+        target->setProperty(propertyName.constData(), newValue);
+    }
+}
+
+void QPropertyAnimationPrivate::_q_targetDestroyed()
+{
+    Q_Q(QPropertyAnimation);
+    //we stop here so that this animation is removed from the global hash
+    q->stop();
+    target = 0;
+}
+
+/*!
+    Construct a QPropertyAnimation object. \a parent is passed to QObject's
+    constructor.
+*/
+QPropertyAnimation::QPropertyAnimation(QObject *parent)
+    : QVariantAnimation(*new QPropertyAnimationPrivate, parent)
+{
+}
+
+/*!
+    Construct a QPropertyAnimation object. \a parent is passed to QObject's
+    constructor. The animation changes the property \a propertyName on \a
+    target. The default duration is 250ms.
+
+    \sa targetObject, propertyName
+*/
+QPropertyAnimation::QPropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent)
+    : QVariantAnimation(*new QPropertyAnimationPrivate, parent)
+{
+    setTargetObject(target);
+    setPropertyName(propertyName);
+}
+
+/*!
+    Destroys the QPropertyAnimation instance.
+ */
+QPropertyAnimation::~QPropertyAnimation()
+{
+    stop();
+}
+
+/*!
+    \property QPropertyAnimation::targetObject
+    \brief the target QObject for this animation.
+
+    This property defines the target QObject for this animation.
+ */
+QObject *QPropertyAnimation::targetObject() const
+{
+    Q_D(const QPropertyAnimation);
+    return d->target;
+}
+
+void QPropertyAnimation::setTargetObject(QObject *target)
+{
+    Q_D(QPropertyAnimation);
+    if (d->target == target)
+        return;
+
+    if (d->state != QAbstractAnimation::Stopped) {
+        qWarning("QPropertyAnimation::setTargetObject: you can't change the target of a running animation");
+        return;
+    }
+
+    //we need to get notified when the target is destroyed
+    if (d->target)
+        disconnect(d->target, SIGNAL(destroyed()), this, SLOT(_q_targetDestroyed()));
+
+    if (target)
+        connect(target, SIGNAL(destroyed()), SLOT(_q_targetDestroyed()));
+
+    d->target = target;
+    d->hasMetaProperty = 0;
+    d->updateMetaProperty();
+}
+
+/*!
+    \property QPropertyAnimation::propertyName
+    \brief the target property name for this animation
+
+    This property defines the target property name for this animation. The
+    property name is required for the animation to operate.
+ */
+QByteArray QPropertyAnimation::propertyName() const
+{
+    Q_D(const QPropertyAnimation);
+    return d->propertyName;
+}
+
+void QPropertyAnimation::setPropertyName(const QByteArray &propertyName)
+{
+    Q_D(QPropertyAnimation);
+    if (d->state != QAbstractAnimation::Stopped) {
+        qWarning("QPropertyAnimation::setPropertyName: you can't change the property name of a running animation");
+        return;
+    }
+
+    d->propertyName = propertyName;
+    d->hasMetaProperty = 0;
+    d->updateMetaProperty();
+}
+
+
+/*!
+    \reimp
+ */
+bool QPropertyAnimation::event(QEvent *event)
+{
+    return QVariantAnimation::event(event);
+}
+
+/*!
+    This virtual function is called by QVariantAnimation whenever the current value
+    changes. \a value is the new, updated value. It updates the current value
+    of the property on the target object.
+
+    \sa currentValue, currentTime
+ */
+void QPropertyAnimation::updateCurrentValue(const QVariant &value)
+{
+    Q_D(QPropertyAnimation);
+    d->updateProperty(value);
+}
+
+/*!
+    \reimp
+
+    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)
+{
+    Q_D(QPropertyAnimation);
+
+    if (!d->target) {
+        qWarning("QPropertyAnimation::updateState: Changing state of an animation without target");
+        return;
+    }
+
+    QVariantAnimation::updateState(oldState, newState);
+    QMutexLocker locker(guardHashLock());
+    QPropertyAnimationHash * hash = _q_runningAnimations();
+    QPropertyAnimationPair key(d->target, d->propertyName);
+    if (newState == Running) {
+        d->updateMetaProperty();
+        QPropertyAnimation *oldAnim = hash->value(key, 0);
+        if (oldAnim) {
+            // try to stop the top level group
+            QAbstractAnimation *current = oldAnim;
+            while (current->group() && current->state() != Stopped)
+                current = current->group();
+            current->stop();
+        }
+        hash->insert(key, this);
+
+        // update the default start value
+        if (oldState == Stopped) {
+            d->setDefaultStartValue(d->target->property(d->propertyName.constData()));
+        }
+    } else if (hash->value(key) == this) {
+        hash->remove(key);
+    }
+}
+
+#include "moc_qpropertyanimation.cpp"
+
+QT_END_NAMESPACE
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qpropertyanimation.h b/src/corelib/animation/qpropertyanimation.h
new file mode 100644
index 0000000..5b06bd2
--- /dev/null
+++ b/src/corelib/animation/qpropertyanimation.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROPERTYANIMATION_H
+#define QPROPERTYANIMATION_H
+
+#include <QtCore/qvariantanimation.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QPropertyAnimationPrivate;
+class Q_CORE_EXPORT QPropertyAnimation : public QVariantAnimation
+{
+    Q_OBJECT
+    Q_PROPERTY(QByteArray propertyName READ propertyName WRITE setPropertyName)
+    Q_PROPERTY(QObject* targetObject READ targetObject WRITE setTargetObject)
+
+public:
+    QPropertyAnimation(QObject *parent = 0);
+    QPropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = 0);
+    ~QPropertyAnimation();
+
+    QObject *targetObject() const;
+    void setTargetObject(QObject *target);
+
+    QByteArray propertyName() const;
+    void setPropertyName(const QByteArray &propertyName);
+
+protected:
+    bool event(QEvent *event);
+
+    void updateCurrentValue(const QVariant &value);
+    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    Q_PRIVATE_SLOT(d_func(), void _q_targetDestroyed());
+private:
+    Q_DISABLE_COPY(QPropertyAnimation)
+    Q_DECLARE_PRIVATE(QPropertyAnimation)
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPROPERTYANIMATION_H
diff --git a/src/corelib/animation/qpropertyanimation_p.h b/src/corelib/animation/qpropertyanimation_p.h
new file mode 100644
index 0000000..b51d039
--- /dev/null
+++ b/src/corelib/animation/qpropertyanimation_p.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROPERTYANIMATION_P_H
+#define QPROPERTYANIMATION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qpropertyanimation.h"
+#include <QtCore/qmetaobject.h>
+
+#include "qvariantanimation_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPropertyAnimationPrivate : public QVariantAnimationPrivate
+{
+   Q_DECLARE_PUBLIC(QPropertyAnimation)
+public:
+    QPropertyAnimationPrivate()
+        : target(0), propertyType(0), propertyIndex(0), hasMetaProperty(false)
+    {
+    }
+
+    void _q_targetDestroyed();
+
+    QObject *target;
+
+    //for the QProperty
+    QMetaProperty property;
+    int propertyType;
+    int propertyIndex;
+
+    int hasMetaProperty;
+    QByteArray propertyName;
+    void updateProperty(const QVariant &);
+    void updateMetaProperty();
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/animation/qsequentialanimationgroup.cpp b/src/corelib/animation/qsequentialanimationgroup.cpp
new file mode 100644
index 0000000..14814a7
--- /dev/null
+++ b/src/corelib/animation/qsequentialanimationgroup.cpp
@@ -0,0 +1,594 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QSequentialAnimationGroup
+    \brief The QSequentialAnimationGroup class provides a sequential group of animations.
+    \since 4.6
+    \ingroup animation
+
+    QSequentialAnimationGroup is a QAnimationGroup that runs its
+    animations in sequence, i.e., it starts one animation after
+    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
+    finishes when its last animation has finished.
+
+    At each moment there is at most one animation that is active in
+    the group; it is returned by currentAnimation(). An empty group
+    has no current animation.
+
+    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
+    pause to a sequential animation group.
+
+    \code
+        QSequentialAnimationGroup group;
+
+        group.addAnimation(anim1);
+        group.addAnimation(anim2);
+
+        group.start();
+    \endcode
+
+    In this example, \c anim1 and \c anim2 are two already set up
+    \l{QPropertyAnimation}s.
+
+    \sa QAnimationGroup, QAbstractAnimation, {The Animation Framework}
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qsequentialanimationgroup.h"
+#include "qsequentialanimationgroup_p.h"
+
+#include "qpauseanimation.h"
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+
+
+bool QSequentialAnimationGroupPrivate::atEnd() const
+{
+    // we try to detect if we're at the end of the group
+    //this is true if the following conditions are true:
+    // 1. we're in the last loop
+    // 2. the direction is forward
+    // 3. the current animation is the last one
+    // 4. the current animation has reached its end
+    const int animTotalCurrentTime = QAbstractAnimationPrivate::get(currentAnimation)->totalCurrentTime;
+    return (currentLoop == loopCount - 1
+        && direction == QAbstractAnimation::Forward
+        && currentAnimation == animations.last()
+        && animTotalCurrentTime == animationActualTotalDuration(currentAnimationIndex));
+}
+
+int QSequentialAnimationGroupPrivate::animationActualTotalDuration(int index) const
+{
+    QAbstractAnimation *anim = animations.at(index);
+    int ret = anim->totalDuration();
+    if (ret == -1 && actualDuration.size() > index)
+        ret = actualDuration.at(index); //we can try the actual duration there
+    return ret;
+}
+
+QSequentialAnimationGroupPrivate::AnimationIndex QSequentialAnimationGroupPrivate::indexForTime(int msecs) const
+{
+    Q_Q(const QSequentialAnimationGroup);
+    Q_ASSERT(!animations.isEmpty());
+
+    AnimationIndex ret;
+    int duration = 0;
+
+    // in case duration is -1, currentLoop will always be 0
+    ret.timeOffset = currentLoop * q->duration();
+
+    for (int i = 0; i < animations.size(); ++i) {
+        duration = animationActualTotalDuration(i);
+
+        // 'animation' is the current animation if one of these reasons is true:
+        // 1. it's duration is undefined
+        // 2. it ends after msecs
+        // 3. it is the last animation (this can happen in case there is at least 1 uncontrolled animation)
+        // 4. it ends exactly in msecs and the direction is backwards
+        if (duration == -1 || msecs < (ret.timeOffset + duration)
+            || (msecs == (ret.timeOffset + duration) && direction == QAbstractAnimation::Backward)) {
+            ret.index = i;
+            return ret;
+        }
+
+        // 'animation' has a non-null defined duration and is not the one at time 'msecs'.
+        ret.timeOffset += duration;
+    }
+
+    // this can only happen when one of those conditions is true:
+    // 1. the duration of the group is undefined and we passed its actual duration
+    // 2. there are only 0-duration animations in the group
+    ret.timeOffset -= duration;
+    ret.index = animations.size() - 1;
+    return ret;
+}
+
+void QSequentialAnimationGroupPrivate::restart()
+{
+    // restarting the group by making the first/last animation the current one
+    if (direction == QAbstractAnimation::Forward) {
+        lastLoop = 0;
+        if (currentAnimationIndex == 0)
+            activateCurrentAnimation();
+        else
+            setCurrentAnimation(0);
+    } else { // direction == QAbstractAnimation::Backward
+        lastLoop = loopCount - 1;
+        int index = animations.size() - 1;
+        if (currentAnimationIndex == index)
+            activateCurrentAnimation();
+        else
+            setCurrentAnimation(index);
+    }
+}
+
+/*!
+    \internal
+    This manages advancing the execution of a group running forwards (time has gone forward),
+    which is the same behaviour for rewinding the execution of a group running backwards
+    (time has gone backward).
+*/
+void QSequentialAnimationGroupPrivate::advanceForwards(const AnimationIndex &newAnimationIndex)
+{
+    if (lastLoop < currentLoop) {
+        // we need to fast forward to the end
+        for (int i = currentAnimationIndex; i < animations.size(); ++i) {
+            QAbstractAnimation *anim = animations.at(i);
+            setCurrentAnimation(i, true);
+            anim->setCurrentTime(animationActualTotalDuration(i));
+        }
+        // this will make sure the current animation is reset to the beginning
+        if (animations.size() == 1)
+            // we need to force activation because setCurrentAnimation will have no effect
+            activateCurrentAnimation();
+        else
+            setCurrentAnimation(0, true);
+    }
+
+    // and now we need to fast forward from the current position to
+    for (int i = currentAnimationIndex; i < newAnimationIndex.index; ++i) {     //### WRONG,
+        QAbstractAnimation *anim = animations.at(i);
+        setCurrentAnimation(i, true);
+        anim->setCurrentTime(animationActualTotalDuration(i));
+    }
+    // setting the new current animation will happen later
+}
+
+/*!
+    \internal
+    This manages rewinding the execution of a group running forwards (time has gone forward),
+    which is the same behaviour for advancing the execution of a group running backwards
+    (time has gone backward).
+*/
+void QSequentialAnimationGroupPrivate::rewindForwards(const AnimationIndex &newAnimationIndex)
+{
+    if (lastLoop > currentLoop) {
+        // we need to fast rewind to the beginning
+        for (int i = currentAnimationIndex; i >= 0 ; --i) {
+            QAbstractAnimation *anim = animations.at(i);
+            setCurrentAnimation(i, true);
+            anim->setCurrentTime(0);
+        }
+        // this will make sure the current animation is reset to the end
+        if (animations.size() == 1)
+            // we need to force activation because setCurrentAnimation will have no effect
+            activateCurrentAnimation();
+        else
+            setCurrentAnimation(animations.count() - 1, true);
+    }
+
+    // and now we need to fast rewind from the current position to
+    for (int i = currentAnimationIndex; i > newAnimationIndex.index; --i) {
+        QAbstractAnimation *anim = animations.at(i);
+        setCurrentAnimation(i, true);
+        anim->setCurrentTime(0);
+    }
+    // setting the new current animation will happen later
+}
+
+/*!
+    \fn QSequentialAnimationGroup::currentAnimationChanged(QAbstractAnimation *current)
+
+    QSequentialAnimationGroup emits this signal when currentAnimation
+    has been changed. \a current is the current animation.
+
+    \sa currentAnimation()
+*/
+
+
+/*!
+    Constructs a QSequentialAnimationGroup.
+    \a parent is passed to QObject's constructor.
+*/
+QSequentialAnimationGroup::QSequentialAnimationGroup(QObject *parent)
+    : QAnimationGroup(*new QSequentialAnimationGroupPrivate, parent)
+{
+}
+
+/*!
+    \internal
+*/
+QSequentialAnimationGroup::QSequentialAnimationGroup(QSequentialAnimationGroupPrivate &dd,
+                                                     QObject *parent)
+    : QAnimationGroup(dd, parent)
+{
+}
+
+/*!
+    Destroys the animation group. It will also destroy all its animations.
+*/
+QSequentialAnimationGroup::~QSequentialAnimationGroup()
+{
+}
+
+/*!
+    Adds a pause of \a msecs to this animation group.
+    The pause is considered as a special type of animation, thus count() will be
+    increased by one.
+    \sa insertPauseAt(), QAnimationGroup::addAnimation()
+*/
+QPauseAnimation *QSequentialAnimationGroup::addPause(int msecs)
+{
+    QPauseAnimation *pause = new QPauseAnimation(msecs);
+    addAnimation(pause);
+    return pause;
+}
+
+/*!
+    Inserts a pause of \a msecs milliseconds at \a index in this animation
+    group.
+
+    \sa addPause(), QAnimationGroup::insertAnimationAt()
+*/
+QPauseAnimation *QSequentialAnimationGroup::insertPauseAt(int index, int msecs)
+{
+    Q_D(const QSequentialAnimationGroup);
+
+    if (index < 0 || index > d->animations.size()) {
+        qWarning("QSequentialAnimationGroup::insertPauseAt: index is out of bounds");
+        return 0;
+    }
+
+    QPauseAnimation *pause = new QPauseAnimation(msecs);
+    insertAnimationAt(index, pause);
+    return pause;
+}
+
+
+/*!
+    \property QSequentialAnimationGroup::currentAnimation
+    Returns the animation in the current time.
+
+    \sa currentAnimationChanged()
+*/
+QAbstractAnimation *QSequentialAnimationGroup::currentAnimation() const
+{
+    Q_D(const QSequentialAnimationGroup);
+    return d->currentAnimation;
+}
+
+/*!
+    \reimp
+*/
+int QSequentialAnimationGroup::duration() const
+{
+    Q_D(const QSequentialAnimationGroup);
+    int ret = 0;
+
+    for (int i = 0; i < d->animations.size(); ++i) {
+        QAbstractAnimation *animation = d->animations.at(i);
+        const int currentDuration = animation->totalDuration();
+        if (currentDuration == -1)
+            return -1; // Undetermined length
+
+        ret += currentDuration;
+    }
+
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+void QSequentialAnimationGroup::updateCurrentTime(int msecs)
+{
+    Q_D(QSequentialAnimationGroup);
+    if (!d->currentAnimation)
+        return;
+
+    const QSequentialAnimationGroupPrivate::AnimationIndex newAnimationIndex = d->indexForTime(msecs);
+
+    // remove unneeded animations from actualDuration list
+    while (newAnimationIndex.index < d->actualDuration.size())
+        d->actualDuration.removeLast();
+
+    // newAnimationIndex.index is the new current animation
+    if (d->lastLoop < d->currentLoop
+        || (d->lastLoop == d->currentLoop && d->currentAnimationIndex < newAnimationIndex.index)) {
+            // advancing with forward direction is the same as rewinding with backwards direction
+            d->advanceForwards(newAnimationIndex);
+    } else if (d->lastLoop > d->currentLoop
+        || (d->lastLoop == d->currentLoop && d->currentAnimationIndex > newAnimationIndex.index)) {
+            // rewinding with forward direction is the same as advancing with backwards direction
+            d->rewindForwards(newAnimationIndex);
+    }
+
+    d->setCurrentAnimation(newAnimationIndex.index);
+
+    const int newCurrentTime = msecs - newAnimationIndex.timeOffset;
+
+    if (d->currentAnimation) {
+        d->currentAnimation->setCurrentTime(newCurrentTime);
+        if (d->atEnd()) {
+            //we make sure that we don't exceed the duration here
+            d->currentTime += QAbstractAnimationPrivate::get(d->currentAnimation)->totalCurrentTime - newCurrentTime;
+            stop();
+        }
+    } else {
+        //the only case where currentAnimation could be null
+        //is when all animations have been removed
+        Q_ASSERT(d->animations.isEmpty());
+        d->currentTime = 0;
+        stop();
+    }
+
+    d->lastLoop = d->currentLoop;
+}
+
+/*!
+    \reimp
+*/
+void QSequentialAnimationGroup::updateState(QAbstractAnimation::State oldState,
+                                            QAbstractAnimation::State newState)
+{
+    Q_D(QSequentialAnimationGroup);
+    QAnimationGroup::updateState(oldState, newState);
+
+    if (!d->currentAnimation)
+        return;
+
+    switch (newState) {
+    case Stopped:
+        d->currentAnimation->stop();
+        break;
+    case Paused:
+        if (oldState == d->currentAnimation->state()
+            && oldState == QSequentialAnimationGroup::Running) {
+                d->currentAnimation->pause();
+            }
+        else
+            d->restart();
+        break;
+    case Running:
+        if (oldState == d->currentAnimation->state()
+            && oldState == QSequentialAnimationGroup::Paused)
+            d->currentAnimation->start();
+        else
+            d->restart();
+        break;
+    }
+}
+
+/*!
+    \reimp
+*/
+void QSequentialAnimationGroup::updateDirection(QAbstractAnimation::Direction direction)
+{
+    Q_D(QSequentialAnimationGroup);
+    // we need to update the direction of the current animation
+    if (state() != Stopped && d->currentAnimation)
+        d->currentAnimation->setDirection(direction);
+}
+
+/*!
+    \reimp
+*/
+bool QSequentialAnimationGroup::event(QEvent *event)
+{
+    return QAnimationGroup::event(event);
+}
+
+void QSequentialAnimationGroupPrivate::setCurrentAnimation(int index, bool intermediate)
+{
+    Q_Q(QSequentialAnimationGroup);
+
+    index = qMin(index, animations.count() - 1);
+
+    if (index == -1) {
+        Q_ASSERT(animations.isEmpty());
+        currentAnimationIndex = -1;
+        currentAnimation = 0;
+        return;
+    }
+
+    // need these two checks below because this func can be called after the current animation
+    // has been removed
+    if (index == currentAnimationIndex && animations.at(index) == currentAnimation)
+        return;
+
+    // stop the old current animation
+    if (currentAnimation)
+        currentAnimation->stop();
+
+    currentAnimation = animations.at(index);
+    currentAnimationIndex = index;
+
+    emit q->currentAnimationChanged(currentAnimation);
+
+    activateCurrentAnimation(intermediate);
+}
+
+void QSequentialAnimationGroupPrivate::activateCurrentAnimation(bool intermediate)
+{
+    Q_Q(QSequentialAnimationGroup);
+
+    if (!currentAnimation)
+        return;
+
+    if (state == QSequentialAnimationGroup::Stopped)
+        return;
+
+    currentAnimation->stop();
+
+    // we ensure the direction is consistent with the group's direction
+    currentAnimation->setDirection(direction);
+
+    // connects to the finish signal of uncontrolled animations
+    if (currentAnimation->totalDuration() == -1)
+        QObject::connect(currentAnimation, SIGNAL(finished()), q, SLOT(_q_uncontrolledAnimationFinished()));
+
+    currentAnimation->start();
+    if (!intermediate && state == QSequentialAnimationGroup::Paused)
+        currentAnimation->pause();
+}
+
+void QSequentialAnimationGroupPrivate::_q_uncontrolledAnimationFinished()
+{
+    Q_Q(QSequentialAnimationGroup);
+    Q_ASSERT(qobject_cast<QAbstractAnimation *>(q->sender()) == currentAnimation);
+
+    // we trust the duration returned by the animation
+    while (actualDuration.size() < (currentAnimationIndex + 1))
+        actualDuration.append(-1);
+    actualDuration[currentAnimationIndex] = currentAnimation->currentTime();
+
+    QObject::disconnect(currentAnimation, SIGNAL(finished()), q, SLOT(_q_uncontrolledAnimationFinished()));
+
+    if ((direction == QAbstractAnimation::Forward && currentAnimation == animations.last())
+        || (direction == QAbstractAnimation::Backward && currentAnimationIndex == 0)) {
+        // we don't handle looping of a group with undefined duration
+        q->stop();
+    } else if (direction == QAbstractAnimation::Forward) {
+        // set the current animation to be the next one
+        setCurrentAnimation(currentAnimationIndex + 1);
+    } else {
+        // set the current animation to be the previous one
+        setCurrentAnimation(currentAnimationIndex - 1);
+    }
+}
+
+/*!
+    \internal
+    This method is called whenever an animation is added to
+    the group at index \a index.
+    Note: We only support insertion after the current animation
+*/
+void QSequentialAnimationGroupPrivate::animationInsertedAt(int index)
+{
+    if (currentAnimation == 0)
+        setCurrentAnimation(0); // initialize the current animation
+
+    if (currentAnimationIndex == index
+        && currentAnimation->currentTime() == 0 && currentAnimation->currentLoop() == 0) {
+            //in this case we simply insert an animation before the current one has actually started
+            setCurrentAnimation(index);
+    }
+
+    //we update currentAnimationIndex in case it has changed (the animation pointer is still valid)
+    currentAnimationIndex = animations.indexOf(currentAnimation);
+
+    if (index < currentAnimationIndex || currentLoop != 0) {
+        qWarning("QSequentialGroup::insertAnimationAt only supports to add animations after the current one.");
+        return; //we're not affected because it is added after the current one
+    }
+}
+
+/*!
+    \internal
+    This method is called whenever an animation is removed from
+    the group at index \a index. The animation is no more listed when this
+    method is called.
+*/
+void QSequentialAnimationGroupPrivate::animationRemovedAt(int index)
+{
+    Q_Q(QSequentialAnimationGroup);
+    QAnimationGroupPrivate::animationRemovedAt(index);
+
+    Q_ASSERT(currentAnimation); // currentAnimation should always be set
+
+    if (actualDuration.size() > index)
+        actualDuration.removeAt(index);
+
+    const int currentIndex = animations.indexOf(currentAnimation);
+    if (currentIndex == -1) {
+        //we're removing the current animation, let's update it to another one
+        if (index < animations.count())
+            setCurrentAnimation(index); //let's try to take the next one
+        else if (index > 0)
+            setCurrentAnimation(index - 1);
+        else// case all animations were removed
+            setCurrentAnimation(-1);
+    } else if (currentAnimationIndex > index) {
+        currentAnimationIndex--;
+    }
+
+    // duration of the previous animations up to the current animation
+    currentTime = 0;
+    for (int i = 0; i < currentAnimationIndex; ++i) {
+        const int current = animationActualTotalDuration(i);
+        currentTime += current;
+    }
+
+    if (currentIndex != -1) {
+        //the current animation is not the one being removed
+        //so we add its current time to the current time of this group
+        currentTime += QAbstractAnimationPrivate::get(currentAnimation)->totalCurrentTime;
+    }
+
+    //let's also update the total current time
+    totalCurrentTime = currentTime + loopCount * q->duration();
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qsequentialanimationgroup.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qsequentialanimationgroup.h b/src/corelib/animation/qsequentialanimationgroup.h
new file mode 100644
index 0000000..4701a76
--- /dev/null
+++ b/src/corelib/animation/qsequentialanimationgroup.h
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSEQUENTIALANIMATIONGROUP_H
+#define QSEQUENTIALANIMATIONGROUP_H
+
+#include <QtCore/qanimationgroup.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QPauseAnimation;
+class QSequentialAnimationGroupPrivate;
+
+class Q_CORE_EXPORT QSequentialAnimationGroup : public QAnimationGroup
+{
+    Q_OBJECT
+    Q_PROPERTY(QAbstractAnimation* currentAnimation READ currentAnimation NOTIFY currentAnimationChanged)
+
+public:
+    QSequentialAnimationGroup(QObject *parent = 0);
+    ~QSequentialAnimationGroup();
+
+    QPauseAnimation *addPause(int msecs);
+    QPauseAnimation *insertPauseAt(int index, int msecs);
+
+    QAbstractAnimation *currentAnimation() const;
+    int duration() const;
+
+Q_SIGNALS:
+    void currentAnimationChanged(QAbstractAnimation *current);
+
+protected:
+    QSequentialAnimationGroup(QSequentialAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+
+    void updateCurrentTime(int msecs);
+    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void updateDirection(QAbstractAnimation::Direction direction);
+
+private:
+    Q_DISABLE_COPY(QSequentialAnimationGroup)
+    Q_DECLARE_PRIVATE(QSequentialAnimationGroup)
+    Q_PRIVATE_SLOT(d_func(), void _q_uncontrolledAnimationFinished())
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif //QSEQUENTIALANIMATIONGROUP_H
diff --git a/src/corelib/animation/qsequentialanimationgroup_p.h b/src/corelib/animation/qsequentialanimationgroup_p.h
new file mode 100644
index 0000000..3ac90f8
--- /dev/null
+++ b/src/corelib/animation/qsequentialanimationgroup_p.h
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSEQUENTIALANIMATIONGROUP_P_H
+#define QSEQUENTIALANIMATIONGROUP_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qsequentialanimationgroup.h"
+#include "qanimationgroup_p.h"
+
+
+QT_BEGIN_NAMESPACE
+
+class QSequentialAnimationGroupPrivate : public QAnimationGroupPrivate
+{
+    Q_DECLARE_PUBLIC(QSequentialAnimationGroup)
+public:
+    QSequentialAnimationGroupPrivate()
+        : currentAnimation(0), currentAnimationIndex(-1), lastLoop(0)
+    { }
+
+
+    struct AnimationIndex
+    {
+        AnimationIndex() : index(0), timeOffset(0) {}
+        // index points to the animation at timeOffset, skipping 0 duration animations.
+        // Note that the index semantic is slightly different depending on the direction.
+        int index; // the index of the animation in timeOffset
+        int timeOffset; // time offset when the animation at index starts.
+    };
+
+    int animationActualTotalDuration(int index) const;
+    AnimationIndex indexForTime(int msecs) const;
+
+    void setCurrentAnimation(int index, bool intermediate = false);
+    void activateCurrentAnimation(bool intermediate = false);
+
+    void animationInsertedAt(int index);
+    void animationRemovedAt(int index);
+
+    bool atEnd() const;
+
+    QAbstractAnimation *currentAnimation;
+    int currentAnimationIndex;
+
+    // this is the actual duration of uncontrolled animations
+    // it helps seeking and even going forward
+    QList<int> actualDuration;
+
+    void restart();
+    int lastLoop;
+
+    // handle time changes
+    void rewindForwards(const AnimationIndex &newAnimationIndex);
+    void advanceForwards(const AnimationIndex &newAnimationIndex);
+
+    // private slot
+    void _q_uncontrolledAnimationFinished();
+};
+
+QT_END_NAMESPACE
+
+#endif //QSEQUENTIALANIMATIONGROUP_P_H
diff --git a/src/corelib/animation/qvariantanimation.cpp b/src/corelib/animation/qvariantanimation.cpp
new file mode 100644
index 0000000..a6834bb
--- /dev/null
+++ b/src/corelib/animation/qvariantanimation.cpp
@@ -0,0 +1,644 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qvariantanimation.h"
+#include "qvariantanimation_p.h"
+
+#include <QtCore/QRect>
+#include <QtCore/QLineF>
+#include <QtCore/QLine>
+#include <QtCore/QReadWriteLock>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QVariantAnimation
+    \ingroup animation
+    \brief The QVariantAnimation class provides an abstract base class for animations.
+    \since 4.6
+
+    This class is part of \l{The Animation Framework}. It serves as a
+    base class for property and item animations, with functions for
+    shared functionality.
+
+    QVariantAnimation cannot be used directly as it is an abstract
+    class; it does not implement
+    \l{QAbstractAnimation::}{updateCurrentValue()} from
+    QAbstractAnimation. The class performs interpolation over
+    \l{QVariant}s, but leaves using the interpolated values to its
+    subclasses. Currently, Qt provides QPropertyAnimation, which
+    animates Qt \l{Qt's Property System}{properties}. See the
+    QPropertyAnimation class description if you wish to animate such
+    properties.
+
+    You can then set start and end values for the property by calling
+    setStartValue() and setEndValue(), and finally call start() to
+    start the animation. QVariantAnimation will interpolate the
+    property of the target object and emit valueChanged(). To react to
+    a change in the current value you have to reimplement the
+    updateCurrentValue() virtual function.
+
+    It is also possible to set values at specified steps situated
+    between the start and end value. The interpolation will then
+    touch these points at the specified steps. Note that the start and
+    end values are defined as the key values at 0.0 and 1.0.
+
+    There are two ways to affect how QVariantAnimation interpolates
+    the values. You can set an easing curve by calling
+    setEasingCurve(), and configure the duration by calling
+    setDuration(). You can change how the QVariants are interpolated
+    by creating a subclass of QVariantAnimation, and reimplementing
+    the virtual interpolated() function.
+
+    Subclassing QVariantAnimation can be an alternative if you have
+    \l{QVariant}s that you do not wish to declare as Qt properties.
+    Note, however, that you in most cases will be better off declaring
+    your QVariant as a property.
+
+    Not all QVariant types are supported. Below is a list of currently
+    supported QVariant types:
+
+    \list
+        \o \l{QMetaType::}{Int}
+        \o \l{QMetaType::}{Double}
+        \o \l{QMetaType::}{Float}
+        \o \l{QMetaType::}{QLine}
+        \o \l{QMetaType::}{QLineF}
+        \o \l{QMetaType::}{QPoint}
+        \o \l{QMetaType::}{QSize}
+        \o \l{QMetaType::}{QSizeF}
+        \o \l{QMetaType::}{QRect}
+        \o \l{QMetaType::}{QRectF}
+    \endlist
+
+    If you need to interpolate other variant types, including custom
+    types, you have to implement interpolation for these yourself.
+    You do this by reimplementing interpolated(), which returns
+    interpolation values for the value being interpolated.
+
+    \omit We need some snippets around here. \endomit
+
+    \sa QPropertyAnimation, QAbstractAnimation, {The Animation Framework}
+*/
+
+/*!
+    \fn void QVariantAnimation::valueChanged(const QVariant &value)
+
+    QVariantAnimation emits this signal whenever the current \a value changes.
+
+    \sa currentValue, startValue, endValue
+*/
+
+static bool animationValueLessThan(const QVariantAnimation::KeyValue &p1, const QVariantAnimation::KeyValue &p2)
+{
+    return p1.first < p2.first;
+}
+
+template<> Q_INLINE_TEMPLATE QRect _q_interpolate(const QRect &f, const QRect &t, qreal progress)
+{
+    QRect ret;
+    ret.setCoords(_q_interpolate(f.left(), t.left(), progress),
+                  _q_interpolate(f.top(), t.top(), progress),
+                  _q_interpolate(f.right(), t.right(), progress),
+                  _q_interpolate(f.bottom(), t.bottom(), progress));
+    return ret;
+}
+
+template<> Q_INLINE_TEMPLATE QRectF _q_interpolate(const QRectF &f, const QRectF &t, qreal progress)
+{
+    qreal x1, y1, w1, h1;
+    f.getRect(&x1, &y1, &w1, &h1);
+    qreal x2, y2, w2, h2;
+    t.getRect(&x2, &y2, &w2, &h2);
+    return QRectF(_q_interpolate(x1, x2, progress), _q_interpolate(y1, y2, progress),
+                  _q_interpolate(w1, w2, progress), _q_interpolate(h1, h2, progress));
+}
+
+template<> Q_INLINE_TEMPLATE QLine _q_interpolate(const QLine &f, const QLine &t, qreal progress)
+{
+    return QLine( _q_interpolate(f.p1(), t.p1(), progress), _q_interpolate(f.p2(), t.p2(), progress));
+}
+
+template<> Q_INLINE_TEMPLATE QLineF _q_interpolate(const QLineF &f, const QLineF &t, qreal progress)
+{
+    return QLineF( _q_interpolate(f.p1(), t.p1(), progress), _q_interpolate(f.p2(), t.p2(), progress));
+}
+
+void QVariantAnimationPrivate::convertValues(int t)
+{
+    //this ensures that all the keyValues are of type t
+    for (int i = 0; i < keyValues.count(); ++i) {
+        QVariantAnimation::KeyValue &pair = keyValues[i];
+        if (pair.second.userType() != t)
+            pair.second.convert(static_cast<QVariant::Type>(t));
+    }
+    interpolator = 0; // if the type changed we need to update the interpolator
+}
+
+/*!
+    \internal
+    The goal of this function is to update the currentInterval member. As a consequence, we also
+    need to update the currentValue.
+    Set \a force to true to always recalculate the interval.
+*/
+void QVariantAnimationPrivate::recalculateCurrentInterval(bool force/*=false*/)
+{
+    // can't interpolate if we have only 1 key value
+    if (keyValues.count() <= 1)
+        return;
+
+    const qreal progress = easing.valueForProgress(((duration == 0) ? qreal(1) : qreal(currentTime) / qreal(duration)));
+
+    if (force || progress < currentInterval.start.first || progress > currentInterval.end.first) {
+        //let's update currentInterval
+        QVariantAnimation::KeyValues::const_iterator itStart = qLowerBound(keyValues.constBegin(),
+                                                                           keyValues.constEnd(),
+                                                                           qMakePair(progress, QVariant()),
+                                                                           animationValueLessThan);
+        QVariantAnimation::KeyValues::const_iterator itEnd = itStart;
+
+        // If we are at the end we should continue to use the last keyValues in case of extrapolation (progress > 1.0).
+        // This is because the easing function can return a value slightly outside the range [0, 1]
+        if (itStart != keyValues.constEnd()) {
+            // this can't happen because we always prepend the default start value there
+            if (itStart == keyValues.constBegin()) {
+                ++itEnd;
+            } else {
+                --itStart;
+            }
+
+            // update all the values of the currentInterval
+            currentInterval.start = *itStart;
+            currentInterval.end = *itEnd;
+        }
+    }
+    setCurrentValueForProgress(progress);
+}
+
+void QVariantAnimationPrivate::setCurrentValueForProgress(const qreal progress)
+{
+    Q_Q(QVariantAnimation);
+
+    const qreal startProgress = currentInterval.start.first;
+    const qreal endProgress = currentInterval.end.first;
+    const qreal localProgress = (progress - startProgress) / (endProgress - startProgress);
+
+    QVariant ret = q->interpolated(currentInterval.start.second,
+                                   currentInterval.end.second,
+                                   localProgress);
+    qSwap(currentValue, ret);
+    q->updateCurrentValue(currentValue);
+    if ((connectedSignals & changedSignalMask) && currentValue != ret) {
+        //the value has changed
+        emit q->valueChanged(currentValue);
+    }
+}
+
+QVariant QVariantAnimationPrivate::valueAt(qreal step) const
+{
+    QVariantAnimation::KeyValues::const_iterator result =
+        qBinaryFind(keyValues.begin(), keyValues.end(), qMakePair(step, QVariant()), animationValueLessThan);
+    if (result != keyValues.constEnd())
+        return result->second;
+
+    return QVariant();
+}
+
+void QVariantAnimationPrivate::setValueAt(qreal step, const QVariant &value)
+{
+    if (step < qreal(0.0) || step > qreal(1.0)) {
+        qWarning("QVariantAnimation::setValueAt: invalid step = %f", step);
+        return;
+    }
+
+    QVariantAnimation::KeyValue pair(step, value);
+
+    QVariantAnimation::KeyValues::iterator result = qLowerBound(keyValues.begin(), keyValues.end(), pair, animationValueLessThan);
+    if (result == keyValues.end() || result->first != step) {
+        keyValues.insert(result, pair);
+    } else {
+        if (value.isValid())
+            result->second = value; // replaces the previous value
+        else if (step == 0 && !hasStartValue && defaultStartValue.isValid())
+            result->second = defaultStartValue; // resets to the default start value
+        else
+            keyValues.erase(result); // removes the previous value
+    }
+
+    recalculateCurrentInterval(/*force=*/true);
+}
+
+void QVariantAnimationPrivate::setDefaultStartValue(const QVariant &value)
+{
+    defaultStartValue = value;
+    if (!hasStartValue)
+      setValueAt(0, value);
+}
+
+/*!
+    Construct a QVariantAnimation object. \a parent is passed to QAbstractAnimation's
+    constructor.
+*/
+QVariantAnimation::QVariantAnimation(QObject *parent) : QAbstractAnimation(*new QVariantAnimationPrivate, parent)
+{
+   d_func()->init();
+}
+
+/*!
+    \internal
+*/
+QVariantAnimation::QVariantAnimation(QVariantAnimationPrivate &dd, QObject *parent) : QAbstractAnimation(dd, parent)
+{
+   d_func()->init();
+}
+
+/*!
+    Destroys the animation.
+*/
+QVariantAnimation::~QVariantAnimation()
+{
+}
+
+/*!
+    \property QVariantAnimation::easingCurve
+    \brief the easing curve of the animation
+
+    This property defines the easing curve of the animation. By
+    default, a linear easing curve is used, resulting in linear
+    interpolation. Other curves are provided, for instance,
+    QEasingCurve::InCirc, which provides a circular entry curve.
+    Another example is QEasingCurve::InOutElastic, which provides an
+    elastic effect on the values of the interpolated variant.
+
+    The easing curve is used with the interpolator, the interpolated()
+    virtual function, the animation's duration, and iterationCount, to
+    control how the current value changes as the animation progresses.
+*/
+QEasingCurve QVariantAnimation::easingCurve() const
+{
+    Q_D(const QVariantAnimation);
+    return d->easing;
+}
+
+void QVariantAnimation::setEasingCurve(const QEasingCurve &easing)
+{
+    Q_D(QVariantAnimation);
+    d->easing = easing;
+    d->recalculateCurrentInterval();
+}
+
+Q_GLOBAL_STATIC(QVector<QVariantAnimation::Interpolator>, registeredInterpolators)
+Q_GLOBAL_STATIC(QReadWriteLock, registeredInterpolatorsLock)
+
+/*!
+    \fn void qRegisterAnimationInterpolator(QVariant (*func)(const T &from, const T &to, qreal progress))
+    \relates QVariantAnimation
+    \threadsafe
+
+    Registers a custom interpolator \a func for the template type \c{T}.
+    The interpolator has to be registered before the animation is constructed.
+    To unregister (and use the default interpolator) set \a func to 0.
+ */
+
+/*!
+    \internal
+    \typedef QVariantAnimation::Interpolator
+
+    This is a typedef for a pointer to a function with the following
+    signature:
+    \code
+    QVariant myInterpolator(const QVariant &from, const QVariant &to, qreal progress);
+    \endcode
+
+*/
+
+/*! \internal
+ * Registers a custom interpolator \a func for the specific \a interpolationType.
+ * The interpolator has to be registered before the animation is constructed.
+ * To unregister (and use the default interpolator) set \a func to 0.
+ */
+void QVariantAnimation::registerInterpolator(QVariantAnimation::Interpolator func, int interpolationType)
+{
+    // will override any existing interpolators
+    QWriteLocker locker(registeredInterpolatorsLock());
+    if (int(interpolationType) >= registeredInterpolators()->count())
+        registeredInterpolators()->resize(int(interpolationType) + 1);
+    registeredInterpolators()->replace(interpolationType, func);
+}
+
+
+template<typename T> static inline QVariantAnimation::Interpolator castToInterpolator(QVariant (*func)(const T &from, const T &to, qreal progress))
+{
+     return reinterpret_cast<QVariantAnimation::Interpolator>(func);
+}
+
+QVariantAnimation::Interpolator QVariantAnimationPrivate::getInterpolator(int interpolationType)
+{
+    QReadLocker locker(registeredInterpolatorsLock());
+    QVariantAnimation::Interpolator ret = 0;
+    if (interpolationType < registeredInterpolators()->count()) {
+        ret = registeredInterpolators()->at(interpolationType);
+        if (ret) return ret;
+    }
+
+    switch(interpolationType)
+    {
+    case QMetaType::Int:
+        return castToInterpolator(_q_interpolateVariant<int>);
+    case QMetaType::Double:
+        return castToInterpolator(_q_interpolateVariant<double>);
+    case QMetaType::Float:
+        return castToInterpolator(_q_interpolateVariant<float>);
+    case QMetaType::QLine:
+        return castToInterpolator(_q_interpolateVariant<QLine>);
+    case QMetaType::QLineF:
+        return castToInterpolator(_q_interpolateVariant<QLineF>);
+    case QMetaType::QPoint:
+        return castToInterpolator(_q_interpolateVariant<QPoint>);
+    case QMetaType::QPointF:
+        return castToInterpolator(_q_interpolateVariant<QPointF>);
+    case QMetaType::QSize:
+        return castToInterpolator(_q_interpolateVariant<QSize>);
+    case QMetaType::QSizeF:
+        return castToInterpolator(_q_interpolateVariant<QSizeF>);
+    case QMetaType::QRect:
+        return castToInterpolator(_q_interpolateVariant<QRect>);
+    case QMetaType::QRectF:
+        return castToInterpolator(_q_interpolateVariant<QRectF>);
+    default:
+        return 0; //this type is not handled
+    }
+}
+
+/*!
+    \property QVariantAnimation::duration
+    \brief the duration of the animation
+
+    This property describes the duration in milliseconds of the
+    animation. The default duration is 250 milliseconds.
+
+    \sa QAbstractAnimation::duration()
+ */
+int QVariantAnimation::duration() const
+{
+    Q_D(const QVariantAnimation);
+    return d->duration;
+}
+
+void QVariantAnimation::setDuration(int msecs)
+{
+    Q_D(QVariantAnimation);
+    if (msecs < 0) {
+        qWarning("QVariantAnimation::setDuration: cannot set a negative duration");
+        return;
+    }
+    if (d->duration == msecs)
+        return;
+    d->duration = msecs;
+    d->recalculateCurrentInterval();
+}
+
+/*!
+    \property QVariantAnimation::startValue
+    \brief the optional start value of the animation
+
+    This property describes the optional start value of the animation. If
+    omitted, or if a null QVariant is assigned as the start value, the
+    animation will use the current position of the end when the animation
+    is started.
+
+    \sa endValue
+*/
+QVariant QVariantAnimation::startValue() const
+{
+    return keyValueAt(0);
+}
+
+void QVariantAnimation::setStartValue(const QVariant &value)
+{
+    setKeyValueAt(0, value);
+}
+
+/*!
+    \property QVariantAnimation::endValue
+    \brief the end value of the animation
+
+    This property describes the end value of the animation.
+
+    \sa startValue
+ */
+QVariant QVariantAnimation::endValue() const
+{
+    return keyValueAt(1);
+}
+
+void QVariantAnimation::setEndValue(const QVariant &value)
+{
+    setKeyValueAt(1, value);
+}
+
+
+/*!
+    Returns the key frame value for the given \a step. The given \a step
+    must be in the range 0 to 1. If there is no KeyValue for \a step,
+    it returns an invalid QVariant.
+
+    \sa keyValues(), setKeyValueAt()
+*/
+QVariant QVariantAnimation::keyValueAt(qreal step) const
+{
+    Q_D(const QVariantAnimation);
+    if (step == 0 && !d->hasStartValue)
+        return QVariant(); //special case where we don't have an explicit startValue
+
+    return d->valueAt(step);
+}
+
+/*!
+    \typedef QVariantAnimation::KeyValue
+
+    This is a typedef for QPair<qreal, QVariant>.
+*/
+/*!
+    \typedef QVariantAnimation::KeyValues
+
+    This is a typedef for QVector<KeyValue>
+*/
+
+/*!
+    Creates a key frame at the given \a step with the given \a value.
+    The given \a step must be in the range 0 to 1.
+
+    \sa setKeyValues(), keyValueAt()
+*/
+void QVariantAnimation::setKeyValueAt(qreal step, const QVariant &value)
+{
+    Q_D(QVariantAnimation);
+    if (step == 0)
+        d->hasStartValue = value.isValid();
+    d->setValueAt(step, value);
+}
+
+/*!
+    Returns the key frames of this animation.
+
+    \sa keyValueAt(), setKeyValues()
+*/
+QVariantAnimation::KeyValues QVariantAnimation::keyValues() const
+{
+    Q_D(const QVariantAnimation);
+    QVariantAnimation::KeyValues ret = d->keyValues;
+    //in case we added the default start value, we remove it
+    if (!d->hasStartValue && !ret.isEmpty() && ret.at(0).first == 0)
+        ret.remove(0);
+    return ret;
+}
+
+/*!
+    Replaces the current set of key frames with the given \a keyValues.
+    the step of the key frames must be in the range 0 to 1.
+
+    \sa keyValues(), keyValueAt()
+*/
+void QVariantAnimation::setKeyValues(const KeyValues &keyValues)
+{
+    Q_D(QVariantAnimation);
+    d->keyValues = keyValues;
+    qSort(d->keyValues.begin(), d->keyValues.end(), animationValueLessThan);
+    d->hasStartValue = !d->keyValues.isEmpty() && d->keyValues.at(0).first == 0;
+    d->recalculateCurrentInterval(/*force=*/true);
+}
+
+/*!
+    \property QVariantAnimation::currentValue
+    \brief the current value of the animation.
+
+    This property describes the current value; an interpolated value
+    between the \l{startValue}{start value} and the \l{endValue}{end
+    value}, using the current time for progress. The value itself is
+    obtained from interpolated(), which is called repeatedly as the
+    animation is running.
+
+    QVariantAnimation calls the virtual updateCurrentValue() function
+    when the current value changes. This is particularly useful for
+    subclasses that need to track updates. For example,
+    QPropertyAnimation uses this function to animate Qt \l{Qt's
+    Property System}{properties}.
+
+    \sa startValue, endValue
+*/
+QVariant QVariantAnimation::currentValue() const
+{
+    Q_D(const QVariantAnimation);
+    if (!d->currentValue.isValid())
+        const_cast<QVariantAnimationPrivate*>(d)->recalculateCurrentInterval();
+    return d->currentValue;
+}
+
+/*!
+    \reimp
+ */
+bool QVariantAnimation::event(QEvent *event)
+{
+    return QAbstractAnimation::event(event);
+}
+
+/*!
+    \reimp
+*/
+void QVariantAnimation::updateState(QAbstractAnimation::State oldState,
+                                    QAbstractAnimation::State newState)
+{
+    Q_UNUSED(oldState);
+    Q_UNUSED(newState);
+}
+
+/*!
+
+    This virtual function returns the linear interpolation between
+    variants \a from and \a to, at \a progress, usually a value
+    between 0 and 1. You can reimplement this function in a subclass
+    of QVariantAnimation to provide your own interpolation algorithm.
+
+    Note that in order for the interpolation to work with a
+    QEasingCurve that return a value smaller than 0 or larger than 1
+    (such as QEasingCurve::InBack) you should make sure that it can
+    extrapolate. If the semantic of the datatype does not allow
+    extrapolation this function should handle that gracefully.
+
+    You should call the QVariantAnimation implementation of this
+    function if you want your class to handle the types already
+    supported by Qt (see class QVariantAnimation description for a
+    list of supported types).
+
+    \sa QEasingCurve
+ */
+QVariant QVariantAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
+{
+    Q_D(const QVariantAnimation);
+    if (d->interpolator == 0) {
+        if (from.userType() == to.userType())
+            d->interpolator = QVariantAnimationPrivate::getInterpolator(from.userType());
+        if (d->interpolator == 0) //no interpolator found
+            return QVariant();
+    }
+
+    return d->interpolator(from.constData(), to.constData(), progress);
+}
+
+/*!
+    \reimp
+ */
+void QVariantAnimation::updateCurrentTime(int msecs)
+{
+    Q_D(QVariantAnimation);
+    Q_UNUSED(msecs);
+    d->recalculateCurrentInterval();
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qvariantanimation.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qvariantanimation.h b/src/corelib/animation/qvariantanimation.h
new file mode 100644
index 0000000..3ae172f
--- /dev/null
+++ b/src/corelib/animation/qvariantanimation.h
@@ -0,0 +1,130 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANIMATION_H
+#define QANIMATION_H
+
+#include <QtCore/qeasingcurve.h>
+#include <QtCore/qabstractanimation.h>
+#include <QtCore/qvector.h>
+#include <QtCore/qvariant.h>
+#include <QtCore/qpair.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QVariantAnimationPrivate;
+class Q_CORE_EXPORT QVariantAnimation : public QAbstractAnimation
+{
+    Q_OBJECT
+    Q_PROPERTY(QVariant startValue READ startValue WRITE setStartValue)
+    Q_PROPERTY(QVariant endValue READ endValue WRITE setEndValue)
+    Q_PROPERTY(QVariant currentValue READ currentValue NOTIFY currentValueChanged)
+    Q_PROPERTY(int duration READ duration WRITE setDuration)
+    Q_PROPERTY(QEasingCurve easingCurve READ easingCurve WRITE setEasingCurve)
+
+public:
+    typedef QPair<qreal, QVariant> KeyValue;
+    typedef QVector<KeyValue> KeyValues;
+
+    QVariantAnimation(QObject *parent = 0);
+    ~QVariantAnimation();
+
+    QVariant startValue() const;
+    void setStartValue(const QVariant &value);
+
+    QVariant endValue() const;
+    void setEndValue(const QVariant &value);
+
+    QVariant keyValueAt(qreal step) const;
+    void setKeyValueAt(qreal step, const QVariant &value);
+
+    KeyValues keyValues() const;
+    void setKeyValues(const KeyValues &values);
+
+    QVariant currentValue() const;
+
+    int duration() const;
+    void setDuration(int msecs);
+
+    QEasingCurve easingCurve() const;
+    void setEasingCurve(const QEasingCurve &easing);
+
+    typedef QVariant (*Interpolator)(const void *from, const void *to, qreal progress);
+
+Q_SIGNALS:
+    void valueChanged(const QVariant &value);
+
+protected:
+    QVariantAnimation(QVariantAnimationPrivate &dd, QObject *parent = 0);
+    bool event(QEvent *event);
+
+    void updateCurrentTime(int msecs);
+    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+
+    virtual void updateCurrentValue(const QVariant &value) = 0;
+    virtual QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const;
+
+private:
+    template <typename T> friend void qRegisterAnimationInterpolator(QVariant (*func)(const T &, const T &, qreal));
+    static void registerInterpolator(Interpolator func, int interpolationType);
+
+    Q_DISABLE_COPY(QVariantAnimation)
+    Q_DECLARE_PRIVATE(QVariantAnimation)
+};
+
+template <typename T>
+void qRegisterAnimationInterpolator(QVariant (*func)(const T &from, const T &to, qreal progress)) {
+    QVariantAnimation::registerInterpolator(reinterpret_cast<QVariantAnimation::Interpolator>(func), qMetaTypeId<T>());
+}
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif //QANIMATION_H
diff --git a/src/corelib/animation/qvariantanimation_p.h b/src/corelib/animation/qvariantanimation_p.h
new file mode 100644
index 0000000..0d296db
--- /dev/null
+++ b/src/corelib/animation/qvariantanimation_p.h
@@ -0,0 +1,130 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANIMATION_P_H
+#define QANIMATION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qvariantanimation.h"
+#include <QtCore/qeasingcurve.h>
+#include <QtCore/qmetaobject.h>
+#include <QtCore/qvector.h>
+
+#include "qabstractanimation_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QVariantAnimationPrivate : public QAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QVariantAnimation)
+public:
+
+    QVariantAnimationPrivate() : duration(250), hasStartValue(false)
+    {
+    }
+
+    void init()
+    {
+        //we keep the mask so that we emit valueChanged only when needed (for performance reasons)
+        changedSignalMask = (1 << q_func()->metaObject()->indexOfSignal("valueChanged(QVariant)"));
+        currentInterval.start.first = currentInterval.end.first = 2; //will force the initial refresh
+        interpolator = 0;
+    }
+
+    static QVariantAnimationPrivate *get(QVariantAnimation *q)
+    {
+        return q->d_func();
+    }
+
+    void setDefaultStartValue(const QVariant &value);
+
+    int duration;
+    QEasingCurve easing;
+
+    QVariantAnimation::KeyValues keyValues;
+    QVariant currentValue;
+    QVariant defaultStartValue;
+    bool hasStartValue;
+
+    //this is used to keep track of the KeyValue interval in which we currently are
+    struct
+    {
+        QVariantAnimation::KeyValue start, end;
+    } currentInterval;
+
+    mutable QVariantAnimation::Interpolator interpolator;
+
+    quint32 changedSignalMask;
+
+    void setCurrentValueForProgress(const qreal progress);
+    void recalculateCurrentInterval(bool force=false);
+    void setValueAt(qreal, const QVariant &);
+    QVariant valueAt(qreal step) const;
+    void convertValues(int t);
+
+    static QVariantAnimation::Interpolator getInterpolator(int interpolationType);
+};
+
+//this should make the interpolation faster
+template<typename T> inline T _q_interpolate(const T &f, const T &t, qreal progress)
+{
+    return T(f + (t - f) * progress);
+}
+
+template<typename T > inline QVariant _q_interpolateVariant(const T &from, const T &to, qreal progress)
+{
+    return _q_interpolate(from, to, progress);
+}
+
+
+QT_END_NAMESPACE
+
+#endif //QANIMATION_P_H
diff --git a/src/corelib/corelib.pro b/src/corelib/corelib.pro
index f99d57f..db51d43 100644
--- a/src/corelib/corelib.pro
+++ b/src/corelib/corelib.pro
@@ -5,6 +5,7 @@ DEFINES   += QT_BUILD_CORE_LIB QT_NO_USING_NAMESPACE
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x67000000
 
 include(../qbase.pri)
+include(animation/animation.pri)
 include(arch/arch.pri)
 include(concurrent/concurrent.pri)
 include(global/global.pri)
@@ -14,6 +15,7 @@ include(io/io.pri)
 include(plugin/plugin.pri)
 include(kernel/kernel.pri)
 include(codecs/codecs.pri)
+include(statemachine/statemachine.pri)
 include(xml/xml.pri)
 
 mac|darwin:LIBS += -framework ApplicationServices
diff --git a/src/corelib/io/qfile.cpp b/src/corelib/io/qfile.cpp
index 04750b0..4deaddb 100644
--- a/src/corelib/io/qfile.cpp
+++ b/src/corelib/io/qfile.cpp
@@ -719,38 +719,47 @@ QFile::rename(const QString &newName)
             return true;
         }
 
-        QFile in(fileName());
+        if (isSequential()) {
+            d->setError(QFile::RenameError, tr("Will not rename sequential file using block copy"));
+            return false;
+        }
+
         QFile out(newName);
-        if (in.open(QIODevice::ReadOnly)) {
+        if (open(QIODevice::ReadOnly)) {
             if (out.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
                 bool error = false;
                 char block[4096];
-                qint64 read;
-                while ((read = in.read(block, sizeof(block))) > 0) {
-                    if (read != out.write(block, read)) {
+                qint64 bytes;
+                while ((bytes = read(block, sizeof(block))) > 0) {
+                    if (bytes != out.write(block, bytes)) {
                         d->setError(QFile::RenameError, out.errorString());
                         error = true;
                         break;
                     }
                 }
-                if (read == -1) {
-                    d->setError(QFile::RenameError, in.errorString());
+                if (bytes == -1) {
+                    d->setError(QFile::RenameError, errorString());
                     error = true;
                 }
                 if(!error) {
-                    if (!in.remove()) {
+                    if (!remove()) {
                         d->setError(QFile::RenameError, tr("Cannot remove source file"));
                         error = true;
                     }
                 }
                 if (error)
                     out.remove();
-                else
+                else {
+                    setPermissions(permissions());
+                    unsetError();
                     setFileName(newName);
+                }
+                close();
                 return !error;
             }
+            close();
         }
-        d->setError(QFile::RenameError, out.isOpen() ? in.errorString() : out.errorString());
+        d->setError(QFile::RenameError, out.isOpen() ? errorString() : out.errorString());
     }
     return false;
 }
diff --git a/src/corelib/io/qfsfileengine.cpp b/src/corelib/io/qfsfileengine.cpp
index 61ea7cc..e79d867 100644
--- a/src/corelib/io/qfsfileengine.cpp
+++ b/src/corelib/io/qfsfileengine.cpp
@@ -312,6 +312,10 @@ bool QFSFileEnginePrivate::openFh(QIODevice::OpenMode openMode, FILE *fh)
         if (ret == -1) {
             q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
                         qt_error_string(int(errno)));
+
+            this->openMode = QIODevice::NotOpen;
+            this->fh = 0;
+
             return false;
         }
     }
@@ -335,6 +339,7 @@ bool QFSFileEngine::open(QIODevice::OpenMode openMode, int fd)
     if ((openMode & QFile::WriteOnly) && !(openMode & (QFile::ReadOnly | QFile::Append)))
         openMode |= QFile::Truncate;
 
+    d->openMode = openMode;
     d->lastFlushFailed = false;
     d->closeFileHandle = false;
     d->nativeFilePath.clear();
@@ -367,6 +372,10 @@ bool QFSFileEnginePrivate::openFd(QIODevice::OpenMode openMode, int fd)
         if (ret == -1) {
             q->setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError,
                         qt_error_string(int(errno)));
+
+            this->openMode = QIODevice::NotOpen;
+            this->fd = -1;
+
             return false;
         }
     }
@@ -868,6 +877,119 @@ bool QFSFileEngine::supportsExtension(Extension extension) const
     return false;
 }
 
+/*! \fn bool QFSFileEngine::caseSensitive() const
+  Returns true for Windows, false for Unix.
+*/
+
+/*! \fn bool QFSFileEngine::copy(const QString &copyName)
+
+  For windows, copy the file to file \a copyName.
+
+  Not implemented for Unix.
+*/
+
+/*! \fn QString QFSFileEngine::currentPath(const QString &fileName)
+  For Unix, returns the current working directory for the file
+  engine.
+  
+  For Windows, returns the canonicalized form of the current path used
+  by the file engine for the drive specified by \a fileName.  On
+  Windows, each drive has its own current directory, so a different
+  path is returned for file names that include different drive names
+  (e.g. A: or C:).
+
+  \sa setCurrentPath()
+*/
+
+/*! \fn QFileInfoList QFSFileEngine::drives()
+  For Windows, returns the list of drives in the file system as a list
+  of QFileInfo objects. On unix, Mac OS X and Windows CE, only the
+  root path is returned.  On Windows, this function returns all drives
+  (A:\, C:\, D:\, etc.).
+
+  For Unix, the list contains just the root path "/".
+*/
+
+/*! \fn QString QFSFileEngine::fileName(FileName file) const
+  \reimp
+*/
+
+/*! \fn QDateTime QFSFileEngine::fileTime(FileTime time) const
+  \reimp
+*/
+
+/*! \fn QString QFSFileEngine::homePath()
+  Returns the home path of the current user.
+
+  \sa rootPath()
+*/
+
+/*! \fn bool QFSFileEngine::isRelativePath() const
+  \reimp
+*/
+
+/*! \fn bool QFSFileEngine::link(const QString &newName)
+
+  Creates a link from the file currently specified by fileName() to
+  \a newName. What a link is depends on the underlying filesystem
+  (be it a shortcut on Windows or a symbolic link on Unix). Returns
+  true if successful; otherwise returns false.
+*/
+
+/*! \fn bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
+  \reimp
+*/
+
+/*! \fn uint QFSFileEngine::ownerId(FileOwner own) const
+  In Unix, if stat() is successful, the \c uid is returned if
+  \a own is the owner. Otherwise the \c gid is returned. If stat()
+  is unsuccessful, -2 is reuturned.
+
+  For Windows, -2 is always returned.
+*/
+
+/*! \fn QString QFSFileEngine::owner() const
+  \reimp
+*/
+
+/*! \fn bool QFSFileEngine::remove()
+  \reimp
+*/
+
+/*! \fn bool QFSFileEngine::rename(const QString &newName)
+  \reimp
+*/
+
+/*! \fn bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
+  \reimp
+*/
+
+/*! \fn QString QFSFileEngine::rootPath()
+  Returns the root path.
+
+  \sa homePath()
+*/
+
+/*! \fn bool QFSFileEngine::setCurrentPath(const QString &path)
+  Sets the current path (e.g., for QDir), to \a path. Returns true if the
+  new path exists; otherwise this function does nothing, and returns false.
+
+  \sa currentPath()
+*/
+
+/*! \fn bool QFSFileEngine::setPermissions(uint perms)
+  \reimp
+*/
+
+/*! \fn bool QFSFileEngine::setSize(qint64 size)
+  \reimp
+*/
+
+/*! \fn QString QFSFileEngine::tempPath()
+  Returns the temporary path (i.e., a path in which it is safe
+  to store temporary files).
+*/
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_FSFILEENGINE
diff --git a/src/corelib/io/qfsfileengine_unix.cpp b/src/corelib/io/qfsfileengine_unix.cpp
index 7a6a85b..8ea48d1 100644
--- a/src/corelib/io/qfsfileengine_unix.cpp
+++ b/src/corelib/io/qfsfileengine_unix.cpp
@@ -273,9 +273,8 @@ qint64 QFSFileEnginePrivate::nativeRead(char *data, qint64 len)
         int oldFlags = fcntl(QT_FILENO(fh), F_GETFL);
         for (int i = 0; i < 2; ++i) {
             // Unix: Make the underlying file descriptor non-blocking
-            int v = 1;
             if ((oldFlags & O_NONBLOCK) == 0)
-                fcntl(QT_FILENO(fh), F_SETFL, oldFlags | O_NONBLOCK, &v, sizeof(v));
+                fcntl(QT_FILENO(fh), F_SETFL, oldFlags | O_NONBLOCK);
 
             // Cross platform stdlib read
             size_t read = 0;
@@ -293,8 +292,7 @@ qint64 QFSFileEnginePrivate::nativeRead(char *data, qint64 len)
 
             // Unix: Restore the blocking state of the underlying socket
             if ((oldFlags & O_NONBLOCK) == 0) {
-                int v = 1;
-                fcntl(QT_FILENO(fh), F_SETFL, oldFlags, &v, sizeof(v));
+                fcntl(QT_FILENO(fh), F_SETFL, oldFlags);
                 if (readBytes == 0) {
                     int readByte = 0;
                     do {
@@ -311,8 +309,7 @@ qint64 QFSFileEnginePrivate::nativeRead(char *data, qint64 len)
         }
         // Unix: Restore the blocking state of the underlying socket
         if ((oldFlags & O_NONBLOCK) == 0) {
-            int v = 1;
-            fcntl(QT_FILENO(fh), F_SETFL, oldFlags, &v, sizeof(v));
+            fcntl(QT_FILENO(fh), F_SETFL, oldFlags);
         }
         if (readBytes == 0 && !feof(fh)) {
             // if we didn't read anything and we're not at EOF, it must be an error
diff --git a/src/corelib/io/qfsfileengine_win.cpp b/src/corelib/io/qfsfileengine_win.cpp
index c5b54b4..5d6cd06 100644
--- a/src/corelib/io/qfsfileengine_win.cpp
+++ b/src/corelib/io/qfsfileengine_win.cpp
@@ -946,9 +946,6 @@ bool QFSFileEnginePrivate::nativeIsSequential() const
     return false;
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::remove()
 {
     Q_D(QFSFileEngine);
@@ -959,9 +956,6 @@ bool QFSFileEngine::remove()
     });
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::copy(const QString &copyName)
 {
     Q_D(QFSFileEngine);
@@ -974,9 +968,6 @@ bool QFSFileEngine::copy(const QString &copyName)
     });
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::rename(const QString &newName)
 {
     Q_D(QFSFileEngine);
@@ -1017,9 +1008,6 @@ static inline bool mkDir(const QString &path)
     });
 }
 
-/*!
-    \reimp
-*/
 static inline bool rmDir(const QString &path)
 {
     QT_WA({
@@ -1029,9 +1017,6 @@ static inline bool rmDir(const QString &path)
     });
 }
 
-/*!
-    \reimp
-*/
 static inline bool isDirPath(const QString &dirPath, bool *existed)
 {
     QString path = dirPath;
@@ -1054,9 +1039,6 @@ static inline bool isDirPath(const QString &dirPath, bool *existed)
     return fileAttrib & FILE_ATTRIBUTE_DIRECTORY;
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) const
 {
     QString dirName = name;
@@ -1097,9 +1079,6 @@ bool QFSFileEngine::mkdir(const QString &name, bool createParentDirectories) con
     return mkDir(name);
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) const
 {
     QString dirName = name;
@@ -1120,20 +1099,11 @@ bool QFSFileEngine::rmdir(const QString &name, bool recurseParentDirectories) co
     return rmDir(name);
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::caseSensitive() const
 {
     return false;
 }
 
-/*!
-    Sets the current path (e.g., for QDir), to \a path. Returns true if the
-    new path exists; otherwise this function does nothing, and returns false.
-
-    \sa currentPath()
-*/
 bool QFSFileEngine::setCurrentPath(const QString &path)
 {
     if (!QDir(path).exists())
@@ -1153,16 +1123,6 @@ bool QFSFileEngine::setCurrentPath(const QString &path)
 #endif
 }
 
-/*!
-    Returns the canonicalized form of the current path used by the file
-    engine for the drive specified by \a fileName.
-
-    On Windows, each drive has its own current directory, so a different
-    path is returned for file names that include different drive names
-    (e.g. A: or C:).
-
-    \sa setCurrentPath()
-*/
 QString QFSFileEngine::currentPath(const QString &fileName)
 {
 #if !defined(Q_OS_WINCE)
@@ -1219,11 +1179,6 @@ QString QFSFileEngine::currentPath(const QString &fileName)
 #endif
 }
 
-/*!
-    Returns the home path of the current user.
-
-    \sa rootPath()
-*/
 QString QFSFileEngine::homePath()
 {
     QString ret;
@@ -1277,11 +1232,6 @@ QString QFSFileEngine::homePath()
     return QDir::fromNativeSeparators(ret);
 }
 
-/*!
-    Returns the root path.
-
-    \sa homePath()
-*/
 QString QFSFileEngine::rootPath()
 {
 #if defined(Q_OS_WINCE)
@@ -1299,10 +1249,6 @@ QString QFSFileEngine::rootPath()
     return ret;
 }
 
-/*!
-    Returns the temporary path (i.e., a path in which it is safe to store
-    temporary files).
-*/
 QString QFSFileEngine::tempPath()
 {
     QString ret;
@@ -1330,11 +1276,6 @@ QString QFSFileEngine::tempPath()
     return ret;
 }
 
-/*!
-    Returns the list of drives in the file system as a list of QFileInfo
-    objects. On unix, Mac OS X and Windows CE, only the root path is returned.
-    On Windows, this function returns all drives (A:\, C:\, D:\, etc.).
-*/
 QFileInfoList QFSFileEngine::drives()
 {
     QFileInfoList ret;
@@ -1554,9 +1495,6 @@ QString QFSFileEnginePrivate::getLink() const
     return readLink(filePath);
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::link(const QString &newName)
 {
 #if !defined(Q_OS_WINCE)
@@ -1814,9 +1752,6 @@ QAbstractFileEngine::FileFlags QFSFileEngine::fileFlags(QAbstractFileEngine::Fil
     return ret;
 }
 
-/*!
-    \reimp
-*/
 QString QFSFileEngine::fileName(FileName file) const
 {
     Q_D(const QFSFileEngine);
@@ -1910,9 +1845,6 @@ QString QFSFileEngine::fileName(FileName file) const
     return d->filePath;
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::isRelativePath() const
 {
     Q_D(const QFSFileEngine);
@@ -1922,18 +1854,12 @@ bool QFSFileEngine::isRelativePath() const
         || (d->filePath.at(0) == QLatin1Char('/') && d->filePath.at(1) == QLatin1Char('/')))));                // drive, e.g. a:
 }
 
-/*!
-    \reimp
-*/
 uint QFSFileEngine::ownerId(FileOwner /*own*/) const
 {
     static const uint nobodyID = (uint) -2;
     return nobodyID;
 }
 
-/*!
-    \reimp
-*/
 QString QFSFileEngine::owner(FileOwner own) const
 {
 #if !defined(QT_NO_LIBRARY)
@@ -1972,9 +1898,6 @@ QString QFSFileEngine::owner(FileOwner own) const
     return QString(QLatin1String(""));
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::setPermissions(uint perms)
 {
     Q_D(QFSFileEngine);
@@ -2001,9 +1924,6 @@ bool QFSFileEngine::setPermissions(uint perms)
    return ret;
 }
 
-/*!
-    \reimp
-*/
 bool QFSFileEngine::setSize(qint64 size)
 {
     Q_D(QFSFileEngine);
@@ -2073,9 +1993,6 @@ static inline QDateTime fileTimeToQDateTime(const FILETIME *time)
     return ret;
 }
 
-/*!
-    \reimp
-*/
 QDateTime QFSFileEngine::fileTime(FileTime time) const
 {
     Q_D(const QFSFileEngine);
diff --git a/src/corelib/io/qprocess_unix.cpp b/src/corelib/io/qprocess_unix.cpp
index 2f05f6e..e87c314 100644
--- a/src/corelib/io/qprocess_unix.cpp
+++ b/src/corelib/io/qprocess_unix.cpp
@@ -140,15 +140,6 @@ static void qt_native_close(int fd)
     } while (ret == -1 && errno == EINTR);
 }
 
-static void qt_native_sigaction(int signum, const struct sigaction *act,
-                                struct sigaction *oldact)
-{
-    int ret;
-    do {
-        ret = ::sigaction(signum, act, oldact);
-    } while (ret == -1 && errno == EINTR);
-}
-
 static void qt_native_dup2(int oldfd, int newfd)
 {
     int ret;
@@ -255,7 +246,7 @@ QProcessManager::QProcessManager()
     memset(&action, 0, sizeof(action));
     action.sa_handler = qt_sa_sigchld_handler;
     action.sa_flags = SA_NOCLDSTOP;
-    qt_native_sigaction(SIGCHLD, &action, &oldAction);
+    ::sigaction(SIGCHLD, &action, &oldAction);
     if (oldAction.sa_handler != qt_sa_sigchld_handler)
 	qt_sa_old_sigchld_handler = oldAction.sa_handler;
 }
@@ -282,9 +273,9 @@ QProcessManager::~QProcessManager()
     memset(&action, 0, sizeof(action));
     action.sa_handler = qt_sa_old_sigchld_handler;
     action.sa_flags = SA_NOCLDSTOP;
-    qt_native_sigaction(SIGCHLD, &action, &oldAction);
+    ::sigaction(SIGCHLD, &action, &oldAction);
     if (oldAction.sa_handler != qt_sa_sigchld_handler) {
-        qt_native_sigaction(SIGCHLD, &oldAction, 0);
+        ::sigaction(SIGCHLD, &oldAction, 0);
     }
 }
 
@@ -394,17 +385,10 @@ static void qt_create_pipe(int *pipe)
         qt_native_close(pipe[0]);
     if (pipe[1] != -1)
         qt_native_close(pipe[1]);
-#ifdef Q_OS_IRIX
-    if (::socketpair(AF_UNIX, SOCK_STREAM, 0, pipe) == -1) {
-        qWarning("QProcessPrivate::createPipe: Cannot create pipe %p: %s",
-                 pipe, qPrintable(qt_error_string(errno)));
-    }
-#else
     if (::pipe(pipe) != 0) {
         qWarning("QProcessPrivate::createPipe: Cannot create pipe %p: %s",
                  pipe, qPrintable(qt_error_string(errno)));
     }
-#endif
     ::fcntl(pipe[0], F_SETFD, FD_CLOEXEC);
     ::fcntl(pipe[1], F_SETFD, FD_CLOEXEC);
 }
@@ -596,29 +580,27 @@ void QProcessPrivate::startProcess()
     processManager()->start();
 
     // Initialize pipes
+    if (!createChannel(stdinChannel) ||
+        !createChannel(stdoutChannel) ||
+        !createChannel(stderrChannel))
+        return;
     qt_create_pipe(childStartedPipe);
+    qt_create_pipe(deathPipe);
+    ::fcntl(deathPipe[0], F_SETFD, FD_CLOEXEC);
+    ::fcntl(deathPipe[1], F_SETFD, FD_CLOEXEC);
+
     if (threadData->eventDispatcher) {
         startupSocketNotifier = new QSocketNotifier(childStartedPipe[0],
                                                     QSocketNotifier::Read, q);
         QObject::connect(startupSocketNotifier, SIGNAL(activated(int)),
                          q, SLOT(_q_startupNotification()));
-    }
 
-    qt_create_pipe(deathPipe);
-    ::fcntl(deathPipe[0], F_SETFD, FD_CLOEXEC);
-    ::fcntl(deathPipe[1], F_SETFD, FD_CLOEXEC);
-    if (threadData->eventDispatcher) {
         deathNotifier = new QSocketNotifier(deathPipe[0],
                                             QSocketNotifier::Read, q);
         QObject::connect(deathNotifier, SIGNAL(activated(int)),
                          q, SLOT(_q_processDied()));
     }
 
-    if (!createChannel(stdinChannel) ||
-        !createChannel(stdoutChannel) ||
-        !createChannel(stderrChannel))
-        return;
-
     // Start the process (platform dependent)
     q->setProcessState(QProcess::Starting);
 
@@ -906,7 +888,7 @@ static void qt_ignore_sigpipe()
         struct sigaction noaction;
         memset(&noaction, 0, sizeof(noaction));
         noaction.sa_handler = SIG_IGN;
-        qt_native_sigaction(SIGPIPE, &noaction, 0);
+        ::sigaction(SIGPIPE, &noaction, 0);
     }
 }
 
@@ -1276,7 +1258,7 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a
         struct sigaction noaction;
         memset(&noaction, 0, sizeof(noaction));
         noaction.sa_handler = SIG_IGN;
-        qt_native_sigaction(SIGPIPE, &noaction, 0);
+        ::sigaction(SIGPIPE, &noaction, 0);
 
         ::setsid();
 
@@ -1322,7 +1304,7 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a
             struct sigaction noaction;
             memset(&noaction, 0, sizeof(noaction));
             noaction.sa_handler = SIG_IGN;
-            qt_native_sigaction(SIGPIPE, &noaction, 0);
+            ::sigaction(SIGPIPE, &noaction, 0);
 
             // '\1' means execv failed
             char c = '\1';
@@ -1333,7 +1315,7 @@ bool QProcessPrivate::startDetached(const QString &program, const QStringList &a
             struct sigaction noaction;
             memset(&noaction, 0, sizeof(noaction));
             noaction.sa_handler = SIG_IGN;
-            qt_native_sigaction(SIGPIPE, &noaction, 0);
+            ::sigaction(SIGPIPE, &noaction, 0);
 
             // '\2' means internal error
             char c = '\2';
diff --git a/src/corelib/io/qtemporaryfile.cpp b/src/corelib/io/qtemporaryfile.cpp
index 6a9125c..b4d8a48 100644
--- a/src/corelib/io/qtemporaryfile.cpp
+++ b/src/corelib/io/qtemporaryfile.cpp
@@ -291,14 +291,22 @@ class QTemporaryFileEngine : public QFSFileEngine
 {
     Q_DECLARE_PRIVATE(QFSFileEngine)
 public:
-    QTemporaryFileEngine(const QString &file) : QFSFileEngine(file) { }
+    QTemporaryFileEngine(const QString &file, bool fileIsTemplate = true)
+        : QFSFileEngine(file), filePathIsTemplate(fileIsTemplate)
+    {
+    }
+
     ~QTemporaryFileEngine();
 
+    bool isReallyOpen();
     void setFileName(const QString &file);
 
     bool open(QIODevice::OpenMode flags);
     bool remove();
+    bool rename(const QString &newName);
     bool close();
+
+    bool filePathIsTemplate;
 };
 
 QTemporaryFileEngine::~QTemporaryFileEngine()
@@ -306,6 +314,21 @@ QTemporaryFileEngine::~QTemporaryFileEngine()
     QFSFileEngine::close();
 }
 
+bool QTemporaryFileEngine::isReallyOpen()
+{
+    Q_D(QFSFileEngine);
+
+    if (!((0 == d->fh) && (-1 == d->fd)
+#if defined Q_OS_WIN
+                && (INVALID_HANDLE_VALUE == d->fileHandle)
+#endif
+            ))
+        return true;
+
+    return false;
+
+}
+
 void QTemporaryFileEngine::setFileName(const QString &file)
 {
     // Really close the file, so we don't leak
@@ -316,13 +339,16 @@ void QTemporaryFileEngine::setFileName(const QString &file)
 bool QTemporaryFileEngine::open(QIODevice::OpenMode openMode)
 {
     Q_D(QFSFileEngine);
+    Q_ASSERT(!isReallyOpen());
+
+    if (!filePathIsTemplate)
+        return QFSFileEngine::open(openMode);
 
     QString qfilename = d->filePath;
     if(!qfilename.contains(QLatin1String("XXXXXX")))
         qfilename += QLatin1String(".XXXXXX");
 
     int suffixLength = qfilename.length() - (qfilename.lastIndexOf(QLatin1String("XXXXXX"), -1, Qt::CaseSensitive) + 6);
-    d->closeFileHandle = true;
     char *filename = qstrdup(qfilename.toLocal8Bit());
 
 #ifndef Q_WS_WIN
@@ -330,16 +356,20 @@ bool QTemporaryFileEngine::open(QIODevice::OpenMode openMode)
     if (fd != -1) {
         // First open the fd as an external file descriptor to
         // initialize the engine properly.
-        QFSFileEngine::open(openMode, fd);
+        if (QFSFileEngine::open(openMode, fd)) {
 
-        // Allow the engine to close the handle even if it's "external".
-        d->closeFileHandle = true;
+            // Allow the engine to close the handle even if it's "external".
+            d->closeFileHandle = true;
 
-        // Restore the file names (open() resets them).
-        d->filePath = QString::fromLocal8Bit(filename); //changed now!
-        d->nativeInitFileName();
-        delete [] filename;
-        return true;
+            // Restore the file names (open() resets them).
+            d->filePath = QString::fromLocal8Bit(filename); //changed now!
+            filePathIsTemplate = false;
+            d->nativeInitFileName();
+            delete [] filename;
+            return true;
+        }
+
+        QT_CLOSE(fd);
     }
     delete [] filename;
     setError(errno == EMFILE ? QFile::ResourceError : QFile::OpenError, qt_error_string(errno));
@@ -351,6 +381,7 @@ bool QTemporaryFileEngine::open(QIODevice::OpenMode openMode)
     }
 
     d->filePath = QString::fromLocal8Bit(filename);
+    filePathIsTemplate = false;
     d->nativeInitFileName();
     d->closeFileHandle = true;
     delete [] filename;
@@ -364,9 +395,17 @@ bool QTemporaryFileEngine::remove()
     // Since the QTemporaryFileEngine::close() does not really close the file,
     // we must explicitly call QFSFileEngine::close() before we remove it.
     QFSFileEngine::close();
-    bool removed = QFSFileEngine::remove();
-    d->filePath.clear();
-    return removed;
+    if (QFSFileEngine::remove()) {
+        d->filePath.clear();
+        return true;
+    }
+    return false;
+}
+
+bool QTemporaryFileEngine::rename(const QString &newName)
+{
+    QFSFileEngine::close();
+    return QFSFileEngine::rename(newName);
 }
 
 bool QTemporaryFileEngine::close()
@@ -388,17 +427,14 @@ protected:
 
     bool autoRemove;
     QString templateName;
-    mutable QTemporaryFileEngine *fileEngine;
 };
 
-QTemporaryFilePrivate::QTemporaryFilePrivate() : autoRemove(true), fileEngine(0)
+QTemporaryFilePrivate::QTemporaryFilePrivate() : autoRemove(true)
 {
 }
 
 QTemporaryFilePrivate::~QTemporaryFilePrivate()
 {
-    delete fileEngine;
-    fileEngine = 0;
 }
 
 //************* QTemporaryFile
@@ -430,8 +466,8 @@ QTemporaryFilePrivate::~QTemporaryFilePrivate()
     file will exist and be kept open internally by QTemporaryFile.
 
     The file name of the temporary file can be found by calling fileName().
-    Note that this is only defined while the file is open; the function returns
-    an empty string before the file is opened and after it is closed.
+    Note that this is only defined after the file is first opened; the function
+    returns an empty string before this.
 
     A temporary file will have some static part of the name and some
     part that is calculated to be unique. The default filename \c
@@ -601,7 +637,8 @@ void QTemporaryFile::setAutoRemove(bool b)
 
 QString QTemporaryFile::fileName() const
 {
-    if(!isOpen())
+    Q_D(const QTemporaryFile);
+    if(d->fileName.isEmpty())
         return QString();
     return fileEngine()->fileName(QAbstractFileEngine::DefaultName);
 }
@@ -695,8 +732,12 @@ QTemporaryFile *QTemporaryFile::createLocalFile(QFile &file)
 QAbstractFileEngine *QTemporaryFile::fileEngine() const
 {
     Q_D(const QTemporaryFile);
-    if(!d->fileEngine)
-        d->fileEngine = new QTemporaryFileEngine(d->templateName);
+    if(!d->fileEngine) {
+        if (d->fileName.isEmpty())
+            d->fileEngine = new QTemporaryFileEngine(d->templateName);
+        else
+            d->fileEngine = new QTemporaryFileEngine(d->fileName, false);
+    }
     return d->fileEngine;
 }
 
@@ -711,10 +752,13 @@ bool QTemporaryFile::open(OpenMode flags)
 {
     Q_D(QTemporaryFile);
     if (!d->fileName.isEmpty()) {
-        setOpenMode(flags);
-        return true;
+        if (static_cast<QTemporaryFileEngine*>(fileEngine())->isReallyOpen()) {
+            setOpenMode(flags);
+            return true;
+        }
     }
 
+    flags |= QIODevice::ReadWrite;
     if (QFile::open(flags)) {
         d->fileName = d->fileEngine->fileName(QAbstractFileEngine::DefaultName);
         return true;
@@ -722,6 +766,8 @@ bool QTemporaryFile::open(OpenMode flags)
     return false;
 }
 
+QT_END_NAMESPACE
+
 #endif // QT_NO_TEMPORARYFILE
 
-QT_END_NAMESPACE
+
diff --git a/src/corelib/kernel/kernel.pri b/src/corelib/kernel/kernel.pri
index 68649a6..ecef555 100644
--- a/src/corelib/kernel/kernel.pri
+++ b/src/corelib/kernel/kernel.pri
@@ -12,7 +12,7 @@ HEADERS += \
 	kernel/qcoreevent.h \
 	kernel/qmetaobject.h \
 	kernel/qmetatype.h \
-        kernel/qmimedata.h \
+	kernel/qmimedata.h \
 	kernel/qobject.h \
 	kernel/qobjectdefs.h \
 	kernel/qsignalmapper.h \
@@ -27,8 +27,8 @@ HEADERS += \
         kernel/qvariant_p.h \
         kernel/qmetaobject_p.h \
         kernel/qobject_p.h \
-        kernel/qcoreglobaldata_p.h \
-        kernel/qsharedmemory.h \
+	kernel/qcoreglobaldata_p.h \
+	kernel/qsharedmemory.h \
         kernel/qsharedmemory_p.h \
         kernel/qsystemsemaphore.h \
         kernel/qsystemsemaphore_p.h \
@@ -43,7 +43,7 @@ SOURCES += \
 	kernel/qcoreevent.cpp \
 	kernel/qmetaobject.cpp \
 	kernel/qmetatype.cpp \
-        kernel/qmimedata.cpp \
+	kernel/qmimedata.cpp \
 	kernel/qobject.cpp \
 	kernel/qobjectcleanuphandler.cpp \
 	kernel/qsignalmapper.cpp \
diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp
index 11a2d3c..d6b0174 100644
--- a/src/corelib/kernel/qcoreevent.cpp
+++ b/src/corelib/kernel/qcoreevent.cpp
@@ -264,6 +264,8 @@ QT_BEGIN_NAMESPACE
     \omitvalue NetworkReplyUpdated
     \omitvalue FutureCallOut
     \omitvalue CocoaRequestModal
+    \omitvalue Wrapped
+    \omitvalue Signal
 */
 
 /*!
diff --git a/src/corelib/kernel/qcoreevent.h b/src/corelib/kernel/qcoreevent.h
index fa472e6..18188a8 100644
--- a/src/corelib/kernel/qcoreevent.h
+++ b/src/corelib/kernel/qcoreevent.h
@@ -44,6 +44,7 @@
 
 #include <QtCore/qnamespace.h>
 #include <QtCore/qbytearray.h>
+#include <QtCore/qobjectdefs.h>
 
 QT_BEGIN_HEADER
 
@@ -54,7 +55,9 @@ QT_MODULE(Core)
 class QEventPrivate;
 class Q_CORE_EXPORT QEvent           // event base class
 {
+    Q_GADGET
     QDOC_PROPERTY(bool accepted READ isAccepted WRITE setAccepted)
+    Q_ENUMS(Type)
 public:
     enum Type {
         /*
@@ -266,7 +269,10 @@ public:
         CocoaRequestModal = 190,                // Internal for requesting an application modal Cocoa Window
         MacGLClearDrawable = 191,               // Internal Cocoa, the window has changed, so we must clear
 
-        // 512 reserved for Qt Jambi's MetaCall event
+        Signal = 192,
+        Wrapped = 193,
+
+	// 512 reserved for Qt Jambi's MetaCall event
         // 513 reserved for Qt Jambi's DeleteOnMainThread event
 
         User = 1000,                            // first user event id
diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp
index cfd8493..1e9e284 100644
--- a/src/corelib/kernel/qobject.cpp
+++ b/src/corelib/kernel/qobject.cpp
@@ -92,8 +92,8 @@ static int *queuedConnectionTypes(const QList<QByteArray> &typeNames)
     return types;
 }
 
-QBasicAtomicPointer<QMutexPool> signalSlotMutexes = Q_BASIC_ATOMIC_INITIALIZER(0);
-QBasicAtomicInt objectCount = Q_BASIC_ATOMIC_INITIALIZER(0);
+static QBasicAtomicPointer<QMutexPool> signalSlotMutexes = Q_BASIC_ATOMIC_INITIALIZER(0);
+static QBasicAtomicInt objectCount = Q_BASIC_ATOMIC_INITIALIZER(0);
 
 /** \internal
  * mutex to be locked when accessing the connectionlists or the senders list
@@ -117,8 +117,7 @@ extern "C" Q_CORE_EXPORT void qt_addObject(QObject *)
 extern "C" Q_CORE_EXPORT void qt_removeObject(QObject *)
 {
     if(!objectCount.deref()) {
-        QMutexPool *old = signalSlotMutexes;
-        signalSlotMutexes.testAndSetAcquire(old, 0);
+        QMutexPool *old = signalSlotMutexes.fetchAndStoreAcquire(0);
         delete old;
     }
 }
diff --git a/src/corelib/kernel/qsharedmemory_unix.cpp b/src/corelib/kernel/qsharedmemory_unix.cpp
index cd248dc..12f21b7 100644
--- a/src/corelib/kernel/qsharedmemory_unix.cpp
+++ b/src/corelib/kernel/qsharedmemory_unix.cpp
@@ -47,9 +47,12 @@
 #include <qdir.h>
 #include <qdebug.h>
 
+#include <errno.h>
+
 #ifndef QT_NO_SHAREDMEMORY
 
-#include <errno.h>
+QT_BEGIN_NAMESPACE
+
 #include <sys/types.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
diff --git a/src/corelib/kernel/qsystemsemaphore_p.h b/src/corelib/kernel/qsystemsemaphore_p.h
index 81d4f10..a4a7389 100644
--- a/src/corelib/kernel/qsystemsemaphore_p.h
+++ b/src/corelib/kernel/qsystemsemaphore_p.h
@@ -101,9 +101,9 @@ public:
     QSystemSemaphore::SystemSemaphoreError error;
 };
 
-#endif // QT_NO_SYSTEMSEMAPHORE
+QT_END_NAMESPACE
 
+#endif // QT_NO_SYSTEMSEMAPHORE
 
-QT_END_NAMESPACE
 #endif // QSYSTEMSEMAPHORE_P_H
 
diff --git a/src/corelib/kernel/qtranslator.cpp b/src/corelib/kernel/qtranslator.cpp
index 77d6599..3e4b467 100644
--- a/src/corelib/kernel/qtranslator.cpp
+++ b/src/corelib/kernel/qtranslator.cpp
@@ -819,6 +819,6 @@ bool QTranslator::isEmpty() const
     Use translate(\a context, \a sourceText, \a comment) instead.
 */
 
-#endif // QT_NO_TRANSLATION
-
 QT_END_NAMESPACE
+
+#endif // QT_NO_TRANSLATION
diff --git a/src/corelib/statemachine/qabstractstate.cpp b/src/corelib/statemachine/qabstractstate.cpp
new file mode 100644
index 0000000..942722f
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate.cpp
@@ -0,0 +1,202 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qabstractstate.h"
+#include "qabstractstate_p.h"
+#include "qstate.h"
+#include "qstate_p.h"
+#include "qstatemachine.h"
+#include "qstatemachine_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QAbstractState
+
+  \brief The QAbstractState class is the base class of states of a QStateMachine.
+
+  \since 4.6
+  \ingroup statemachine
+
+  The QAbstractState class is the abstract base class of states that are part
+  of a QStateMachine. It defines the interface that all state objects have in
+  common. QAbstractState is part of \l{The State Machine Framework}.
+
+  The entered() signal is emitted when the state has been entered. The
+  exited() signal is emitted when the state has been exited.
+
+  The parentState() function returns the state's parent state. The machine()
+  function returns the state machine that the state is part of.
+
+  \section1 Subclassing
+
+  The onEntry() function is called when the state is entered; reimplement this
+  function to perform custom processing when the state is entered.
+
+  The onExit() function is called when the state is exited; reimplement this
+  function to perform custom processing when the state is exited.
+*/
+
+QAbstractStatePrivate::QAbstractStatePrivate()    
+{
+}
+
+QAbstractStatePrivate *QAbstractStatePrivate::get(QAbstractState *q)
+{
+    return q->d_func();
+}
+
+QStateMachine *QAbstractStatePrivate::machine() const
+{
+    Q_Q(const QAbstractState);
+    QObject *par = q->parent();
+    while (par != 0) {
+        if (QStateMachine *mach = qobject_cast<QStateMachine*>(par))
+            return mach;
+        par = par->parent();
+    }
+    return 0;
+}
+
+void QAbstractStatePrivate::callOnEntry(QEvent *e)
+{
+    Q_Q(QAbstractState);
+    q->onEntry(e);
+}
+
+void QAbstractStatePrivate::callOnExit(QEvent *e)
+{
+    Q_Q(QAbstractState);
+    q->onExit(e);
+}
+
+void QAbstractStatePrivate::emitEntered()
+{
+    Q_Q(QAbstractState);
+    emit q->entered();
+}
+
+void QAbstractStatePrivate::emitExited()
+{
+    Q_Q(QAbstractState);
+    emit q->exited();
+}
+
+/*!
+  Constructs a new state with the given \a parent state.
+*/
+QAbstractState::QAbstractState(QState *parent)
+    : QObject(*new QAbstractStatePrivate, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QAbstractState::QAbstractState(QAbstractStatePrivate &dd, QState *parent)
+    : QObject(dd, parent)
+{
+}
+
+/*!
+  Destroys this state.
+*/
+QAbstractState::~QAbstractState()
+{
+}
+
+/*!
+  Returns this state's parent state, or 0 if the state has no parent state.
+*/
+QState *QAbstractState::parentState() const
+{
+    return qobject_cast<QState*>(parent());
+}
+
+/*!
+  Returns the state machine that this state is part of, or 0 if the state is
+  not part of a state machine.
+*/
+QStateMachine *QAbstractState::machine() const
+{
+    Q_D(const QAbstractState);
+    return d->machine();
+}
+
+/*!
+  \fn QAbstractState::onExit(QEvent *event)
+
+  This function is called when the state is exited. The given \a event is what
+  caused the state to be exited. Reimplement this function to perform custom
+  processing when the state is exited.
+*/
+
+/*!
+  \fn QAbstractState::onEntry(QEvent *event)
+
+  This function is called when the state is entered. The given \a event is
+  what caused the state to be entered. Reimplement this function to perform
+  custom processing when the state is entered.
+*/
+
+/*!
+  \fn QAbstractState::entered()
+
+  This signal is emitted when the state has been entered (after onEntry() has
+  been called).
+*/
+
+/*!
+  \fn QAbstractState::exited()
+
+  This signal is emitted when the state has been exited (after onExit() has
+  been called).
+*/
+
+/*!
+  \reimp
+*/
+bool QAbstractState::event(QEvent *e)
+{
+    return QObject::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qabstractstate.h b/src/corelib/statemachine/qabstractstate.h
new file mode 100644
index 0000000..d0ebb52
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTSTATE_H
+#define QABSTRACTSTATE_H
+
+#include <QtCore/qobject.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QState;
+class QStateMachine;
+
+class QAbstractStatePrivate;
+class Q_CORE_EXPORT QAbstractState : public QObject
+{
+    Q_OBJECT
+public:
+    ~QAbstractState();
+
+    QState *parentState() const;
+    QStateMachine *machine() const;
+
+Q_SIGNALS:
+    void entered();
+    void exited();
+
+protected:
+    QAbstractState(QState *parent = 0);
+
+    virtual void onEntry(QEvent *event) = 0;
+    virtual void onExit(QEvent *event) = 0;
+
+    bool event(QEvent *e);
+
+protected:
+    QAbstractState(QAbstractStatePrivate &dd, QState *parent);
+
+private:
+    Q_DISABLE_COPY(QAbstractState)
+    Q_DECLARE_PRIVATE(QAbstractState)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qabstractstate_p.h b/src/corelib/statemachine/qabstractstate_p.h
new file mode 100644
index 0000000..2aad47e
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate_p.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTSTATE_P_H
+#define QABSTRACTSTATE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QStateMachine;
+
+class QAbstractState;
+class Q_CORE_EXPORT QAbstractStatePrivate
+    : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QAbstractState)
+
+public:
+    QAbstractStatePrivate();
+
+    static QAbstractStatePrivate *get(QAbstractState *q);
+
+    QStateMachine *machine() const;
+
+    void callOnEntry(QEvent *e);
+    void callOnExit(QEvent *e);
+
+    void emitEntered();
+    void emitExited();
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qabstracttransition.cpp b/src/corelib/statemachine/qabstracttransition.cpp
new file mode 100644
index 0000000..dfcafeb
--- /dev/null
+++ b/src/corelib/statemachine/qabstracttransition.cpp
@@ -0,0 +1,342 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qabstracttransition.h"
+#include "qabstracttransition_p.h"
+#include "qabstractstate.h"
+#include "qstate.h"
+#include "qstatemachine.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QAbstractTransition
+
+  \brief The QAbstractTransition class is the base class of transitions between QAbstractState objects.
+
+  \since 4.6
+  \ingroup statemachine
+
+  The QAbstractTransition class is the abstract base class of transitions
+  between states (QAbstractState objects) of a
+  QStateMachine. QAbstractTransition is part of \l{The State Machine
+  Framework}.
+
+  The sourceState() function returns the source of the transition. The
+  targetStates() function returns the targets of the transition. The machine()
+  function returns the state machine that the transition is part of.
+
+  Transitions can cause animations to be played. Use the addAnimation()
+  function to add an animation to the transition.
+
+  \section1 Subclassing
+
+  The eventTest() function is called by the state machine to determine whether
+  an event should trigger the transition. In your reimplementation you
+  typically check the event type and cast the event object to the proper type,
+  and check that one or more properties of the event meet your criteria.
+
+  The onTransition() function is called when the transition is triggered;
+  reimplement this function to perform custom processing for the transition.
+*/
+
+/*!
+    \property QAbstractTransition::sourceState
+
+    \brief the source state (parent) of this transition
+*/
+
+/*!
+    \property QAbstractTransition::targetState
+
+    \brief the target state of this transition
+*/
+
+/*!
+    \property QAbstractTransition::targetStates
+
+    \brief the target states of this transition
+
+    If multiple states are specified, all must be descendants of the same
+    parallel group state.
+*/
+
+QAbstractTransitionPrivate::QAbstractTransitionPrivate()
+{
+}
+
+QAbstractTransitionPrivate *QAbstractTransitionPrivate::get(QAbstractTransition *q)
+{
+    return q->d_func();
+}
+
+QStateMachine *QAbstractTransitionPrivate::machine() const
+{
+    Q_Q(const QAbstractTransition);
+    QObject *par = q->parent();
+    while (par != 0) {
+        if (QStateMachine *mach = qobject_cast<QStateMachine*>(par))
+            return mach;
+        par = par->parent();
+    }
+    return 0;
+}
+
+bool QAbstractTransitionPrivate::callEventTest(QEvent *e)
+{
+    Q_Q(QAbstractTransition);
+    return q->eventTest(e);
+}
+
+void QAbstractTransitionPrivate::callOnTransition(QEvent *e)
+{
+    Q_Q(QAbstractTransition);
+    q->onTransition(e);
+}
+
+QState *QAbstractTransitionPrivate::sourceState() const
+{
+    Q_Q(const QAbstractTransition);
+    return qobject_cast<QState*>(q->parent());
+}
+
+/*!
+  Constructs a new QAbstractTransition object with the given \a sourceState.
+*/
+QAbstractTransition::QAbstractTransition(QState *sourceState)
+    : QObject(*new QAbstractTransitionPrivate, sourceState)
+{
+}
+
+/*!
+  Constructs a new QAbstractTransition object with the given \a targets and \a
+  sourceState.
+*/
+QAbstractTransition::QAbstractTransition(const QList<QAbstractState*> &targets,
+                                         QState *sourceState)
+    : QObject(*new QAbstractTransitionPrivate, sourceState)
+{
+    setTargetStates(targets);
+}
+
+/*!
+  \internal
+*/
+QAbstractTransition::QAbstractTransition(QAbstractTransitionPrivate &dd,
+                                         QState *parent)
+    : QObject(dd, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QAbstractTransition::QAbstractTransition(QAbstractTransitionPrivate &dd,
+                                         const QList<QAbstractState*> &targets,
+                                         QState *parent)
+    : QObject(dd, parent)
+{
+    setTargetStates(targets);
+}
+
+/*!
+  Destroys this transition.
+*/
+QAbstractTransition::~QAbstractTransition()
+{
+}
+
+/*!
+  Returns the source state of this transition, or 0 if this transition has no
+  source state.
+*/
+QState *QAbstractTransition::sourceState() const
+{
+    Q_D(const QAbstractTransition);
+    return d->sourceState();
+}
+
+/*!
+  Returns the target state of this transition, or 0 if the transition has no
+  target.
+*/
+QAbstractState *QAbstractTransition::targetState() const
+{
+    Q_D(const QAbstractTransition);
+    if (d->targetStates.isEmpty())
+        return 0;
+    return d->targetStates.first();
+}
+
+/*!
+  Sets the \a target state of this transition.
+*/
+void QAbstractTransition::setTargetState(QAbstractState* target)
+{
+    Q_D(QAbstractTransition);
+    if (!target)
+        d->targetStates.clear();
+    else
+        setTargetStates(QList<QAbstractState*>() << target);
+}
+
+/*!
+  Returns the target states of this transition, or an empty list if this
+  transition has no target states.
+*/
+QList<QAbstractState*> QAbstractTransition::targetStates() const
+{
+    Q_D(const QAbstractTransition);
+    QList<QAbstractState*> result;
+    for (int i = 0; i < d->targetStates.size(); ++i) {
+        QAbstractState *target = d->targetStates.at(i);
+        if (target)
+            result.append(target);
+    }
+    return result;
+}
+
+/*!
+  Sets the target states of this transition to be the given \a targets.
+*/
+void QAbstractTransition::setTargetStates(const QList<QAbstractState*> &targets)
+{
+    Q_D(QAbstractTransition);
+
+    for (int i=0; i<targets.size(); ++i) {
+        QAbstractState *target = targets.at(i);
+        if (!target) {
+            qWarning("QAbstractTransition::setTargetStates: target state(s) cannot be null");
+            return;
+        }
+        if (target->machine() != 0 && target->machine()->rootState() == target) {
+            qWarning("QAbstractTransition::setTargetStates: root state cannot be target of transition");
+            return;
+        }
+    }
+
+    d->targetStates.clear();
+    for (int i = 0; i < targets.size(); ++i)
+        d->targetStates.append(targets.at(i));
+}
+
+/*!
+  Returns the state machine that this transition is part of, or 0 if the
+  transition is not part of a state machine.
+*/
+QStateMachine *QAbstractTransition::machine() const
+{
+    Q_D(const QAbstractTransition);
+    return d->machine();
+}
+
+#ifndef QT_NO_ANIMATION
+
+/*!
+  Adds the given \a animation to this transition.
+  The transition does not take ownership of the animation.
+
+  \sa removeAnimation(), animations()
+*/
+void QAbstractTransition::addAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QAbstractTransition);
+    if (!animation) {
+        qWarning("QAbstractTransition::addAnimation: cannot add null animation");
+        return;
+    }
+    d->animations.append(animation);
+}
+
+/*!
+  Removes the given \a animation from this transition.
+
+  \sa addAnimation()
+*/
+void QAbstractTransition::removeAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QAbstractTransition);
+    if (!animation) {
+        qWarning("QAbstractTransition::removeAnimation: cannot remove null animation");
+        return;
+    }
+    d->animations.removeOne(animation);
+}
+
+/*!
+  Returns the list of animations associated with this transition, or an empty
+  list if it has no animations.
+
+  \sa addAnimation()
+*/
+QList<QAbstractAnimation*> QAbstractTransition::animations() const
+{
+    Q_D(const QAbstractTransition);
+    return d->animations;
+}
+
+#endif
+
+/*!
+  \fn QAbstractTransition::eventTest(QEvent *event)
+
+  This function is called to determine whether the given \a event should cause
+  this transition to trigger. Reimplement this function and return true if the
+  event should trigger the transition, otherwise return false.
+*/
+
+/*!
+  \fn QAbstractTransition::onTransition(QEvent *event)
+
+  This function is called when the transition is triggered. The given \a event
+  is what caused the transition to trigger. Reimplement this function to
+  perform custom processing when the transition is triggered.
+*/
+
+/*!
+  \reimp
+*/
+bool QAbstractTransition::event(QEvent *e)
+{
+    return QObject::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qabstracttransition.h b/src/corelib/statemachine/qabstracttransition.h
new file mode 100644
index 0000000..c63d55a
--- /dev/null
+++ b/src/corelib/statemachine/qabstracttransition.h
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTTRANSITION_H
+#define QABSTRACTTRANSITION_H
+
+#include <QtCore/qobject.h>
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QEvent;
+class QAbstractState;
+class QState;
+class QStateMachine;
+
+#ifndef QT_NO_ANIMATION
+class QAbstractAnimation;
+#endif
+
+class QAbstractTransitionPrivate;
+class Q_CORE_EXPORT QAbstractTransition : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QState* sourceState READ sourceState)
+    Q_PROPERTY(QAbstractState* targetState READ targetState WRITE setTargetState)
+    Q_PROPERTY(QList<QAbstractState*> targetStates READ targetStates WRITE setTargetStates)
+public:
+    QAbstractTransition(QState *sourceState = 0);
+    QAbstractTransition(const QList<QAbstractState*> &targets, QState *sourceState = 0);
+    virtual ~QAbstractTransition();
+
+    QState *sourceState() const;
+    QAbstractState *targetState() const;
+    void setTargetState(QAbstractState* target);
+    QList<QAbstractState*> targetStates() const;
+    void setTargetStates(const QList<QAbstractState*> &targets);
+
+    QStateMachine *machine() const;
+
+#ifndef QT_NO_ANIMATION
+    void addAnimation(QAbstractAnimation *animation);
+    void removeAnimation(QAbstractAnimation *animation);
+    QList<QAbstractAnimation*> animations() const;
+#endif
+
+protected:
+    virtual bool eventTest(QEvent *event) = 0;
+
+    virtual void onTransition(QEvent *event) = 0;
+
+    bool event(QEvent *e);
+
+protected:
+    QAbstractTransition(QAbstractTransitionPrivate &dd, QState *parent);
+    QAbstractTransition(QAbstractTransitionPrivate &dd,
+                        const QList<QAbstractState*> &targets, QState *parent);
+
+private:
+    Q_DISABLE_COPY(QAbstractTransition)
+    Q_DECLARE_PRIVATE(QAbstractTransition)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qabstracttransition_p.h b/src/corelib/statemachine/qabstracttransition_p.h
new file mode 100644
index 0000000..f067984
--- /dev/null
+++ b/src/corelib/statemachine/qabstracttransition_p.h
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTTRANSITION_P_H
+#define QABSTRACTTRANSITION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qobject_p.h>
+
+#include <QtCore/qlist.h>
+#include <QtCore/qpointer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QAbstractState;
+class QState;
+class QStateMachine;
+
+class QAbstractTransition;
+class Q_CORE_EXPORT QAbstractTransitionPrivate
+    : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QAbstractTransition)
+public:
+    QAbstractTransitionPrivate();
+
+    static QAbstractTransitionPrivate *get(QAbstractTransition *q);
+
+    bool callEventTest(QEvent *e);
+    void callOnTransition(QEvent *e);
+    QState *sourceState() const;
+    QStateMachine *machine() const;
+
+    QList<QPointer<QAbstractState> > targetStates;
+
+#ifndef QT_NO_ANIMATION
+    QList<QAbstractAnimation*> animations;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qeventtransition.cpp b/src/corelib/statemachine/qeventtransition.cpp
new file mode 100644
index 0000000..f25d821
--- /dev/null
+++ b/src/corelib/statemachine/qeventtransition.cpp
@@ -0,0 +1,285 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qeventtransition.h"
+#include "qeventtransition_p.h"
+#include "qwrappedevent.h"
+#include "qstate.h"
+#include "qstate_p.h"
+#include "qstatemachine.h"
+#include "qstatemachine_p.h"
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QEventTransition
+
+  \brief The QEventTransition class provides a QObject-specific transition for Qt events.
+
+  \since 4.6
+  \ingroup statemachine
+
+  A QEventTransition object binds an event to a particular QObject.
+  QEventTransition is part of \l{The State Machine Framework}.
+
+  Example:
+
+  \code
+  QPushButton *button = ...;
+  QState *s1 = ...;
+  QState *s2 = ...;
+  // If in s1 and the button receives an Enter event, transition to s2
+  QEventTransition *enterTransition = new QEventTransition(button, QEvent::Enter);
+  enterTransition->setTargetState(s2);
+  s1->addTransition(enterTransition);
+  // If in s2 and the button receives an Exit event, transition back to s1
+  QEventTransition *leaveTransition = new QEventTransition(button, QEvent::Leave);
+  leaveTransition->setTargetState(s1);
+  s2->addTransition(leaveTransition);
+  \endcode
+
+  \section1 Subclassing
+
+  When reimplementing the eventTest() function, you should first call the base
+  implementation to verify that the event is a QWrappedEvent for the proper
+  object and event type. You may then cast the event to a QWrappedEvent and
+  get the original event by calling QWrappedEvent::event(), and perform
+  additional checks on that object.
+
+  \sa QState::addTransition()
+*/
+
+/*!
+    \property QEventTransition::eventObject
+
+    \brief the event source that this event transition is associated with
+*/
+
+/*!
+    \property QEventTransition::eventType
+
+    \brief the type of event that this event transition is associated with
+*/
+QEventTransitionPrivate::QEventTransitionPrivate()
+{
+    object = 0;
+    eventType = QEvent::None;
+    registered = false;
+}
+
+QEventTransitionPrivate *QEventTransitionPrivate::get(QEventTransition *q)
+{
+    return q->d_func();
+}
+
+void QEventTransitionPrivate::unregister()
+{
+    Q_Q(QEventTransition);
+    if (!registered || !machine())
+        return;
+    QStateMachinePrivate::get(machine())->unregisterEventTransition(q);
+}
+
+void QEventTransitionPrivate::maybeRegister()
+{
+    Q_Q(QEventTransition);
+    if (!machine() || !machine()->configuration().contains(sourceState()))
+        return;
+    QStateMachinePrivate::get(machine())->registerEventTransition(q);
+}
+
+/*!
+  Constructs a new QEventTransition object with the given \a sourceState.
+*/
+QEventTransition::QEventTransition(QState *sourceState)
+    : QAbstractTransition(*new QEventTransitionPrivate, sourceState)
+{
+}
+
+/*!
+  Constructs a new QEventTransition object associated with events of the given
+  \a type for the given \a object, and with the given \a sourceState.
+*/
+QEventTransition::QEventTransition(QObject *object, QEvent::Type type,
+                                   QState *sourceState)
+    : QAbstractTransition(*new QEventTransitionPrivate, sourceState)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  Constructs a new QEventTransition object associated with events of the given
+  \a type for the given \a object. The transition has the given \a targets and
+  \a sourceState.
+*/
+QEventTransition::QEventTransition(QObject *object, QEvent::Type type,
+                                   const QList<QAbstractState*> &targets,
+                                   QState *sourceState)
+    : QAbstractTransition(*new QEventTransitionPrivate, targets, sourceState)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  \internal
+*/
+QEventTransition::QEventTransition(QEventTransitionPrivate &dd, QState *parent)
+    : QAbstractTransition(dd, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QEventTransition::QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                                   QEvent::Type type, QState *parent)
+    : QAbstractTransition(dd, parent)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  \internal
+*/
+QEventTransition::QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                                   QEvent::Type type, const QList<QAbstractState*> &targets,
+                                   QState *parent)
+    : QAbstractTransition(dd, targets, parent)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  Destroys this QObject event transition.
+*/
+QEventTransition::~QEventTransition()
+{
+}
+
+/*!
+  Returns the event type that this event transition is associated with.
+*/
+QEvent::Type QEventTransition::eventType() const
+{
+    Q_D(const QEventTransition);
+    return d->eventType;
+}
+
+/*!
+  Sets the event \a type that this event transition is associated with.
+*/
+void QEventTransition::setEventType(QEvent::Type type)
+{
+    Q_D(QEventTransition);
+    if (d->eventType == type)
+        return;
+    d->unregister();
+    d->eventType = type;
+    d->maybeRegister();
+}
+
+/*!
+  Returns the event source associated with this event transition.
+*/
+QObject *QEventTransition::eventObject() const
+{
+    Q_D(const QEventTransition);
+    return d->object;
+}
+
+/*!
+  Sets the event source associated with this event transition to be the given
+  \a object.
+*/
+void QEventTransition::setEventObject(QObject *object)
+{
+    Q_D(QEventTransition);
+    if (d->object == object)
+        return;
+    d->unregister();
+    d->object = object;
+    d->maybeRegister();
+}
+
+/*!
+  \reimp
+*/
+bool QEventTransition::eventTest(QEvent *event)
+{
+    Q_D(const QEventTransition);
+    if (event->type() == QEvent::Wrapped) {
+        QWrappedEvent *we = static_cast<QWrappedEvent*>(event);
+        return (we->object() == d->object)
+            && (we->event()->type() == d->eventType);
+    }
+    return false;
+}
+
+/*!
+  \reimp
+*/
+void QEventTransition::onTransition(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+bool QEventTransition::event(QEvent *e)
+{
+    return QAbstractTransition::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qeventtransition.h b/src/corelib/statemachine/qeventtransition.h
new file mode 100644
index 0000000..3530bdd
--- /dev/null
+++ b/src/corelib/statemachine/qeventtransition.h
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEVENTTRANSITION_H
+#define QEVENTTRANSITION_H
+
+#include <QtCore/qabstracttransition.h>
+#include <QtCore/qcoreevent.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QEventTransitionPrivate;
+class Q_CORE_EXPORT QEventTransition : public QAbstractTransition
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* eventObject READ eventObject WRITE setEventObject)
+    Q_PROPERTY(QEvent::Type eventType READ eventType WRITE setEventType)
+public:
+    QEventTransition(QState *sourceState = 0);
+    QEventTransition(QObject *object, QEvent::Type type, QState *sourceState = 0);
+    QEventTransition(QObject *object, QEvent::Type type,
+                     const QList<QAbstractState*> &targets, QState *sourceState = 0);
+    ~QEventTransition();
+
+    QObject *eventObject() const;
+    void setEventObject(QObject *object);
+
+    QEvent::Type eventType() const;
+    void setEventType(QEvent::Type type);
+
+protected:
+    bool eventTest(QEvent *event);
+    void onTransition(QEvent *event);
+
+    bool event(QEvent *e);
+
+protected:
+    QEventTransition(QEventTransitionPrivate &dd, QState *parent);
+    QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                     QEvent::Type type, QState *parent);
+    QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                     QEvent::Type type, const QList<QAbstractState*> &targets,
+                     QState *parent);
+
+private:
+    Q_DISABLE_COPY(QEventTransition)
+    Q_DECLARE_PRIVATE(QEventTransition)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qeventtransition_p.h b/src/corelib/statemachine/qeventtransition_p.h
new file mode 100644
index 0000000..600cec0
--- /dev/null
+++ b/src/corelib/statemachine/qeventtransition_p.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEVENTTRANSITION_P_H
+#define QEVENTTRANSITION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qabstracttransition_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEventTransition;
+class Q_CORE_EXPORT QEventTransitionPrivate : public QAbstractTransitionPrivate
+{
+    Q_DECLARE_PUBLIC(QEventTransition)
+public:
+    QEventTransitionPrivate();
+
+    static QEventTransitionPrivate *get(QEventTransition *q);
+
+    void unregister();
+    void maybeRegister();
+
+    bool registered;
+    QObject *object;
+    QEvent::Type eventType;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qfinalstate.cpp b/src/corelib/statemachine/qfinalstate.cpp
new file mode 100644
index 0000000..0980336
--- /dev/null
+++ b/src/corelib/statemachine/qfinalstate.cpp
@@ -0,0 +1,134 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qfinalstate.h"
+#include "qabstractstate_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QFinalState
+
+  \brief The QFinalState class provides a final state.
+
+  \since 4.6
+  \ingroup statemachine
+
+  A final state is used to communicate that (part of) a QStateMachine has
+  finished its work. When a final top-level state is entered, the state
+  machine's \l{QStateMachine::finished()}{finished}() signal is emitted. In
+  general, when a final substate (a child of a QState) is entered, the parent
+  state's \l{QState::finished()}{finished}() signal is emitted.  QFinalState
+  is part of \l{The State Machine Framework}.
+
+  To use a final state, you create a QFinalState object and add a transition
+  to it from another state. Example:
+
+  \code
+  QPushButton button;
+
+  QStateMachine machine;
+  QState *s1 = new QState();
+  QFinalState *s2 = new QFinalState();
+  s1->addTransition(&button, SIGNAL(clicked()), s2);
+  machine.addState(s1);
+  machine.addState(s2);
+
+  QObject::connect(&machine, SIGNAL(finished()), QApplication::instance(), SLOT(quit()));
+  machine.setInitialState(s1);
+  machine.start();
+  \endcode
+
+  \sa QStateMachine::finished(), QState::finished()
+*/
+
+class QFinalStatePrivate : public QAbstractStatePrivate
+{
+    Q_DECLARE_PUBLIC(QFinalState)
+
+public:
+    QFinalStatePrivate();
+};
+
+QFinalStatePrivate::QFinalStatePrivate()
+{
+}
+
+/*!
+  Constructs a new QFinalState object with the given \a parent state.
+*/
+QFinalState::QFinalState(QState *parent)
+    : QAbstractState(*new QFinalStatePrivate, parent)
+{
+}
+
+/*!
+  Destroys this final state.
+*/
+QFinalState::~QFinalState()
+{
+}
+
+/*!
+  \reimp
+*/
+void QFinalState::onEntry(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+void QFinalState::onExit(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+bool QFinalState::event(QEvent *e)
+{
+    return QAbstractState::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qfinalstate.h b/src/corelib/statemachine/qfinalstate.h
new file mode 100644
index 0000000..fa68394
--- /dev/null
+++ b/src/corelib/statemachine/qfinalstate.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFINALSTATE_H
+#define QFINALSTATE_H
+
+#include <QtCore/qabstractstate.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QFinalStatePrivate;
+class Q_CORE_EXPORT QFinalState : public QAbstractState
+{
+    Q_OBJECT
+public:
+    QFinalState(QState *parent = 0);
+    ~QFinalState();
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+
+    bool event(QEvent *e);
+
+private:
+    Q_DISABLE_COPY(QFinalState)
+    Q_DECLARE_PRIVATE(QFinalState)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qhistorystate.cpp b/src/corelib/statemachine/qhistorystate.cpp
new file mode 100644
index 0000000..517faa8
--- /dev/null
+++ b/src/corelib/statemachine/qhistorystate.cpp
@@ -0,0 +1,223 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qhistorystate.h"
+#include "qhistorystate_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QHistoryState
+
+  \brief The QHistoryState class provides a means of returning to a previously active substate.
+
+  \since 4.6
+  \ingroup statemachine
+
+  A history state is a pseudo-state that represents the child state that the
+  parent state was in the last time the parent state was exited. A transition
+  with a history state as its target is in fact a transition to one of the
+  other child states of the parent state. QHistoryState is part of \l{The
+  State Machine Framework}.
+
+  Use the setDefaultState() function to set the state that should be entered
+  if the parent state has never been entered.  Example:
+
+  \code
+  QStateMachine machine;
+
+  QState *s1 = new QState();
+  QState *s11 = new QState(s1);
+  QState *s12 = new QState(s1);
+
+  QHistoryState *s1h = new QHistoryState(s1);
+  s1h->setDefaultState(s11);
+
+  machine.addState(s1);
+
+  QState *s2 = new QState();
+  machine.addState(s2);
+
+  QPushButton *button = new QPushButton();
+  // Clicking the button will cause the state machine to enter the child state
+  // that s1 was in the last time s1 was exited, or the history state's default
+  // state if s1 has never been entered.
+  s1->addTransition(button, SIGNAL(clicked()), s1h);
+  \endcode
+
+  By default a history state is shallow, meaning that it won't remember nested
+  states. This can be configured through the historyType property.
+*/
+
+/*!
+  \property QHistoryState::defaultState
+
+  \brief the default state of this history state
+*/
+
+/*!
+  \property QHistoryState::historyType
+
+  \brief the type of history that this history state records
+
+  The default value of this property is QHistoryState::ShallowHistory.
+*/
+
+/*!
+  \enum QHistoryState::HistoryType
+
+  This enum specifies the type of history that a QHistoryState records.
+
+  \value ShallowHistory Only the immediate child states of the parent state
+  are recorded. In this case a transition with the history state as its
+  target will end up in the immediate child state that the parent was in the
+  last time it was exited. This is the default.
+
+  \value DeepHistory Nested states are recorded. In this case a transition
+  with the history state as its target will end up in the most deeply nested
+  descendant state the parent was in the last time it was exited.
+*/
+
+QHistoryStatePrivate::QHistoryStatePrivate()
+    : defaultState(0)
+{
+}
+
+QHistoryStatePrivate *QHistoryStatePrivate::get(QHistoryState *q)
+{
+    return q->d_func();
+}
+
+/*!
+  Constructs a new shallow history state with the given \a parent state.
+*/
+QHistoryState::QHistoryState(QState *parent)
+    : QAbstractState(*new QHistoryStatePrivate, parent)
+{
+    Q_D(QHistoryState);
+    d->historyType = ShallowHistory;
+}
+/*!
+  Constructs a new history state of the given \a type, with the given \a
+  parent state.
+*/
+QHistoryState::QHistoryState(HistoryType type, QState *parent)
+    : QAbstractState(*new QHistoryStatePrivate, parent)
+{
+    Q_D(QHistoryState);
+    d->historyType = type;
+}
+
+/*!
+  Destroys this history state.
+*/
+QHistoryState::~QHistoryState()
+{
+}
+
+/*!
+  Returns this history state's default state.  The default state indicates the
+  state to transition to if the parent state has never been entered before.
+*/
+QAbstractState *QHistoryState::defaultState() const
+{
+    Q_D(const QHistoryState);
+    return d->defaultState;
+}
+
+/*!
+  Sets this history state's default state to be the given \a state.
+  \a state must be a sibling of this history state.
+*/
+void QHistoryState::setDefaultState(QAbstractState *state)
+{
+    Q_D(QHistoryState);
+    if (state && state->parentState() != parentState()) {
+        qWarning("QHistoryState::setDefaultState: state %p does not belong "
+                 "to this history state's group (%p)", state, parentState());
+        return;
+    }
+    d->defaultState = state;
+}
+
+/*!
+  Returns the type of history that this history state records.
+*/
+QHistoryState::HistoryType QHistoryState::historyType() const
+{
+    Q_D(const QHistoryState);
+    return d->historyType;
+}
+
+/*!
+  Sets the \a type of history that this history state records.
+*/
+void QHistoryState::setHistoryType(HistoryType type)
+{
+    Q_D(QHistoryState);
+    d->historyType = type;
+}
+
+/*!
+  \reimp
+*/
+void QHistoryState::onEntry(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+void QHistoryState::onExit(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+bool QHistoryState::event(QEvent *e)
+{
+    return QAbstractState::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qhistorystate.h b/src/corelib/statemachine/qhistorystate.h
new file mode 100644
index 0000000..a0682bd
--- /dev/null
+++ b/src/corelib/statemachine/qhistorystate.h
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QHISTORYSTATE_H
+#define QHISTORYSTATE_H
+
+#include <QtCore/qabstractstate.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QHistoryStatePrivate;
+class Q_CORE_EXPORT QHistoryState : public QAbstractState
+{
+    Q_OBJECT
+    Q_PROPERTY(QAbstractState* defaultState READ defaultState WRITE setDefaultState)
+    Q_PROPERTY(HistoryType historyType READ historyType WRITE setHistoryType)
+    Q_ENUMS(HistoryType)
+public:
+    enum HistoryType {
+        ShallowHistory,
+        DeepHistory
+    };
+
+    QHistoryState(QState *parent = 0);
+    QHistoryState(HistoryType type, QState *parent = 0);
+    ~QHistoryState();
+
+    QAbstractState *defaultState() const;
+    void setDefaultState(QAbstractState *state);
+
+    HistoryType historyType() const;
+    void setHistoryType(HistoryType type);
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+
+    bool event(QEvent *e);
+
+private:
+    Q_DISABLE_COPY(QHistoryState)
+    Q_DECLARE_PRIVATE(QHistoryState)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qhistorystate_p.h b/src/corelib/statemachine/qhistorystate_p.h
new file mode 100644
index 0000000..5aaa64c
--- /dev/null
+++ b/src/corelib/statemachine/qhistorystate_p.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QHISTORYSTATE_P_H
+#define QHISTORYSTATE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qabstractstate_p.h"
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_NAMESPACE
+
+class QHistoryState;
+class QHistoryStatePrivate : public QAbstractStatePrivate
+{
+    Q_DECLARE_PUBLIC(QHistoryState)
+
+public:
+    QHistoryStatePrivate();
+
+    static QHistoryStatePrivate *get(QHistoryState *q);
+
+    QAbstractState *defaultState;
+    QHistoryState::HistoryType historyType;
+    QList<QAbstractState*> configuration;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qsignalevent.h b/src/corelib/statemachine/qsignalevent.h
new file mode 100644
index 0000000..8221f68
--- /dev/null
+++ b/src/corelib/statemachine/qsignalevent.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSIGNALEVENT_H
+#define QSIGNALEVENT_H
+
+#include <QtCore/qcoreevent.h>
+
+#include <QtCore/qlist.h>
+#include <QtCore/qvariant.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class Q_CORE_EXPORT QSignalEvent : public QEvent
+{
+public:
+    QSignalEvent(const QObject *sender, int signalIndex,
+                 const QList<QVariant> &arguments);
+    ~QSignalEvent();
+
+    inline const QObject *sender() const { return m_sender; }
+    inline int signalIndex() const { return m_signalIndex; }
+    inline QList<QVariant> arguments() const { return m_arguments; }
+
+private:
+    const QObject *m_sender;
+    int m_signalIndex;
+    QList<QVariant> m_arguments;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qsignaleventgenerator_p.h b/src/corelib/statemachine/qsignaleventgenerator_p.h
new file mode 100644
index 0000000..cf0ea1e
--- /dev/null
+++ b/src/corelib/statemachine/qsignaleventgenerator_p.h
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSIGNALEVENTGENERATOR_P_H
+#define QSIGNALEVENTGENERATOR_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qobject.h>
+
+QT_BEGIN_NAMESPACE
+
+class QStateMachine;
+
+class QSignalEventGenerator : public QObject
+{
+public:
+    QSignalEventGenerator(QStateMachine *parent);
+
+    static const QMetaObject staticMetaObject;
+    virtual const QMetaObject *metaObject() const;
+    virtual void *qt_metacast(const char *);
+    virtual int qt_metacall(QMetaObject::Call, int, void **argv);
+
+private:
+    Q_DISABLE_COPY(QSignalEventGenerator)
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qsignaltransition.cpp b/src/corelib/statemachine/qsignaltransition.cpp
new file mode 100644
index 0000000..9ffcb9c
--- /dev/null
+++ b/src/corelib/statemachine/qsignaltransition.cpp
@@ -0,0 +1,260 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsignaltransition.h"
+#include "qsignaltransition_p.h"
+#include "qsignalevent.h"
+#include "qstate.h"
+#include "qstate_p.h"
+#include "qstatemachine.h"
+#include "qstatemachine_p.h"
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QSignalTransition
+
+  \brief The QSignalTransition class provides a transition based on a Qt signal.
+
+  \since 4.6
+  \ingroup statemachine
+
+  Typically you would use the overload of QState::addTransition() that takes a
+  sender and signal as arguments, rather than creating QSignalTransition
+  objects directly. QSignalTransition is part of \l{The State Machine
+  Framework}.
+
+  You can subclass QSignalTransition and reimplement eventTest() to make a
+  signal transition conditional; the event object passed to eventTest() will
+  be a QSignalEvent object. Example:
+
+  \code
+  class CheckedTransition : public QSignalTransition
+  {
+  public:
+      CheckedTransition(QCheckBox *check)
+          : QSignalTransition(check, SIGNAL(stateChanged(int))) {}
+  protected:
+      bool eventTest(QEvent *e) const {
+          if (!QSignalTransition::eventTest(e))
+              return false;
+          QSignalEvent *se = static_cast<QSignalEvent*>(e);
+          return (se->arguments().at(0).toInt() == Qt::Checked);
+      }
+  };
+
+  ...
+
+  QCheckBox *check = new QCheckBox();
+  check->setTristate(true);
+
+  QState *s1 = new QState();
+  QState *s2 = new QState();
+  CheckedTransition *t1 = new CheckedTransition(check);
+  t1->setTargetState(s2);
+  s1->addTransition(t1);
+  \endcode
+*/
+
+/*!
+    \property QSignalTransition::senderObject
+
+    \brief the sender object that this signal transition is associated with
+*/
+
+/*!
+    \property QSignalTransition::signal
+
+    \brief the signal that this signal transition is associated with
+*/
+
+QSignalTransitionPrivate::QSignalTransitionPrivate()
+{
+    sender = 0;
+    signalIndex = -1;
+}
+
+QSignalTransitionPrivate *QSignalTransitionPrivate::get(QSignalTransition *q)
+{
+    return q->d_func();
+}
+
+void QSignalTransitionPrivate::unregister()
+{
+    Q_Q(QSignalTransition);
+    if ((signalIndex == -1) || !machine())
+        return;
+    QStateMachinePrivate::get(machine())->unregisterSignalTransition(q);
+}
+
+void QSignalTransitionPrivate::maybeRegister()
+{
+    Q_Q(QSignalTransition);
+    if (!machine() || !machine()->configuration().contains(sourceState()))
+        return;
+    QStateMachinePrivate::get(machine())->registerSignalTransition(q);
+}
+
+/*!
+  Constructs a new signal transition with the given \a sourceState.
+*/
+QSignalTransition::QSignalTransition(QState *sourceState)
+    : QAbstractTransition(*new QSignalTransitionPrivate, sourceState)
+{
+}
+
+/*!
+  Constructs a new signal transition associated with the given \a signal of
+  the given \a sender, and with the given \a sourceState.
+*/
+QSignalTransition::QSignalTransition(QObject *sender, const char *signal,
+                                     QState *sourceState)
+    : QAbstractTransition(*new QSignalTransitionPrivate, sourceState)
+{
+    Q_D(QSignalTransition);
+    d->sender = sender;
+    d->signal = signal;
+}
+
+/*!
+  Constructs a new signal transition associated with the given \a signal of
+  the given \a sender. The transition has the given \a targets and \a
+  sourceState.
+*/
+QSignalTransition::QSignalTransition(QObject *sender, const char *signal,
+                                     const QList<QAbstractState*> &targets,
+                                     QState *sourceState)
+    : QAbstractTransition(*new QSignalTransitionPrivate, targets, sourceState)
+{
+    Q_D(QSignalTransition);
+    d->sender = sender;
+    d->signal = signal;
+}
+
+/*!
+  Destroys this signal transition.
+*/
+QSignalTransition::~QSignalTransition()
+{
+}
+
+/*!
+  Returns the sender object associated with this signal transition.
+*/
+QObject *QSignalTransition::senderObject() const
+{
+    Q_D(const QSignalTransition);
+    return d->sender;
+}
+
+/*!
+  Sets the \a sender object associated with this signal transition.
+*/
+void QSignalTransition::setSenderObject(QObject *sender)
+{
+    Q_D(QSignalTransition);
+    if (sender == d->sender)
+        return;
+    d->unregister();
+    d->sender = sender;
+    d->maybeRegister();
+}
+
+/*!
+  Returns the signal associated with this signal transition.
+*/
+QByteArray QSignalTransition::signal() const
+{
+    Q_D(const QSignalTransition);
+    return d->signal;
+}
+
+/*!
+  Sets the \a signal associated with this signal transition.
+*/
+void QSignalTransition::setSignal(const QByteArray &signal)
+{
+    Q_D(QSignalTransition);
+    if (signal == d->signal)
+        return;
+    d->unregister();
+    d->signal = signal;
+    d->maybeRegister();
+}
+
+/*!
+  \reimp
+
+  The \a event is a QSignalEvent object.  The default implementation returns
+  true if the event's sender and signal index match this transition, and
+  returns false otherwise.
+*/
+bool QSignalTransition::eventTest(QEvent *event)
+{
+    Q_D(const QSignalTransition);
+    if (event->type() == QEvent::Signal) {
+        if (d->signalIndex == -1)
+            return false;
+        QSignalEvent *se = static_cast<QSignalEvent*>(event);
+        return (se->sender() == d->sender)
+            && (se->signalIndex() == d->signalIndex);
+    }
+    return false;
+}
+
+/*!
+  \reimp
+*/
+void QSignalTransition::onTransition(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+bool QSignalTransition::event(QEvent *e)
+{
+    return QAbstractTransition::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qsignaltransition.h b/src/corelib/statemachine/qsignaltransition.h
new file mode 100644
index 0000000..b485785
--- /dev/null
+++ b/src/corelib/statemachine/qsignaltransition.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSIGNALTRANSITION_H
+#define QSIGNALTRANSITION_H
+
+#include <QtCore/qabstracttransition.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QSignalTransitionPrivate;
+class Q_CORE_EXPORT QSignalTransition : public QAbstractTransition
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* senderObject READ senderObject WRITE setSenderObject)
+    Q_PROPERTY(QByteArray signal READ signal WRITE setSignal)
+public:
+    QSignalTransition(QState *sourceState = 0);
+    QSignalTransition(QObject *sender, const char *signal,
+                      QState *sourceState = 0);
+    QSignalTransition(QObject *sender, const char *signal,
+                      const QList<QAbstractState*> &targets,
+                      QState *sourceState = 0);
+    ~QSignalTransition();
+
+    QObject *senderObject() const;
+    void setSenderObject(QObject *sender);
+
+    QByteArray signal() const;
+    void setSignal(const QByteArray &signal);
+
+protected:
+    bool eventTest(QEvent *event);
+    void onTransition(QEvent *event);
+
+    bool event(QEvent *e);
+
+private:
+    Q_DISABLE_COPY(QSignalTransition)
+    Q_DECLARE_PRIVATE(QSignalTransition)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qsignaltransition_p.h b/src/corelib/statemachine/qsignaltransition_p.h
new file mode 100644
index 0000000..339de63
--- /dev/null
+++ b/src/corelib/statemachine/qsignaltransition_p.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSIGNALTRANSITION_P_H
+#define QSIGNALTRANSITION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qabstracttransition_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QSignalTransition;
+class QSignalTransitionPrivate : public QAbstractTransitionPrivate
+{
+    Q_DECLARE_PUBLIC(QSignalTransition)
+public:
+    QSignalTransitionPrivate();
+
+    static QSignalTransitionPrivate *get(QSignalTransition *q);
+
+    void unregister();
+    void maybeRegister();
+
+    QObject *sender;
+    QByteArray signal;
+    int signalIndex;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qstate.cpp b/src/corelib/statemachine/qstate.cpp
new file mode 100644
index 0000000..e42e463
--- /dev/null
+++ b/src/corelib/statemachine/qstate.cpp
@@ -0,0 +1,497 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qstate.h"
+#include "qstate_p.h"
+#include "qhistorystate.h"
+#include "qhistorystate_p.h"
+#include "qabstracttransition.h"
+#include "qabstracttransition_p.h"
+#include "qsignaltransition.h"
+#include "qstatemachine.h"
+#include "qstatemachine_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QState
+
+  \brief The QState class provides a general-purpose state for QStateMachine.
+
+  \since 4.6
+  \ingroup statemachine
+
+  QState objects can have child states, and can have transitions to other
+  states. QState is part of \l{The State Machine Framework}.
+
+  The addTransition() function adds a transition. The removeTransition()
+  function removes a transition.
+
+  The assignProperty() function is used for defining property assignments that
+  should be performed when a state is entered.
+
+  Top-level states must be passed QStateMachine::rootState() as their parent
+  state, or added to a state machine using QStateMachine::addState().
+
+  \section1 States with Child States
+
+  The childMode property determines how child states are treated. For
+  non-parallel state groups, the setInitialState() function must be called to
+  set the initial state. The child states are mutually exclusive states, and
+  the state machine needs to know which child state to enter when the parent
+  state is the target of a transition.
+
+  The state emits the QState::finished() signal when a final child state
+  (QFinalState) is entered.
+
+  The setErrorState() sets the state's error state. The error state is the
+  state that the state machine will transition to if an error is detected when
+  attempting to enter the state (e.g. because no initial state has been set).
+
+*/
+
+/*!
+    \property QState::initialState
+
+    \brief the initial state of this state (one of its child states)
+*/
+
+/*!
+    \property QState::errorState
+
+    \brief the error state of this state
+*/
+
+/*!
+    \property QState::childMode
+
+    \brief the child mode of this state
+
+    The default value of this property is QState::ExclusiveStates.
+*/
+
+/*!
+  \enum QState::ChildMode
+
+  This enum specifies how a state's child states are treated.
+
+  \value ExclusiveStates The child states are mutually exclusive and an
+  initial state must be set by calling QState::setInitialState().
+
+  \value ParallelStates The child states are parallel. When the parent state
+  is entered, all its child states are entered in parallel.
+*/
+
+QStatePrivate::QStatePrivate()
+    : errorState(0), initialState(0), childMode(QState::ExclusiveStates)
+{
+}
+
+QStatePrivate::~QStatePrivate()
+{
+}
+
+QStatePrivate *QStatePrivate::get(QState *q)
+{
+    if (!q)
+        return 0;
+    return q->d_func();
+}
+
+const QStatePrivate *QStatePrivate::get(const QState *q)
+{
+    if (!q)
+        return 0;
+    return q->d_func();
+}
+
+void QStatePrivate::emitFinished()
+{
+    Q_Q(QState);
+    emit q->finished();
+}
+
+void QStatePrivate::emitPolished()
+{
+    Q_Q(QState);
+    emit q->polished();
+}
+
+/*!
+  Constructs a new state with the given \a parent state.
+*/
+QState::QState(QState *parent)
+    : QAbstractState(*new QStatePrivate, parent)
+{
+}
+
+/*!
+  Constructs a new state with the given \a childMode and the given \a parent
+  state.
+*/
+QState::QState(ChildMode childMode, QState *parent)
+    : QAbstractState(*new QStatePrivate, parent)
+{
+    Q_D(QState);
+    d->childMode = childMode;
+}
+
+/*!
+  \internal
+*/
+QState::QState(QStatePrivate &dd, QState *parent)
+    : QAbstractState(dd, parent)
+{
+}
+
+/*!
+  Destroys this state.
+*/
+QState::~QState()
+{
+}
+
+QList<QAbstractState*> QStatePrivate::childStates() const
+{
+    QList<QAbstractState*> result;
+    QList<QObject*>::const_iterator it;
+    for (it = children.constBegin(); it != children.constEnd(); ++it) {
+        QAbstractState *s = qobject_cast<QAbstractState*>(*it);
+        if (!s || qobject_cast<QHistoryState*>(s))
+            continue;
+        result.append(s);
+    }
+    return result;
+}
+
+QList<QHistoryState*> QStatePrivate::historyStates() const
+{
+    QList<QHistoryState*> result;
+    QList<QObject*>::const_iterator it;
+    for (it = children.constBegin(); it != children.constEnd(); ++it) {
+        QHistoryState *h = qobject_cast<QHistoryState*>(*it);
+        if (h)
+            result.append(h);
+    }
+    return result;
+}
+
+QList<QAbstractTransition*> QStatePrivate::transitions() const
+{
+    QList<QAbstractTransition*> result;
+    QList<QObject*>::const_iterator it;
+    for (it = children.constBegin(); it != children.constEnd(); ++it) {
+        QAbstractTransition *t = qobject_cast<QAbstractTransition*>(*it);
+        if (t)
+            result.append(t);
+    }
+    return result;
+}
+
+/*!
+  Instructs this state to set the property with the given \a name of the given
+  \a object to the given \a value when the state is entered.
+
+  \sa polished()
+*/
+void QState::assignProperty(QObject *object, const char *name,
+                            const QVariant &value)
+{
+    Q_D(QState);
+    if (!object) {
+        qWarning("QState::assignProperty: cannot assign property '%s' of null object", name);
+        return;
+    }
+    for (int i = 0; i < d->propertyAssignments.size(); ++i) {
+        QPropertyAssignment &assn = d->propertyAssignments[i];
+        if ((assn.object == object) && (assn.propertyName == name)) {
+            assn.value = value;
+            return;
+        }
+    }
+    d->propertyAssignments.append(QPropertyAssignment(object, name, value));
+}
+
+/*!
+  Returns this state group's error state. 
+
+  \sa QStateMachine::errorState(), QStateMachine::setErrorState()
+*/
+QAbstractState *QState::errorState() const
+{
+    Q_D(const QState);
+    return d->errorState;
+}
+
+/*!
+  Sets this state's error state to be the given \a state. If the error state
+  is not set, or if it is set to 0, the state will inherit its parent's error
+  state recursively.
+
+  \sa QStateMachine::setErrorState(), QStateMachine::errorState()
+*/
+void QState::setErrorState(QAbstractState *state)
+{
+    Q_D(QState);
+    if (state != 0 && state->machine() != machine()) {
+        qWarning("QState::setErrorState: error state cannot belong "
+                 "to a different state machine");
+        return;
+    }
+    if (state != 0 && state->machine() != 0 && state->machine()->rootState() == state) {
+        qWarning("QStateMachine::setErrorState: root state cannot be error state");
+        return;
+    }
+
+    d->errorState = state;
+}
+
+/*!
+  Adds the given \a transition. The transition has this state as the source.
+  This state takes ownership of the transition. If the transition is successfully
+  added, the function will return the \a transition pointer. Otherwise it will return null.
+*/
+QAbstractTransition *QState::addTransition(QAbstractTransition *transition)
+{
+    Q_D(QState);
+    if (!transition) {
+        qWarning("QState::addTransition: cannot add null transition");
+        return 0;
+    }
+
+    // machine() will always be non-null for root state
+    if (machine() != 0 && machine()->rootState() == this) {
+        qWarning("QState::addTransition: cannot add transition from root state");
+        return 0;
+    }
+
+    const QList<QPointer<QAbstractState> > &targets = QAbstractTransitionPrivate::get(transition)->targetStates;
+    for (int i = 0; i < targets.size(); ++i) {
+        QAbstractState *t = targets.at(i);
+        if (!t) {
+            qWarning("QState::addTransition: cannot add transition to null state");
+            return 0;
+        }
+        if ((QAbstractStatePrivate::get(t)->machine() != d->machine())
+            && QAbstractStatePrivate::get(t)->machine() && d->machine()) {
+            qWarning("QState::addTransition: cannot add transition "
+                     "to a state in a different state machine");
+            return 0;
+        }
+    }
+    transition->setParent(this);
+    if (machine() != 0 && machine()->configuration().contains(this))
+        QStateMachinePrivate::get(machine())->registerTransitions(this);
+    return transition;
+}
+
+/*!
+  Adds a transition associated with the given \a signal of the given \a sender
+  object, and returns the new QSignalTransition object. The transition has
+  this state as the source, and the given \a target as the target state.
+*/
+QSignalTransition *QState::addTransition(QObject *sender, const char *signal,
+                                         QAbstractState *target)
+{
+    if (!sender) {
+        qWarning("QState::addTransition: sender cannot be null");
+        return 0;
+    }
+    if (!signal) {
+        qWarning("QState::addTransition: signal cannot be null");
+        return 0;
+    }
+    if (!target) {
+        qWarning("QState::addTransition: cannot add transition to null state");
+        return 0;
+    }
+    if (*signal && sender->metaObject()->indexOfSignal(signal+1) == -1) {
+        qWarning("QState::addTransition: no such signal %s::%s",
+                 sender->metaObject()->className(), signal+1);
+        return 0;
+    }
+    QSignalTransition *trans = new QSignalTransition(sender, signal, QList<QAbstractState*>() << target);
+    addTransition(trans);
+    return trans;
+}
+
+namespace {
+
+// ### Make public?
+class UnconditionalTransition : public QAbstractTransition
+{
+public:
+    UnconditionalTransition(QAbstractState *target)
+        : QAbstractTransition(QList<QAbstractState*>() << target) {}
+protected:
+    void onTransition(QEvent *) {}
+    bool eventTest(QEvent *) { return true; }
+};
+
+} // namespace
+
+/*!
+  Adds an unconditional transition from this state to the given \a target
+  state, and returns then new transition object.
+*/
+QAbstractTransition *QState::addTransition(QAbstractState *target)
+{
+    if (!target) {
+        qWarning("QState::addTransition: cannot add transition to null state");
+        return 0;
+    }
+    UnconditionalTransition *trans = new UnconditionalTransition(target);
+    return addTransition(trans);
+}
+
+/*!
+  Removes the given \a transition from this state.  The state releases
+  ownership of the transition.
+
+  \sa addTransition()
+*/
+void QState::removeTransition(QAbstractTransition *transition)
+{
+    Q_D(QState);
+    if (!transition) {
+        qWarning("QState::removeTransition: cannot remove null transition");
+        return;
+    }
+    if (transition->sourceState() != this) {
+        qWarning("QState::removeTransition: transition %p's source state (%p)"
+                 " is different from this state (%p)",
+                 transition, transition->sourceState(), this);
+        return;
+    }
+    QStateMachinePrivate *mach = QStateMachinePrivate::get(d->machine());
+    if (mach)
+        mach->unregisterTransition(transition);
+    transition->setParent(0);
+}
+
+/*!
+  \reimp
+*/
+void QState::onEntry(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+void QState::onExit(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  Returns this state's initial state, or 0 if the state has no initial state.
+*/
+QAbstractState *QState::initialState() const
+{
+    Q_D(const QState);
+    return d->initialState;
+}
+
+/*!
+  Sets this state's initial state to be the given \a state.
+  \a state has to be a child of this state.
+*/
+void QState::setInitialState(QAbstractState *state)
+{
+    Q_D(QState);
+    if (d->childMode == QState::ParallelStates) {
+        qWarning("QState::setInitialState: ignoring attempt to set initial state "
+                 "of parallel state group %p", this);
+        return;
+    }
+    if (state && (state->parentState() != this)) {
+        qWarning("QState::setInitialState: state %p is not a child of this state (%p)",
+                 state, this);
+        return;
+    }
+    d->initialState = state;
+}
+
+/*!
+  Returns the child mode of this state.
+*/
+QState::ChildMode QState::childMode() const
+{
+    Q_D(const QState);
+    return d->childMode;
+}
+
+/*!
+  Sets the child \a mode of this state.
+*/
+void QState::setChildMode(ChildMode mode)
+{
+    Q_D(QState);
+    d->childMode = mode;
+}
+
+/*!
+  \reimp
+*/
+bool QState::event(QEvent *e)
+{
+    return QAbstractState::event(e);
+}
+
+/*!
+  \fn QState::finished()
+
+  This signal is emitted when a final child state of this state is entered.
+
+  \sa QFinalState
+*/
+
+/*!
+  \fn QState::polished()
+
+  This signal is emitted when all properties have been assigned their final value.
+
+  \sa QState::assignProperty(), QAbstractTransition::addAnimation()
+*/
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qstate.h b/src/corelib/statemachine/qstate.h
new file mode 100644
index 0000000..6729c69
--- /dev/null
+++ b/src/corelib/statemachine/qstate.h
@@ -0,0 +1,113 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTATE_H
+#define QSTATE_H
+
+#include <QtCore/qabstractstate.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QAbstractTransition;
+class QSignalTransition;
+
+class QStatePrivate;
+class Q_CORE_EXPORT QState : public QAbstractState
+{
+    Q_OBJECT
+    Q_PROPERTY(QAbstractState* initialState READ initialState WRITE setInitialState)
+    Q_PROPERTY(QAbstractState* errorState READ errorState WRITE setErrorState)
+    Q_PROPERTY(ChildMode childMode READ childMode WRITE setChildMode)
+    Q_ENUMS(ChildMode)
+public:
+    enum ChildMode {
+        ExclusiveStates,
+        ParallelStates
+    };
+
+    QState(QState *parent = 0);
+    QState(ChildMode childMode, QState *parent = 0);
+    ~QState();
+
+    QAbstractState *errorState() const;
+    void setErrorState(QAbstractState *state);
+
+    QAbstractTransition *addTransition(QAbstractTransition *transition);
+    QSignalTransition *addTransition(QObject *sender, const char *signal, QAbstractState *target);
+    QAbstractTransition *addTransition(QAbstractState *target);
+    void removeTransition(QAbstractTransition *transition);
+
+    QAbstractState *initialState() const;
+    void setInitialState(QAbstractState *state);
+
+    ChildMode childMode() const;
+    void setChildMode(ChildMode mode);
+
+    void assignProperty(QObject *object, const char *name,
+                        const QVariant &value);
+
+Q_SIGNALS:
+    void finished();
+    void polished();
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+
+    bool event(QEvent *e);
+
+protected:
+    QState(QStatePrivate &dd, QState *parent);
+
+private:
+    Q_DISABLE_COPY(QState)
+    Q_DECLARE_PRIVATE(QState)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qstate_p.h b/src/corelib/statemachine/qstate_p.h
new file mode 100644
index 0000000..1f913b4
--- /dev/null
+++ b/src/corelib/statemachine/qstate_p.h
@@ -0,0 +1,108 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTATE_P_H
+#define QSTATE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qabstractstate_p.h"
+
+#include <QtCore/qlist.h>
+#include <QtCore/qbytearray.h>
+#include <QtCore/qvariant.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QPropertyAssignment
+{
+    QPropertyAssignment()
+        : object(0) {}
+    QPropertyAssignment(QObject *o, const QByteArray &n,
+                        const QVariant &v, bool es = true)
+        : object(o), propertyName(n), value(v), explicitlySet(es)
+        {}
+    QObject *object;
+    QByteArray propertyName;
+    QVariant value;
+    bool explicitlySet;
+};
+
+class QAbstractTransition;
+class QHistoryState;
+
+class QState;
+class Q_CORE_EXPORT QStatePrivate : public QAbstractStatePrivate
+{
+    Q_DECLARE_PUBLIC(QState)
+public:
+    QStatePrivate();
+    ~QStatePrivate();
+
+    static QStatePrivate *get(QState *q);
+    static const QStatePrivate *get(const QState *q);
+
+    QList<QAbstractState*> childStates() const;
+    QList<QHistoryState*> historyStates() const;
+    QList<QAbstractTransition*> transitions() const;
+
+    void emitFinished();
+    void emitPolished();
+
+    QAbstractState *errorState;
+    QAbstractState *initialState;
+    QState::ChildMode childMode;
+
+    QList<QPropertyAssignment> propertyAssignments;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qstatemachine.cpp b/src/corelib/statemachine/qstatemachine.cpp
new file mode 100644
index 0000000..744515b
--- /dev/null
+++ b/src/corelib/statemachine/qstatemachine.cpp
@@ -0,0 +1,2216 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qstatemachine.h"
+#include "qstate.h"
+#include "qstate_p.h"
+#include "qstatemachine_p.h"
+#include "qabstracttransition.h"
+#include "qabstracttransition_p.h"
+#include "qsignaltransition.h"
+#include "qsignaltransition_p.h"
+#include "qsignalevent.h"
+#include "qsignaleventgenerator_p.h"
+#include "qabstractstate.h"
+#include "qabstractstate_p.h"
+#include "qfinalstate.h"
+#include "qhistorystate.h"
+#include "qhistorystate_p.h"
+#include "private/qobject_p.h"
+#include "private/qthread_p.h"
+
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+#include "qeventtransition.h"
+#include "qeventtransition_p.h"
+#include "qwrappedevent.h"
+#endif
+
+#ifndef QT_NO_ANIMATION
+#include "qpropertyanimation.h"
+#include "qanimationgroup.h"
+#include <private/qvariantanimation_p.h>
+#endif
+
+#include <QtCore/qmetaobject.h>
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QStateMachine
+  \reentrant
+
+  \brief The QStateMachine class provides a hierarchical finite state machine.
+
+  \since 4.6
+  \ingroup statemachine
+
+    QStateMachine is based on the concepts and notation of
+    \l{Statecharts: A visual formalism for complex
+    systems}{Statecharts}. QStateMachine is part of \l{The State
+    Machine Framework}.
+
+    A state machine manages a set of states (classes that inherit from
+    QAbstractState) and transitions (descendants of
+    QAbstractTransition) between those states; these states and
+    transitions define a state graph. Once a state graph has been
+    built, the state machine can execute it. \l{QStateMachine}'s
+    execution algorithm is based on the \l{State Chart XML: State
+    Machine Notation for Control Abstraction}{State Chart XML (SCXML)}
+    algorithm. The framework's \l{The State Machine
+    Framework}{overview} gives several state graphs and the code to
+    build them.
+
+    The rootState() is the parent of all top-level states in the
+    machine; it is used, for instance, when the state graph is
+    deleted. It is created by the machine.
+
+    Use the addState() function to add a state to the state machine.
+    All top-level states are added to the root state. States are
+    removed with the removeState() function. Removing states while the
+    machine is running is discouraged.
+
+    Before the machine can be started, the \l{initialState}{initial
+    state} must be set. The initial state is the state that the
+    machine enters when started. You can then start() the state
+    machine. The started() signal is emitted when the initial state is
+    entered.
+
+    The machine is event driven and keeps its own event loop. Events
+    are posted to the machine through postEvent(). Note that this
+    means that it executes asynchronously, and that it will not
+    progress without a running event loop. You will normally not have
+    to post events to the machine directly as Qt's transitions, e.g.,
+    QEventTransition and its subclasses, handle this. But for custom
+    transitions triggered by events, postEvent() is useful.
+
+    The state machine processes events and takes transitions until a
+    top-level final state is entered; the state machine then emits the
+    finished() signal. You can also stop() the state machine
+    explicitly. The stopped() signal is emitted in this case.
+
+    The following snippet shows a state machine that will finish when a button
+    is clicked:
+
+    \code
+    QPushButton button;
+
+    QStateMachine machine;
+    QState *s1 = new QState();
+    s1->assignProperty(&button, "text", "Click me");
+
+    QFinalState *s2 = new QFinalState();
+    s1->addTransition(&button, SIGNAL(clicked()), s2);
+
+    machine.addState(s1);
+    machine.addState(s2);
+    machine.setInitialState(s1);
+    machine.start();
+    \endcode
+
+    This code example uses QState, which inherits QAbstractState. The
+    QState class provides a state that you can use to set properties
+    and invoke methods on \l{QObject}s when the state is entered or
+    exited. It also contains convenience functions for adding
+    transitions, e.g., \l{QSignalTransition}s as in this example. See
+    the QState class description for further details.
+
+    If an error is encountered, the machine will enter the
+    \l{errorState}{error state}, which is a special state created by
+    the machine. The types of errors possible are described by the
+    \l{QStateMachine::}{Error} enum. After the error state is entered,
+    the type of the error can be retrieved with error(). The execution
+    of the state graph will not stop when the error state is entered.
+    So it is possible to handle the error, for instance, by connecting
+    to the \l{QAbstractState::}{entered()} signal of the error state.
+    It is also possible to set a custom error state with
+    setErrorState().
+
+    \omit This stuff will be moved elsewhere
+This is
+  typically used in conjunction with \l{Signals and Slots}{signals}; the
+  signals determine the flow of the state graph, whereas the states' property
+  assignments and method invocations are the actions.
+
+  The postEvent() function posts an event to the state machine. This is useful
+  when you are using custom events to trigger transitions.
+    \endomit
+
+  \sa QAbstractState, QAbstractTransition, QState, {The State Machine Framework}
+*/
+
+/*!
+    \property QStateMachine::rootState
+
+    \brief the root state of this state machine
+*/
+
+/*!
+    \property QStateMachine::initialState
+
+    \brief the initial state of this state machine
+
+    The initial state must be one of the rootState()'s child states.
+*/
+
+/*!
+    \property QStateMachine::errorState
+
+    \brief the error state of this state machine
+*/
+
+/*!
+    \property QStateMachine::errorString
+
+    \brief the error string of this state machine
+*/
+
+/*!
+    \property QStateMachine::globalRestorePolicy
+
+    \brief the restore policy for states of this state machine.
+
+    The default value of this property is
+    QStateMachine::DoNotRestoreProperties.
+*/
+
+#ifndef QT_NO_ANIMATION
+/*!
+    \property QStateMachine::animationsEnabled
+
+    \brief whether animations are enabled
+
+    The default value of this property is true.
+
+    \sa QAbstractTransition::addAnimation()
+*/
+#endif
+
+// #define QSTATEMACHINE_DEBUG
+
+QStateMachinePrivate::QStateMachinePrivate()
+{
+    state = NotRunning;
+    processing = false;
+    processingScheduled = false;
+    stop = false;
+    error = QStateMachine::NoError;
+    globalRestorePolicy = QStateMachine::DoNotRestoreProperties;
+    rootState = 0;
+    initialErrorStateForRoot = 0;
+    signalEventGenerator = 0;
+#ifndef QT_NO_ANIMATION
+    animationsEnabled = true;
+#endif
+}
+
+QStateMachinePrivate::~QStateMachinePrivate()
+{
+    qDeleteAll(internalEventQueue);
+    qDeleteAll(externalEventQueue);
+}
+
+QStateMachinePrivate *QStateMachinePrivate::get(QStateMachine *q)
+{
+    if (q)
+        return q->d_func();
+    return 0;
+}
+
+static QEvent *cloneEvent(QEvent *e)
+{
+    switch (e->type()) {
+    case QEvent::None:
+        return new QEvent(*e);
+    case QEvent::Timer:
+        return new QTimerEvent(*static_cast<QTimerEvent*>(e));
+    default:
+        Q_ASSERT_X(false, "cloneEvent()", "not implemented");
+        break;
+    }
+    return 0;
+}
+
+const QStateMachinePrivate::Handler qt_kernel_statemachine_handler = {
+    cloneEvent
+};
+
+const QStateMachinePrivate::Handler *QStateMachinePrivate::handler = &qt_kernel_statemachine_handler;
+
+Q_CORE_EXPORT const QStateMachinePrivate::Handler *qcoreStateMachineHandler()
+{
+    return &qt_kernel_statemachine_handler;
+}
+
+static int indexOfDescendant(QState *s, QAbstractState *desc)
+{
+    QList<QAbstractState*> childStates = QStatePrivate::get(s)->childStates();
+    for (int i = 0; i < childStates.size(); ++i) {
+        QAbstractState *c = childStates.at(i);
+        if ((c == desc) || QStateMachinePrivate::isDescendantOf(desc, c)) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+bool QStateMachinePrivate::stateEntryLessThan(QAbstractState *s1, QAbstractState *s2)
+{
+    if (s1->parent() == s2->parent()) {
+        return s1->children().indexOf(s1)
+            < s2->children().indexOf(s2);
+    } else if (isDescendantOf(s1, s2)) {
+        return false;
+    } else if (isDescendantOf(s2, s1)) {
+        return true;
+    } else {
+        QState *lca = findLCA(QList<QAbstractState*>() << s1 << s2);
+        Q_ASSERT(lca != 0);
+        return (indexOfDescendant(lca, s1) < indexOfDescendant(lca, s2));
+    }
+}
+
+bool QStateMachinePrivate::stateExitLessThan(QAbstractState *s1, QAbstractState *s2)
+{
+    if (s1->parent() == s2->parent()) {
+        return s1->children().indexOf(s1)
+            < s2->children().indexOf(s2);
+    } else if (isDescendantOf(s1, s2)) {
+        return true;
+    } else if (isDescendantOf(s2, s1)) {
+        return false;
+    } else {
+        QState *lca = findLCA(QList<QAbstractState*>() << s1 << s2);
+        Q_ASSERT(lca != 0);
+        return (indexOfDescendant(lca, s1) < indexOfDescendant(lca, s2));
+    }
+}
+
+QState *QStateMachinePrivate::findLCA(const QList<QAbstractState*> &states)
+{
+    if (states.isEmpty())
+        return 0;
+    QList<QState*> ancestors = properAncestors(states.at(0), 0);
+    for (int i = 0; i < ancestors.size(); ++i) {
+        QState *anc = ancestors.at(i);
+        bool ok = true;
+        for (int j = states.size() - 1; (j > 0) && ok; --j) {
+            const QAbstractState *s = states.at(j);
+            if (!isDescendantOf(s, anc))
+                ok = false;
+        }
+        if (ok)
+            return anc;
+    }
+    return 0;
+}
+
+bool QStateMachinePrivate::isPreempted(const QAbstractState *s, const QSet<QAbstractTransition*> &transitions) const
+{
+    QSet<QAbstractTransition*>::const_iterator it;
+    for (it = transitions.constBegin(); it != transitions.constEnd(); ++it) {
+        QAbstractTransition *t = *it;
+        QList<QAbstractState*> lst = t->targetStates();
+        if (!lst.isEmpty()) {
+            lst.prepend(t->sourceState());
+            QAbstractState *lca = findLCA(lst);
+            if (isDescendantOf(s, lca)) {
+#ifdef QSTATEMACHINE_DEBUG
+                qDebug() << q_func() << ":" << transitions << "preempts selection of a transition from"
+                         << s << "because" << s << "is a descendant of" << lca;
+#endif
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+QSet<QAbstractTransition*> QStateMachinePrivate::selectTransitions(QEvent *event) const
+{
+    Q_Q(const QStateMachine);
+    QSet<QAbstractTransition*> enabledTransitions;
+    QSet<QAbstractState*>::const_iterator it;
+    const_cast<QStateMachine*>(q)->beginSelectTransitions(event);
+    for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
+        QAbstractState *state = *it;
+        if (!isAtomic(state))
+            continue;
+        if (isPreempted(state, enabledTransitions))
+            continue;
+        QList<QState*> lst = properAncestors(state, 0);
+        if (QState *grp = qobject_cast<QState*>(state))
+            lst.prepend(grp);
+        bool found = false;
+        for (int j = 0; (j < lst.size()) && !found; ++j) {
+            QState *s = lst.at(j);
+            QList<QAbstractTransition*> transitions = QStatePrivate::get(s)->transitions();
+            for (int k = 0; k < transitions.size(); ++k) {
+                QAbstractTransition *t = transitions.at(k);
+                if (QAbstractTransitionPrivate::get(t)->callEventTest(event)) {
+#ifdef QSTATEMACHINE_DEBUG
+                    qDebug() << q << ": selecting transition" << t;
+#endif
+                    enabledTransitions.insert(t);
+                    found = true;
+                    break;
+                }
+            }
+        }
+    }
+    const_cast<QStateMachine*>(q)->endSelectTransitions(event);
+    return enabledTransitions;
+}
+
+void QStateMachinePrivate::microstep(QEvent *event, const QList<QAbstractTransition*> &enabledTransitions)
+{
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q_func() << ": begin microstep( enabledTransitions:" << enabledTransitions << ")";
+    qDebug() << q_func() << ": configuration before exiting states:" << configuration;
+#endif
+    QList<QAbstractState*> exitedStates = exitStates(event, enabledTransitions);
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q_func() << ": configuration after exiting states:" << configuration;
+#endif
+    executeTransitionContent(event, enabledTransitions);
+    QList<QAbstractState*> enteredStates = enterStates(event, enabledTransitions);
+    applyProperties(enabledTransitions, exitedStates, enteredStates);
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q_func() << ": configuration after entering states:" << configuration;
+    qDebug() << q_func() << ": end microstep";
+#endif
+}
+
+QList<QAbstractState*> QStateMachinePrivate::exitStates(QEvent *event, const QList<QAbstractTransition*> &enabledTransitions)
+{
+//    qDebug() << "exitStates(" << enabledTransitions << ")";
+    QSet<QAbstractState*> statesToExit;
+//    QSet<QAbstractState*> statesToSnapshot;
+    for (int i = 0; i < enabledTransitions.size(); ++i) {
+        QAbstractTransition *t = enabledTransitions.at(i);
+        QList<QAbstractState*> lst = t->targetStates();
+        if (lst.isEmpty())
+            continue;
+        lst.prepend(t->sourceState());
+        QAbstractState *lca = findLCA(lst);
+        if (lca == 0) {
+            setError(QStateMachine::NoCommonAncestorForTransitionError, t->sourceState());
+            lst = pendingErrorStates.toList();
+            lst.prepend(t->sourceState());
+            
+            lca = findLCA(lst);
+            Q_ASSERT(lca != 0);
+        }
+
+        {
+            QSet<QAbstractState*>::const_iterator it;
+            for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
+                QAbstractState *s = *it;
+                if (isDescendantOf(s, lca))
+                    statesToExit.insert(s);
+            }
+        }
+    }
+    QList<QAbstractState*> statesToExit_sorted = statesToExit.toList();
+    qSort(statesToExit_sorted.begin(), statesToExit_sorted.end(), stateExitLessThan);
+    for (int i = 0; i < statesToExit_sorted.size(); ++i) {
+        QAbstractState *s = statesToExit_sorted.at(i);
+        if (QState *grp = qobject_cast<QState*>(s)) {
+            QList<QHistoryState*> hlst = QStatePrivate::get(grp)->historyStates();
+            for (int j = 0; j < hlst.size(); ++j) {
+                QHistoryState *h = hlst.at(j);
+                QHistoryStatePrivate::get(h)->configuration.clear();
+                QSet<QAbstractState*>::const_iterator it;
+                for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
+                    QAbstractState *s0 = *it;
+                    if (QHistoryStatePrivate::get(h)->historyType == QHistoryState::DeepHistory) {
+                        if (isAtomic(s0) && isDescendantOf(s0, s))
+                            QHistoryStatePrivate::get(h)->configuration.append(s0);
+                    } else if (s0->parentState() == s) {
+                        QHistoryStatePrivate::get(h)->configuration.append(s0);
+                    }
+                }
+#ifdef QSTATEMACHINE_DEBUG
+                qDebug() << q_func() << ": recorded" << ((QHistoryStatePrivate::get(h)->historyType == QHistoryState::DeepHistory) ? "deep" : "shallow")
+                         << "history for" << s << "in" << h << ":" << QHistoryStatePrivate::get(h)->configuration;
+#endif
+            }
+        }
+    }
+    for (int i = 0; i < statesToExit_sorted.size(); ++i) {
+        QAbstractState *s = statesToExit_sorted.at(i);
+#ifdef QSTATEMACHINE_DEBUG
+        qDebug() << q_func() << ": exiting" << s;
+#endif
+        QAbstractStatePrivate::get(s)->callOnExit(event);
+        configuration.remove(s);
+        QAbstractStatePrivate::get(s)->emitExited();
+    }
+    return statesToExit_sorted;
+}
+
+void QStateMachinePrivate::executeTransitionContent(QEvent *event, const QList<QAbstractTransition*> &enabledTransitions)
+{
+    for (int i = 0; i < enabledTransitions.size(); ++i) {
+        QAbstractTransition *t = enabledTransitions.at(i);
+#ifdef QSTATEMACHINE_DEBUG
+        qDebug() << q_func() << ": triggering" << t;
+#endif
+        QAbstractTransitionPrivate::get(t)->callOnTransition(event);
+    }
+}
+
+QList<QAbstractState*> QStateMachinePrivate::enterStates(QEvent *event, const QList<QAbstractTransition*> &enabledTransitions)
+{
+#ifdef QSTATEMACHINE_DEBUG
+    Q_Q(QStateMachine);
+#endif
+//    qDebug() << "enterStates(" << enabledTransitions << ")";
+    QSet<QAbstractState*> statesToEnter;
+    QSet<QAbstractState*> statesForDefaultEntry;
+
+    if (pendingErrorStates.isEmpty()) {
+        for (int i = 0; i < enabledTransitions.size(); ++i) {
+            QAbstractTransition *t = enabledTransitions.at(i);
+            QList<QAbstractState*> lst = t->targetStates();
+            if (lst.isEmpty())
+                continue;
+            lst.prepend(t->sourceState());
+            QState *lca = findLCA(lst);
+            for (int j = 1; j < lst.size(); ++j) {
+                QAbstractState *s = lst.at(j);
+			    addStatesToEnter(s, lca, statesToEnter, statesForDefaultEntry);
+                if (isParallel(lca)) {
+                    QList<QAbstractState*> lcac = QStatePrivate::get(lca)->childStates();
+                    foreach (QAbstractState* child,lcac) {
+                        if (!statesToEnter.contains(child))
+                            addStatesToEnter(child,lca,statesToEnter,statesForDefaultEntry);                    
+                    }
+                }
+            }
+        }
+    }
+
+    // Did an error occur while selecting transitions? Then we enter the error state.
+    if (!pendingErrorStates.isEmpty()) {
+        statesToEnter.clear();
+        statesToEnter = pendingErrorStates;
+        statesForDefaultEntry = pendingErrorStatesForDefaultEntry;
+        pendingErrorStates.clear();
+        pendingErrorStatesForDefaultEntry.clear();
+    }
+
+    QList<QAbstractState*> statesToEnter_sorted = statesToEnter.toList();
+    qSort(statesToEnter_sorted.begin(), statesToEnter_sorted.end(), stateEntryLessThan);
+
+    for (int i = 0; i < statesToEnter_sorted.size(); ++i) {
+        QAbstractState *s = statesToEnter_sorted.at(i);
+#ifdef QSTATEMACHINE_DEBUG
+        qDebug() << q << ": entering" << s;
+#endif
+        configuration.insert(s);
+        registerTransitions(s);
+        QAbstractStatePrivate::get(s)->callOnEntry(event);
+        QAbstractStatePrivate::get(s)->emitEntered();
+        if (statesForDefaultEntry.contains(s)) {
+            // ### executeContent(s.initial.transition.children())
+        }
+        if (isFinal(s)) {
+            QState *parent = s->parentState();
+            if (parent) {
+                QState *grandparent = parent->parentState();
+#ifdef QSTATEMACHINE_DEBUG
+                qDebug() << q << ": emitting finished signal for" << parent;
+#endif
+                QStatePrivate::get(parent)->emitFinished();
+                if (grandparent && isParallel(grandparent)) {
+                    bool allChildStatesFinal = true;
+                    QList<QAbstractState*> childStates = QStatePrivate::get(grandparent)->childStates();
+                    for (int j = 0; j < childStates.size(); ++j) {
+                        QAbstractState *cs = childStates.at(j);
+                        if (!isInFinalState(cs)) {
+                            allChildStatesFinal = false;
+                            break;
+                        }
+                    }
+                    if (allChildStatesFinal) {
+#ifdef QSTATEMACHINE_DEBUG
+                        qDebug() << q << ": emitting finished signal for" << grandparent;
+#endif
+                        QStatePrivate::get(grandparent)->emitFinished();
+                    }
+                }
+            }
+        }
+    }
+    {
+        QSet<QAbstractState*>::const_iterator it;
+        for (it = configuration.constBegin(); it != configuration.constEnd(); ++it) {
+            if (isFinal(*it) && (*it)->parentState() == rootState) {
+                processing = false;
+                stopProcessingReason = Finished;
+                break;
+            }
+        }
+    }
+//    qDebug() << "configuration:" << configuration.toList();
+    return statesToEnter_sorted;
+}
+
+void QStateMachinePrivate::addStatesToEnter(QAbstractState *s, QState *root,
+                                            QSet<QAbstractState*> &statesToEnter,
+                                            QSet<QAbstractState*> &statesForDefaultEntry)
+{
+	if (QHistoryState *h = qobject_cast<QHistoryState*>(s)) {
+		QList<QAbstractState*> hconf = QHistoryStatePrivate::get(h)->configuration;
+		if (!hconf.isEmpty()) {
+			for (int k = 0; k < hconf.size(); ++k) {
+				QAbstractState *s0 = hconf.at(k);
+				addStatesToEnter(s0, root, statesToEnter, statesForDefaultEntry);
+			}
+	#ifdef QSTATEMACHINE_DEBUG
+			qDebug() <<q_func() << ": restoring"
+					<< ((QHistoryStatePrivate::get(h)->historyType == QHistoryState::DeepHistory) ? "deep" : "shallow")
+					<< "history from" << s << ":" << hconf;
+	#endif
+		} else {
+			QList<QAbstractState*> hlst;
+			if (QHistoryStatePrivate::get(h)->defaultState)
+				hlst.append(QHistoryStatePrivate::get(h)->defaultState);
+
+			if (hlst.isEmpty()) {
+				setError(QStateMachine::NoDefaultStateInHistoryStateError, h);
+			} else {
+				for (int k = 0; k < hlst.size(); ++k) {
+					QAbstractState *s0 = hlst.at(k);
+					addStatesToEnter(s0, root, statesToEnter, statesForDefaultEntry);
+				}
+	#ifdef QSTATEMACHINE_DEBUG
+				qDebug() << q_func() << ": initial history targets for" << s << ":" << hlst;                    
+	#endif
+			}
+		}
+	} else {
+		statesToEnter.insert(s);
+		if (isParallel(s)) {
+			QState *grp = qobject_cast<QState*>(s);
+			QList<QAbstractState*> lst = QStatePrivate::get(grp)->childStates();
+			for (int i = 0; i < lst.size(); ++i) {
+				QAbstractState *child = lst.at(i);
+				addStatesToEnter(child, grp, statesToEnter, statesForDefaultEntry);
+			}
+		} else if (isCompound(s)) {
+			statesForDefaultEntry.insert(s);
+			QState *grp = qobject_cast<QState*>(s);
+			QAbstractState *initial = grp->initialState();
+			if (initial != 0) {
+				addStatesToEnter(initial, grp, statesToEnter, statesForDefaultEntry);
+			} else {
+				setError(QStateMachine::NoInitialStateError, grp);
+				return;
+			}
+		}
+		QList<QState*> ancs = properAncestors(s, root);
+		for (int i = 0; i < ancs.size(); ++i) {
+			QState *anc = ancs.at(i);
+			if (!anc->parentState())
+				continue;
+			statesToEnter.insert(anc);
+			if (isParallel(anc)) {
+				QList<QAbstractState*> lst = QStatePrivate::get(anc)->childStates();
+				for (int j = 0; j < lst.size(); ++j) {
+					QAbstractState *child = lst.at(j);
+					bool hasDescendantInList = false;
+					QSet<QAbstractState*>::const_iterator it;
+					for (it = statesToEnter.constBegin(); it != statesToEnter.constEnd(); ++it) {
+						if (isDescendantOf(*it, child)) {
+							hasDescendantInList = true;
+							break;
+						}
+					}
+					if (!hasDescendantInList)
+						addStatesToEnter(child, anc, statesToEnter, statesForDefaultEntry);
+				}
+			}
+		}
+	}
+}
+
+void QStateMachinePrivate::applyProperties(const QList<QAbstractTransition*> &transitionList,
+                                           const QList<QAbstractState*> &exitedStates,
+                                           const QList<QAbstractState*> &enteredStates)
+{
+    Q_Q(QStateMachine);
+#ifdef QT_NO_ANIMATION
+    Q_UNUSED(transitionList);
+#endif
+    // Process the property assignments of the entered states.
+    QHash<QAbstractState*, QList<QPropertyAssignment> > propertyAssignmentsForState;
+    QHash<RestorableId, QVariant> pendingRestorables = registeredRestorables;
+    for (int i = 0; i < enteredStates.size(); ++i) {
+        QState *s = qobject_cast<QState*>(enteredStates.at(i));
+        if (!s)
+            continue;
+
+        QList<QPropertyAssignment> assignments = QStatePrivate::get(s)->propertyAssignments;
+        for (int j = 0; j < assignments.size(); ++j) {
+            const QPropertyAssignment &assn = assignments.at(j);
+            if (globalRestorePolicy == QStateMachine::RestoreProperties) {
+                registerRestorable(assn.object, assn.propertyName);
+            }
+            pendingRestorables.remove(RestorableId(assn.object, assn.propertyName));
+            propertyAssignmentsForState[s].append(assn);
+        }
+
+        // Remove pending restorables for all parent states to avoid restoring properties
+        // before the state that assigned them is exited. If state does not explicitly 
+        // assign a property which is assigned by the parent, it inherits the parent's assignment.
+        QState *parentState = s;
+        while ((parentState = parentState->parentState()) != 0) {
+            assignments = QStatePrivate::get(parentState)->propertyAssignments;
+            for (int j=0; j<assignments.size(); ++j) {
+                const QPropertyAssignment &assn = assignments.at(j);
+                int c = pendingRestorables.remove(RestorableId(assn.object, assn.propertyName));
+                if (c > 0)
+                    propertyAssignmentsForState[s].append(assn);                
+            }
+        }
+    }
+    if (!pendingRestorables.isEmpty()) {
+        QAbstractState *s;
+        if (!enteredStates.isEmpty())
+            s = enteredStates.last(); // ### handle if parallel
+        else
+            s = 0;
+        propertyAssignmentsForState[s] << restorablesToPropertyList(pendingRestorables);
+    }
+
+#ifndef QT_NO_ANIMATION
+    // Gracefully terminate playing animations for states that are exited.
+    for (int i = 0; i < exitedStates.size(); ++i) {
+        QAbstractState *s = exitedStates.at(i);
+        QList<QAbstractAnimation*> animations = animationsForState.take(s);
+        for (int j = 0; j < animations.size(); ++j) {
+            QAbstractAnimation *anim = animations.at(j);
+            QObject::disconnect(anim, SIGNAL(finished()), q, SLOT(_q_animationFinished()));
+            stateForAnimation.remove(anim);
+
+            // Stop the (top-level) animation.
+            // ### Stopping nested animation has weird behavior.
+            QAbstractAnimation *topLevelAnim = anim;
+            while (QAnimationGroup *group = topLevelAnim->group())
+                topLevelAnim = group;
+            topLevelAnim->stop();
+
+            if (resetAnimationEndValues.contains(anim)) {
+                qobject_cast<QVariantAnimation*>(anim)->setEndValue(QVariant()); // ### generalize
+                resetAnimationEndValues.remove(anim);
+            }
+            QPropertyAssignment assn = propertyForAnimation.take(anim);
+            Q_ASSERT(assn.object != 0);
+            // If there is no property assignment that sets this property,
+            // set the property to its target value.
+            bool found = false;
+            QHash<QAbstractState*, QList<QPropertyAssignment> >::const_iterator it;
+            for (it = propertyAssignmentsForState.constBegin(); it != propertyAssignmentsForState.constEnd(); ++it) {
+                const QList<QPropertyAssignment> &assignments = it.value();
+                for (int k = 0; k < assignments.size(); ++k) {
+                    if ((assignments.at(k).object == assn.object)
+                        && (assignments.at(k).propertyName == assn.propertyName)) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found) {
+                assn.object->setProperty(assn.propertyName, assn.value);
+            }
+        }
+    }
+
+    // Find the animations to use for the state change.
+    QList<QAbstractAnimation*> selectedAnimations;
+    if (animationsEnabled) {
+        for (int i = 0; i < transitionList.size(); ++i) {
+            QAbstractTransition *transition = transitionList.at(i);
+
+            selectedAnimations << transition->animations();
+            selectedAnimations << defaultAnimationsForSource.values(transition->sourceState());
+
+            QList<QAbstractState *> targetStates = transition->targetStates();
+            for (int j=0; j<targetStates.size(); ++j) 
+                selectedAnimations << defaultAnimationsForTarget.values(targetStates.at(j));
+        }
+        selectedAnimations << defaultAnimations;
+    }
+
+    // Initialize animations from property assignments.
+    for (int i = 0; i < selectedAnimations.size(); ++i) {
+        QAbstractAnimation *anim = selectedAnimations.at(i);
+        QHash<QAbstractState*, QList<QPropertyAssignment> >::iterator it;
+        for (it = propertyAssignmentsForState.begin(); it != propertyAssignmentsForState.end(); ) {
+            QList<QPropertyAssignment>::iterator it2;
+            QAbstractState *s = it.key();
+            QList<QPropertyAssignment> &assignments = it.value();
+            for (it2 = assignments.begin(); it2 != assignments.end(); ) {
+                QPair<QList<QAbstractAnimation*>, QList<QAbstractAnimation*> > ret;
+                ret = initializeAnimation(anim, *it2);
+                QList<QAbstractAnimation*> handlers = ret.first;
+                if (!handlers.isEmpty()) {
+                    for (int j = 0; j < handlers.size(); ++j) {
+                        QAbstractAnimation *a = handlers.at(j);
+                        propertyForAnimation.insert(a, *it2);
+                        stateForAnimation.insert(a, s);
+                        animationsForState[s].append(a);
+                        // ### connect to just the top-level animation?
+                        QObject::disconnect(a, SIGNAL(finished()), q, SLOT(_q_animationFinished()));
+                        QObject::connect(a, SIGNAL(finished()), q, SLOT(_q_animationFinished()));
+                    }
+                    it2 = assignments.erase(it2);
+                } else {
+                    ++it2;
+                }
+                for (int j = 0; j < ret.second.size(); ++j)
+                    resetAnimationEndValues.insert(ret.second.at(j));
+            }
+            if (assignments.isEmpty())
+                it = propertyAssignmentsForState.erase(it);
+            else
+                ++it;
+        }
+        // We require that at least one animation is valid.
+        // ### generalize
+        QList<QVariantAnimation*> variantAnims = qFindChildren<QVariantAnimation*>(anim);
+        if (QVariantAnimation *va = qobject_cast<QVariantAnimation*>(anim))
+            variantAnims.append(va);
+        
+        bool hasValidEndValue = false;
+        for (int j = 0; j < variantAnims.size(); ++j) {
+            if (variantAnims.at(j)->endValue().isValid()) {
+                hasValidEndValue = true;
+                break;
+            }
+        }
+
+        if (hasValidEndValue) {
+            anim->start();
+        }
+    }
+#endif // !QT_NO_ANIMATION
+
+    // Immediately set the properties that are not animated.
+    {
+        QHash<QAbstractState*, QList<QPropertyAssignment> >::const_iterator it;
+        for (it = propertyAssignmentsForState.constBegin(); it != propertyAssignmentsForState.constEnd(); ++it) {
+            const QList<QPropertyAssignment> &assignments = it.value();
+            for (int i = 0; i < assignments.size(); ++i) {
+                const QPropertyAssignment &assn = assignments.at(i);
+                assn.object->setProperty(assn.propertyName, assn.value);
+            }
+        }
+    }
+
+    // Emit polished signal for entered states that have no animated properties.
+    for (int i = 0; i < enteredStates.size(); ++i) {
+        QState *s = qobject_cast<QState*>(enteredStates.at(i));
+        if (s && !animationsForState.contains(s))
+            QStatePrivate::get(s)->emitPolished();
+    }
+}
+
+bool QStateMachinePrivate::isFinal(const QAbstractState *s)
+{
+    return qobject_cast<const QFinalState*>(s) != 0;
+}
+
+bool QStateMachinePrivate::isParallel(const QAbstractState *s)
+{
+    const QState *ss = qobject_cast<const QState*>(s);
+    return ss && (QStatePrivate::get(ss)->childMode == QState::ParallelStates);
+}
+
+bool QStateMachinePrivate::isCompound(const QAbstractState *s)
+{
+    const QState *group = qobject_cast<const QState*>(s);
+    if (!group)
+        return false;
+    return (!isParallel(group) && !QStatePrivate::get(group)->childStates().isEmpty())
+        || (qobject_cast<QStateMachine*>(group->parent()) != 0);
+}
+
+bool QStateMachinePrivate::isAtomic(const QAbstractState *s)
+{
+    const QState *ss = qobject_cast<const QState*>(s);
+    return (ss && QStatePrivate::get(ss)->childStates().isEmpty())
+         || isFinal(s);
+}
+
+
+bool QStateMachinePrivate::isDescendantOf(const QAbstractState *state, const QAbstractState *other)
+{
+    Q_ASSERT(state != 0);
+    for (QAbstractState *s = state->parentState(); s != 0; s = s->parentState()) {
+        if (s == other)
+            return true;
+    }
+    return false;
+}
+
+QList<QState*> QStateMachinePrivate::properAncestors(const QAbstractState *state, const QState *upperBound)
+{
+    Q_ASSERT(state != 0);
+    QList<QState*> result;
+    for (QState *s = state->parentState(); s && s != upperBound; s = s->parentState()) {
+        result.append(s);
+    }
+    return result;
+}
+
+bool QStateMachinePrivate::isInFinalState(QAbstractState* s) const
+{
+    if (isCompound(s)) {
+        QState *grp = qobject_cast<QState*>(s);
+        QList<QAbstractState*> lst = QStatePrivate::get(grp)->childStates();
+        for (int i = 0; i < lst.size(); ++i) {
+            QAbstractState *cs = lst.at(i);
+            if (isFinal(cs) && configuration.contains(cs))
+                return true;
+        }
+        return false;
+    } else if (isParallel(s)) {
+        QState *grp = qobject_cast<QState*>(s);
+        QList<QAbstractState*> lst = QStatePrivate::get(grp)->childStates();
+        for (int i = 0; i < lst.size(); ++i) {
+            QAbstractState *cs = lst.at(i);
+            if (!isInFinalState(cs))
+                return false;
+        }
+        return true;
+    }
+    else
+        return false;
+}
+
+void QStateMachinePrivate::registerRestorable(QObject *object, const QByteArray &propertyName)
+{
+    RestorableId id(object, propertyName);
+    if (!registeredRestorables.contains(id))
+        registeredRestorables.insert(id, object->property(propertyName));
+}
+
+QList<QPropertyAssignment> QStateMachinePrivate::restorablesToPropertyList(const QHash<RestorableId, QVariant> &restorables) const
+{
+    QList<QPropertyAssignment> result;
+    QHash<RestorableId, QVariant>::const_iterator it;
+    for (it = restorables.constBegin(); it != restorables.constEnd(); ++it) {
+//        qDebug() << "restorable:" << it.key().first << it.key().second << it.value();
+        result.append(QPropertyAssignment(it.key().first, it.key().second, it.value(), /*explicitlySet=*/false));
+    }
+    return result;
+}
+
+/*! 
+   \internal
+   Returns true if the variable with the given \a id has been registered for restoration.
+*/
+bool QStateMachinePrivate::hasRestorable(QObject *object, const QByteArray &propertyName) const
+{
+    return registeredRestorables.contains(RestorableId(object, propertyName));
+}
+
+QVariant QStateMachinePrivate::restorableValue(QObject *object, const QByteArray &propertyName) const
+{
+    return registeredRestorables.value(RestorableId(object, propertyName), QVariant());
+}
+
+
+/*!
+   \internal
+    Unregisters the variable identified by \a id
+*/
+void QStateMachinePrivate::unregisterRestorable(QObject *object, const QByteArray &propertyName)
+{
+//    qDebug() << "unregisterRestorable(" << object << propertyName << ")";
+    RestorableId id(object, propertyName);
+    registeredRestorables.remove(id);
+}
+
+QAbstractState *QStateMachinePrivate::findErrorState(QAbstractState *context)
+{
+    // If the user sets the root state's error state to 0, we return the initial error state
+    if (context == 0)
+        return initialErrorStateForRoot;
+
+    // Find error state recursively in parent hierarchy if not set explicitly for context state
+    QAbstractState *errorState = 0;
+    
+    QState *s = qobject_cast<QState*>(context);
+    if (s)
+        errorState = s->errorState();
+
+    if (!errorState)
+        errorState = findErrorState(context->parentState());
+    
+    return errorState;   
+}
+
+void QStateMachinePrivate::setError(QStateMachine::Error errorCode, QAbstractState *currentContext)
+{
+    error = errorCode;
+
+    switch (errorCode) {
+    case QStateMachine::NoInitialStateError:        
+        Q_ASSERT(currentContext != 0);
+
+        errorString = QStateMachine::tr("Missing initial state in compound state '%1'")
+                        .arg(currentContext->objectName());
+
+        break;
+    case QStateMachine::NoDefaultStateInHistoryStateError:
+        Q_ASSERT(currentContext != 0);
+
+        errorString = QStateMachine::tr("Missing default state in history state '%1'")
+                        .arg(currentContext->objectName());
+        break;
+
+    case QStateMachine::NoCommonAncestorForTransitionError:
+        Q_ASSERT(currentContext != 0);
+
+        errorString = QStateMachine::tr("No common ancestor for targets and source of transition from state '%1'")
+                        .arg(currentContext->objectName());
+        break;
+    default:
+        errorString = QStateMachine::tr("Unknown error");
+    };
+
+    pendingErrorStates.clear(); 
+    pendingErrorStatesForDefaultEntry.clear();
+
+    QAbstractState *currentErrorState = findErrorState(currentContext);
+
+    // Avoid infinite loop if the error state itself has an error
+    if (currentContext == currentErrorState) {
+        Q_ASSERT(currentContext != initialErrorStateForRoot); // RootErrorState is broken
+        currentErrorState = initialErrorStateForRoot;
+    }
+
+    Q_ASSERT(currentErrorState != 0);
+    Q_ASSERT(currentErrorState != rootState);
+    
+    QState *lca = findLCA(QList<QAbstractState*>() << currentErrorState << currentContext);
+    addStatesToEnter(currentErrorState, lca, pendingErrorStates, pendingErrorStatesForDefaultEntry);
+}
+
+#ifndef QT_NO_ANIMATION
+
+QPair<QList<QAbstractAnimation*>, QList<QAbstractAnimation*> >
+QStateMachinePrivate::initializeAnimation(QAbstractAnimation *abstractAnimation, 
+                                          const QPropertyAssignment &prop)
+{
+    QList<QAbstractAnimation*> handledAnimations;
+    QList<QAbstractAnimation*> localResetEndValues;
+    QAnimationGroup *group = qobject_cast<QAnimationGroup*>(abstractAnimation);
+    if (group) {
+        for (int i = 0; i < group->animationCount(); ++i) {
+            QAbstractAnimation *animationChild = group->animationAt(i);
+            QPair<QList<QAbstractAnimation*>, QList<QAbstractAnimation*> > ret;
+            ret = initializeAnimation(animationChild, prop);
+            handledAnimations << ret.first;
+            localResetEndValues << ret.second;
+        }
+    } else { 
+        QPropertyAnimation *animation = qobject_cast<QPropertyAnimation *>(abstractAnimation);
+        if (animation != 0 
+            && prop.object == animation->targetObject()
+            && prop.propertyName == animation->propertyName()) {
+
+            // Only change end value if it is undefined
+            if (!animation->endValue().isValid()) {
+                animation->setEndValue(prop.value);
+                localResetEndValues.append(animation);
+            }
+            handledAnimations.append(animation);
+        }
+    }
+    return qMakePair(handledAnimations, localResetEndValues);
+}
+
+void QStateMachinePrivate::_q_animationFinished()
+{
+    Q_Q(QStateMachine);
+    QAbstractAnimation *anim = qobject_cast<QAbstractAnimation*>(q->sender());
+    Q_ASSERT(anim != 0);
+    QObject::disconnect(anim, SIGNAL(finished()), q, SLOT(_q_animationFinished()));
+    if (resetAnimationEndValues.contains(anim)) {
+        qobject_cast<QVariantAnimation*>(anim)->setEndValue(QVariant()); // ### generalize
+        resetAnimationEndValues.remove(anim);
+    }
+
+    // Set the final property value.
+    QPropertyAssignment assn = propertyForAnimation.take(anim);
+    Q_ASSERT(assn.object != 0);
+    assn.object->setProperty(assn.propertyName, assn.value);
+    if (!assn.explicitlySet)
+        unregisterRestorable(assn.object, assn.propertyName);
+
+    QAbstractState *state = stateForAnimation.take(anim);
+    Q_ASSERT(state != 0);
+    QHash<QAbstractState*, QList<QAbstractAnimation*> >::iterator it;
+    it = animationsForState.find(state);
+    Q_ASSERT(it != animationsForState.end());
+    QList<QAbstractAnimation*> &animations = it.value();
+    animations.removeOne(anim);
+    if (animations.isEmpty()) {
+        animationsForState.erase(it);
+        QStatePrivate::get(qobject_cast<QState*>(state))->emitPolished();
+    }
+}
+
+#endif // !QT_NO_ANIMATION
+
+namespace {
+
+class StartState : public QState
+{
+public:
+    StartState(QState *parent)
+        : QState(parent) {}
+protected:
+    void onEntry(QEvent *) {}
+    void onExit(QEvent *) {}
+};
+
+class InitialTransition : public QAbstractTransition
+{
+public:
+    InitialTransition(QAbstractState *target)
+        : QAbstractTransition(QList<QAbstractState*>() << target) {}
+protected:
+    virtual bool eventTest(QEvent *) { return true; }
+    virtual void onTransition(QEvent *) {}
+};
+
+} // namespace
+
+void QStateMachinePrivate::_q_start()
+{
+    Q_Q(QStateMachine);
+    Q_ASSERT(state == Starting);
+    if (!rootState) {
+        state = NotRunning;
+        return;
+    }
+    QAbstractState *initial = rootState->initialState();
+    if (initial == 0)
+        setError(QStateMachine::NoInitialStateError, rootState);    
+
+    configuration.clear();
+    qDeleteAll(internalEventQueue);
+    internalEventQueue.clear();
+    qDeleteAll(externalEventQueue);
+    externalEventQueue.clear();
+
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q << ": starting";
+#endif
+    state = Running;
+    processingScheduled = true; // we call _q_process() below
+    emit q->started();
+
+    StartState *start = new StartState(rootState);
+    QAbstractTransition *initialTransition = new InitialTransition(initial);
+    start->addTransition(initialTransition);
+    QList<QAbstractTransition*> transitions;
+    transitions.append(initialTransition);
+    QEvent nullEvent(QEvent::None);
+    executeTransitionContent(&nullEvent, transitions);
+    enterStates(&nullEvent, transitions);
+    applyProperties(transitions, QList<QAbstractState*>() << start,
+                    QList<QAbstractState*>() << initial);
+    delete start;
+
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q << ": initial configuration:" << configuration;
+#endif
+    _q_process();
+}
+
+void QStateMachinePrivate::_q_process()
+{
+    Q_Q(QStateMachine);
+    Q_ASSERT(state == Running);
+    Q_ASSERT(!processing);
+    processing = true;
+    processingScheduled = false;
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q << ": starting the event processing loop";
+#endif
+    while (processing) {
+        if (stop) {
+            stop = false;
+            processing = false;
+            stopProcessingReason = Stopped;
+            break;
+        }
+        QSet<QAbstractTransition*> enabledTransitions;
+        QEvent *e = new QEvent(QEvent::None);
+        enabledTransitions = selectTransitions(e);
+        if (enabledTransitions.isEmpty()) {
+            delete e;
+            e = 0;
+        }
+        if (enabledTransitions.isEmpty() && !internalEventQueue.isEmpty()) {
+            e = internalEventQueue.takeFirst();
+#ifdef QSTATEMACHINE_DEBUG
+            qDebug() << q << ": dequeued internal event" << e << "of type" << e->type();
+#endif
+            enabledTransitions = selectTransitions(e);
+            if (enabledTransitions.isEmpty()) {
+                delete e;
+                e = 0;
+            }
+        }
+        if (enabledTransitions.isEmpty()) {
+            if (externalEventQueue.isEmpty()) {
+                if (internalEventQueue.isEmpty()) {
+                    processing = false;
+                    stopProcessingReason = EventQueueEmpty;
+                }
+            } else {
+                e = externalEventQueue.takeFirst();
+#ifdef QSTATEMACHINE_DEBUG
+                qDebug() << q << ": dequeued external event" << e << "of type" << e->type();
+#endif
+                enabledTransitions = selectTransitions(e);
+                if (enabledTransitions.isEmpty()) {
+                    delete e;
+                    e = 0;
+                }
+            }
+        }
+        if (!enabledTransitions.isEmpty()) {
+            q->beginMicrostep(e);
+            microstep(e, enabledTransitions.toList());
+            q->endMicrostep(e);
+        }
+#ifdef QSTATEMACHINE_DEBUG
+        else {
+            qDebug() << q << ": no transitions enabled";
+        }
+#endif
+        delete e;
+    }
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q << ": finished the event processing loop";
+#endif
+    switch (stopProcessingReason) {
+    case EventQueueEmpty:
+        break;
+    case Finished:
+        state = NotRunning;
+        unregisterAllTransitions();
+        emit q->finished();
+        break;
+    case Stopped:
+        state = NotRunning;
+        unregisterAllTransitions();
+        emit q->stopped();
+        break;
+    }
+}
+
+void QStateMachinePrivate::scheduleProcess()
+{
+    if ((state != Running) || processing || processingScheduled)
+        return;
+    processingScheduled = true;
+    QMetaObject::invokeMethod(q_func(), "_q_process", Qt::QueuedConnection);
+}
+
+void QStateMachinePrivate::registerTransitions(QAbstractState *state)
+{
+    QState *group = qobject_cast<QState*>(state);
+    if (!group)
+        return;
+    QList<QAbstractTransition*> transitions = QStatePrivate::get(group)->transitions();
+    for (int i = 0; i < transitions.size(); ++i) {
+        QAbstractTransition *t = transitions.at(i);
+        if (QSignalTransition *st = qobject_cast<QSignalTransition*>(t)) {
+            registerSignalTransition(st);
+        }
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+        else if (QEventTransition *oet = qobject_cast<QEventTransition*>(t)) {
+            registerEventTransition(oet);
+        }
+#endif
+    }
+}
+
+void QStateMachinePrivate::unregisterTransition(QAbstractTransition *transition)
+{
+    if (QSignalTransition *st = qobject_cast<QSignalTransition*>(transition)) {
+        unregisterSignalTransition(st);
+    }
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+    else if (QEventTransition *oet = qobject_cast<QEventTransition*>(transition)) {
+        unregisterEventTransition(oet);
+    }
+#endif
+}
+
+static int senderSignalIndex(const QObject *sender)
+{
+    QObjectPrivate *d = QObjectPrivate::get(const_cast<QObject*>(sender));
+    QMutexLocker(&d->threadData->mutex);
+    if (!d->currentSender)
+        return -1;
+
+    // Return -1 if d->currentSender isn't in d->senders
+    bool found = false;
+    for (int i = 0; !found && i < d->senders.count(); ++i)
+        found = (d->senders.at(i)->sender == d->currentSender->sender);
+    if (!found)
+        return -1;
+    return d->currentSender->signal;
+}
+
+void QStateMachinePrivate::registerSignalTransition(QSignalTransition *transition)
+{
+    Q_Q(QStateMachine);
+    if (QSignalTransitionPrivate::get(transition)->signalIndex != -1)
+        return; // already registered
+    QObject *sender = QSignalTransitionPrivate::get(transition)->sender;
+    if (!sender)
+        return;
+    QByteArray signal = QSignalTransitionPrivate::get(transition)->signal;
+    if (signal.startsWith('0'+QSIGNAL_CODE))
+        signal.remove(0, 1);
+    int signalIndex = sender->metaObject()->indexOfSignal(signal);
+    if (signalIndex == -1) {
+        qWarning("QSignalTransition: no such signal: %s::%s",
+                 sender->metaObject()->className(), signal.constData());
+        return;
+    }
+    QVector<int> &connectedSignalIndexes = connections[sender];
+    if (connectedSignalIndexes.size() <= signalIndex)
+        connectedSignalIndexes.resize(signalIndex+1);
+    if (connectedSignalIndexes.at(signalIndex) == 0) {
+        if (!signalEventGenerator)
+            signalEventGenerator = new QSignalEventGenerator(q);
+        bool ok = QMetaObject::connect(sender, signalIndex, signalEventGenerator,
+                                       signalEventGenerator->metaObject()->methodOffset());
+        if (!ok) {
+#ifdef QSTATEMACHINE_DEBUG
+            qDebug() << q << ": FAILED to add signal transition from" << transition->sourceState()
+                     << ": ( sender =" << sender << ", signal =" << (signal.mid(1))
+                     << ", targets =" << transition->targetStates() << ")";
+#endif
+            return;
+        }
+    }
+    ++connectedSignalIndexes[signalIndex];
+    QSignalTransitionPrivate::get(transition)->signalIndex = signalIndex;
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q << ": added signal transition from" << transition->sourceState()
+             << ": ( sender =" << sender << ", signal =" << (signal.mid(1))
+             << ", targets =" << transition->targetStates() << ")";
+#endif
+}
+
+void QStateMachinePrivate::unregisterSignalTransition(QSignalTransition *transition)
+{
+    int signalIndex = QSignalTransitionPrivate::get(transition)->signalIndex;
+    if (signalIndex == -1)
+        return; // not registered
+    QSignalTransitionPrivate::get(transition)->signalIndex = -1;
+    const QObject *sender = QSignalTransitionPrivate::get(transition)->sender;
+    QVector<int> &connectedSignalIndexes = connections[sender];
+    Q_ASSERT(connectedSignalIndexes.size() > signalIndex);
+    Q_ASSERT(connectedSignalIndexes.at(signalIndex) != 0);
+    if (--connectedSignalIndexes[signalIndex] == 0) {
+        Q_ASSERT(signalEventGenerator != 0);
+        QMetaObject::disconnect(sender, signalIndex, signalEventGenerator,
+                                signalEventGenerator->metaObject()->methodOffset());
+        int sum = 0;
+        for (int i = 0; i < connectedSignalIndexes.size(); ++i)
+            sum += connectedSignalIndexes.at(i);
+        if (sum == 0)
+            connections.remove(sender);
+    }
+}
+
+void QStateMachinePrivate::unregisterAllTransitions()
+{
+    {
+        QList<QSignalTransition*> transitions = qFindChildren<QSignalTransition*>(rootState);
+        for (int i = 0; i < transitions.size(); ++i)
+            unregisterSignalTransition(transitions.at(i));
+    }
+    {
+        QList<QEventTransition*> transitions = qFindChildren<QEventTransition*>(rootState);
+        for (int i = 0; i < transitions.size(); ++i)
+            unregisterEventTransition(transitions.at(i));
+    }
+}
+
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+void QStateMachinePrivate::registerEventTransition(QEventTransition *transition)
+{
+    Q_Q(QStateMachine);
+    if (QEventTransitionPrivate::get(transition)->registered)
+        return;
+    if (transition->eventType() >= QEvent::User) {
+        qWarning("QObject event transitions are not supported for custom types");
+        return;
+    }
+    QObject *object = QEventTransitionPrivate::get(transition)->object;
+    if (!object)
+        return;
+    QObjectPrivate *od = QObjectPrivate::get(object);
+    if (!od->eventFilters.contains(q))
+        object->installEventFilter(q);
+    ++qobjectEvents[object][transition->eventType()];
+    QEventTransitionPrivate::get(transition)->registered = true;
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q << ": added event transition from" << transition->sourceState()
+             << ": ( object =" << object << ", event =" << transition->eventType()
+             << ", targets =" << transition->targetStates() << ")";
+#endif
+}
+
+void QStateMachinePrivate::unregisterEventTransition(QEventTransition *transition)
+{
+    Q_Q(QStateMachine);
+    if (!QEventTransitionPrivate::get(transition)->registered)
+        return;
+    QObject *object = QEventTransitionPrivate::get(transition)->object;
+    QHash<QEvent::Type, int> &events = qobjectEvents[object];
+    Q_ASSERT(events.value(transition->eventType()) > 0);
+    if (--events[transition->eventType()] == 0) {
+        events.remove(transition->eventType());
+        int sum = 0;
+        QHash<QEvent::Type, int>::const_iterator it;
+        for (it = events.constBegin(); it != events.constEnd(); ++it)
+            sum += it.value();
+        if (sum == 0) {
+            qobjectEvents.remove(object);
+            object->removeEventFilter(q);
+        }
+    }
+    QEventTransitionPrivate::get(transition)->registered = false;
+}
+#endif
+
+void QStateMachinePrivate::handleTransitionSignal(const QObject *sender, int signalIndex,
+                                                  void **argv)
+{
+    const QVector<int> &connectedSignalIndexes = connections[sender];
+    Q_ASSERT(connectedSignalIndexes.at(signalIndex) != 0);
+    const QMetaObject *meta = sender->metaObject();
+    QMetaMethod method = meta->method(signalIndex);
+    QList<QByteArray> parameterTypes = method.parameterTypes();
+    int argc = parameterTypes.count();
+    QList<QVariant> vargs;
+    for (int i = 0; i < argc; ++i) {
+        int type = QMetaType::type(parameterTypes.at(i));
+        vargs.append(QVariant(type, argv[i+1]));
+    }
+
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q_func() << ": sending signal event ( sender =" << sender
+             << ", signal =" << sender->metaObject()->method(signalIndex).signature() << ")";
+#endif
+    internalEventQueue.append(new QSignalEvent(sender, signalIndex, vargs));
+    scheduleProcess();
+}
+
+/*!
+  Constructs a new state machine with the given \a parent.
+*/
+QStateMachine::QStateMachine(QObject *parent)
+    : QObject(*new QStateMachinePrivate, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QStateMachine::QStateMachine(QStateMachinePrivate &dd, QObject *parent)
+    : QObject(dd, parent)
+{
+}
+
+/*!
+  Destroys this state machine.
+*/
+QStateMachine::~QStateMachine()
+{
+}
+
+namespace {
+
+class RootErrorState : public QAbstractState 
+{
+public:
+    RootErrorState(QState *parent) 
+        : QAbstractState(parent) 
+    {
+        setObjectName(QString::fromLatin1("DefaultErrorState"));
+    }
+
+    void onEntry(QEvent *)
+    {
+        QAbstractStatePrivate *d = QAbstractStatePrivate::get(this);
+        QStateMachine *machine = d->machine();
+
+        qWarning("Unrecoverable error detected in running state machine: %s", 
+                 qPrintable(machine->errorString()));
+    }
+
+    void onExit(QEvent *) {}
+};
+
+class RootState : public QState
+{
+public:
+    RootState(QState *parent)
+        : QState(parent)
+    {                
+    }
+
+    void onEntry(QEvent *) {}
+    void onExit(QEvent *) {}
+};
+
+} // namespace
+
+/*!
+  Returns this state machine's root state.
+*/
+QState *QStateMachine::rootState() const
+{
+    Q_D(const QStateMachine);
+    if (!d->rootState) {
+        const_cast<QStateMachinePrivate*>(d)->rootState = new RootState(0);
+        const_cast<QStateMachinePrivate*>(d)->initialErrorStateForRoot = new RootErrorState(d->rootState);
+        d->rootState->setParent(const_cast<QStateMachine*>(this));
+        d->rootState->setErrorState(d->initialErrorStateForRoot);
+    }
+    return d->rootState;
+}
+
+/*!
+  Returns the error state of the state machine's root state. 
+
+  \sa QState::errorState()
+*/
+QAbstractState *QStateMachine::errorState() const
+{
+    return rootState()->errorState();
+}
+
+/*!
+  Sets the error state of this state machine's root state to be \a state. When a running state 
+  machine encounters an error which puts it in an undefined state, it will enter an error state 
+  based on the context of the error that occurred. It will enter this state regardless of what 
+  is currently in the event queue.
+  
+  If the erroneous state has an error state set, this will be entered by the machine. If no error
+  state has been set, the state machine will search the parent hierarchy recursively for an 
+  error state. The error state of the root state can thus be seen as a global error state that 
+  applies for the states for which a more specific error state has not been set.
+  
+  Before entering the error state, the state machine will set the error code returned by error() and 
+  error  message returned by errorString(). 
+
+  The default error state will print a warning to the console containing the information returned by 
+  errorString(). By setting a new error state on either the state machine itself, or on specific 
+  states, you can fine tune error handling in the state machine. 
+
+  If the root state's error state is set to 0, or if the error state selected by the machine itself
+  contains an error, the default error state will be used.
+
+  \sa QState::setErrorState(), rootState()
+*/
+void QStateMachine::setErrorState(QAbstractState *state)
+{
+    rootState()->setErrorState(state);
+}
+
+/*! \enum QStateMachine::Error 
+
+    This enum type defines errors that can occur in the state machine at run time. When the state
+    machine encounters an unrecoverable error at run time, it will set the error code returned 
+    by error(), the error message returned by errorString(), and enter an error state based on 
+    the context of the error.
+
+    \value NoError No error has occurred.
+    \value NoInitialStateError The machine has entered a QState with children which does not have an
+           initial state set. The context of this error is the state which is missing an initial
+           state.
+    \value NoDefaultStateInHistoryStateError The machine has entered a QHistoryState which does not have 
+           a default state set. The context of this error is the QHistoryState which is missing a
+           default state.
+    \value NoCommonAncestorForTransitionError The machine has selected a transition whose source 
+           and targets are not part of the same tree of states, and thus are not part of the same 
+           state machine. Commonly, this could mean that one of the states has not been given 
+           any parent or added to any machine. The context of this error is the source state of 
+           the transition.
+
+    \sa setErrorState()
+*/
+
+/*!
+   \enum QStateMachine::RestorePolicy
+
+   This enum specifies the restore policy type. The restore policy
+   takes effect when the machine enters a state which sets one or more
+   properties. If the restore policy is set to RestoreProperties,
+   the state machine will save the original value of the property before the
+   new value is set.
+
+   Later, when the machine either enters a state which does not set
+   a value for the given property, the property will automatically be restored
+   to its initial value.
+
+   Only one initial value will be saved for any given property. If a value for a property has 
+   already been saved by the state machine, it will not be overwritten until the property has been
+   successfully restored. 
+
+   \value DoNotRestoreProperties The state machine should not save the initial values of properties 
+          and restore them later.
+   \value RestoreProperties The state machine should save the initial values of properties 
+          and restore them later.
+
+   \sa QStateMachine::globalRestorePolicy QState::assignProperty()
+*/
+
+
+/*!
+  Returns the error code of the last error that occurred in the state machine.
+*/
+QStateMachine::Error QStateMachine::error() const
+{
+    Q_D(const QStateMachine);
+    return d->error;
+}
+
+/*!
+  Returns the error string of the last error that occurred in the state machine.
+*/
+QString QStateMachine::errorString() const
+{
+    Q_D(const QStateMachine);
+    return d->errorString;
+}
+
+/*!
+  Clears the error string and error code of the state machine.
+*/
+void QStateMachine::clearError()
+{
+    Q_D(QStateMachine);
+    d->errorString.clear();
+    d->error = NoError;
+}
+
+/*!
+   Returns the restore policy of the state machine.
+
+   \sa setGlobalRestorePolicy()
+*/
+QStateMachine::RestorePolicy QStateMachine::globalRestorePolicy() const
+{
+    Q_D(const QStateMachine);
+    return d->globalRestorePolicy;
+}
+
+/*!
+   Sets the restore policy of the state machine to \a restorePolicy. The default 
+   restore policy is QAbstractState::DoNotRestoreProperties.
+   
+   \sa globalRestorePolicy()
+*/
+void QStateMachine::setGlobalRestorePolicy(QStateMachine::RestorePolicy restorePolicy) 
+{
+    Q_D(QStateMachine);
+    d->globalRestorePolicy = restorePolicy;
+}
+
+/*!
+  Returns this state machine's initial state, or 0 if no initial state has
+  been set.
+*/
+QAbstractState *QStateMachine::initialState() const
+{
+    Q_D(const QStateMachine);
+    if (!d->rootState)
+        return 0;
+    return d->rootState->initialState();
+}
+
+/*!
+  Sets this state machine's initial \a state.
+*/
+void QStateMachine::setInitialState(QAbstractState *state)
+{
+    Q_D(QStateMachine);
+    if (!d->rootState) {
+        if (!state)
+            return;
+        rootState()->setInitialState(state);
+    }
+    d->rootState->setInitialState(state);
+}
+
+/*!
+  Adds the given \a state to this state machine. The state becomes a top-level
+  state (i.e. a child of the rootState()).
+
+  If the state is already in a different machine, it will first be removed
+  from its old machine, and then added to this machine.
+
+  \sa removeState(), rootState(), setInitialState()
+*/
+void QStateMachine::addState(QAbstractState *state)
+{
+    if (!state) {
+        qWarning("QStateMachine::addState: cannot add null state");
+        return;
+    }
+    if (QAbstractStatePrivate::get(state)->machine() == this) {
+        qWarning("QStateMachine::addState: state has already been added to this machine");
+        return;
+    }
+    state->setParent(rootState());
+}
+
+/*!
+  Removes the given \a state from this state machine.  The state machine
+  releases ownership of the state.
+
+  \sa addState()
+*/
+void QStateMachine::removeState(QAbstractState *state)
+{
+    if (!state) {
+        qWarning("QStateMachine::removeState: cannot remove null state");
+        return;
+    }
+    if (QAbstractStatePrivate::get(state)->machine() != this) {
+        qWarning("QStateMachine::removeState: state %p's machine (%p)"
+                 " is different from this machine (%p)",
+                 state, QAbstractStatePrivate::get(state)->machine(), this);
+        return;
+    }
+    state->setParent(0);
+}
+
+/*!
+  Returns whether this state machine is running.
+
+  start(), stop()
+*/
+bool QStateMachine::isRunning() const
+{
+    Q_D(const QStateMachine);
+    return (d->state == QStateMachinePrivate::Running);
+}
+
+/*!
+  Starts this state machine.  The machine will reset its configuration and
+  transition to the initial state.  When a final top-level state (QFinalState)
+  is entered, the machine will emit the finished() signal.
+
+  \sa started(), finished(), stop(), initialState()
+*/
+void QStateMachine::start()
+{
+    Q_D(QStateMachine);
+
+    if (rootState()->initialState() == 0) {
+        qWarning("QStateMachine::start: No initial state set for machine. Refusing to start.");
+        return;
+    }
+
+    switch (d->state) {
+    case QStateMachinePrivate::NotRunning:
+        d->state = QStateMachinePrivate::Starting;
+        QMetaObject::invokeMethod(this, "_q_start", Qt::QueuedConnection);
+        break;
+    case QStateMachinePrivate::Starting:
+        break;
+    case QStateMachinePrivate::Running:
+        qWarning("QStateMachine::start(): already running");
+        break;
+    }
+}
+
+/*!
+  Stops this state machine. The state machine will stop processing events and
+  then emit the stopped() signal.
+
+  \sa stopped(), start()
+*/
+void QStateMachine::stop()
+{
+    Q_D(QStateMachine);
+    switch (d->state) {
+    case QStateMachinePrivate::NotRunning:
+        break;
+    case QStateMachinePrivate::Starting:
+        // the machine will exit as soon as it enters the event processing loop
+        d->stop = true;
+        break;
+    case QStateMachinePrivate::Running:
+        d->stop = true;
+        d->scheduleProcess();
+        break;
+    }
+}
+
+/*!
+  Posts the given \a event for processing by this state machine, with a delay
+  of \a delay milliseconds.
+
+  This function returns immediately. The event is added to the state machine's
+  event queue. Events are processed in the order posted. The state machine
+  takes ownership of the event and deletes it once it has been processed.
+
+  You can only post events when the state machine is running.
+*/
+void QStateMachine::postEvent(QEvent *event, int delay)
+{
+    Q_D(QStateMachine);
+    if (d->state != QStateMachinePrivate::Running) {
+        qWarning("QStateMachine::postEvent: cannot post event when the state machine is not running");
+        return;
+    }
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << this << ": posting external event" << event << "with delay" << delay;
+#endif
+    if (delay) {
+        int tid = startTimer(delay);
+        d->delayedEvents[tid] = event;
+    } else {
+        d->externalEventQueue.append(event);
+        d->scheduleProcess();
+    }
+}
+
+/*!
+  \internal
+
+  Posts the given internal \a event for processing by this state machine.
+*/
+void QStateMachine::postInternalEvent(QEvent *event)
+{
+    Q_D(QStateMachine);
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << this << ": posting internal event" << event;
+#endif
+    d->internalEventQueue.append(event);
+    d->scheduleProcess();
+}
+
+/*!
+  \internal
+
+   Returns the maximal consistent set of states (including parallel and final
+   states) that this state machine is currently in. If a state \c s is in the
+   configuration, it is always the case that the parent of \c s is also in
+   c. Note, however, that the rootState() is not an explicit member of the
+   configuration.
+*/
+QSet<QAbstractState*> QStateMachine::configuration() const
+{
+    Q_D(const QStateMachine);
+    return d->configuration;
+}
+
+/*!
+  \fn QStateMachine::started()
+
+  This signal is emitted when the state machine has entered its initial state
+  (QStateMachine::initialState).
+
+  \sa QStateMachine::finished(), QStateMachine::start()
+*/
+
+/*!
+  \fn QStateMachine::finished()
+
+  This signal is emitted when the state machine has reached a top-level final
+  state (QFinalState).
+
+  \sa QStateMachine::started()
+*/
+
+/*!
+  \fn QStateMachine::stopped()
+
+  This signal is emitted when the state machine has stopped.
+
+  \sa QStateMachine::stop(), QStateMachine::finished()
+*/
+
+/*!
+  \reimp
+*/
+bool QStateMachine::event(QEvent *e)
+{
+    Q_D(QStateMachine);
+    if (e->type() == QEvent::Timer) {
+        QTimerEvent *te = static_cast<QTimerEvent*>(e);
+        int tid = te->timerId();
+        if (d->delayedEvents.contains(tid)) {
+            killTimer(tid);
+            QEvent *ee = d->delayedEvents.take(tid);
+            d->externalEventQueue.append(ee);
+            d->scheduleProcess();
+            return true;
+        }
+    } else if (e->type() == QEvent::ChildAdded) {
+        QChildEvent *ce = static_cast<QChildEvent*>(e);
+        if (QAbstractState *state = qobject_cast<QAbstractState*>(ce->child())) {
+            if (state != rootState()) {
+                state->setParent(rootState());
+                return true;
+            }
+        }
+    }
+    return QObject::event(e);
+}
+
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+/*!
+  \reimp
+*/
+bool QStateMachine::eventFilter(QObject *watched, QEvent *event)
+{
+    Q_D(QStateMachine);
+    Q_ASSERT(d->qobjectEvents.contains(watched));
+    if (d->qobjectEvents[watched].contains(event->type()))
+        postEvent(new QWrappedEvent(watched, d->handler->cloneEvent(event)));
+    return false;
+}
+#endif
+
+/*!
+  \internal
+
+  This function is called when the state machine is about to select
+  transitions based on the given \a event.
+
+  The default implementation does nothing.
+*/
+void QStateMachine::beginSelectTransitions(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \internal
+
+  This function is called when the state machine has finished selecting
+  transitions based on the given \a event.
+
+  The default implementation does nothing.
+*/
+void QStateMachine::endSelectTransitions(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \internal
+
+  This function is called when the state machine is about to do a microstep.
+
+  The default implementation does nothing.
+*/
+void QStateMachine::beginMicrostep(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \internal
+
+  This function is called when the state machine has finished doing a
+  microstep.
+
+  The default implementation does nothing.
+*/
+void QStateMachine::endMicrostep(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+#ifndef QT_NO_ANIMATION
+
+/*!
+  Returns whether animations are enabled for this state machine.
+*/
+bool QStateMachine::animationsEnabled() const
+{
+    Q_D(const QStateMachine);
+    return d->animationsEnabled;
+}
+
+/*!
+  Sets whether animations are \a enabled for this state machine.
+*/
+void QStateMachine::setAnimationsEnabled(bool enabled)
+{
+    Q_D(QStateMachine);
+    d->animationsEnabled = enabled;
+}
+
+/*!
+    Adds a default \a animation to be considered for any transition.
+*/    
+void QStateMachine::addDefaultAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QStateMachine);
+    d->defaultAnimations.append(animation);
+}
+
+/*!
+    Returns the list of default animations that will be considered for any transition.
+*/
+QList<QAbstractAnimation*> QStateMachine::defaultAnimations() const
+{    
+    Q_D(const QStateMachine);
+    return d->defaultAnimations;
+}
+
+/*!
+    Removes \a animation from the list of default animations. 
+*/
+void QStateMachine::removeDefaultAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QStateMachine);
+    d->defaultAnimations.removeAll(animation);
+}
+
+#endif // QT_NO_ANIMATION
+
+
+static const uint qt_meta_data_QSignalEventGenerator[] = {
+
+ // content:
+       2,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       1,   12, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+
+ // slots: signature, parameters, type, tag, flags
+      23,   22,   22,   22, 0x0a,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_QSignalEventGenerator[] = {
+    "QSignalEventGenerator\0\0execute()\0"
+};
+
+const QMetaObject QSignalEventGenerator::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_QSignalEventGenerator,
+      qt_meta_data_QSignalEventGenerator, 0 }
+};
+
+const QMetaObject *QSignalEventGenerator::metaObject() const
+{
+    return &staticMetaObject;
+}
+
+void *QSignalEventGenerator::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_QSignalEventGenerator))
+        return static_cast<void*>(const_cast< QSignalEventGenerator*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int QSignalEventGenerator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QObject::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        switch (_id) {
+        case 0: {
+// ### in Qt 4.6 we can use QObject::senderSignalIndex()
+            int signalIndex = senderSignalIndex(this);
+            Q_ASSERT(signalIndex != -1);
+            QStateMachine *machine = qobject_cast<QStateMachine*>(parent());
+            QStateMachinePrivate::get(machine)->handleTransitionSignal(sender(), signalIndex, _a);
+            break;
+        }
+        default: ;
+        }
+        _id -= 1;
+    }
+    return _id;
+}
+
+QSignalEventGenerator::QSignalEventGenerator(QStateMachine *parent)
+    : QObject(parent)
+{
+}
+
+/*!
+  \class QSignalEvent
+
+  \brief The QSignalEvent class represents a Qt signal event.
+
+  \since 4.6
+  \ingroup statemachine
+
+  A signal event is generated by a QStateMachine in response to a Qt
+  signal. The QSignalTransition class provides a transition associated with a
+  signal event. QSignalEvent is part of \l{The State Machine Framework}.
+
+  The sender() function returns the object that generated the signal. The
+  signalIndex() function returns the index of the signal. The arguments()
+  function returns the arguments of the signal.
+
+  \sa QSignalTransition
+*/
+
+/*!
+  \internal
+
+  Constructs a new QSignalEvent object with the given \a sender, \a
+  signalIndex and \a arguments.
+*/
+QSignalEvent::QSignalEvent(const QObject *sender, int signalIndex,
+                           const QList<QVariant> &arguments)
+    : QEvent(QEvent::Signal), m_sender(sender),
+      m_signalIndex(signalIndex), m_arguments(arguments)
+{
+}
+
+/*!
+  Destroys this QSignalEvent.
+*/
+QSignalEvent::~QSignalEvent()
+{
+}
+
+/*!
+  \fn QSignalEvent::sender() const
+
+  Returns the object that emitted the signal.
+
+  \sa QObject::sender()
+*/
+
+/*!
+  \fn QSignalEvent::signalIndex() const
+
+  Returns the index of the signal.
+
+  \sa QMetaObject::indexOfSignal(), QMetaObject::method()
+*/
+
+/*!
+  \fn QSignalEvent::arguments() const
+
+  Returns the arguments of the signal.
+*/
+
+
+/*!
+  \class QWrappedEvent
+
+  \brief The QWrappedEvent class holds a clone of an event associated with a QObject.
+
+  \since 4.6
+  \ingroup statemachine
+
+  A wrapped event is generated by a QStateMachine in response to a Qt
+  event. The QEventTransition class provides a transition associated with a
+  such an event. QWrappedEvent is part of \l{The State Machine Framework}.
+
+  The object() function returns the object that generated the event. The
+  event() function returns a clone of the original event.
+
+  \sa QEventTransition
+*/
+
+/*!
+  \internal
+
+  Constructs a new QWrappedEvent object with the given \a object
+  and \a event.
+*/
+QWrappedEvent::QWrappedEvent(QObject *object, QEvent *event)
+    : QEvent(QEvent::Wrapped), m_object(object), m_event(event)
+{
+}
+
+/*!
+  Destroys this QWrappedEvent.
+*/
+QWrappedEvent::~QWrappedEvent()
+{
+}
+
+/*!
+  \fn QWrappedEvent::object() const
+
+  Returns the object that the event is associated with.
+*/
+
+/*!
+  \fn QWrappedEvent::event() const
+
+  Returns a clone of the original event.
+*/
+
+QT_END_NAMESPACE
+
+#include "moc_qstatemachine.cpp"
diff --git a/src/corelib/statemachine/qstatemachine.h b/src/corelib/statemachine/qstatemachine.h
new file mode 100644
index 0000000..2a98a9a
--- /dev/null
+++ b/src/corelib/statemachine/qstatemachine.h
@@ -0,0 +1,166 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTATEMACHINE_H
+#define QSTATEMACHINE_H
+
+#include <QtCore/qabstractstate.h>
+
+#include <QtCore/qlist.h>
+#include <QtCore/qobject.h>
+#include <QtCore/qset.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QEvent;
+class QAbstractState;
+class QState;
+
+class QStateMachinePrivate;
+class QAbstractAnimation;
+class QAbstractState;
+class Q_CORE_EXPORT QStateMachine : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QState* rootState READ rootState)
+    Q_PROPERTY(QAbstractState* initialState READ initialState WRITE setInitialState)
+    Q_PROPERTY(QAbstractState* errorState READ errorState WRITE setErrorState)
+    Q_PROPERTY(QString errorString READ errorString)
+    Q_PROPERTY(RestorePolicy globalRestorePolicy READ globalRestorePolicy WRITE setGlobalRestorePolicy)
+    Q_ENUMS(RestorePolicy)
+#ifndef QT_NO_ANIMATION
+    Q_PROPERTY(bool animationsEnabled READ animationsEnabled WRITE setAnimationsEnabled)
+#endif
+public:
+    enum RestorePolicy {
+        DoNotRestoreProperties,
+        RestoreProperties
+    };
+
+    enum Error {
+        NoError, 
+        NoInitialStateError,
+        NoDefaultStateInHistoryStateError,
+        NoCommonAncestorForTransitionError
+    };
+
+    QStateMachine(QObject *parent = 0);
+    ~QStateMachine();
+
+    void addState(QAbstractState *state);
+    void removeState(QAbstractState *state);
+
+    QState *rootState() const;
+
+    QAbstractState *initialState() const;
+    void setInitialState(QAbstractState *state);
+
+    QAbstractState *errorState() const;
+    void setErrorState(QAbstractState *state);
+
+    Error error() const;
+    QString errorString() const;
+    void clearError();
+
+    bool isRunning() const;
+
+#ifndef QT_NO_ANIMATION
+    bool animationsEnabled() const;
+    void setAnimationsEnabled(bool enabled);
+
+    void addDefaultAnimation(QAbstractAnimation *animation);
+    QList<QAbstractAnimation *> defaultAnimations() const;
+    void removeDefaultAnimation(QAbstractAnimation *animation);
+#endif // QT_NO_ANIMATION
+
+    QStateMachine::RestorePolicy globalRestorePolicy() const;
+    void setGlobalRestorePolicy(QStateMachine::RestorePolicy restorePolicy);
+
+    void postEvent(QEvent *event, int delay = 0);
+
+    QSet<QAbstractState*> configuration() const;
+
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+    bool eventFilter(QObject *watched, QEvent *event);
+#endif
+
+public Q_SLOTS:
+    void start();
+    void stop();
+
+Q_SIGNALS:
+    void started();
+    void stopped();
+    void finished();
+
+protected:
+    void postInternalEvent(QEvent *event);
+
+    virtual void beginSelectTransitions(QEvent *event);
+    virtual void endSelectTransitions(QEvent *event);
+
+    virtual void beginMicrostep(QEvent *event);
+    virtual void endMicrostep(QEvent *event);
+
+    bool event(QEvent *e);
+
+protected:
+    QStateMachine(QStateMachinePrivate &dd, QObject *parent);
+
+private:
+    Q_DISABLE_COPY(QStateMachine)
+    Q_DECLARE_PRIVATE(QStateMachine)
+    Q_PRIVATE_SLOT(d_func(), void _q_start())
+    Q_PRIVATE_SLOT(d_func(), void _q_process())
+#ifndef QT_NO_ANIMATION
+    Q_PRIVATE_SLOT(d_func(), void _q_animationFinished())
+#endif
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qstatemachine_p.h b/src/corelib/statemachine/qstatemachine_p.h
new file mode 100644
index 0000000..dfa5575
--- /dev/null
+++ b/src/corelib/statemachine/qstatemachine_p.h
@@ -0,0 +1,217 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSTATEMACHINE_P_H
+#define QSTATEMACHINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qobject_p.h>
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qpair.h>
+#include <QtCore/qset.h>
+#include <QtCore/qvector.h>
+
+#include "qstate.h"
+#include "qstate_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEvent;
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+class QEventTransition;
+#endif
+class QSignalEventGenerator;
+class QSignalTransition;
+class QAbstractState;
+class QAbstractTransition;
+class QState;
+
+#ifndef QT_NO_ANIMATION
+class QAbstractAnimation;
+#endif
+
+class QStateMachine;
+class Q_CORE_EXPORT QStateMachinePrivate
+    : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QStateMachine)
+public:
+    enum State {
+        NotRunning,
+        Starting,
+        Running
+    };
+    enum StopProcessingReason {
+        EventQueueEmpty,
+        Finished,
+        Stopped
+    };
+
+    QStateMachinePrivate();
+    ~QStateMachinePrivate();
+
+    static QStateMachinePrivate *get(QStateMachine *q);
+
+    static QState *findLCA(const QList<QAbstractState*> &states);
+
+    static bool stateEntryLessThan(QAbstractState *s1, QAbstractState *s2);
+    static bool stateExitLessThan(QAbstractState *s1, QAbstractState *s2);
+
+    QAbstractState *findErrorState(QAbstractState *context);
+    void setError(QStateMachine::Error error, QAbstractState *currentContext);
+
+    // private slots
+    void _q_start();
+    void _q_process();
+#ifndef QT_NO_ANIMATION
+    void _q_animationFinished();
+#endif
+
+    void microstep(QEvent *event, const QList<QAbstractTransition*> &transitionList);
+    bool isPreempted(const QAbstractState *s, const QSet<QAbstractTransition*> &transitions) const;
+    QSet<QAbstractTransition*> selectTransitions(QEvent *event) const;
+    QList<QAbstractState*> exitStates(QEvent *event, const QList<QAbstractTransition*> &transitionList);
+    void executeTransitionContent(QEvent *event, const QList<QAbstractTransition*> &transitionList);
+    QList<QAbstractState*> enterStates(QEvent *event, const QList<QAbstractTransition*> &enabledTransitions);
+    void addStatesToEnter(QAbstractState *s, QState *root,
+                          QSet<QAbstractState*> &statesToEnter,
+                          QSet<QAbstractState*> &statesForDefaultEntry);
+
+    void applyProperties(const QList<QAbstractTransition*> &transitionList,
+                         const QList<QAbstractState*> &exitedStates,
+                         const QList<QAbstractState*> &enteredStates);
+
+    bool isInFinalState(QAbstractState *s) const;
+    static bool isFinal(const QAbstractState *s);
+    static bool isParallel(const QAbstractState *s);
+    static bool isCompound(const QAbstractState *s);
+    static bool isAtomic(const QAbstractState *s);
+    static bool isDescendantOf(const QAbstractState *s, const QAbstractState *other);
+    static QList<QState*> properAncestors(const QAbstractState *s, const QState *upperBound);
+
+    void registerTransitions(QAbstractState *state);
+    void registerSignalTransition(QSignalTransition *transition);
+    void unregisterSignalTransition(QSignalTransition *transition);
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+    void registerEventTransition(QEventTransition *transition);
+    void unregisterEventTransition(QEventTransition *transition);
+#endif
+    void unregisterTransition(QAbstractTransition *transition);
+    void unregisterAllTransitions();
+    void handleTransitionSignal(const QObject *sender, int signalIndex,
+                                void **args);    
+    void scheduleProcess();
+    
+    typedef QPair<QObject *, QByteArray> RestorableId;
+    QHash<RestorableId, QVariant> registeredRestorables;
+    void registerRestorable(QObject *object, const QByteArray &propertyName);
+    void unregisterRestorable(QObject *object, const QByteArray &propertyName);
+    bool hasRestorable(QObject *object, const QByteArray &propertyName) const;
+    QVariant restorableValue(QObject *object, const QByteArray &propertyName) const;
+    QList<QPropertyAssignment> restorablesToPropertyList(const QHash<RestorableId, QVariant> &restorables) const;
+
+    State state;
+    bool processing;
+    bool processingScheduled;
+    bool stop;
+    StopProcessingReason stopProcessingReason;
+    QState *rootState;
+    QSet<QAbstractState*> configuration;
+    QList<QEvent*> internalEventQueue;
+    QList<QEvent*> externalEventQueue;
+
+    QStateMachine::Error error;
+    QStateMachine::RestorePolicy globalRestorePolicy;
+
+    QString errorString;
+    QSet<QAbstractState *> pendingErrorStates;
+    QSet<QAbstractState *> pendingErrorStatesForDefaultEntry;
+    QAbstractState *initialErrorStateForRoot;
+
+#ifndef QT_NO_ANIMATION
+    bool animationsEnabled;
+
+    QPair<QList<QAbstractAnimation*>, QList<QAbstractAnimation*> >
+        initializeAnimation(QAbstractAnimation *abstractAnimation, 
+                            const QPropertyAssignment &prop);
+
+    QHash<QAbstractState*, QList<QAbstractAnimation*> > animationsForState;
+    QHash<QAbstractAnimation*, QPropertyAssignment> propertyForAnimation;
+    QHash<QAbstractAnimation*, QAbstractState*> stateForAnimation;
+    QSet<QAbstractAnimation*> resetAnimationEndValues;
+
+    QList<QAbstractAnimation *> defaultAnimations;
+    QMultiHash<QAbstractState *, QAbstractAnimation *> defaultAnimationsForSource;
+    QMultiHash<QAbstractState *, QAbstractAnimation *> defaultAnimationsForTarget;
+
+#endif // QT_NO_ANIMATION
+
+    QSignalEventGenerator *signalEventGenerator;
+
+    QHash<const QObject*, QVector<int> > connections;
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+    QHash<QObject*, QHash<QEvent::Type, int> > qobjectEvents;
+#endif
+    QHash<int, QEvent*> delayedEvents;
+  
+    typedef QEvent* (*f_cloneEvent)(QEvent*);
+    struct Handler {
+        f_cloneEvent cloneEvent;
+    };
+
+    static const Handler *handler;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qwrappedevent.h b/src/corelib/statemachine/qwrappedevent.h
new file mode 100644
index 0000000..b01c608
--- /dev/null
+++ b/src/corelib/statemachine/qwrappedevent.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWRAPPEDEVENT_H
+#define QWRAPPEDEVENT_H
+
+#include <QtCore/qcoreevent.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QObject;
+
+class Q_CORE_EXPORT QWrappedEvent : public QEvent
+{
+public:
+    QWrappedEvent(QObject *object, QEvent *event);
+    ~QWrappedEvent();
+
+    inline QObject *object() const { return m_object; }
+    inline QEvent *event() const { return m_event; }
+
+private:
+    QObject *m_object;
+    QEvent *m_event;
+
+private:
+    Q_DISABLE_COPY(QWrappedEvent)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/statemachine.pri b/src/corelib/statemachine/statemachine.pri
new file mode 100644
index 0000000..5b19bc1
--- /dev/null
+++ b/src/corelib/statemachine/statemachine.pri
@@ -0,0 +1,30 @@
+HEADERS += $$PWD/qstatemachine.h \
+	   $$PWD/qstatemachine_p.h \
+	   $$PWD/qsignaleventgenerator_p.h \
+	   $$PWD/qabstractstate.h \
+	   $$PWD/qabstractstate_p.h \
+	   $$PWD/qstate.h \
+	   $$PWD/qstate_p.h \
+	   $$PWD/qfinalstate.h \
+	   $$PWD/qhistorystate.h \
+	   $$PWD/qhistorystate_p.h \
+	   $$PWD/qabstracttransition.h \
+	   $$PWD/qabstracttransition_p.h \
+	   $$PWD/qsignalevent.h \
+	   $$PWD/qsignaltransition.h \
+	   $$PWD/qsignaltransition_p.h
+
+SOURCES += $$PWD/qstatemachine.cpp \
+	   $$PWD/qabstractstate.cpp \
+	   $$PWD/qstate.cpp \
+	   $$PWD/qfinalstate.cpp \
+	   $$PWD/qhistorystate.cpp \
+	   $$PWD/qabstracttransition.cpp \
+	   $$PWD/qsignaltransition.cpp
+
+!contains(DEFINES, QT_NO_STATEMACHINE_EVENTFILTER) {
+HEADERS += $$PWD/qwrappedevent.h \
+	   $$PWD/qeventtransition.h \
+	   $$PWD/qeventtransition_p.h
+SOURCES += $$PWD/qeventtransition.cpp
+}
diff --git a/src/corelib/thread/qmutexpool.cpp b/src/corelib/thread/qmutexpool.cpp
index 96a9940..0d7c890 100644
--- a/src/corelib/thread/qmutexpool.cpp
+++ b/src/corelib/thread/qmutexpool.cpp
@@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE
 // qt_global_mutexpool is here for backwards compatability only,
 // use QMutexpool::instance() in new clode.
 Q_CORE_EXPORT QMutexPool *qt_global_mutexpool = 0;
-Q_GLOBAL_STATIC_WITH_ARGS(QMutexPool, globalMutexPool, (true))
+Q_GLOBAL_STATIC_WITH_ARGS(QMutexPool, globalMutexPool, (QMutex::Recursive))
 
 /*!
     \class QMutexPool
@@ -88,17 +88,17 @@ Q_GLOBAL_STATIC_WITH_ARGS(QMutexPool, globalMutexPool, (true))
 */
 
 /*!
-    Constructs  a QMutexPool, reserving space for \a size QMutexes. If
-    \a recursive is true, all QMutexes in the pool will be recursive
-    mutexes; otherwise they will all be non-recursive (the default).
+    Constructs  a QMutexPool, reserving space for \a size QMutexes. All
+    mutexes in the pool are created with \a recursionMode. By default,
+    all mutexes are non-recursive.
 
     The QMutexes are created when needed, and deleted when the
     QMutexPool is destructed.
 */
-QMutexPool::QMutexPool(bool recursive, int size)
-    : mutexes(size), count(size), recurs(recursive)
+QMutexPool::QMutexPool(QMutex::RecursionMode recursionMode, int size)
+    : mutexes(size), recursionMode(recursionMode)
 {
-    for (int index = 0; index < count; ++index) {
+    for (int index = 0; index < mutexes.count(); ++index) {
         mutexes[index] = 0;
     }
 }
@@ -109,7 +109,7 @@ QMutexPool::QMutexPool(bool recursive, int size)
 */
 QMutexPool::~QMutexPool()
 {
-    for (int index = 0; index < count; ++index) {
+    for (int index = 0; index < mutexes.count(); ++index) {
         delete mutexes[index];
         mutexes[index] = 0;
     }
@@ -130,11 +130,11 @@ QMutexPool *QMutexPool::instance()
 QMutex *QMutexPool::get(const void *address)
 {
     Q_ASSERT_X(address != 0, "QMutexPool::get()", "'address' argument cannot be zero");
-    int index = int((quintptr(address) >> (sizeof(address) >> 1)) % count);
+    int index = int((quintptr(address) >> (sizeof(address) >> 1)) % mutexes.count());
 
     if (!mutexes[index]) {
         // mutex not created, create one
-        QMutex *newMutex = new QMutex(recurs ? QMutex::Recursive : QMutex::NonRecursive);
+        QMutex *newMutex = new QMutex(recursionMode);
         if (!mutexes[index].testAndSetOrdered(0, newMutex))
             delete newMutex;
     }
diff --git a/src/corelib/thread/qmutexpool_p.h b/src/corelib/thread/qmutexpool_p.h
index 1009ebb..30a16d4 100644
--- a/src/corelib/thread/qmutexpool_p.h
+++ b/src/corelib/thread/qmutexpool_p.h
@@ -64,7 +64,7 @@ QT_BEGIN_NAMESPACE
 class Q_CORE_EXPORT QMutexPool
 {
 public:
-    explicit QMutexPool(bool recursive = false, int size = 128);
+    explicit QMutexPool(QMutex::RecursionMode recursionMode = QMutex::NonRecursive, int size = 131);
     ~QMutexPool();
 
     QMutex *get(const void *address);
@@ -72,9 +72,8 @@ public:
     static QMutex *globalInstanceGet(const void *address);
 
 private:
-    QVarLengthArray<QAtomicPointer<QMutex>, 128> mutexes;
-    int count;
-    bool recurs;
+    QVarLengthArray<QAtomicPointer<QMutex>, 131> mutexes;
+    QMutex::RecursionMode recursionMode;
 };
 
 extern Q_CORE_EXPORT QMutexPool *qt_global_mutexpool;
diff --git a/src/corelib/tools/qeasingcurve.cpp b/src/corelib/tools/qeasingcurve.cpp
new file mode 100644
index 0000000..2b027fc
--- /dev/null
+++ b/src/corelib/tools/qeasingcurve.cpp
@@ -0,0 +1,846 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*
+
+| *property* | *Used for type* |
+| period     | QEasingCurve::{In,Out,InOut,OutIn}Elastic |
+| amplitude  | QEasingCurve::{In,Out,InOut,OutIn}Bounce, QEasingCurve::{In,Out,InOut,OutIn}Elastic |
+| overshoot  | QEasingCurve::{In,Out,InOut,OutIn}Back   |
+
+*/
+
+
+
+
+/*!
+    \class QEasingCurve
+    \since 4.6
+    \ingroup animation
+    \brief The QEasingCurve class provides easing curves for controlling animation.
+
+    Easing curves describe a function that controls how the speed of the interpolation
+    between 0 and 1 should be. Easing curves allow transitions from
+    one value to another to appear more natural than a simple constant speed would allow.
+    The QEasingCurve class is usually used in conjunction with the QAnimation class,
+    but can be used on its own.
+
+    To calculate the speed of the interpolation, the easing curve provides the function
+    valueForProgress(), where the \a progress argument specifies the progress of the
+    interpolation: 0 is the start value of the interpolation, 1 is the end value of the
+    interpolation. The returned value is the effective progress of the interpolation.
+    If the returned value is the same as the input value for all input values the easing
+    curve is a linear curve. This is the default behaviour.
+
+    For example,
+    \code
+    QEasingCurve easing(QEasingCurve::InOutQuad);
+
+    for(qreal t = 0.0; t < 1.0; t+=0.1)
+        qWarning() << "Effective progress" << t << " is
+                   << easing.valueForProgress(t);
+    \endcode
+    will print the effective progress of the interpolation between 0 and 1.
+
+    When using a QAnimation, the easing curve will be used to control the
+    progress of the interpolation between startValue and endValue:
+    \code
+    QAnimation animation;
+    animation.setStartValue(0);
+    animation.setEndValue(1000);
+    animation.setDuration(1000);
+    animation.setEasingCurve(QEasingCurve::InOutQuad);
+    \endcode
+ */
+
+/*!
+    \enum QEasingCurve::Type
+
+    The type of easing curve.
+
+    \value Linear       \inlineimage qeasingcurve-linear.png
+                        \br
+                        Easing equation function for a simple linear tweening,
+                        with no easing.
+    \value InQuad       \inlineimage qeasingcurve-inquad.png
+                        \br
+                        Easing equation function for a quadratic (t^2) easing
+                        in: accelerating from zero velocity.
+    \value OutQuad      \inlineimage qeasingcurve-outquad.png
+                        \br
+                        Easing equation function for a quadratic (t^2) easing
+                        out: decelerating to zero velocity.
+    \value InOutQuad    \inlineimage qeasingcurve-inoutquad.png
+                        \br
+                        Easing equation function for a quadratic (t^2) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInQuad    \inlineimage qeasingcurve-outinquad.png
+                        \br
+                        Easing equation function for a quadratic (t^2) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InCubic      \inlineimage qeasingcurve-incubic.png
+                        \br
+                        Easing equation function for a cubic (t^3) easing
+                        in: accelerating from zero velocity.
+    \value OutCubic     \inlineimage qeasingcurve-outcubic.png
+                        \br
+                        Easing equation function for a cubic (t^3) easing
+                        out: decelerating from zero velocity.
+    \value InOutCubic   \inlineimage qeasingcurve-inoutcubic.png
+                        \br
+                        Easing equation function for a cubic (t^3) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInCubic   \inlineimage qeasingcurve-outincubic.png
+                        \br
+                        Easing equation function for a cubic (t^3) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InQuart      \inlineimage qeasingcurve-inquart.png
+                        \br
+                        Easing equation function for a quartic (t^4) easing
+                        in: accelerating from zero velocity.
+    \value OutQuart     \inlineimage qeasingcurve-outquart.png
+                        \br
+                        Easing equation function for a quartic (t^4) easing
+                        out: decelerating from zero velocity.
+    \value InOutQuart   \inlineimage qeasingcurve-inoutquart.png
+                        \br
+                        Easing equation function for a quartic (t^4) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInQuart   \inlineimage qeasingcurve-outinquart.png
+                        \br
+                        Easing equation function for a quartic (t^4) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InQuint      \inlineimage qeasingcurve-inquint.png
+                        \br
+                        Easing equation function for a quintic (t^5) easing
+                        in: accelerating from zero velocity.
+    \value OutQuint     \inlineimage qeasingcurve-outquint.png
+                        \br
+                        Easing equation function for a quintic (t^5) easing
+                        out: decelerating from zero velocity.
+    \value InOutQuint   \inlineimage qeasingcurve-inoutquint.png
+                        \br
+                        Easing equation function for a quintic (t^5) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInQuint   \inlineimage qeasingcurve-outinquint.png
+                        \br
+                        Easing equation function for a quintic (t^5) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InSine       \inlineimage qeasingcurve-insine.png
+                        \br
+                        Easing equation function for a sinusoidal (sin(t)) easing
+                        in: accelerating from zero velocity.
+    \value OutSine      \inlineimage qeasingcurve-outsine.png
+                        \br
+                        Easing equation function for a sinusoidal (sin(t)) easing
+                        out: decelerating from zero velocity.
+    \value InOutSine    \inlineimage qeasingcurve-inoutsine.png
+                        \br
+                        Easing equation function for a sinusoidal (sin(t)) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInSine    \inlineimage qeasingcurve-outinsine.png
+                        \br
+                        Easing equation function for a sinusoidal (sin(t)) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InExpo       \inlineimage qeasingcurve-inexpo.png
+                        \br
+                        Easing equation function for an exponential (2^t) easing
+                        in: accelerating from zero velocity.
+    \value OutExpo      \inlineimage qeasingcurve-outexpo.png
+                        \br
+                        Easing equation function for an exponential (2^t) easing
+                        out: decelerating from zero velocity.
+    \value InOutExpo    \inlineimage qeasingcurve-inoutexpo.png
+                        \br
+                        Easing equation function for an exponential (2^t) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInExpo    \inlineimage qeasingcurve-outinexpo.png
+                        \br
+                        Easing equation function for an exponential (2^t) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InCirc       \inlineimage qeasingcurve-incirc.png
+                        \br
+                        Easing equation function for a circular (sqrt(1-t^2)) easing
+                        in: accelerating from zero velocity.
+    \value OutCirc      \inlineimage qeasingcurve-outcirc.png
+                        \br
+                        Easing equation function for a circular (sqrt(1-t^2)) easing
+                        out: decelerating from zero velocity.
+    \value InOutCirc    \inlineimage qeasingcurve-inoutcirc.png
+                        \br
+                        Easing equation function for a circular (sqrt(1-t^2)) easing
+                        in/out: acceleration until halfway, then deceleration.
+    \value OutInCirc    \inlineimage qeasingcurve-outincirc.png
+                        \br
+                        Easing equation function for a circular (sqrt(1-t^2)) easing
+                        out/in: deceleration until halfway, then acceleration.
+    \value InElastic    \inlineimage qeasingcurve-inelastic.png
+                        \br
+                        Easing equation function for an elastic
+                        (exponentially decaying sine wave) easing in:
+                        accelerating from zero velocity.  The peak amplitude
+                        can be set with the \e amplitude parameter, and the
+                        period of decay by the \e period parameter.
+    \value OutElastic   \inlineimage qeasingcurve-outelastic.png
+                        \br
+                        Easing equation function for an elastic
+                        (exponentially decaying sine wave) easing out:
+                        decelerating from zero velocity.  The peak amplitude
+                        can be set with the \e amplitude parameter, and the
+                        period of decay by the \e period parameter.
+    \value InOutElastic \inlineimage qeasingcurve-inoutelastic.png
+                        \br
+                        Easing equation function for an elastic
+                        (exponentially decaying sine wave) easing in/out:
+                        acceleration until halfway, then deceleration.
+    \value OutInElastic \inlineimage qeasingcurve-outinelastic.png
+                        \br
+                        Easing equation function for an elastic
+                        (exponentially decaying sine wave) easing out/in:
+                        deceleration until halfway, then acceleration.
+    \value InBack       \inlineimage qeasingcurve-inback.png
+                        \br
+                        Easing equation function for a back (overshooting
+                        cubic easing: (s+1)*t^3 - s*t^2) easing in:
+                        accelerating from zero velocity.
+    \value OutBack      \inlineimage qeasingcurve-outback.png
+                        \br
+                        Easing equation function for a back (overshooting
+                        cubic easing: (s+1)*t^3 - s*t^2) easing out:
+                        decelerating from zero velocity.
+    \value InOutBack    \inlineimage qeasingcurve-inoutback.png
+                        \br
+                        Easing equation function for a back (overshooting
+                        cubic easing: (s+1)*t^3 - s*t^2) easing in/out:
+                        acceleration until halfway, then deceleration.
+    \value OutInBack    \inlineimage qeasingcurve-outinback.png
+                        \br
+                        Easing equation function for a back (overshooting
+                        cubic easing: (s+1)*t^3 - s*t^2) easing out/in:
+                        deceleration until halfway, then acceleration.
+    \value InBounce     \inlineimage qeasingcurve-inbounce.png
+                        \br
+                        Easing equation function for a bounce (exponentially
+                        decaying parabolic bounce) easing in: accelerating
+                        from zero velocity.
+    \value OutBounce    \inlineimage qeasingcurve-outbounce.png
+                        \br
+                        Easing equation function for a bounce (exponentially
+                        decaying parabolic bounce) easing out: decelerating
+                        from zero velocity.
+    \value InOutBounce  \inlineimage qeasingcurve-inoutbounce.png
+                        \br
+                        Easing equation function for a bounce (exponentially
+                        decaying parabolic bounce) easing in/out:
+                        acceleration until halfway, then deceleration.
+    \value OutInBounce  \inlineimage qeasingcurve-outinbounce.png
+                        \br
+                        Easing equation function for a bounce (exponentially
+                        decaying parabolic bounce) easing out/in:
+                        deceleration until halfway, then acceleration.
+    \omitvalue InCurve
+    \omitvalue OutCurve
+    \omitvalue SineCurve
+    \omitvalue CosineCurve
+    \value Custom       This is returned if the user have specified a custom curve type with setCustomType(). Note that you cannot call setType() with this value, but type() can return it.
+    \omitvalue NCurveTypes
+*/
+
+/*!
+    \typedef QEasingCurve::EasingFunction
+
+    This is a typedef for a pointer to a function with the following
+    signature:
+
+    \snippet doc/src/snippets/code/src_corelib_tools_qeasingcurve.cpp 0
+*/
+
+#include "qeasingcurve.h"
+
+#ifndef QT_NO_DEBUG_STREAM
+#include <QtCore/qdebug.h>
+#include <QtCore/QString>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+static bool isConfigFunction(QEasingCurve::Type type)
+{
+    return type >= QEasingCurve::InElastic
+            && type <= QEasingCurve::OutInBounce;
+}
+
+class QEasingCurveFunction
+{
+public:
+    enum Type { In, Out, InOut, OutIn };
+
+    QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = 0.3, qreal amplitude = 1.0,
+        qreal overshoot = 1.70158f)
+        : _t(type), _p(period), _a(amplitude), _o(overshoot)
+    { }
+    virtual ~QEasingCurveFunction() {}
+    virtual qreal value(qreal t);
+    virtual QEasingCurveFunction *copy() const;
+    bool operator==(const QEasingCurveFunction& other);
+
+    Type _t;
+    qreal _p;
+    qreal _a;
+    qreal _o;
+};
+
+qreal QEasingCurveFunction::value(qreal t)
+{
+    return t;
+}
+
+QEasingCurveFunction *QEasingCurveFunction::copy() const
+{
+    return new QEasingCurveFunction(_t, _p, _a, _o);
+}
+
+bool QEasingCurveFunction::operator==(const QEasingCurveFunction& other)
+{
+    return _t == other._t &&
+           _p == other._p &&
+           _a == other._a &&
+           _o == other._o;
+}
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include "../../3rdparty/easing/easing.cpp"
+QT_END_INCLUDE_NAMESPACE
+
+class QEasingCurvePrivate
+{
+public:
+    QEasingCurvePrivate()
+        : type(QEasingCurve::Linear),
+          config(0),
+          func(&easeNone)
+    { }
+    ~QEasingCurvePrivate() { delete config; }
+    void setType_helper(QEasingCurve::Type);
+
+    QEasingCurve::Type type;
+    QEasingCurveFunction *config;
+    QEasingCurve::EasingFunction func;
+};
+
+struct ElasticEase : public QEasingCurveFunction
+{
+    ElasticEase(Type type)
+        : QEasingCurveFunction(type, qreal(0.3), qreal(1.0))
+    { }
+
+    QEasingCurveFunction *copy() const
+    {
+        ElasticEase *rv = new ElasticEase(_t);
+        rv->_p = _p;
+        rv->_a = _a;
+        return rv;
+    }
+
+    qreal value(qreal t)
+    {
+        qreal p = (_p < 0) ? 0.3f : _p;
+        qreal a = (_a < 0) ? 1.0f : _a;
+        switch(_t) {
+        case In:
+            return easeInElastic(t, a, p);
+        case Out:
+            return easeOutElastic(t, a, p);
+        case InOut:
+            return easeInOutElastic(t, a, p);
+        case OutIn:
+            return easeOutInElastic(t, a, p);
+        default:
+            return t;
+        }
+    }
+};
+
+struct BounceEase : public QEasingCurveFunction
+{
+    BounceEase(Type type)
+        : QEasingCurveFunction(type, 0.3f, 1.0f)
+    { }
+
+    QEasingCurveFunction *copy() const
+    {
+        BounceEase *rv = new BounceEase(_t);
+        rv->_a = _a;
+        return rv;
+    }
+
+    qreal value(qreal t)
+    {
+        qreal a = (_a < 0) ? 1.0f : _a;
+        switch(_t) {
+        case In:
+            return easeInBounce(t, a);
+        case Out:
+            return easeOutBounce(t, a);
+        case InOut:
+            return easeInOutBounce(t, a);
+        case OutIn:
+            return easeOutInBounce(t, a);
+        default:
+            return t;
+        }
+    }
+};
+
+struct BackEase : public QEasingCurveFunction
+{
+    BackEase(Type type)
+        : QEasingCurveFunction(type, 0.3f, 1.0f, 1.70158f)
+    { }
+
+    QEasingCurveFunction *copy() const
+    {
+        BackEase *rv = new BackEase(_t);
+        rv->_o = _o;
+        return rv;
+    }
+
+    qreal value(qreal t)
+    {
+        qreal o = (_o < 0) ? 1.70158f : _o;
+        switch(_t) {
+        case In:
+            return easeInBack(t, o);
+        case Out:
+            return easeOutBack(t, o);
+        case InOut:
+            return easeInOutBack(t, o);
+        case OutIn:
+            return easeOutInBack(t, o);
+        default:
+            return t;
+        }
+    }
+};
+
+static QEasingCurve::EasingFunction curveToFunc(QEasingCurve::Type curve)
+{
+    switch(curve) {
+    case QEasingCurve::Linear:
+        return &easeNone;
+    case QEasingCurve::InQuad:
+        return &easeInQuad;
+    case QEasingCurve::OutQuad:
+        return &easeOutQuad;
+    case QEasingCurve::InOutQuad:
+        return &easeInOutQuad;
+    case QEasingCurve::OutInQuad:
+        return &easeOutInQuad;
+    case QEasingCurve::InCubic:
+        return &easeInCubic;
+    case QEasingCurve::OutCubic:
+        return &easeOutCubic;
+    case QEasingCurve::InOutCubic:
+        return &easeInOutCubic;
+    case QEasingCurve::OutInCubic:
+        return &easeOutInCubic;
+    case QEasingCurve::InQuart:
+        return &easeInQuart;
+    case QEasingCurve::OutQuart:
+        return &easeOutQuart;
+    case QEasingCurve::InOutQuart:
+        return &easeInOutQuart;
+    case QEasingCurve::OutInQuart:
+        return &easeOutInQuart;
+    case QEasingCurve::InQuint:
+        return &easeInQuint;
+    case QEasingCurve::OutQuint:
+        return &easeOutQuint;
+    case QEasingCurve::InOutQuint:
+        return &easeInOutQuint;
+    case QEasingCurve::OutInQuint:
+        return &easeOutInQuint;
+    case QEasingCurve::InSine:
+        return &easeInSine;
+    case QEasingCurve::OutSine:
+        return &easeOutSine;
+    case QEasingCurve::InOutSine:
+        return &easeInOutSine;
+    case QEasingCurve::OutInSine:
+        return &easeOutInSine;
+    case QEasingCurve::InExpo:
+        return &easeInExpo;
+    case QEasingCurve::OutExpo:
+        return &easeOutExpo;
+    case QEasingCurve::InOutExpo:
+        return &easeInOutExpo;
+    case QEasingCurve::OutInExpo:
+        return &easeOutInExpo;
+    case QEasingCurve::InCirc:
+        return &easeInCirc;
+    case QEasingCurve::OutCirc:
+        return &easeOutCirc;
+    case QEasingCurve::InOutCirc:
+        return &easeInOutCirc;
+    case QEasingCurve::OutInCirc:
+        return &easeOutInCirc;
+    // Internal for, compatibility with QTimeLine only ??
+    case QEasingCurve::InCurve:
+        return &easeInCurve;
+    case QEasingCurve::OutCurve:
+        return &easeOutCurve;
+    case QEasingCurve::SineCurve:
+        return &easeSineCurve;
+    case QEasingCurve::CosineCurve:
+        return &easeCosineCurve;
+    default:
+        return 0;
+    };
+}
+
+static QEasingCurveFunction *curveToFunctionObject(QEasingCurve::Type type)
+{
+    QEasingCurveFunction *curveFunc = 0;
+    switch(type) {
+    case QEasingCurve::InElastic:
+        curveFunc = new ElasticEase(ElasticEase::In);
+        break;
+    case QEasingCurve::OutElastic:
+        curveFunc = new ElasticEase(ElasticEase::Out);
+        break;
+    case QEasingCurve::InOutElastic:
+        curveFunc = new ElasticEase(ElasticEase::InOut);
+        break;
+    case QEasingCurve::OutInElastic:
+        curveFunc = new ElasticEase(ElasticEase::OutIn);
+        break;
+    case QEasingCurve::OutBounce:
+        curveFunc = new BounceEase(BounceEase::Out);
+        break;
+    case QEasingCurve::InBounce:
+        curveFunc = new BounceEase(BounceEase::In);
+        break;
+    case QEasingCurve::OutInBounce:
+        curveFunc = new BounceEase(BounceEase::OutIn);
+        break;
+    case QEasingCurve::InOutBounce:
+        curveFunc = new BounceEase(BounceEase::InOut);
+        break;
+    case QEasingCurve::InBack:
+        curveFunc = new BackEase(BackEase::In);
+        break;
+    case QEasingCurve::OutBack:
+        curveFunc = new BackEase(BackEase::Out);
+        break;
+    case QEasingCurve::InOutBack:
+        curveFunc = new BackEase(BackEase::InOut);
+        break;
+    case QEasingCurve::OutInBack:
+        curveFunc = new BackEase(BackEase::OutIn);
+        break;
+    default:
+        curveFunc = new QEasingCurveFunction(QEasingCurveFunction::In, 0.3f, 1.0f, 1.70158f);     // ###
+    }
+
+    return curveFunc;
+}
+
+/*!
+    Constructs an easing curve of the given \a type.
+ */
+QEasingCurve::QEasingCurve(Type type)
+    : d_ptr(new QEasingCurvePrivate)
+{
+    setType(type);
+}
+
+/*!
+    Construct a copy of \a other.
+ */
+QEasingCurve::QEasingCurve(const QEasingCurve &other)
+: d_ptr(new QEasingCurvePrivate)
+{
+    // ### non-atomic, requires malloc on shallow copy
+    *d_ptr = *other.d_ptr;
+    if(other.d_ptr->config)
+        d_ptr->config = other.d_ptr->config->copy();
+}
+
+/*!
+    Destructor.
+ */
+
+QEasingCurve::~QEasingCurve()
+{
+    delete d_ptr;
+}
+
+/*!
+    Copy \a other.
+ */
+QEasingCurve &QEasingCurve::operator=(const QEasingCurve &other)
+{
+    // ### non-atomic, requires malloc on shallow copy
+    if (d_ptr->config) {
+        delete d_ptr->config;
+        d_ptr->config = 0;
+    }
+
+    *d_ptr = *other.d_ptr;
+    if(other.d_ptr->config)
+        d_ptr->config = other.d_ptr->config->copy();
+
+    return *this;
+}
+
+/*!
+    Compare this easing curve with \a other and returns true if they are
+    equal. It will also compare the properties of a curve.
+ */
+bool QEasingCurve::operator==(const QEasingCurve &other) const
+{
+    bool res = d_ptr->func == other.d_ptr->func
+            && d_ptr->type == other.d_ptr->type;
+    if (res && d_ptr->config && other.d_ptr->config) {
+        // catch the config content
+        res = d_ptr->config->operator==(*(other.d_ptr->config));
+    }
+    return res;
+}
+
+/*!
+    \fn bool QEasingCurve::operator!=(const QEasingCurve &other) const
+    Compare this easing curve with \a other and returns true if they are not equal.
+    It will also compare the properties of a curve.
+
+    \sa operator==()
+*/
+
+/*!
+    Returns the amplitude. This is not applicable for all curve types.
+    It is only applicable for bounce and elastic curves (curves of type()
+    QEasingCurve::InBounce, QEasingCurve::OutBounce, QEasingCurve::InOutBounce,
+    QEasingCurve::OutInBounce, QEasingCurve::InElastic, QEasingCurve::OutElastic,
+    QEasingCurve::InOutElastic or QEasingCurve::OutInElastic).
+ */
+qreal QEasingCurve::amplitude() const
+{
+    return d_ptr->config ? d_ptr->config->_a : 1.0;
+}
+
+/*!
+    Sets the amplitude to \a amplitude.
+
+    This will set the amplitude of the bounce or the amplitude of the
+    elastic "spring" effect. The higher the number, the higher the amplitude.
+    \sa amplitude()
+*/
+void QEasingCurve::setAmplitude(qreal amplitude)
+{
+    if (!d_ptr->config)
+        d_ptr->config = curveToFunctionObject(d_ptr->type);
+    d_ptr->config->_a = amplitude;
+}
+
+/*!
+    Returns the period. This is not applicable for all curve types.
+    It is only applicable if type() is QEasingCurve::InElastic, QEasingCurve::OutElastic,
+    QEasingCurve::InOutElastic or QEasingCurve::OutInElastic.
+ */
+qreal QEasingCurve::period() const
+{
+    return d_ptr->config ? d_ptr->config->_p : 0.3;
+}
+
+/*!
+    Sets the period to \a period.
+    Setting a small period value will give a high frequency of the curve. A
+    large period will give it a small frequency.
+
+    \sa period()
+*/
+void QEasingCurve::setPeriod(qreal period)
+{
+    if (!d_ptr->config)
+        d_ptr->config = curveToFunctionObject(d_ptr->type);
+    d_ptr->config->_p = period;
+}
+
+/*!
+    Returns the overshoot. This is not applicable for all curve types.
+    It is only applicable if type() is QEasingCurve::InBack, QEasingCurve::OutBack,
+    QEasingCurve::InOutBack or QEasingCurve::OutInBack.
+ */
+qreal QEasingCurve::overshoot() const
+{
+    return d_ptr->config ? d_ptr->config->_o : 1.70158f;
+}
+
+/*!
+    Sets the overshoot to \a overshoot.
+
+    0 produces no overshoot, and the default value of 1.70158 produces an overshoot of 10 percent.
+
+    \sa overshoot()
+*/
+void QEasingCurve::setOvershoot(qreal overshoot)
+{
+    if (!d_ptr->config)
+        d_ptr->config = curveToFunctionObject(d_ptr->type);
+    d_ptr->config->_o = overshoot;
+}
+
+/*!
+    Returns the type of the easing curve.
+*/
+QEasingCurve::Type QEasingCurve::type() const
+{
+    return d_ptr->type;
+}
+
+void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType)
+{
+    qreal amp = -1.0;
+    qreal period = -1.0;
+    qreal overshoot = -1.0;
+
+    if (config) {
+        amp = config->_a;
+        period = config->_p;
+        overshoot = config->_o;
+        delete config;
+        config = 0;
+    }
+
+    if (isConfigFunction(newType) || (amp != -1.0) || (period != -1.0) || (overshoot != -1.0)) {
+        config = curveToFunctionObject(newType);
+        if (amp != -1.0)
+            config->_a = amp;
+        if (period != -1.0)
+            config->_p = period;
+        if (overshoot != -1.0)
+            config->_o = overshoot;
+        func = 0;
+    } else if (newType != QEasingCurve::Custom) {
+        func = curveToFunc(newType);
+    }
+    Q_ASSERT((func == 0) == (config != 0));
+    type = newType;
+}
+
+/*!
+    Sets the type of the easing curve to \a type.
+*/
+void QEasingCurve::setType(Type type)
+{
+    if (d_ptr->type == type)
+        return;
+    if (type < Linear || type >= NCurveTypes - 1) {
+        qWarning("QEasingCurve: Invalid curve type %d", type);
+        return;
+    }
+
+    d_ptr->setType_helper(type);
+}
+
+/*!
+    Sets a custom easing curve that is defined by the user in the function \a func.
+    The signature of the function is qreal myEasingFunction(qreal progress),
+    where \e progress and the return value is considered to be normalized between 0 and 1.
+    (In some cases the return value can be outside that range)
+    After calling this function type() will return QEasingCurve::Custom.
+    \a func cannot be zero.
+
+    \sa customType()
+    \sa valueForProgress()
+*/
+void QEasingCurve::setCustomType(EasingFunction func)
+{
+    if (!func) {
+        qWarning("Function pointer must not be null");
+        return;
+    }
+    d_ptr->func = func;
+    d_ptr->setType_helper(Custom);
+}
+
+/*!
+    Returns the function pointer to the custom easing curve.
+    If type() does not return QEasingCurve::Custom, this function
+    will return 0.
+*/
+QEasingCurve::EasingFunction QEasingCurve::customType() const
+{
+    return d_ptr->type == Custom ? d_ptr->func : 0;
+}
+
+/*!
+    Return the effective progress for the easing curve at \a progress.
+    While  \a progress must be between 0 and 1, the returned effective progress
+    can be outside those bounds. For instance, QEasingCurve::InBack will
+    return negative values in the beginning of the function.
+ */
+qreal QEasingCurve::valueForProgress(qreal progress) const
+{
+    progress = qBound<qreal>(0, progress, 1);
+    if (d_ptr->func)
+        return d_ptr->func(progress);
+    else if (d_ptr->config)
+        return d_ptr->config->value(progress);
+    else
+        return progress;
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug debug, const QEasingCurve &item)
+{
+    debug << "type:" << item.d_ptr->type
+          << "func:" << item.d_ptr->func;
+    if (item.d_ptr->config) {
+        debug << QString::fromAscii("period:%1").arg(item.d_ptr->config->_p, 0, 'f', 20)
+              << QString::fromAscii("amp:%1").arg(item.d_ptr->config->_a, 0, 'f', 20)
+              << QString::fromAscii("overshoot:%1").arg(item.d_ptr->config->_o, 0, 'f', 20);
+    }
+    return debug;
+}
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/corelib/tools/qeasingcurve.h b/src/corelib/tools/qeasingcurve.h
new file mode 100644
index 0000000..a240bc0
--- /dev/null
+++ b/src/corelib/tools/qeasingcurve.h
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEASINGCURVE_H
+#define QEASINGCURVE_H
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qobjectdefs.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QEasingCurvePrivate;
+class Q_CORE_EXPORT QEasingCurve
+{
+    Q_GADGET
+    Q_ENUMS(Type)
+public:
+    enum Type {
+        Linear,
+        InQuad, OutQuad, InOutQuad, OutInQuad,
+        InCubic, OutCubic, InOutCubic, OutInCubic,
+        InQuart, OutQuart, InOutQuart, OutInQuart,
+        InQuint, OutQuint, InOutQuint, OutInQuint,
+        InSine, OutSine, InOutSine, OutInSine,
+        InExpo, OutExpo, InOutExpo, OutInExpo,
+        InCirc, OutCirc, InOutCirc, OutInCirc,
+        InElastic, OutElastic, InOutElastic, OutInElastic,
+        InBack, OutBack, InOutBack, OutInBack,
+        InBounce, OutBounce, InOutBounce, OutInBounce,
+        InCurve, OutCurve, SineCurve, CosineCurve,
+        Custom, NCurveTypes
+    };
+
+    QEasingCurve(Type type = Linear);
+    QEasingCurve(const QEasingCurve &other);
+    ~QEasingCurve();
+
+    QEasingCurve &operator=(const QEasingCurve &other);
+    bool operator==(const QEasingCurve &other) const;
+    inline bool operator!=(const QEasingCurve &other) const
+    { return !(this->operator==(other)); }
+
+    qreal amplitude() const;
+    void setAmplitude(qreal amplitude);
+
+    qreal period() const;
+    void setPeriod(qreal period);
+
+    qreal overshoot() const;
+    void setOvershoot(qreal overshoot);
+
+    Type type() const;
+    void setType(Type type);
+    typedef qreal (*EasingFunction)(qreal progress);
+    void setCustomType(EasingFunction func);
+    EasingFunction customType() const;
+
+    qreal valueForProgress(qreal progress) const;
+private:
+    QEasingCurvePrivate *d_ptr;
+    friend Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QEasingCurve &item);
+};
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QEasingCurve &item);
+#endif
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index c3649e3..29509c5 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -195,6 +195,68 @@ static int ucstrnicmp(const ushort *a, const ushort *b, int l)
     return ucstricmp(a, a + l, b, b + l);
 }
 
+static bool qMemEquals(const quint16 *a, const quint16 *b, int length)
+{
+    // Benchmarking indicates that doing memcmp is much slower than
+    // executing the comparison ourselves.
+    // To make it even faster, we do a 32-bit comparison, comparing
+    // twice the amount of data as a normal word-by-word comparison.
+    //
+    // Benchmarking results on a 2.33 GHz Core2 Duo, with a 64-QChar
+    // block of data, with 4194304 iterations (per iteration):
+    //    operation             usec            cpu ticks
+    //     memcmp                330               710
+    //     16-bit                 79             167-171
+    //  32-bit aligned            49             105-109
+    //
+    // Testing also indicates that unaligned 32-bit loads are as
+    // performant as 32-bit aligned.
+    if (a == b || !length)
+        return true;
+
+    register union {
+        const quint16 *w;
+        const quint32 *d;
+        quintptr value;
+    } sa, sb;
+    sa.w = a;
+    sb.w = b;
+
+    // check alignment
+    if ((sa.value & 2) == (sb.value & 2)) {
+        // both addresses have the same alignment
+        if (sa.value & 2) {
+            // both addresses are not aligned to 4-bytes boundaries
+            // compare the first character
+            if (*sa.w != *sb.w)
+                return false;
+            --length;
+            ++sa.w;
+            ++sb.w;
+
+            // now both addresses are 4-bytes aligned
+        }
+
+        // both addresses are 4-bytes aligned
+        // do a fast 32-bit comparison
+        register const quint32 *e = sa.d + (length >> 1);
+        for ( ; sa.d != e; ++sa.d, ++sb.d) {
+            if (*sa.d != *sb.d)
+                return false;
+        }
+
+        // do we have a tail?
+        return (length & 1) ? *sa.w == *sb.w : true;
+    } else {
+        // one of the addresses isn't 4-byte aligned but the other is
+        register const quint16 *e = sa.w + length;
+        for ( ; sa.w != e; ++sa.w, ++sb.w) {
+            if (*sa.w != *sb.w)
+                return false;
+        }
+    }
+    return true;
+}
 
 /*!
     \internal
@@ -1908,8 +1970,10 @@ QString &QString::replace(QChar c, const QLatin1String &after, Qt::CaseSensitivi
 */
 bool QString::operator==(const QString &other) const
 {
-    return (size() == other.size()) &&
-        (memcmp((char*)unicode(),(char*)other.unicode(), size()*sizeof(QChar))==0);
+    if (d->size != other.d->size)
+        return false;
+
+    return qMemEquals(d->data, other.d->data, d->size);
 }
 
 /*!
@@ -3136,7 +3200,7 @@ bool QString::startsWith(const QString& s, Qt::CaseSensitivity cs) const
     if (s.d->size > d->size)
         return false;
     if (cs == Qt::CaseSensitive) {
-        return memcmp((char*)d->data, (char*)s.d->data, s.d->size*sizeof(QChar)) == 0;
+        return qMemEquals(d->data, s.d->data, s.d->size);
     } else {
         uint last = 0;
         uint olast = 0;
@@ -3207,7 +3271,7 @@ bool QString::endsWith(const QString& s, Qt::CaseSensitivity cs) const
     if (pos < 0)
         return false;
     if (cs == Qt::CaseSensitive) {
-        return memcmp((char*)&d->data[pos], (char*)s.d->data, s.d->size*sizeof(QChar)) == 0;
+        return qMemEquals(d->data + pos, s.d->data, s.d->size);
     } else {
         uint last = 0;
         uint olast = 0;
@@ -7692,7 +7756,8 @@ QString QStringRef::toString() const {
 */
 bool operator==(const QStringRef &s1,const QStringRef &s2)
 { return (s1.size() == s2.size() &&
-          (memcmp((char*)s1.unicode(), (char*)s2.unicode(), s1.size()*sizeof(QChar))==0)); }
+          qMemEquals((const ushort *)s1.unicode(), (const ushort *)s2.unicode(), s1.size()));
+}
 
 /*! \relates QStringRef
 
@@ -7701,7 +7766,8 @@ bool operator==(const QStringRef &s1,const QStringRef &s2)
 */
 bool operator==(const QString &s1,const QStringRef &s2)
 { return (s1.size() == s2.size() &&
-          (memcmp((char*)s1.unicode(), (char*)s2.unicode(), s1.size()*sizeof(QChar))==0)); }
+          qMemEquals((const ushort *)s1.unicode(), (const ushort *)s2.unicode(), s1.size()));
+}
 
 /*! \relates QStringRef
 
diff --git a/src/corelib/tools/qtimeline.cpp b/src/corelib/tools/qtimeline.cpp
index 3a03558..ee4f73c 100644
--- a/src/corelib/tools/qtimeline.cpp
+++ b/src/corelib/tools/qtimeline.cpp
@@ -48,20 +48,6 @@
 
 QT_BEGIN_NAMESPACE
 
-static const qreal pi = qreal(3.14159265359);
-static const qreal halfPi = pi / qreal(2.0);
-
-
-static inline qreal qt_sinProgress(qreal value)
-{
-    return qSin((value * pi) - halfPi) / 2 + qreal(0.5);
-}
-
-static inline qreal qt_smoothBeginEndMixFactor(qreal value)
-{
-    return qMin(qMax(1 - value * 2 + qreal(0.3), qreal(0.0)), qreal(1.0));
-}
-
 class QTimeLinePrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QTimeLine)
@@ -70,7 +56,7 @@ public:
         : startTime(0), duration(1000), startFrame(0), endFrame(0),
           updateInterval(1000 / 25),
           totalLoopCount(1), currentLoopCount(0), currentTime(0), timerId(0),
-          direction(QTimeLine::Forward), curveShape(QTimeLine::EaseInOutCurve),
+          direction(QTimeLine::Forward), easingCurve(QEasingCurve::InOutSine),
           state(QTimeLine::NotRunning)
     { }
 
@@ -88,7 +74,7 @@ public:
     QTime timer;
 
     QTimeLine::Direction direction;
-    QTimeLine::CurveShape curveShape;
+    QEasingCurve easingCurve;
     QTimeLine::State state;
     inline void setState(QTimeLine::State newState)
     {
@@ -523,12 +509,68 @@ void QTimeLine::setUpdateInterval(int interval)
 QTimeLine::CurveShape QTimeLine::curveShape() const
 {
     Q_D(const QTimeLine);
-    return d->curveShape;
+    switch (d->easingCurve.type()) {
+    default:
+    case QEasingCurve::InOutSine:
+        return EaseInOutCurve;
+    case QEasingCurve::InCurve:
+        return EaseInCurve;
+    case QEasingCurve::OutCurve:
+        return EaseOutCurve;
+    case QEasingCurve::Linear:
+        return LinearCurve;
+    case QEasingCurve::SineCurve:
+        return SineCurve;
+    case QEasingCurve::CosineCurve:
+        return CosineCurve;
+    }
+    return EaseInOutCurve;
 }
+
 void QTimeLine::setCurveShape(CurveShape shape)
 {
+    switch (shape) {
+    default:
+    case EaseInOutCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::InOutSine));
+        break;
+    case EaseInCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::InCurve));
+        break;
+    case EaseOutCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::OutCurve));
+        break;
+    case LinearCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::Linear));
+        break;
+    case SineCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::SineCurve));
+        break;
+    case CosineCurve:
+        setEasingCurve(QEasingCurve(QEasingCurve::CosineCurve));
+        break;
+    } 
+}
+
+/*!
+    \property QTimeLine::easingCurve
+
+    Specifies the easing curve that the timeline will use.
+    If both easing curve and curveShape are set, the last set property will
+    override the previous one. (If valueForTime() is reimplemented it will 
+    override both)
+*/
+
+QEasingCurve QTimeLine::easingCurve() const
+{
+    Q_D(const QTimeLine);
+    return d->easingCurve;
+}
+
+void QTimeLine::setEasingCurve(const QEasingCurve& curve)
+{
     Q_D(QTimeLine);
-    d->curveShape = shape;
+    d->easingCurve = curve;
 }
 
 /*!
@@ -608,42 +650,8 @@ qreal QTimeLine::valueForTime(int msec) const
     Q_D(const QTimeLine);
     msec = qMin(qMax(msec, 0), d->duration);
 
-    // Simple linear interpolation
     qreal value = msec / qreal(d->duration);
-
-    switch (d->curveShape) {
-    case EaseInOutCurve:
-        value = qt_sinProgress(value);
-        break;
-        // SmoothBegin blends Smooth and Linear Interpolation.
-        // Progress 0 - 0.3      : Smooth only
-        // Progress 0.3 - ~ 0.5  : Mix of Smooth and Linear
-        // Progress ~ 0.5  - 1   : Linear only
-    case EaseInCurve: {
-        const qreal sinProgress = qt_sinProgress(value);
-        const qreal linearProgress = value;
-        const qreal mix = qt_smoothBeginEndMixFactor(value);
-        value = sinProgress * mix + linearProgress * (1 - mix);
-        break;
-    }
-    case EaseOutCurve: {
-        const qreal sinProgress = qt_sinProgress(value);
-        const qreal linearProgress = value;
-        const qreal mix = qt_smoothBeginEndMixFactor(1 - value);
-        value = sinProgress * mix + linearProgress * (1 - mix);
-        break;
-    }
-    case SineCurve:
-        value = (qSin(((msec * pi * 2) / d->duration) - pi/2) + 1) / 2;
-        break;
-    case CosineCurve:
-        value = (qCos(((msec * pi * 2) / d->duration) - pi/2) + 1) / 2;
-        break;
-    default:
-        break;
-    }
-
-    return value;
+    return d->easingCurve.valueForProgress(value);
 }
 
 /*!
diff --git a/src/corelib/tools/qtimeline.h b/src/corelib/tools/qtimeline.h
index 18c3980..48c9232 100644
--- a/src/corelib/tools/qtimeline.h
+++ b/src/corelib/tools/qtimeline.h
@@ -42,6 +42,7 @@
 #ifndef QTIMELINE_H
 #define QTIMELINE_H
 
+#include <QtCore/qeasingcurve.h>
 #include <QtCore/qobject.h>
 
 QT_BEGIN_HEADER
@@ -60,6 +61,7 @@ class Q_CORE_EXPORT QTimeLine : public QObject
     Q_PROPERTY(Direction direction READ direction WRITE setDirection)
     Q_PROPERTY(int loopCount READ loopCount WRITE setLoopCount)
     Q_PROPERTY(CurveShape curveShape READ curveShape WRITE setCurveShape)
+    Q_PROPERTY(QEasingCurve easingCurve READ easingCurve WRITE setEasingCurve)
 public:
     enum State {
         NotRunning,
@@ -105,6 +107,9 @@ public:
     CurveShape curveShape() const;
     void setCurveShape(CurveShape shape);
 
+    QEasingCurve easingCurve() const;
+    void setEasingCurve(const QEasingCurve &curve);
+
     int currentTime() const;
     int currentFrame() const;
     qreal currentValue() const;
diff --git a/src/corelib/tools/tools.pri b/src/corelib/tools/tools.pri
index a6fdac7..90287cb 100644
--- a/src/corelib/tools/tools.pri
+++ b/src/corelib/tools/tools.pri
@@ -11,6 +11,7 @@ HEADERS +=  \
 	tools/qcryptographichash.h \
 	tools/qdatetime.h \
 	tools/qdatetime_p.h \
+        tools/qeasingcurve.h \
 	tools/qhash.h \
         tools/qline.h \
 	tools/qlinkedlist.h \
@@ -46,6 +47,7 @@ SOURCES += \
 	tools/qbytearraymatcher.cpp \
 	tools/qcryptographichash.cpp \
 	tools/qdatetime.cpp \
+        tools/qeasingcurve.cpp \
 	tools/qhash.cpp \
         tools/qline.cpp \
 	tools/qlinkedlist.cpp \