Initial import of statemachine branch from the old kinetic repository

39 files changed, 7586 insertions, 0 deletions

diff --git a/src/corelib/statemachine/qabstractstate.cpp b/src/corelib/statemachine/qabstractstate.cpp
new file mode 100644
index 0000000..1795bd6
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate.cpp
@@ -0,0 +1,265 @@
+/****************************************************************************
+**
+** 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 "qstatemachine.h"
+#include "qstatemachine_p.h"
+#include "qstate.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QAbstractState
+
+  \brief The QAbstractState class is the base class of states of a QStateMachine.
+
+  \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 assignProperty() function is used for defining property assignments that
+  should be performed when a state is entered.
+
+  The parentState() function returns the state's parent state.
+
+  \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.
+*/
+
+/*!
+   \enum QAbstractState::RestorePolicy
+
+   This enum specifies the restore policy type for a state. The restore policy
+   takes effect when the machine enters a state which sets one or more
+   properties. If the restore policy of the state 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 has its restore policy
+   set to DoNotRestoreProperties or when it 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. Once the property has been restored, the state machine will clear the 
+   initial value until it enters a new state which sets the property and which has RestoreProperties
+   as its restore policy.
+
+   \value GlobalRestorePolicy The restore policy for the state should be retrieved using 
+          QStateMachine::globalRestorePolicy()
+   \value DoNotRestoreProperties The state machine should not save the initial values of properties 
+          set in the state and restore them later.
+   \value RestoreProperties The state machine should save the initial values of properties 
+          set in the state and restore them later.
+
+
+   \sa setRestorePolicy(), restorePolicy()
+*/
+
+/*!
+   \property QAbstractState::restorePolicy
+
+    \brief the restore policy of this state
+*/
+
+QAbstractStatePrivate::QAbstractStatePrivate()
+    : restorePolicy(QAbstractState::GlobalRestorePolicy)
+{
+}
+
+QAbstractStatePrivate *QAbstractStatePrivate::get(QAbstractState *q)
+{
+    return q->d_func();
+}
+
+const QAbstractStatePrivate *QAbstractStatePrivate::get(const 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()
+{
+    Q_Q(QAbstractState);
+    q->onEntry();
+}
+
+void QAbstractStatePrivate::callOnExit()
+{
+    Q_Q(QAbstractState);
+    q->onExit();
+}
+
+/*!
+  Constructs a new state with the given \a parent state.
+*/
+QAbstractState::QAbstractState(QState *parent)
+    : QObject(
+#ifndef QT_STATEMACHINE_SOLUTION
+        *new QAbstractStatePrivate,
+#endif
+        parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(new QAbstractStatePrivate)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+}
+
+/*!
+  \internal
+*/
+QAbstractState::QAbstractState(QAbstractStatePrivate &dd, QState *parent)
+    : QObject(
+#ifndef QT_STATEMACHINE_SOLUTION
+        dd,
+#endif
+        parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(&dd)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+}
+
+/*!
+  Destroys this state.
+*/
+QAbstractState::~QAbstractState()
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    delete d_ptr;
+#endif
+}
+
+/*!
+  Returns this state's parent state, or 0 if the state has no parent state.
+*/
+QState *QAbstractState::parentState() const
+{
+    return qobject_cast<QState*>(parent());
+}
+
+/*!
+  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.
+*/
+void QAbstractState::assignProperty(QObject *object, const char *name,
+                                    const QVariant &value)
+{
+    Q_D(QAbstractState);
+    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));
+}
+
+/*!
+  Sets the restore policy of this state to \a restorePolicy. 
+  
+  The default restore policy is QAbstractState::GlobalRestorePolicy.
+*/
+void QAbstractState::setRestorePolicy(RestorePolicy restorePolicy)
+{
+    Q_D(QAbstractState);
+    d->restorePolicy = restorePolicy;
+}
+
+/*!
+  Returns the restore policy for this state.
+*/
+QAbstractState::RestorePolicy QAbstractState::restorePolicy() const
+{
+    Q_D(const QAbstractState);
+    return d->restorePolicy;
+}
+
+/*!
+  \fn QAbstractState::onExit()
+
+  This function is called when the state is exited.  Reimplement this function
+  to perform custom processing when the state is exited.
+*/
+
+/*!
+  \fn QAbstractState::onEntry()
+
+  This function is called when the state is entered. Reimplement this function
+  to perform custom processing when the state is entered.
+*/
+
+/*!
+  \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..b788a88
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** 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 QAbstractStatePrivate;
+class Q_CORE_EXPORT QAbstractState : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(RestorePolicy)
+    Q_PROPERTY(RestorePolicy restorePolicy READ restorePolicy WRITE setRestorePolicy)
+public:
+    enum RestorePolicy {
+        GlobalRestorePolicy,
+        DoNotRestoreProperties,
+        RestoreProperties
+    };
+
+    ~QAbstractState();
+
+    QState *parentState() const;
+
+    void assignProperty(QObject *object, const char *name,
+                        const QVariant &value);
+
+    void setRestorePolicy(RestorePolicy restorePolicy);
+    RestorePolicy restorePolicy() const;
+
+protected:
+    QAbstractState(QState *parent = 0);
+
+    virtual void onEntry() = 0;
+    virtual void onExit() = 0;
+
+    bool event(QEvent *e);
+
+protected:
+#ifdef QT_STATEMACHINE_SOLUTION
+     QAbstractStatePrivate *d_ptr;
+#endif
+    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..bf44116
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate_p.h
@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** 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.
+//
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <private/qobject_p.h>
+#endif
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_NAMESPACE
+
+class QAbstractTransition;
+class QHistoryState;
+class QStateMachine;
+
+struct QPropertyAssignment
+{
+    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 QAbstractState;
+class Q_CORE_EXPORT QAbstractStatePrivate
+#ifndef QT_STATEMACHINE_SOLUTION
+    : public QObjectPrivate
+#endif
+{
+    Q_DECLARE_PUBLIC(QAbstractState)
+
+public:
+    QAbstractStatePrivate();
+
+    static QAbstractStatePrivate *get(QAbstractState *q);
+    static const QAbstractStatePrivate *get(const QAbstractState *q);
+
+    QStateMachine *machine() const;
+
+    void callOnEntry();
+    void callOnExit();
+
+    QAbstractState::RestorePolicy restorePolicy;
+    QList<QPropertyAssignment> propertyAssignments;
+
+#ifdef QT_STATEMACHINE_SOLUTION
+    QAbstractState *q_ptr;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qabstracttransition.cpp b/src/corelib/statemachine/qabstracttransition.cpp
new file mode 100644
index 0000000..36de7f5
--- /dev/null
+++ b/src/corelib/statemachine/qabstracttransition.cpp
@@ -0,0 +1,361 @@
+/****************************************************************************
+**
+** 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.
+
+  \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 QTransition class provides a default (action-based) implementation of
+  the QAbstractTransition interface.
+
+  The sourceState() function returns the source of the transition. The
+  targetStates() function returns the targets of the transition.
+
+  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::source
+
+    \brief the source state (parent) of this transition
+*/
+
+/*!
+    \property QAbstractTransition::target
+
+    \brief the target state of this transition
+*/
+
+/*!
+    \property QAbstractTransition::targets
+
+    \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();
+}
+
+const QAbstractTransitionPrivate *QAbstractTransitionPrivate::get(const 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) const
+{
+    Q_Q(const QAbstractTransition);
+    return q->eventTest(e);
+}
+
+void QAbstractTransitionPrivate::callOnTransition()
+{
+    Q_Q(QAbstractTransition);
+    q->onTransition();
+}
+
+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(
+#ifndef QT_STATEMACHINE_SOLUTION
+        *new QAbstractTransitionPrivate,
+#endif
+        sourceState)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(new QAbstractTransitionPrivate)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+}
+
+/*!
+  Constructs a new QAbstractTransition object with the given \a targets and \a
+  sourceState.
+*/
+QAbstractTransition::QAbstractTransition(const QList<QAbstractState*> &targets,
+                                         QState *sourceState)
+    : QObject(
+#ifndef QT_STATEMACHINE_SOLUTION
+        *new QAbstractTransitionPrivate,
+#endif
+        sourceState)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(new QAbstractTransitionPrivate)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+    Q_D(QAbstractTransition);
+    d->targetStates = targets;
+}
+
+/*!
+  \internal
+*/
+QAbstractTransition::QAbstractTransition(QAbstractTransitionPrivate &dd,
+                                         QState *parent)
+    : QObject(
+#ifndef QT_STATEMACHINE_SOLUTION
+        dd,
+#endif
+        parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(&dd)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+}
+
+/*!
+  \internal
+*/
+QAbstractTransition::QAbstractTransition(QAbstractTransitionPrivate &dd,
+                                         const QList<QAbstractState*> &targets,
+                                         QState *parent)
+    : QObject(
+#ifndef QT_STATEMACHINE_SOLUTION
+        dd,
+#endif
+        parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(&dd)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+    Q_D(QAbstractTransition);
+    d->targetStates = targets;
+}
+
+/*!
+  Destroys this transition.
+*/
+QAbstractTransition::~QAbstractTransition()
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    delete d_ptr;
+#endif
+}
+
+/*!
+  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
+        d->targetStates = 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);
+    return d->targetStates;
+}
+
+/*!
+  Sets the target states of this transition to be the given \a targets.
+*/
+void QAbstractTransition::setTargetStates(const QList<QAbstractState*> &targets)
+{
+    Q_D(QAbstractTransition);
+    d->targetStates = targets;
+}
+
+#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) const
+
+  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()
+
+  This function is called when the transition is triggered.  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..c49731f
--- /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;
+
+#ifndef QT_NO_ANIMATION
+class QAbstractAnimation;
+#endif
+
+class QAbstractTransitionPrivate;
+class Q_CORE_EXPORT QAbstractTransition : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QState* source READ sourceState)
+    Q_PROPERTY(QAbstractState* target READ targetState WRITE setTargetState)
+    Q_PROPERTY(QList<QAbstractState*> targets 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);
+
+#ifndef QT_NO_ANIMATION
+    void addAnimation(QAbstractAnimation *animation);
+    void removeAnimation(QAbstractAnimation *animation);
+    QList<QAbstractAnimation*> animations() const;
+#endif
+
+protected:
+    virtual bool eventTest(QEvent *event) const = 0;
+
+    virtual void onTransition() = 0;
+
+    bool event(QEvent *e);
+
+protected:
+#ifdef QT_STATEMACHINE_SOLUTION
+    QAbstractTransitionPrivate *d_ptr;
+#endif
+    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..a48a09c
--- /dev/null
+++ b/src/corelib/statemachine/qabstracttransition_p.h
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** 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.
+//
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <private/qobject_p.h>
+#endif
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_NAMESPACE
+
+class QAbstractState;
+class QState;
+class QStateMachine;
+
+class QAbstractTransition;
+class Q_CORE_EXPORT QAbstractTransitionPrivate
+#ifndef QT_STATEMACHINE_SOLUTION
+    : public QObjectPrivate
+#endif
+{
+    Q_DECLARE_PUBLIC(QAbstractTransition)
+public:
+    QAbstractTransitionPrivate();
+
+    static QAbstractTransitionPrivate *get(QAbstractTransition *q);
+    static const QAbstractTransitionPrivate *get(const QAbstractTransition *q);
+
+    bool callEventTest(QEvent *e) const;
+    void callOnTransition();
+    QState *sourceState() const;
+    QStateMachine *machine() const;
+
+    QList<QAbstractState*> targetStates;
+
+#ifndef QT_NO_ANIMATION
+    QList<QAbstractAnimation*> animations;
+#endif
+
+#ifdef QT_STATEMACHINE_SOLUTION
+    QAbstractTransition *q_ptr;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qactionstate.cpp b/src/corelib/statemachine/qactionstate.cpp
new file mode 100644
index 0000000..77fd036
--- /dev/null
+++ b/src/corelib/statemachine/qactionstate.cpp
@@ -0,0 +1,292 @@
+/****************************************************************************
+**
+** 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 "qactionstate.h"
+#include "qactionstate_p.h"
+#include "qstateaction.h"
+#include "qstateaction_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QActionState
+
+  \brief The QActionState class provides an action-based state.
+
+  \ingroup statemachine
+
+  QActionState executes \l{QStateAction}{state actions} when the state is
+  entered and exited. QActionState is part of \l{The State Machine Framework}.
+
+  You can add actions to a state with the addEntryAction() and addExitAction()
+  functions. The state executes the actions when the state is entered and
+  exited, respectively.
+
+  The invokeMethodOnEntry() and invokeMethodOnExit() functions are used for
+  defining method invocations that should be performed when a state is entered
+  and exited, respectively.
+
+  \code
+  QState *s2 = new QState();
+  s2->invokeMethodOnEntry(&label, "showMaximized");
+  machine.addState(s2);
+  \endcode
+
+  \sa QStateAction
+*/
+
+QActionStatePrivate::QActionStatePrivate()
+{
+}
+
+QActionStatePrivate::~QActionStatePrivate()
+{
+}
+
+QActionStatePrivate *QActionStatePrivate::get(QActionState *q)
+{
+    return q->d_func();
+}
+
+const QActionStatePrivate *QActionStatePrivate::get(const QActionState *q)
+{
+    return q->d_func();
+}
+
+QList<QStateAction*> QActionStatePrivate::entryActions() const
+{
+    QList<QStateAction*> result;
+    QList<QObject*>::const_iterator it;
+#ifdef QT_STATEMACHINE_SOLUTION
+    const QObjectList &children = q_func()->children();
+#endif
+    for (it = children.constBegin(); it != children.constEnd(); ++it) {
+        QStateAction *act = qobject_cast<QStateAction*>(*it);
+        if (act && (QStateActionPrivate::get(act)->when == QStateActionPrivate::ExecuteOnEntry))
+            result.append(act);
+    }
+    return result;
+}
+
+QList<QStateAction*> QActionStatePrivate::exitActions() const
+{
+    QList<QStateAction*> result;
+    QList<QObject*>::const_iterator it;
+#ifdef QT_STATEMACHINE_SOLUTION
+    const QObjectList &children = q_func()->children();
+#endif
+    for (it = children.constBegin(); it != children.constEnd(); ++it) {
+        QStateAction *act = qobject_cast<QStateAction*>(*it);
+        if (act && (QStateActionPrivate::get(act)->when == QStateActionPrivate::ExecuteOnExit))
+            result.append(act);
+    }
+    return result;
+}
+
+/*!
+  Constructs a new action state with the given \a parent state.
+*/
+QActionState::QActionState(QState *parent)
+    : QAbstractState(*new QActionStatePrivate, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QActionState::QActionState(QActionStatePrivate &dd,
+                           QState *parent)
+    : QAbstractState(dd, parent)
+{
+}
+
+/*!
+  Destroys this action state.
+*/
+QActionState::~QActionState()
+{
+}
+
+/*!
+  Instructs this state to invoke the given \a method of the given \a object
+  with the given \a arguments when the state is entered. This function will
+  create a QStateInvokeMethodAction object and add it to the entry actions of
+  the state.
+
+  \sa invokeMethodOnExit(), setPropertyOnEntry(), addEntryAction()
+*/
+void QActionState::invokeMethodOnEntry(QObject *object, const char *method,
+                                       const QList<QVariant> &arguments)
+{
+    addEntryAction(new QStateInvokeMethodAction(object, method, arguments));
+}
+
+/*!
+  Instructs this state to invoke the given \a method of the given \a object
+  with the given \a arguments when the state is exited. This function will
+  create a QStateInvokeMethodAction object and add it to the exit actions of
+  the state.
+
+  \sa invokeMethodOnEntry(), addExitAction()
+*/
+void QActionState::invokeMethodOnExit(QObject *object, const char *method,
+                                      const QList<QVariant> &arguments)
+{
+    addExitAction(new QStateInvokeMethodAction(object, method, arguments));
+}
+
+/*!
+  Adds the given \a action to this state. The action will be executed when
+  this state is entered. The state takes ownership of the action.
+
+  \sa addExitAction(), removeEntryAction()
+*/
+void QActionState::addEntryAction(QStateAction *action)
+{
+    if (!action) {
+        qWarning("QActionState::addEntryAction: cannot add null action");
+        return;
+    }
+    action->setParent(this);
+    QStateActionPrivate::get(action)->when = QStateActionPrivate::ExecuteOnEntry;
+}
+
+/*!
+  Adds the given \a action to this state. The action will be executed when
+  this state is exited. The state takes ownership of the action.
+
+  \sa addEntryAction(), removeExitAction()
+*/
+void QActionState::addExitAction(QStateAction *action)
+{
+    if (!action) {
+        qWarning("QActionState::addExitAction: cannot add null action");
+        return;
+    }
+    action->setParent(this);
+    QStateActionPrivate::get(action)->when = QStateActionPrivate::ExecuteOnExit;
+}
+
+/*!
+  Removes the given entry \a action from this state. The state releases
+  ownership of the action.
+
+  \sa addEntryAction()
+*/
+void QActionState::removeEntryAction(QStateAction *action)
+{
+    if (!action) {
+        qWarning("QActionState::removeEntryAction: cannot remove null action");
+        return;
+    }
+    if (action->parent() == this)
+        action->setParent(0);
+}
+
+/*!
+  Removes the given exit \a action from this state. The state releases
+  ownership of the action.
+
+  \sa addExitAction()
+*/
+void QActionState::removeExitAction(QStateAction *action)
+{
+    if (!action) {
+        qWarning("QActionState::removeExitAction: cannot remove null action");
+        return;
+    }
+    if (action->parent() == this)
+        action->setParent(0);
+}
+
+/*!
+  Returns this state's entry actions.
+
+  \sa addEntryAction(), exitActions()
+*/
+QList<QStateAction*> QActionState::entryActions() const
+{
+    Q_D(const QActionState);
+    return d->entryActions();
+}
+
+/*!
+  Returns this state's exit actions.
+
+  \sa addExitAction(), entryActions()
+*/
+QList<QStateAction*> QActionState::exitActions() const
+{
+    Q_D(const QActionState);
+    return d->exitActions();
+}
+
+/*!
+  \reimp
+*/
+void QActionState::onEntry()
+{
+    Q_D(QActionState);
+    QList<QStateAction*> actions = d->entryActions();
+    for (int i = 0; i < actions.size(); ++i)
+        QStateActionPrivate::get(actions.at(i))->callExecute();
+}
+
+/*!
+  \reimp
+*/
+void QActionState::onExit()
+{
+    Q_D(QActionState);
+    QList<QStateAction*> actions = d->exitActions();
+    for (int i = 0; i < actions.size(); ++i)
+        QStateActionPrivate::get(actions.at(i))->callExecute();
+}
+
+/*!
+  \reimp
+*/
+bool QActionState::event(QEvent *e)
+{
+    return QAbstractState::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qactionstate.h b/src/corelib/statemachine/qactionstate.h
new file mode 100644
index 0000000..517b4b2
--- /dev/null
+++ b/src/corelib/statemachine/qactionstate.h
@@ -0,0 +1,102 @@
+/****************************************************************************
+**
+** 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 QACTIONSTATE_H
+#define QACTIONSTATE_H
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <QtCore/qabstractstate.h>
+#else
+#include "qabstractstate.h"
+#endif
+
+#include <QtCore/qlist.h>
+#include <QtCore/qvariant.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QStateAction;
+
+class QActionStatePrivate;
+class Q_CORE_EXPORT QActionState : public QAbstractState
+{
+    Q_OBJECT
+public:
+    QActionState(QState *parent = 0);
+    ~QActionState();
+
+    void invokeMethodOnEntry(QObject *object, const char *method,
+                             const QList<QVariant> &args = QList<QVariant>());
+    void invokeMethodOnExit(QObject *object, const char *method,
+                            const QList<QVariant> &args = QList<QVariant>());
+
+    void addEntryAction(QStateAction *action);
+    void addExitAction(QStateAction *action);
+
+    void removeEntryAction(QStateAction *action);
+    void removeExitAction(QStateAction *action);
+
+    QList<QStateAction*> entryActions() const;
+    QList<QStateAction*> exitActions() const;
+
+protected:
+    void onEntry();
+    void onExit();
+
+    bool event(QEvent *e);
+
+protected:
+    QActionState(QActionStatePrivate &dd, QState *parent);
+
+private:
+    Q_DISABLE_COPY(QActionState)
+    Q_DECLARE_PRIVATE(QActionState)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qactionstate_p.h b/src/corelib/statemachine/qactionstate_p.h
new file mode 100644
index 0000000..a06dde2
--- /dev/null
+++ b/src/corelib/statemachine/qactionstate_p.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** 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 QACTIONSTATE_P_H
+#define QACTIONSTATE_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 "qactionstate.h"
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_NAMESPACE
+
+class QStateAction;
+
+class QActionState;
+class Q_CORE_EXPORT QActionStatePrivate : public QAbstractStatePrivate
+{
+    Q_DECLARE_PUBLIC(QActionState)
+
+public:
+    QActionStatePrivate();
+    ~QActionStatePrivate();
+
+    static QActionStatePrivate *get(QActionState *q);
+    static const QActionStatePrivate *get(const QActionState *q);
+
+    QList<QStateAction*> entryActions() const;
+    QList<QStateAction*> exitActions() const;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qboundevent_p.h b/src/corelib/statemachine/qboundevent_p.h
new file mode 100644
index 0000000..b641ff3
--- /dev/null
+++ b/src/corelib/statemachine/qboundevent_p.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** 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 QBOUNDEVENT_P_H
+#define QBOUNDEVENT_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/qcoreevent.h>
+
+QT_BEGIN_NAMESPACE
+
+class QBoundEvent : public QEvent
+{
+public:
+    QBoundEvent(QObject *object, QEvent *event)
+#ifdef QT_STATEMACHINE_SOLUTION
+        : QEvent(QEvent::Type(QEvent::User-3)),
+#else
+        : QEvent(QEvent::Bound),
+#endif
+          m_object(object), m_event(event) {}
+    ~QBoundEvent() {}
+
+    inline QObject *object() const { return m_object; }
+    inline QEvent *event() const { return m_event; }
+
+private:
+    QObject *m_object;
+    QEvent *m_event;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qeventtransition.cpp b/src/corelib/statemachine/qeventtransition.cpp
new file mode 100644
index 0000000..b03074d
--- /dev/null
+++ b/src/corelib/statemachine/qeventtransition.cpp
@@ -0,0 +1,291 @@
+/****************************************************************************
+**
+** 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 "qboundevent_p.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.
+
+  \ingroup statemachine
+
+  A QEventTransition object binds an event or transition 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
+
+  Many event classes have attributes in addition to the event type itself.
+  The testEventCondition() function can be reimplemented to check attributes
+  of an event instance in order to determine whether the transition should be
+  triggered or not.
+
+  \sa QState::addTransition()
+*/
+
+/*!
+    \property QEventTransition::object
+
+    \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::invalidate()
+{
+    Q_Q(QEventTransition);
+    if (registered) {
+        QState *source = sourceState();
+        QStatePrivate *source_d = QStatePrivate::get(source);
+        QStateMachinePrivate *mach = QStateMachinePrivate::get(source_d->machine());
+        if (mach) {
+            mach->unregisterEventTransition(q);
+            if (mach->configuration.contains(source))
+                mach->registerEventTransition(q);
+        }
+    }
+}
+
+/*!
+  Constructs a new QEventTransition object with the given \a sourceState.
+*/
+QEventTransition::QEventTransition(QState *sourceState)
+    : QTransition(*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)
+    : QTransition(*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)
+    : QTransition(*new QEventTransitionPrivate, targets, sourceState)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  \internal
+*/
+QEventTransition::QEventTransition(QEventTransitionPrivate &dd, QState *parent)
+    : QTransition(dd, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QEventTransition::QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                                   QEvent::Type type, QState *parent)
+    : QTransition(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)
+    : QTransition(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->eventType = type;
+    d->invalidate();
+}
+
+/*!
+  Returns the event source associated with this event transition.
+*/
+QObject *QEventTransition::eventSource() 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::setEventSource(QObject *object)
+{
+    Q_D(QEventTransition);
+    if (d->object == object)
+        return;
+    d->object = object;
+    d->invalidate();
+}
+
+/*!
+  \reimp
+*/
+bool QEventTransition::eventTest(QEvent *event) const
+{
+    Q_D(const QEventTransition);
+#ifdef QT_STATEMACHINE_SOLUTION
+    if (event->type() == QEvent::Type(QEvent::User-3)) {
+#else
+    if (event->type() == QEvent::Bound) {
+#endif
+        QBoundEvent *oe = static_cast<QBoundEvent*>(event);
+        return (oe->object() == d->object)
+            && (oe->event()->type() == d->eventType)
+            && testEventCondition(oe->event());
+    }
+    return false;
+}
+
+/*!
+  Tests an instance of an event associated with this event transition and
+  returns true if the transition should be taken, otherwise returns false.
+  The type of the given \a event will be eventType().
+
+  Reimplement this function if you have custom conditions associated with
+  the transition. The default implementation always returns true.
+*/
+bool QEventTransition::testEventCondition(QEvent *event) const
+{
+    Q_UNUSED(event);
+    return true;
+}
+
+/*!
+  \reimp
+*/
+bool QEventTransition::event(QEvent *e)
+{
+    return QTransition::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..edd7f8a
--- /dev/null
+++ b/src/corelib/statemachine/qeventtransition.h
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** 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 "qtransition.h"
+#include <QtCore/qcoreevent.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QEventTransitionPrivate;
+class Q_CORE_EXPORT QEventTransition : public QTransition
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* object READ eventSource WRITE setEventSource)
+#ifndef QT_STATEMACHINE_SOLUTION
+    Q_PROPERTY(QEvent::Type eventType READ eventType WRITE setEventType)
+#endif
+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 *eventSource() const;
+    void setEventSource(QObject *object);
+
+    QEvent::Type eventType() const;
+    void setEventType(QEvent::Type type);
+
+protected:
+    virtual bool testEventCondition(QEvent *event) const; // ### name
+
+    bool eventTest(QEvent *event) const;
+
+    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..568e35e
--- /dev/null
+++ b/src/corelib/statemachine/qeventtransition_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 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 "qtransition_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEventTransition;
+class Q_CORE_EXPORT QEventTransitionPrivate : public QTransitionPrivate
+{
+    Q_DECLARE_PUBLIC(QEventTransition)
+public:
+    QEventTransitionPrivate();
+
+    static QEventTransitionPrivate *get(QEventTransition *q);
+
+    void invalidate();
+
+    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..5219b1b
--- /dev/null
+++ b/src/corelib/statemachine/qfinalstate.cpp
@@ -0,0 +1,133 @@
+/****************************************************************************
+**
+** 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 "qactionstate_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QFinalState
+
+  \brief The QFinalState class provides a final state.
+
+  \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, a
+  QStateFinishedEvent is generated for the final state's parent
+  state. 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 QStateFinishedTransition
+*/
+
+class QFinalStatePrivate : public QActionStatePrivate
+{
+    Q_DECLARE_PUBLIC(QFinalState)
+
+public:
+    QFinalStatePrivate();
+};
+
+QFinalStatePrivate::QFinalStatePrivate()
+{
+}
+
+/*!
+  Constructs a new QFinalState object with the given \a parent state.
+*/
+QFinalState::QFinalState(QState *parent)
+    : QActionState(*new QFinalStatePrivate, parent)
+{
+}
+
+/*!
+  Destroys this final state.
+*/
+QFinalState::~QFinalState()
+{
+}
+
+/*!
+  \reimp
+*/
+void QFinalState::onEntry()
+{
+    QActionState::onEntry();
+}
+
+/*!
+  \reimp
+*/
+void QFinalState::onExit()
+{
+    QActionState::onExit();
+}
+
+/*!
+  \reimp
+*/
+bool QFinalState::event(QEvent *e)
+{
+    return QActionState::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..36813f5
--- /dev/null
+++ b/src/corelib/statemachine/qfinalstate.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** 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
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <QtCore/qactionstate.h>
+#else
+#include "qactionstate.h"
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QFinalStatePrivate;
+class Q_CORE_EXPORT QFinalState : public QActionState
+{
+    Q_OBJECT
+public:
+    QFinalState(QState *parent = 0);
+    ~QFinalState();
+
+protected:
+    void onEntry();
+    void onExit();
+
+    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..a0c933c
--- /dev/null
+++ b/src/corelib/statemachine/qhistorystate.cpp
@@ -0,0 +1,175 @@
+/****************************************************************************
+**
+** 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.
+
+  \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 QState::addHistoryState() to construct a history state. 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);
+
+  QState *s1h = s1->addHistoryState();
+  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
+*/
+
+QHistoryStatePrivate::QHistoryStatePrivate()
+    : defaultState(0)
+{
+}
+
+QHistoryState *QHistoryStatePrivate::create(QState::HistoryType type,
+                                            QState *parent)
+{
+    return new QHistoryState(type, parent);
+}
+
+QHistoryStatePrivate *QHistoryStatePrivate::get(QHistoryState *q)
+{
+    return q->d_func();
+}
+
+const QHistoryStatePrivate *QHistoryStatePrivate::get(const QHistoryState *q)
+{
+    return q->d_func();
+}
+
+/*!
+  \internal
+
+  Constructs a new history state of the given \a type, with the given \a
+  parent state.
+*/
+QHistoryState::QHistoryState(QState::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;
+}
+
+/*!
+  \reimp
+*/
+void QHistoryState::onEntry()
+{
+}
+
+/*!
+  \reimp
+*/
+void QHistoryState::onExit()
+{
+}
+
+/*!
+  \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..9cd7f0b
--- /dev/null
+++ b/src/corelib/statemachine/qhistorystate.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 QHISTORYSTATE_H
+#define QHISTORYSTATE_H
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <QtCore/qstate.h>
+#else
+#include "qstate.h"
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QHistoryStatePrivate;
+class Q_CORE_EXPORT QHistoryState : public QAbstractState
+{
+    Q_OBJECT
+public:
+    ~QHistoryState();
+
+    QAbstractState *defaultState() const;
+    void setDefaultState(QAbstractState *state);
+
+protected:
+    void onEntry();
+    void onExit();
+
+    bool event(QEvent *e);
+
+private:
+    QHistoryState(QState::HistoryType type,
+                  QState *parent = 0);
+
+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..84648b5
--- /dev/null
+++ b/src/corelib/statemachine/qhistorystate_p.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** 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 QHistoryState *create(QState::HistoryType type,
+                                 QState *parent);
+
+    static QHistoryStatePrivate *get(QHistoryState *q);
+    static const QHistoryStatePrivate *get(const QHistoryState *q);
+
+    QAbstractState *defaultState;
+    QState::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..5dcabc4
--- /dev/null
+++ b/src/corelib/statemachine/qsignalevent.h
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** 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
+
+#endif
diff --git a/src/corelib/statemachine/qsignaleventgenerator_p.h b/src/corelib/statemachine/qsignaleventgenerator_p.h
new file mode 100644
index 0000000..d18def8
--- /dev/null
+++ b/src/corelib/statemachine/qsignaleventgenerator_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 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(
+#ifdef QT_STATEMACHINE_SOLUTION
+        int signalIndex,
+#endif
+        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:
+#ifdef QT_STATEMACHINE_SOLUTION
+    int signalIndex;
+#endif
+    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..9c03b94
--- /dev/null
+++ b/src/corelib/statemachine/qsignaltransition.cpp
@@ -0,0 +1,251 @@
+/****************************************************************************
+**
+** 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.
+
+  \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::object
+
+    \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::invalidate()
+{
+    Q_Q(QSignalTransition);
+    if (signalIndex != -1) {
+        QState *source = sourceState();
+        QStatePrivate *source_d = QStatePrivate::get(source);
+        QStateMachinePrivate *mach = QStateMachinePrivate::get(source_d->machine());
+        if (mach) {
+            mach->unregisterSignalTransition(q);
+            if (mach->configuration.contains(source))
+                mach->registerSignalTransition(q);
+        }
+    }
+}
+
+/*!
+  Constructs a new signal transition with the given \a sourceState.
+*/
+QSignalTransition::QSignalTransition(QState *sourceState)
+    : QTransition(*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)
+    : QTransition(*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)
+    : QTransition(*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->sender = sender;
+    d->invalidate();
+}
+
+/*!
+  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->signal = signal;
+    d->invalidate();
+}
+
+/*!
+  \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) const
+{
+    Q_D(const QSignalTransition);
+#ifndef QT_STATEMACHINE_SOLUTION
+    if (event->type() == QEvent::Signal) {
+#else
+    if (event->type() == QEvent::Type(QEvent::User-1)) {
+#endif
+        QSignalEvent *se = static_cast<QSignalEvent*>(event);
+        Q_ASSERT(d->signalIndex != -1);
+        return (se->sender() == d->sender)
+            && (se->signalIndex() == d->signalIndex);
+    }
+    return false;
+}
+
+/*!
+  \reimp
+*/
+bool QSignalTransition::event(QEvent *e)
+{
+    return QTransition::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..ba4af17
--- /dev/null
+++ b/src/corelib/statemachine/qsignaltransition.h
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** 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
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <QtCore/qtransition.h>
+#else
+#include "qtransition.h"
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QSignalTransitionPrivate;
+class Q_CORE_EXPORT QSignalTransition : public QTransition
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* object 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) const;
+
+    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..c5fbcfc
--- /dev/null
+++ b/src/corelib/statemachine/qsignaltransition_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 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 "qtransition_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QSignalTransition;
+class QSignalTransitionPrivate : public QTransitionPrivate
+{
+    Q_DECLARE_PUBLIC(QSignalTransition)
+public:
+    QSignalTransitionPrivate();
+
+    static QSignalTransitionPrivate *get(QSignalTransition *q);
+
+    void invalidate();
+
+    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..944ca2c
--- /dev/null
+++ b/src/corelib/statemachine/qstate.cpp
@@ -0,0 +1,430 @@
+/****************************************************************************
+**
+** 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 "qstatefinishedtransition.h"
+#include "qstatemachine.h"
+#include "qstatemachine_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QState
+
+  \brief The QState class provides a general-purpose state for QStateMachine.
+
+  \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.
+
+  \section1 States with Child States
+
+  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 addHistoryState() function adds a history state.
+
+  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).
+*/
+
+/*!
+  \enum QState::Type
+
+  This enum specifies the type of a state.
+
+  \value Normal A normal state. If the state has no child states, it is an
+  atomic state; otherwise, the child states are mutually exclusive and an
+  initial state must be set by calling QState::setInitialState().
+
+  \value ParallelGroup The state is a parallel group state. When a parallel
+  group state is entered, all its child states are entered in parallel.
+*/
+
+/*!
+  \enum QState::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.
+*/
+
+QStatePrivate::QStatePrivate()
+    : errorState(0), isParallelGroup(false), initialState(0)
+{
+}
+
+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();
+}
+
+/*!
+  Constructs a new state with the given \a parent state.
+*/
+QState::QState(QState *parent)
+    : QActionState(*new QStatePrivate, parent)
+{
+}
+
+/*!
+  Constructs a new state of the given \a type with the given \a parent state.
+*/
+QState::QState(Type type, QState *parent)
+    : QActionState(*new QStatePrivate, parent)
+{
+    Q_D(QState);
+    d->isParallelGroup = (type == ParallelGroup);
+}
+
+/*!
+  \internal
+*/
+QState::QState(QStatePrivate &dd, QState *parent)
+    : QActionState(dd, parent)
+{
+}
+
+/*!
+  Destroys this state.
+*/
+QState::~QState()
+{
+}
+
+QList<QAbstractState*> QStatePrivate::childStates() const
+{
+    QList<QAbstractState*> result;
+    QList<QObject*>::const_iterator it;
+#ifdef QT_STATEMACHINE_SOLUTION
+    const QObjectList &children = q_func()->children();
+#endif
+    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;
+#ifdef QT_STATEMACHINE_SOLUTION
+    const QObjectList &children = q_func()->children();
+#endif
+    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;
+#ifdef QT_STATEMACHINE_SOLUTION
+    const QObjectList &children = q_func()->children();
+#endif
+    for (it = children.constBegin(); it != children.constEnd(); ++it) {
+        QAbstractTransition *t = qobject_cast<QAbstractTransition*>(*it);
+        if (t)
+            result.append(t);
+    }
+    return result;
+}
+
+/*!
+  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 && QAbstractStatePrivate::get(state)->machine() != d->machine()) {
+        qWarning("QState::setErrorState: error state cannot belong "
+                 "to a different state machine");
+        return;
+    }
+
+    d->errorState = state;
+}
+
+/*!
+  Adds the given \a transition. The transition has this state as the source.
+  This state takes ownership of the transition.
+*/
+void QState::addTransition(QAbstractTransition *transition)
+{
+    Q_D(QState);
+    if (!transition) {
+        qWarning("QState::addTransition: cannot add null transition");
+        return;
+    }
+    const QList<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;
+        }
+        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;
+        }
+    }
+    transition->setParent(this);
+}
+
+/*!
+  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;
+    }
+    QSignalTransition *trans = new QSignalTransition(sender, signal, QList<QAbstractState*>() << target);
+    addTransition(trans);
+    return trans;
+}
+
+/*!
+  Adds a transition that's triggered by the finished event of this state, and
+  returns the new QStateFinishedTransition object. The transition has the
+  given \a target state.
+
+  \sa QStateFinishedEvent
+*/
+QStateFinishedTransition *QState::addFinishedTransition(QAbstractState *target)
+{
+    QStateFinishedTransition *trans = new QStateFinishedTransition(this, 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() {}
+    bool eventTest(QEvent *) const { 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)
+{
+    UnconditionalTransition *trans = new UnconditionalTransition(target);
+    addTransition(trans);
+    return 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);
+}
+
+/*!
+  Returns the list of transitions from this state, or an empty list if there
+  are no transitions from this state.
+
+  \sa addTransition(), removeTransition()
+*/
+QList<QAbstractTransition*> QState::transitions() const
+{
+    Q_D(const QState);
+    return d->transitions();
+}
+
+/*!
+  Creates a history state of the given \a type for this state and returns the
+  new state.  The history state becomes a child of this state.
+*/
+QHistoryState *QState::addHistoryState(HistoryType type)
+{
+    return QHistoryStatePrivate::create(type, this);
+}
+
+/*!
+  \reimp
+*/
+void QState::onEntry()
+{
+    QActionState::onEntry();
+}
+
+/*!
+  \reimp
+*/
+void QState::onExit()
+{
+    QActionState::onExit();
+}
+
+/*!
+  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->isParallelGroup) {
+        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;
+}
+
+/*!
+  \reimp
+*/
+bool QState::event(QEvent *e)
+{
+    return QActionState::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qstate.h b/src/corelib/statemachine/qstate.h
new file mode 100644
index 0000000..4c86e02
--- /dev/null
+++ b/src/corelib/statemachine/qstate.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 QSTATE_H
+#define QSTATE_H
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <QtCore/qactionstate.h>
+#else
+#include "qactionstate.h"
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QAbstractTransition;
+class QHistoryState;
+class QSignalTransition;
+class QStateFinishedTransition;
+
+class QStatePrivate;
+class Q_CORE_EXPORT QState : public QActionState
+{
+    Q_OBJECT
+public:
+    enum Type {
+        Normal,
+        ParallelGroup
+    };
+
+    enum HistoryType {
+        ShallowHistory,
+        DeepHistory
+    };
+
+    QState(QState *parent = 0);
+    QState(Type type, QState *parent = 0);
+    ~QState();
+
+    QAbstractState *errorState() const;
+    void setErrorState(QAbstractState *state);
+
+    void addTransition(QAbstractTransition *transition);
+    QSignalTransition *addTransition(QObject *sender, const char *signal, QAbstractState *target);
+    QAbstractTransition *addTransition(QAbstractState *target);
+    QStateFinishedTransition *addFinishedTransition(QAbstractState *target);
+    void removeTransition(QAbstractTransition *transition);
+    QList<QAbstractTransition*> transitions() const;
+
+    QHistoryState *addHistoryState(HistoryType type = ShallowHistory);
+
+    QAbstractState *initialState() const;
+    void setInitialState(QAbstractState *state);
+
+protected:
+    void onEntry();
+    void onExit();
+
+    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..17b312a
--- /dev/null
+++ b/src/corelib/statemachine/qstate_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 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 "qactionstate_p.h"
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_NAMESPACE
+
+class QState;
+class Q_CORE_EXPORT QStatePrivate : public QActionStatePrivate
+{
+    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;
+
+    QAbstractState *errorState;
+    bool isParallelGroup;
+    QAbstractState *initialState;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qstateaction.cpp b/src/corelib/statemachine/qstateaction.cpp
new file mode 100644
index 0000000..b03aa19
--- /dev/null
+++ b/src/corelib/statemachine/qstateaction.cpp
@@ -0,0 +1,354 @@
+/****************************************************************************
+**
+** 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 "qstateaction.h"
+#include "qstateaction_p.h"
+#include <QtCore/qvarlengtharray.h>
+#include <QtCore/qmetaobject.h>
+
+QT_BEGIN_NAMESPACE
+
+QStateActionPrivate::QStateActionPrivate()
+{
+    when = ExecuteOnEntry;
+}
+
+QStateActionPrivate::~QStateActionPrivate()
+{
+}
+
+QStateActionPrivate *QStateActionPrivate::get(QStateAction *q)
+{
+    return q->d_func();
+}
+
+void QStateActionPrivate::callExecute()
+{
+    Q_Q(QStateAction);
+    q->execute();
+}
+
+/*!
+  \class QStateAction
+
+  \brief The QStateAction class is the base class of QState actions.
+
+  \ingroup statemachine
+
+  A state action is added to a state by calling QState::addEntryAction() or
+  QState::addExitAction(). QStateAction is part of \l{The State Machine
+  Framework}.
+
+  \section1 Subclassing
+
+  Subclasses must implement the execute() function.
+*/
+
+/*!
+  Constructs a new QStateAction object with the given \a parent.
+*/
+QStateAction::QStateAction(QObject *parent)
+    : QObject(
+#ifndef QT_STATEMACHINE_SOLUTION
+        *new QStateActionPrivate,
+#endif
+        parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(new QStateActionPrivate)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+}
+
+/*!
+  \internal
+*/
+QStateAction::QStateAction(QStateActionPrivate &dd, QObject *parent)
+    : QObject(
+#ifndef QT_STATEMACHINE_SOLUTION
+        dd,
+#endif
+        parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(&dd)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+}
+
+/*!
+  Destroys this QStateAction object.
+*/
+QStateAction::~QStateAction()
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    delete d_ptr;
+#endif
+}
+
+/*!
+  \fn QStateAction::execute()
+
+  Executes this action.
+*/
+
+/*!
+  \reimp
+*/
+bool QStateAction::event(QEvent *e)
+{
+    return QObject::event(e);
+}
+
+QStateInvokeMethodActionPrivate *QStateInvokeMethodActionPrivate::get(QStateInvokeMethodAction *q)
+{
+    return q->d_func();
+}
+
+/*!
+  \class QStateInvokeMethodAction
+
+  \brief The QStateInvokeMethodAction class provides an invoke method action for QObjects.
+
+  \ingroup statemachine
+
+  The QStateInvokeMethodAction class provides an action that calls a method of
+  a QObject when a QState is entered or exited. QStateInvokeMethodAction is
+  part of \l{The State Machine Framework}.
+
+  Typically you don't construct QStateInvokeMethodAction objects directly, but
+  rather call the QState::invokeMethodOnEntry() function or the
+  QState::invokeMethodOnExit() function.
+*/
+
+/*!
+    \property QStateInvokeMethodAction::arguments
+
+    \brief the arguments to the method this action invokes
+*/
+
+/*!
+    \property QStateInvokeMethodAction::methodName
+
+    \brief the name of the method this action invokes
+*/
+
+/*!
+    \property QStateInvokeMethodAction::target
+
+    \brief the object on which this action invokes a method
+*/
+
+/*!
+  Constructs a new QStateInvokeMethodAction object for the method named \a
+  methodName of the given \a target object, with the given \a parent.
+*/
+QStateInvokeMethodAction::QStateInvokeMethodAction(
+    QObject *target, const QByteArray &methodName, QObject *parent)
+    : QStateAction(*new QStateInvokeMethodActionPrivate, parent)
+{
+    Q_D(QStateInvokeMethodAction);
+    d->target = target;
+    d->methodName = methodName;
+    d->methodIndex = -1;
+}
+
+/*!
+  Constructs a new QStateInvokeMethodAction object for the method named \a
+  methodName of the given \a target object, with the given arguments, \a args,
+  and with the given \a parent.
+*/
+QStateInvokeMethodAction::QStateInvokeMethodAction(
+    QObject *target, const QByteArray &methodName,
+    const QList<QVariant> &args, QObject *parent)
+    : QStateAction(*new QStateInvokeMethodActionPrivate, parent)
+{
+    Q_D(QStateInvokeMethodAction);
+    d->target = target;
+    d->methodName = methodName;
+    d->methodIndex = -1;
+    d->args = args;
+}
+
+/*!
+  Constructs a new QStateInvokeMethodAction object with the given \a parent.
+*/
+QStateInvokeMethodAction::QStateInvokeMethodAction(QObject *parent)
+    : QStateAction(*new QStateInvokeMethodActionPrivate, parent)
+{
+    Q_D(QStateInvokeMethodAction);
+    d->target = 0;
+    d->methodIndex = -1;
+}
+
+/*!
+  Destroys this QStateInvokeMethodAction object.
+*/
+QStateInvokeMethodAction::~QStateInvokeMethodAction()
+{
+}
+
+/*!
+  \reimp
+*/
+void QStateInvokeMethodAction::execute()
+{
+    Q_D(QStateInvokeMethodAction);
+    if (!d->target)
+        return;
+
+    if (d->methodIndex == -1) {
+        QVarLengthArray<char, 512> sig;
+        int len = d->methodName.length();
+        if (len <= 0)
+            return;
+        sig.append(d->methodName, len);
+        sig.append('(');
+
+        int paramCount;
+        for (paramCount = 0; paramCount < d->args.size() && paramCount < 10; ++paramCount) {
+            const char *tn = d->args.at(paramCount).typeName();
+            len = qstrlen(tn);
+            if (len <= 0)
+                break;
+            sig.append(tn, len);
+            sig.append(',');
+        }
+        if (paramCount == 0)
+            sig.append(')'); // no parameters
+        else
+            sig[sig.size() - 1] = ')';
+        sig.append('\0');
+
+        const QMetaObject *meta = d->target->metaObject();
+        int idx = meta->indexOfMethod(sig.constData());
+        if (idx < 0) {
+            QByteArray norm = QMetaObject::normalizedSignature(sig.constData());
+            idx = meta->indexOfMethod(norm.constData());
+            if ((idx < 0) || (idx >= meta->methodCount())) {
+                qWarning("InvokeMethodAction: unable to find method '%s' of %s(%p)",
+                         sig.constData(), meta->className(), d->target);
+                return;
+            }
+        }
+        d->methodIndex = idx;
+    }
+
+    void *param[11];
+    param[0] = 0; // return value
+    for (int i = 0; i < 10; ++i)
+        param[i+1] = (i < d->args.size()) ? const_cast<void*>(d->args.at(i).constData()) : (void*)0;
+    (void)d->target->qt_metacall(QMetaObject::InvokeMetaMethod, d->methodIndex, param);
+}
+
+/*!
+  Returns the object on which this action invokes a method.
+*/
+QObject *QStateInvokeMethodAction::targetObject() const
+{
+    Q_D(const QStateInvokeMethodAction);
+    return d->target;
+}
+
+/*!
+  Sets the object on which this action invokes a method.
+*/
+void QStateInvokeMethodAction::setTargetObject(QObject *target)
+{
+    Q_D(QStateInvokeMethodAction);
+    d->target = target;
+}
+
+/*!
+  Returns the name of the method this action will invoke.
+*/
+QByteArray QStateInvokeMethodAction::methodName() const
+{
+    Q_D(const QStateInvokeMethodAction);
+    return d->methodName;
+}
+
+/*!
+  Sets the name of the method this action will invoke.
+*/
+void QStateInvokeMethodAction::setMethodName(const QByteArray &methodName)
+{
+    Q_D(QStateInvokeMethodAction);
+    if (methodName != d->methodName) {
+        d->methodName = methodName;
+        d->methodIndex = -1;
+    }
+}
+
+/*!
+  Returns the arguments to the method this action will invoke.
+*/
+QVariantList QStateInvokeMethodAction::arguments() const
+{
+    Q_D(const QStateInvokeMethodAction);
+    return d->args;
+}
+
+/*!
+  Sets the arguments to the method this action will invoke.
+*/
+void QStateInvokeMethodAction::setArguments(const QVariantList &arguments)
+{
+    Q_D(QStateInvokeMethodAction);
+    if (d->args != arguments) {
+        d->args = arguments;
+        d->methodIndex = -1;
+    }
+}
+
+/*!
+  \reimp
+*/
+bool QStateInvokeMethodAction::event(QEvent *e)
+{
+    return QStateAction::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qstateaction.h b/src/corelib/statemachine/qstateaction.h
new file mode 100644
index 0000000..6843080
--- /dev/null
+++ b/src/corelib/statemachine/qstateaction.h
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** 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 QSTATEACTION_H
+#define QSTATEACTION_H
+
+#include <QtCore/qobject.h>
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QStateActionPrivate;
+class Q_CORE_EXPORT QStateAction : public QObject
+{
+    Q_OBJECT
+public:
+    ~QStateAction();
+
+protected:
+    QStateAction(QObject *parent = 0);
+
+    virtual void execute() = 0;
+
+    bool event(QEvent *e);
+
+protected:
+#ifdef QT_STATEMACHINE_SOLUTION
+    QStateActionPrivate *d_ptr;
+#endif
+    QStateAction(QStateActionPrivate &dd, QObject *parent);
+
+private:
+    Q_DISABLE_COPY(QStateAction)
+    Q_DECLARE_PRIVATE(QStateAction)
+};
+
+class QStateInvokeMethodActionPrivate;
+class Q_CORE_EXPORT QStateInvokeMethodAction : public QStateAction
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* target READ targetObject WRITE setTargetObject)
+    Q_PROPERTY(QByteArray methodName READ methodName WRITE setMethodName)
+    Q_PROPERTY(QVariantList arguments READ arguments WRITE setArguments)
+public:
+    QStateInvokeMethodAction(QObject *target, const QByteArray &methodName,
+                             QObject *parent = 0);
+    QStateInvokeMethodAction(QObject *target, const QByteArray &methodName,
+                             const QList<QVariant> &args, QObject *parent = 0);
+    QStateInvokeMethodAction(QObject *parent = 0);
+    ~QStateInvokeMethodAction();
+
+    QObject *targetObject() const;
+    void setTargetObject(QObject *target);
+
+    QByteArray methodName() const;
+    void setMethodName(const QByteArray &methodName);
+
+    QVariantList arguments() const;
+    void setArguments(const QVariantList &arguments);
+
+protected:
+    void execute();
+
+    bool event(QEvent *e);
+
+private:
+    Q_DISABLE_COPY(QStateInvokeMethodAction)
+    Q_DECLARE_PRIVATE(QStateInvokeMethodAction)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qstateaction_p.h b/src/corelib/statemachine/qstateaction_p.h
new file mode 100644
index 0000000..4016b74
--- /dev/null
+++ b/src/corelib/statemachine/qstateaction_p.h
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** 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 QSTATEACTION_P_H
+#define QSTATEACTION_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.
+//
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <private/qobject_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QStateAction;
+class QStateActionPrivate
+#ifndef QT_STATEMACHINE_SOLUTION
+    : public QObjectPrivate
+#endif
+{
+    Q_DECLARE_PUBLIC(QStateAction)
+public:
+    QStateActionPrivate();
+    ~QStateActionPrivate();
+
+    static QStateActionPrivate *get(QStateAction *q);
+
+    void callExecute();
+
+    enum When {
+        ExecuteOnEntry,
+        ExecuteOnExit
+    };
+
+    When when;
+
+#ifdef QT_STATEMACHINE_SOLUTION
+    QStateAction *q_ptr;
+#endif
+};
+
+class QStateInvokeMethodAction;
+class QStateInvokeMethodActionPrivate : public QStateActionPrivate
+{
+    Q_DECLARE_PUBLIC(QStateInvokeMethodAction)
+public:
+    QStateInvokeMethodActionPrivate() {}
+    ~QStateInvokeMethodActionPrivate() {}
+
+    static QStateInvokeMethodActionPrivate *get(QStateInvokeMethodAction *q);
+
+    QObject *target;
+    QByteArray methodName;
+    int methodIndex;
+    QList<QVariant> args;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qstatefinishedevent.h b/src/corelib/statemachine/qstatefinishedevent.h
new file mode 100644
index 0000000..c2f81f7
--- /dev/null
+++ b/src/corelib/statemachine/qstatefinishedevent.h
@@ -0,0 +1,70 @@
+/****************************************************************************
+**
+** 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 QSTATEFINISHEDEVENT_H
+#define QSTATEFINISHEDEVENT_H
+
+#include <QtCore/qcoreevent.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QState;
+
+class Q_CORE_EXPORT QStateFinishedEvent : public QEvent
+{
+public:
+    QStateFinishedEvent(QState *state);
+    ~QStateFinishedEvent();
+
+    QState *state() const;
+
+private:
+    QState *m_state;
+    void *d;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qstatefinishedtransition.cpp b/src/corelib/statemachine/qstatefinishedtransition.cpp
new file mode 100644
index 0000000..24d2ca4
--- /dev/null
+++ b/src/corelib/statemachine/qstatefinishedtransition.cpp
@@ -0,0 +1,175 @@
+/****************************************************************************
+**
+** 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 "qstatefinishedtransition.h"
+#include "qstatefinishedevent.h"
+#include "qtransition_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QStateFinishedTransition
+
+  \brief The QStateFinishedTransition class provides a transition that triggers when a state is finished.
+
+  \ingroup statemachine
+
+  A state is finished when one of its final child states (a QFinalState) is
+  entered; this will cause a QStateFinishedEvent to be generated. The
+  QStateFinishedTransition class provides a way of associating a transition
+  with such an event. QStateFinishedTransition is part of \l{The State Machine
+  Framework}.
+
+  \code
+    QStateMachine machine;
+    QState *s1 = new QState(machine.rootState());
+    QState *s11 = new QState(s1);
+    QFinalState *s12 = new QFinalState(s1);
+    s11->addTransition(s12);
+
+    QState *s2 = new QState(machine.rootState());
+    QStateFinishedTransition *finishedTransition = new QStateFinishedTransition(s1);
+    finishedTransition->setTargetState(s2);
+    s1->addTransition(finishedTransition);
+  \endcode
+
+  \sa QState::addFinishedTransition(), QStateFinishedEvent
+*/
+
+/*!
+    \property QStateFinishedTransition::state
+
+    \brief the state whose QStateFinishedEvent this transition is associated with
+*/
+
+class QStateFinishedTransitionPrivate : public QTransitionPrivate
+{
+    Q_DECLARE_PUBLIC(QStateFinishedTransition)
+public:
+    QStateFinishedTransitionPrivate();
+
+    static QStateFinishedTransitionPrivate *get(QStateFinishedTransition *q);
+
+    QState *state;
+};
+
+QStateFinishedTransitionPrivate::QStateFinishedTransitionPrivate()
+{
+    state = 0;
+}
+
+QStateFinishedTransitionPrivate *QStateFinishedTransitionPrivate::get(QStateFinishedTransition *q)
+{
+    return q->d_func();
+}
+
+/*!
+  Constructs a new QStateFinishedTransition object that has the given \a
+  sourceState.
+*/
+QStateFinishedTransition::QStateFinishedTransition(QState *sourceState)
+    : QTransition(*new QStateFinishedTransitionPrivate, sourceState)
+{
+}
+
+/*!
+  Constructs a new QStateFinishedTransition object associated with the given
+  \a state, and that has the given \a targets and \a sourceState.
+*/
+QStateFinishedTransition::QStateFinishedTransition(
+    QState *state, const QList<QAbstractState*> &targets, QState *sourceState)
+    : QTransition(*new QStateFinishedTransitionPrivate, targets, sourceState)
+{
+    Q_D(QStateFinishedTransition);
+    d->state = state;
+}
+
+/*!
+  Destroys this QStateFinishedTransition.
+*/
+QStateFinishedTransition::~QStateFinishedTransition()
+{
+}
+
+/*!
+  Returns the state associated with this QStateFinishedTransition.
+*/
+QState *QStateFinishedTransition::state() const
+{
+    Q_D(const QStateFinishedTransition);
+    return d->state;
+}
+
+/*!
+  Sets the \a state associated with this QStateFinishedTransition.
+*/
+void QStateFinishedTransition::setState(QState *state)
+{
+    Q_D(QStateFinishedTransition);
+    d->state = state;
+}
+
+/*!
+  \reimp
+*/
+bool QStateFinishedTransition::eventTest(QEvent *event) const
+{
+    Q_D(const QStateFinishedTransition);
+#ifndef QT_STATEMACHINE_SOLUTION
+    if (event->type() == QEvent::StateFinished) {
+#else
+    if (event->type() == QEvent::Type(QEvent::User-2)) {
+#endif
+        QStateFinishedEvent *sfe = static_cast<QStateFinishedEvent*>(event);
+        return (sfe->state() == d->state);
+    }
+    return false;
+}
+
+/*!
+  \reimp
+*/
+bool QStateFinishedTransition::event(QEvent *e)
+{
+    return QTransition::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qstatefinishedtransition.h b/src/corelib/statemachine/qstatefinishedtransition.h
new file mode 100644
index 0000000..eae3143
--- /dev/null
+++ b/src/corelib/statemachine/qstatefinishedtransition.h
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** 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 QSTATEFINISHEDTRANSITION_H
+#define QSTATEFINISHEDTRANSITION_H
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <QtCore/qtransition.h>
+#else
+#include "qtransition.h"
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QState;
+
+class QStateFinishedTransitionPrivate;
+class Q_CORE_EXPORT QStateFinishedTransition : public QTransition
+{
+    Q_OBJECT
+    Q_PROPERTY(QState* state READ state WRITE setState)
+public:
+    QStateFinishedTransition(QState *sourceState = 0);
+    QStateFinishedTransition(QState *state, const QList<QAbstractState*> &targets,
+                             QState *sourceState = 0);
+    ~QStateFinishedTransition();
+
+    QState *state() const; // ### name
+    void setState(QState *state);
+
+protected:
+    bool eventTest(QEvent *event) const;
+
+    bool event(QEvent *e);
+
+private:
+    Q_DISABLE_COPY(QStateFinishedTransition)
+    Q_DECLARE_PRIVATE(QStateFinishedTransition)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qstatemachine.cpp b/src/corelib/statemachine/qstatemachine.cpp
new file mode 100644
index 0000000..90932f6
--- /dev/null
+++ b/src/corelib/statemachine/qstatemachine.cpp
@@ -0,0 +1,2017 @@
+/****************************************************************************
+**
+** 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 "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 "qactionstate.h"
+#include "qactionstate_p.h"
+#include "qfinalstate.h"
+#include "qhistorystate.h"
+#include "qhistorystate_p.h"
+#include "qstatefinishedevent.h"
+#include "qstatefinishedtransition.h"
+#include "qstate.h"
+#include "qstate_p.h"
+#include "qstateaction.h"
+#include "qstateaction_p.h"
+#ifndef QT_STATEMACHINE_SOLUTION
+#include "private/qobject_p.h"
+#include "private/qthread_p.h"
+#endif
+
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+#include "qeventtransition.h"
+#include "qeventtransition_p.h"
+#include "qboundevent_p.h"
+#endif
+
+#ifndef QT_NO_ANIMATION
+#include "qpropertyanimation.h"
+#include "qanimationgroup.h"
+# ifndef QT_STATEMACHINE_SOLUTION
+# include <private/qvariantanimation_p.h>
+# else
+# include "qvariantanimation_p.h"
+# endif
+#endif
+
+#include <QtCore/qmetaobject.h>
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QStateMachine
+  \reentrant
+
+  \brief The QStateMachine class provides a hierarchical finite state machine.
+
+  \ingroup statemachine
+
+  The QStateMachine class provides a hierarchical finite state machine based
+  on \l{Statecharts: A visual formalism for complex systems}{Statecharts}
+  concepts and notation. QStateMachine is part of \l{The State Machine
+  Framework}.
+
+  A state machine manages a set of states (QAbstractState objects) and
+  transitions (QAbstractTransition objects) between those states; the states
+  and the transitions collectively define a state graph. Once a state graph
+  has been defined, the state machine can execute it. QStateMachine's
+  execution algorithm is based on the \l{State Chart XML: State Machine
+  Notation for Control Abstraction}{State Chart XML (SCXML)} algorithm.
+
+  The QState class provides a state that you can use to set properties and
+  invoke methods on QObjects when the state is entered or exited. 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
+  assigments and method invocations are the actions.
+
+  Use the addState() function to add a state to the state machine;
+  alternatively, pass the machine's rootState() to the state constructor.  Use
+  the removeState() function to remove a state from the state machine.
+
+  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->setPropertyOnEntry(&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
+
+  The setInitialState() function sets the state machine's initial state; this
+  state is entered when the state machine is started.
+
+  The start() function starts the state machine. The state machine executes
+  asynchronously, i.e. you need to run an event loop in order for it to make
+  progress. The started() signal is emitted when the state machine has entered
+  the initial state.
+
+  The state machine processes events and takes transitions until a top-level
+  final state is entered; the state machine then emits the finished() signal.
+
+  The stop() function stops the state machine. The stopped() signal is emitted
+  when the state machine has stopped.
+
+  The postEvent() function posts an event to the state machine. This is useful
+  when you are using custom events to trigger transitions.
+
+  The rootState() function returns the state machine's root state. All
+  top-level states have the root state as their parent.
+
+  \sa QAbstractState, QAbstractTransition
+*/
+
+/*!
+    \property QStateMachine::rootState
+
+    \brief the root state of this state machine
+*/
+
+/*!
+    \property QStateMachine::initialState
+
+    \brief the initial state of this state machine
+*/
+
+/*!
+    \property QStateMachine::errorState
+
+    \brief the error state of this state machine
+*/
+
+/*!
+    \property QStateMachine::errorString
+
+    \brief the error string of this state machine
+*/
+
+// #define QSTATEMACHINE_DEBUG
+
+QStateMachinePrivate::QStateMachinePrivate()
+{
+    state = NotRunning;
+    processing = false;
+    processingScheduled = false;
+    stop = false;
+    error = QStateMachine::NoError;
+    globalRestorePolicy = QAbstractState::DoNotRestoreProperties;
+    rootState = 0;
+    initialErrorStateForRoot = 0;
+#ifndef QT_STATEMACHINE_SOLUTION
+    signalEventGenerator = 0;
+#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;
+}
+
+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 {
+        // ### fixme
+        return s1 < 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 {
+        // ### fixme
+        return s2 < s1;
+    }
+}
+
+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(const QList<QAbstractTransition*> &enabledTransitions)
+{
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q_func() << ": begin microstep( enabledTransitions:" << enabledTransitions << ")";
+    qDebug() << q_func() << ": configuration before exiting states:" << configuration;
+#endif
+    exitStates(enabledTransitions);
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q_func() << ": configuration after exiting states:" << configuration;
+#endif
+    executeTransitionContent(enabledTransitions);
+    QList<QAbstractState*> enteredStates = enterStates(enabledTransitions);
+    applyProperties(enabledTransitions, enteredStates);
+#ifdef QSTATEMACHINE_DEBUG
+    qDebug() << q_func() << ": configuration after entering states:" << configuration;
+    qDebug() << q_func() << ": end microstep";
+#endif
+}
+
+QList<QAbstractState*> QStateMachinePrivate::exitStates(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);
+        {
+            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 == QState::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 == QState::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();
+        configuration.remove(s);
+    }
+    return statesToExit_sorted;
+}
+
+void QStateMachinePrivate::executeTransitionContent(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();
+    }
+}
+
+QList<QAbstractState*> QStateMachinePrivate::enterStates(const QList<QAbstractTransition*> &enabledTransitions)
+{
+#ifdef QSTATEMACHINE_DEBUG
+    Q_Q(QStateMachine);
+#endif
+//    qDebug() << "enterStates(" << enabledTransitions << ")";
+    QSet<QAbstractState*> statesToEnter;
+    QSet<QAbstractState*> statesForDefaultEntry;
+
+    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);
+            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, lca, statesToEnter, statesForDefaultEntry);
+                    }
+#ifdef QSTATEMACHINE_DEBUG
+                    qDebug() << q << ": restoring"
+                            << ((QHistoryStatePrivate::get(h)->historyType == QState::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::NoDefaultStateInHistoryState, h);
+                    } else {
+                        for (int k = 0; k < hlst.size(); ++k) {
+                            QAbstractState *s0 = hlst.at(k);
+                            addStatesToEnter(s0, lca, statesToEnter, statesForDefaultEntry);
+                        }
+#ifdef QSTATEMACHINE_DEBUG
+                        qDebug() << q << ": initial history targets for" << s << ":" << hlst;                    
+#endif
+                    }
+                }
+            } else {
+                addStatesToEnter(s, 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();
+        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 << ": posting finished event for" << parent;
+#endif
+                internalEventQueue.append(new QStateFinishedEvent(parent));
+                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 << ": posting finished event for" << grandparent;
+#endif
+                        internalEventQueue.append(new QStateFinishedEvent(grandparent));
+                    }
+                }
+            }
+        }
+    }
+    {
+        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)
+{
+    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*> &enteredStates)
+{
+#ifndef QT_NO_ANIMATION
+    Q_Q(QStateMachine);
+    // Gracefully terminate playing animations.
+    for (int i = 0; i < playingAnimations.size(); ++i)
+        playingAnimations.at(i)->stop();
+    playingAnimations.clear();
+    for (int i = 0; i < resetEndValues.size(); ++i)
+        qobject_cast<QVariantAnimation*>(resetEndValues.at(i))->setEndValue(QVariant()); // ### generalize
+    resetEndValues.clear();
+
+    // Find the animations to use for the state change.
+    QList<QAbstractAnimation*> selectedAnimations;
+    for (int i = 0; i < transitionList.size(); ++i)
+        selectedAnimations << transitionList.at(i)->animations();
+#else
+    Q_UNUSED(transitionList);
+#endif
+
+    // Process the SetProperty definitions of the entered states.
+    QList<QPropertyAssignment> propertyAssignments;
+    QHash<RestorableId, QVariant> pendingRestorables = registeredRestorables;
+    for (int i = 0; i < enteredStates.size(); ++i) {
+        QAbstractState *s = enteredStates.at(i);
+
+        QAbstractState::RestorePolicy restorePolicy = s->restorePolicy();
+        if (restorePolicy == QAbstractState::GlobalRestorePolicy)
+            restorePolicy = globalRestorePolicy;
+
+        QList<QPropertyAssignment> assignments = QAbstractStatePrivate::get(s)->propertyAssignments;
+        for (int j = 0; j < assignments.size(); ++j) {
+            const QPropertyAssignment &assn = assignments.at(j);
+            if (restorePolicy == QAbstractState::RestoreProperties) {
+                registerRestorable(assn.object, assn.propertyName);
+            }
+            pendingRestorables.remove(RestorableId(assn.object, assn.propertyName));
+            propertyAssignments.append(assn);
+        }
+    }
+    propertyAssignments << restorablesToPropertyList(pendingRestorables);
+
+#ifndef QT_NO_ANIMATION
+    // Set the animated properties that did not finish animating and that are not
+    // set in the new state.
+    for (int i = 0; i < propertiesForAnimations.size(); ++i) {
+        QPropertyAssignment assn = propertiesForAnimations.at(i).second;
+        bool found = false;
+        for (int j = 0; j < propertyAssignments.size(); ++j) {
+            if ((propertyAssignments.at(j).object == assn.object)
+                && (propertyAssignments.at(j).propertyName == assn.propertyName)) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            assn.object->setProperty(assn.propertyName, assn.value);
+        }
+    }
+
+    // Initialize animations from SetProperty definitions.
+    propertiesForAnimations.clear();
+    for (int i = 0; i < selectedAnimations.size(); ++i) {
+        QAbstractAnimation *anim = selectedAnimations.at(i);
+        QList<QPropertyAssignment>::iterator it;
+        for (it = propertyAssignments.begin(); it != propertyAssignments.end(); ) {
+            QPair<QList<QAbstractAnimation*>, QList<QAbstractAnimation*> > ret;
+            ret = initializeAnimation(anim, *it);
+            QList<QAbstractAnimation*> handlers = ret.first;
+            if (!handlers.isEmpty()) {
+                for (int j = 0; j < handlers.size(); ++j)
+                    propertiesForAnimations.append(qMakePair(handlers.at(j), *it));
+                it = propertyAssignments.erase(it);
+            } else {
+                ++it;
+            }
+            resetEndValues << ret.second;
+        }
+
+        // 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) {
+            QObject::disconnect(anim, SIGNAL(finished()), q, SLOT(_q_animationFinished()));
+            QObject::connect(anim, SIGNAL(finished()), q, SLOT(_q_animationFinished()));
+            anim->start();
+            playingAnimations.append(anim);
+        }
+    }
+#endif // !QT_NO_ANIMATION
+
+    // Immediately set the properties that are not animated.
+    for (int i = 0; i < propertyAssignments.size(); ++i) {
+        const QPropertyAssignment &assn = propertyAssignments.at(i);
+        assn.object->setProperty(assn.propertyName, assn.value);
+    }
+}
+
+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)->isParallelGroup;
+}
+
+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)->isParallelGroup
+            && 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(s->parentState());
+        return errorState;
+    }
+
+    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::NoDefaultStateInHistoryState:
+        Q_ASSERT(currentContext != 0);
+
+        errorString = QStateMachine::tr("Missing default state in history 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;
+    }
+
+    if (currentErrorState) {
+        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()) {
+
+            if (!animation->startValue().isValid()) {
+                QByteArray propertyName = animation->propertyName();
+                QVariant currentValue = animation->targetObject()->property(propertyName);
+
+                QVariantAnimationPrivate::get(animation)->setDefaultStartValue(currentValue);
+            }
+
+            // 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);
+}
+
+static bool isAncestorOf(QObject *anc, QObject *o)
+{
+    for (o = o->parent() ; o != 0; o = o->parent()) {
+        if (o == anc)
+            return true;
+    }
+    return false;
+}
+
+void QStateMachinePrivate::_q_animationFinished()
+{
+    Q_Q(QStateMachine);
+    QAbstractAnimation *animation = qobject_cast<QAbstractAnimation*>(q->sender());
+    Q_ASSERT(animation != 0);
+    QList<QPair<QAbstractAnimation*, QPropertyAssignment> >::iterator it;
+    for (it = propertiesForAnimations.begin(); it != propertiesForAnimations.end(); ) {
+        QAbstractAnimation *a = (*it).first;
+        if (a == animation || isAncestorOf(animation, a)) {
+            QPropertyAssignment assn = (*it).second;
+            assn.object->setProperty(assn.propertyName, assn.value);
+            if (!assn.explicitlySet)
+                unregisterRestorable(assn.object, assn.propertyName);
+            it = propertiesForAnimations.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    playingAnimations.removeOne(animation);
+    if (playingAnimations.isEmpty())
+        emit q->animationsFinished();
+}
+
+#endif // !QT_NO_ANIMATION
+
+namespace {
+
+class StartState : public QState
+{
+public:
+    StartState(QState *parent)
+        : QState(parent) {}
+protected:
+    void onEntry() {}
+    void onExit() {}
+};
+
+class InitialTransition : public QAbstractTransition
+{
+public:
+    InitialTransition(QAbstractState *target)
+        : QAbstractTransition(QList<QAbstractState*>() << target) {}
+protected:
+    virtual bool eventTest(QEvent *) const { return true; }
+    virtual void onTransition() {}
+};
+
+} // 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);
+    executeTransitionContent(transitions);
+    enterStates(transitions);
+    applyProperties(transitions, 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(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;
+        emit q->finished();
+        break;
+    case Stopped:
+        state = NotRunning;
+        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
+}
+
+#ifndef QT_STATEMACHINE_SOLUTION
+
+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;
+}
+
+#endif
+
+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;
+    }
+    QList<int> &connectedSignalIndexes = connections[sender];
+    if (!connectedSignalIndexes.contains(signalIndex)) {
+#ifndef QT_STATEMACHINE_SOLUTION
+        if (!signalEventGenerator)
+            signalEventGenerator = new QSignalEventGenerator(q);
+#else
+        QSignalEventGenerator *signalEventGenerator = new QSignalEventGenerator(signalIndex, q);
+#endif
+        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.append(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
+#ifndef QT_STATEMACHINE_SOLUTION
+    const QObject *sender = QSignalTransitionPrivate::get(transition)->sender;
+    QList<int> &connectedSignalIndexes = connections[sender];
+    Q_ASSERT(connectedSignalIndexes.contains(signalIndex));
+    Q_ASSERT(signalEventGenerator != 0);
+    bool ok = QMetaObject::disconnect(sender, signalIndex, signalEventGenerator,
+                                      signalEventGenerator->metaObject()->methodOffset());
+    if (ok) {
+        connectedSignalIndexes.removeOne(signalIndex);
+        if (connectedSignalIndexes.isEmpty())
+            connections.remove(sender);
+        QSignalTransitionPrivate::get(transition)->signalIndex = -1;
+    }
+#endif
+}
+
+#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;
+#ifndef QT_STATEMACHINE_SOLUTION
+    QObjectPrivate *od = QObjectPrivate::get(object);
+    if (!od->eventFilters.contains(q))
+#endif
+        object->installEventFilter(q);
+    qobjectEvents[object].insert(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;
+    QSet<QEvent::Type> &events = qobjectEvents[object];
+    events.remove(transition->eventType());
+    if (events.isEmpty()) {
+        qobjectEvents.remove(object);
+        object->removeEventFilter(q);
+    }
+    QEventTransitionPrivate::get(transition)->registered = false;
+}
+#endif
+
+void QStateMachinePrivate::handleTransitionSignal(const QObject *sender, int signalIndex,
+                                                  void **argv)
+{
+    const QList<int> &connectedSignalIndexes = connections[sender];
+    Q_ASSERT(connectedSignalIndexes.contains(signalIndex));
+    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(
+#ifndef QT_STATEMACHINE_SOLUTION
+        *new QStateMachinePrivate,
+#endif
+        parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(new QStateMachinePrivate)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+}
+
+/*!
+  \internal
+*/
+QStateMachine::QStateMachine(QStateMachinePrivate &dd, QObject *parent)
+    : QObject(
+#ifndef QT_STATEMACHINE_SOLUTION
+        dd,
+#endif
+        parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , d_ptr(&dd)
+#endif
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    d_ptr->q_ptr = this;
+#endif
+}
+
+/*!
+  Destroys this state machine.
+*/
+QStateMachine::~QStateMachine()
+{
+#ifdef QT_STATEMACHINE_SOLUTION
+    delete d_ptr;
+#endif
+}
+
+namespace {
+
+class RootErrorState : public QAbstractState 
+{
+public:
+    RootErrorState(QState *parent) 
+        : QAbstractState(parent) 
+    {
+        setObjectName(QString::fromLatin1("DefaultErrorState"));
+    }
+
+    void onEntry()
+    {
+        QAbstractStatePrivate *d = QAbstractStatePrivate::get(this);
+        QStateMachine *machine = d->machine();
+
+        qWarning("Unrecoverable error detected in running state machine: %s", 
+                 qPrintable(machine->errorString()));
+    }
+
+    void onExit() {}
+};
+
+class RootState : public QState
+{
+public:
+    RootState(QState *parent)
+        : QState(parent)
+    {                
+    }
+
+    void onEntry() {}
+    void onExit() {}
+};
+
+} // 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 NoDefaultStateInHistoryState 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.          
+
+    \sa setErrorState()
+*/
+
+/*!
+  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 global restore policy of the state machine.
+
+   \sa QActionState::restorePolicy()
+*/
+QActionState::RestorePolicy QStateMachine::globalRestorePolicy() const
+{
+    Q_D(const QStateMachine);
+    return d->globalRestorePolicy;
+}
+
+/*!
+   Sets the global restore policy of the state machine to \a restorePolicy. The default global 
+   restore policy is QAbstractState::DoNotRestoreProperties.
+   
+   The global restore policy cannot be set to QAbstractState::GlobalRestorePolicy.
+
+   \sa QAbstractState::setRestorePolicy()
+*/
+void QStateMachine::setGlobalRestorePolicy(QAbstractState::RestorePolicy restorePolicy) 
+{
+    Q_D(QStateMachine);
+    if (restorePolicy == QState::GlobalRestorePolicy) {
+        qWarning("QStateMachine::setGlobalRestorePolicy: Cannot set global restore policy to "
+                 "GlobalRestorePolicy");
+        return;
+    }
+
+    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()
+*/
+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);
+}
+
+/*!
+  Starts this state machine.
+  The machine will reset its configuration and transition to the initial
+  state.  When a final top-level state 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.
+
+  \sa stopped()
+*/
+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();
+}
+
+/*!
+  Returns the list of this state machine's states, or an empty list if the
+  state machine has no states.
+*/
+QList<QAbstractState*> QStateMachine::states() const
+{
+    return QStatePrivate::get(rootState())->childStates();
+}
+
+/*!
+  \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.
+
+  \sa QStateMachine::finished(), QStateMachine::start()
+*/
+
+/*!
+  \fn QStateMachine::finished()
+
+  This signal is emitted when the state machine has reached a top-level final
+  state.
+
+  \sa QStateMachine::started()
+*/
+
+/*!
+  \fn QStateMachine::stopped()
+
+  This signal is emitted when the state machine has stopped.
+
+  \sa QStateMachine::stop()
+*/
+
+#ifndef QT_NO_ANIMATION
+
+/*!
+  \fn QStateMachine::animationsFinished()
+
+  This signal is emitted when the state machine has finished playing all
+  animations associated with the latest transition (i.e., all properties have
+  reached their target values).
+*/
+
+#endif
+
+/*!
+  \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 QBoundEvent(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);
+}
+
+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: {
+#ifndef QT_STATEMACHINE_SOLUTION
+// ### in Qt 4.6 we can use QObject::senderSignalIndex()
+            int signalIndex = senderSignalIndex(this);
+            Q_ASSERT(signalIndex != -1);
+#endif
+            QStateMachine *machine = qobject_cast<QStateMachine*>(parent());
+            QStateMachinePrivate::get(machine)->handleTransitionSignal(sender(), signalIndex, _a);
+            break;
+        }
+        default: ;
+        }
+        _id -= 1;
+    }
+    return _id;
+}
+
+QSignalEventGenerator::QSignalEventGenerator(
+#ifdef QT_STATEMACHINE_SOLUTION
+    int sigIdx,
+#endif
+    QStateMachine *parent)
+    : QObject(parent)
+#ifdef QT_STATEMACHINE_SOLUTION
+    , signalIndex(sigIdx)
+#endif
+{
+}
+
+/*!
+  \class QSignalEvent
+
+  \brief The QSignalEvent class represents a Qt signal event.
+
+  \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
+*/
+
+/*!
+  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)
+    :
+#ifndef QT_STATEMACHINE_SOLUTION
+    QEvent(QEvent::Signal)
+#else
+    QEvent(QEvent::Type(QEvent::User-1))
+#endif
+    , 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()
+*/
+
+/*!
+  \fn QSignalEvent::arguments() const
+
+  Returns the arguments of the signal.
+*/
+
+/*!
+  \class QStateFinishedEvent
+
+  \brief The QStateFinishedEvent class contains parameters that describe a state that has finished.
+
+  \ingroup statemachine
+
+  A state is finished when one of its final child states (a QFinalState) is
+  entered; this will cause a QStateFinishedEvent to be generated by the state
+  machine. QStateFinishedEvent is part of \l{The State Machine Framework}.
+
+  Typically you do not create QStateFinishedEvent objects yourself, but rather
+  use QStateFinishedTransition to create a transition that's triggered by a
+  state's finished event.
+
+  \sa QStateFinishedTransition
+*/
+
+/*!
+  Constructs a new QStateFinishedEvent object associated with the given \a state.
+*/
+QStateFinishedEvent::QStateFinishedEvent(QState *state)
+    :
+#ifndef QT_STATEMACHINE_SOLUTION
+    QEvent(StateFinished)
+#else
+    QEvent(QEvent::Type(QEvent::User-2))
+#endif
+    , m_state(state)
+{
+}
+
+/*!
+  Destroys this QStateFinishedEvent.
+*/
+QStateFinishedEvent::~QStateFinishedEvent()
+{
+}
+
+/*!
+  Returns the state associated with this QStateFinishedEvent.
+*/
+QState *QStateFinishedEvent::state() const
+{
+    return m_state;
+}
+
+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..c7de171
--- /dev/null
+++ b/src/corelib/statemachine/qstatemachine.h
@@ -0,0 +1,155 @@
+/****************************************************************************
+**
+** 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
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#  include <QtCore/qactionstate.h>
+#else
+#  include "qactionstate.h"
+#endif
+
+#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 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)
+public:
+
+    enum Error {
+        NoError, 
+        NoInitialStateError,
+        NoDefaultStateInHistoryState,
+    };
+
+    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();
+
+    QAbstractState::RestorePolicy globalRestorePolicy() const;
+    void setGlobalRestorePolicy(QAbstractState::RestorePolicy restorePolicy);
+
+    void postEvent(QEvent *event, int delay = 0);
+
+    QList<QAbstractState*> states() const;
+    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();
+
+#ifndef QT_NO_ANIMATION
+    void animationsFinished();
+#endif
+
+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:
+#ifdef QT_STATEMACHINE_SOLUTION
+     QStateMachinePrivate *d_ptr;
+#endif
+    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..04dc71e
--- /dev/null
+++ b/src/corelib/statemachine/qstatemachine_p.h
@@ -0,0 +1,214 @@
+/****************************************************************************
+**
+** 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.
+//
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <private/qobject_p.h>
+#endif
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qpair.h>
+#include <QtCore/qset.h>
+
+#include "qabstractstate_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
+#ifndef QT_STATEMACHINE_SOLUTION
+    : public QObjectPrivate
+#endif
+{
+    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(const QList<QAbstractTransition*> &transitionList);
+    bool isPreempted(const QAbstractState *s, const QSet<QAbstractTransition*> &transitions) const;
+    QSet<QAbstractTransition*> selectTransitions(QEvent *event) const;
+    QList<QAbstractState*> exitStates(const QList<QAbstractTransition*> &transitionList);
+    void executeTransitionContent(const QList<QAbstractTransition*> &transitionList);
+    QList<QAbstractState*> enterStates(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*> &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 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;
+    QActionState::RestorePolicy globalRestorePolicy;
+
+    QString errorString;
+    QSet<QAbstractState *> pendingErrorStates;
+    QSet<QAbstractState *> pendingErrorStatesForDefaultEntry;
+    QAbstractState *initialErrorStateForRoot;
+
+#ifndef QT_NO_ANIMATION
+    QPair<QList<QAbstractAnimation*>, QList<QAbstractAnimation*> >
+        initializeAnimation(QAbstractAnimation *abstractAnimation, 
+                            const QPropertyAssignment &prop);
+
+    QList<QPair<QAbstractAnimation*, QPropertyAssignment> > propertiesForAnimations;
+    QList<QAbstractAnimation*> playingAnimations;
+    QList<QAbstractAnimation*> resetEndValues;
+#endif
+
+#ifndef QT_STATEMACHINE_SOLUTION
+    QSignalEventGenerator *signalEventGenerator;
+#endif
+    QHash<const QObject*, QList<int> > connections;
+#ifndef QT_NO_STATEMACHINE_EVENTFILTER
+    QHash<QObject*, QSet<QEvent::Type> > qobjectEvents;
+#endif
+    QHash<int, QEvent*> delayedEvents;
+  
+    typedef QEvent* (*f_cloneEvent)(QEvent*);
+    struct Handler {
+        f_cloneEvent cloneEvent;
+    };
+
+    static const Handler *handler;
+
+#ifdef QT_STATEMACHINE_SOLUTION
+    QStateMachine *q_ptr;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qtransition.cpp b/src/corelib/statemachine/qtransition.cpp
new file mode 100644
index 0000000..3becc3a
--- /dev/null
+++ b/src/corelib/statemachine/qtransition.cpp
@@ -0,0 +1,231 @@
+/****************************************************************************
+**
+** 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 "qtransition.h"
+#include "qtransition_p.h"
+#include "qstateaction.h"
+#include "qstateaction_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QTransition
+
+  \brief The QTransition class provides an action-based transition.
+
+  \ingroup statemachine
+
+  QTransition provides an action-based transition; you add actions with the
+  addAction() function. The transition executes the actions when the
+  transition is triggered. QTransition is part of \l{The State Machine
+  Framework}.
+
+  The invokeMethodOnTransition() function is used for defining method
+  invocations that should be performed when a transition is taken.
+
+  \code
+  QStateMachine machine;
+  QState *s1 = new QState();
+  machine.addState(s1);
+  QTransition *t1 = new QTransition();
+  QLabel label;
+  t1->invokeMethodOnTransition(&label, "clear");
+  QState *s2 = new QState();
+  machine.addState(s2);
+  t1->setTargetState(s2);
+  s1->addTransition(t1);
+  \endcode
+
+  Actions are executed in the order in which they were added.
+
+  \sa QState::addTransition(), QStateAction
+*/
+
+QTransitionPrivate::QTransitionPrivate()
+{
+}
+
+QTransitionPrivate::~QTransitionPrivate()
+{
+}
+
+QTransitionPrivate *QTransitionPrivate::get(QTransition *q)
+{
+    return q->d_func();
+}
+
+const QTransitionPrivate *QTransitionPrivate::get(const QTransition *q)
+{
+    return q->d_func();
+}
+
+QList<QStateAction*> QTransitionPrivate::actions() const
+{
+    QList<QStateAction*> result;
+    QList<QObject*>::const_iterator it;
+#ifdef QT_STATEMACHINE_SOLUTION
+    const QObjectList &children = q_func()->children();
+#endif
+    for (it = children.constBegin(); it != children.constEnd(); ++it) {
+        QStateAction *s = qobject_cast<QStateAction*>(*it);
+        if (s)
+            result.append(s);
+    }
+    return result;
+}
+
+/*!
+  Constructs a new QTransition object with the given \a sourceState.
+*/
+QTransition::QTransition(QState *sourceState)
+    : QAbstractTransition(*new QTransitionPrivate, sourceState)
+{
+}
+
+/*!
+  Constructs a new QTransition object with the given \a targets and \a
+  sourceState.
+*/
+QTransition::QTransition(const QList<QAbstractState*> &targets, QState *sourceState)
+    : QAbstractTransition(*new QTransitionPrivate, targets, sourceState)
+{
+}
+
+/*!
+  \internal
+*/
+QTransition::QTransition(QTransitionPrivate &dd, QState *parent)
+    : QAbstractTransition(dd, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QTransition::QTransition(QTransitionPrivate &dd, const QList<QAbstractState*> &targets, QState *parent)
+    : QAbstractTransition(dd, targets, parent)
+{
+}
+
+/*!
+  Destroys this transition.
+*/
+QTransition::~QTransition()
+{
+}
+
+/*!
+  Instructs this QTransition to invoke the given \a method of the given \a
+  object with the given \a arguments when the transition is taken. This
+  function will create a QStateInvokeMethodAction object and add it to the
+  actions of the transition.
+
+  \sa setPropertyOnTransition()
+*/
+void QTransition::invokeMethodOnTransition(QObject *object, const char *method,
+                                           const QList<QVariant> &arguments)
+{
+    addAction(new QStateInvokeMethodAction(object, method, arguments));
+}
+
+/*!
+  Adds the given \a action to this transition.
+  The action will be executed when the transition is triggered.
+  The transition takes ownership of the action.
+
+  \sa removeAction()
+*/
+void QTransition::addAction(QStateAction *action)
+{
+    if (!action) {
+        qWarning("QTransition::addAction: cannot add null action");
+        return;
+    }
+    action->setParent(this);
+}
+
+/*!
+  Removes the given \a action from this transition.
+  The transition releases ownership of the action.
+
+  \sa addAction()
+*/
+void QTransition::removeAction(QStateAction *action)
+{
+    if (!action) {
+        qWarning("QTransition::removeAction: cannot remove null action");
+        return;
+    }
+    action->setParent(0);
+}
+
+/*!
+  Returns this transitions's actions, or an empty list if the transition has
+  no actions.
+
+  \sa addAction()
+*/
+QList<QStateAction*> QTransition::actions() const
+{
+    Q_D(const QTransition);
+    return d->actions();
+}
+
+/*!
+  \reimp
+*/
+void QTransition::onTransition()
+{
+    Q_D(QTransition);
+    QList<QStateAction*> actions = d->actions();
+    for (int i = 0; i < actions.size(); ++i)
+        QStateActionPrivate::get(actions.at(i))->callExecute();
+}
+
+/*!
+  \reimp
+*/
+bool QTransition::event(QEvent *e)
+{
+    return QAbstractTransition::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qtransition.h b/src/corelib/statemachine/qtransition.h
new file mode 100644
index 0000000..7eec136
--- /dev/null
+++ b/src/corelib/statemachine/qtransition.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 QTRANSITION_H
+#define QTRANSITION_H
+
+#ifndef QT_STATEMACHINE_SOLUTION
+#include <QtCore/qabstracttransition.h>
+#else
+#include "qabstracttransition.h"
+#endif
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QStateAction;
+
+class QTransitionPrivate;
+class Q_CORE_EXPORT QTransition : public QAbstractTransition
+{
+    Q_OBJECT
+public:
+    QTransition(QState *sourceState = 0);
+    QTransition(const QList<QAbstractState*> &targets, QState *sourceState = 0);
+    ~QTransition();
+
+    void invokeMethodOnTransition(QObject *object, const char *method,
+                                  const QList<QVariant> &args = QList<QVariant>());
+
+    void addAction(QStateAction *action);
+    void removeAction(QStateAction *action);
+    QList<QStateAction*> actions() const;
+
+protected:
+    virtual void onTransition();
+
+    bool event(QEvent *e);
+
+protected:
+    QTransition(QTransitionPrivate &dd, QState *parent);
+    QTransition(QTransitionPrivate &dd, const QList<QAbstractState*> &targets, QState *parent);
+
+private:
+    Q_DISABLE_COPY(QTransition)
+    Q_DECLARE_PRIVATE(QTransition)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qtransition_p.h b/src/corelib/statemachine/qtransition_p.h
new file mode 100644
index 0000000..d43a4d4
--- /dev/null
+++ b/src/corelib/statemachine/qtransition_p.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** 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 QTRANSITION_P_H
+#define QTRANSITION_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"
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_NAMESPACE
+
+class QStateAction;
+
+class QTransition;
+class Q_CORE_EXPORT QTransitionPrivate : public QAbstractTransitionPrivate
+{
+    Q_DECLARE_PUBLIC(QTransition)
+public:
+    QTransitionPrivate();
+    ~QTransitionPrivate();
+
+    static QTransitionPrivate *get(QTransition *q);
+    static const QTransitionPrivate *get(const QTransition *q);
+
+    QList<QStateAction*> actions() const;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/statemachine.pri b/src/corelib/statemachine/statemachine.pri
new file mode 100644
index 0000000..9c797e2
--- /dev/null
+++ b/src/corelib/statemachine/statemachine.pri
@@ -0,0 +1,42 @@
+HEADERS += $$PWD/qstatemachine.h \
+	   $$PWD/qstatemachine_p.h \
+	   $$PWD/qstateaction.h \
+	   $$PWD/qstateaction_p.h \
+	   $$PWD/qsignaleventgenerator_p.h \
+	   $$PWD/qabstractstate.h \
+	   $$PWD/qabstractstate_p.h \
+	   $$PWD/qactionstate.h \
+	   $$PWD/qactionstate_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/qtransition.h \
+	   $$PWD/qtransition_p.h \
+	   $$PWD/qstatefinishedevent.h \
+	   $$PWD/qstatefinishedtransition.h \
+	   $$PWD/qsignalevent.h \
+	   $$PWD/qsignaltransition.h \
+	   $$PWD/qsignaltransition_p.h
+
+SOURCES += $$PWD/qstatemachine.cpp \
+	   $$PWD/qstateaction.cpp \
+	   $$PWD/qabstractstate.cpp \
+	   $$PWD/qactionstate.cpp \
+	   $$PWD/qstate.cpp \
+	   $$PWD/qfinalstate.cpp \
+	   $$PWD/qhistorystate.cpp \
+	   $$PWD/qabstracttransition.cpp \
+	   $$PWD/qtransition.cpp \
+	   $$PWD/qstatefinishedtransition.cpp \
+	   $$PWD/qsignaltransition.cpp
+
+!contains(DEFINES, QT_NO_STATEMACHINE_EVENTFILTER) {
+HEADERS += $$PWD/qboundevent_p.h \
+	   $$PWD/qeventtransition.h \
+	   $$PWD/qeventtransition_p.h
+SOURCES += $$PWD/qeventtransition.cpp
+}