Say hello to animation API & state machine API

author: Kent Hansen <khansen@trolltech.com> 2009-05-22 11:11:41 (GMT)
committer: Kent Hansen <khansen@trolltech.com> 2009-05-22 11:11:41 (GMT)
commit: 1a709fbe25a2446a9b311ded88aec5565258f3ac (patch)
tree: 0c7b0a5fbd94b7a4d59666f671fc8f995153161b /src
parent: 5a734e4657161e0877b32181df35a56241b21de4 (diff)
download: Qt-1a709fbe25a2446a9b311ded88aec5565258f3ac.zip
Qt-1a709fbe25a2446a9b311ded88aec5565258f3ac.tar.gz
Qt-1a709fbe25a2446a9b311ded88aec5565258f3ac.tar.bz2
77 files changed, 14047 insertions, 63 deletions
diff --git a/src/3rdparty/easing/easing.cpp b/src/3rdparty/easing/easing.cpp
new file mode 100644
index 0000000..81af40f
--- /dev/null
+++ b/src/3rdparty/easing/easing.cpp
@@ -0,0 +1,670 @@
+/*
+Disclaimer for Robert Penner's Easing Equations license:
+
+TERMS OF USE - EASING EQUATIONS
+
+Open source under the BSD License.
+
+Copyright © 2001 Robert Penner
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the author nor the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <QtCore/qmath.h>
+#include <math.h>
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+#ifndef M_PI_2
+#define M_PI_2 (M_PI / 2)
+#endif
+
+QT_USE_NAMESPACE
+
+/**
+ * Easing equation function for a simple linear tweening, with no easing.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeNone(qreal progress)
+{
+    return progress;
+}
+
+/**
+ * Easing equation function for a quadratic (t^2) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInQuad(qreal t)
+{
+    return t*t;
+}
+
+/**
+* Easing equation function for a quadratic (t^2) easing out: decelerating to zero velocity.
+*
+* @param t		Current time (in frames or seconds).
+* @return		The correct value.
+*/
+static qreal easeOutQuad(qreal t)
+{
+    return -t*(t-2);
+}
+
+/**
+ * Easing equation function for a quadratic (t^2) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInOutQuad(qreal t)
+{
+    t*=2.0;
+    if (t < 1) {
+        return t*t/qreal(2);
+    } else {
+        --t;
+        return -0.5 * (t*(t-2) - 1);
+    }
+}
+
+/**
+ * Easing equation function for a quadratic (t^2) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutInQuad(qreal t)
+{
+    if (t < 0.5) return easeOutQuad (t*2)/2;
+    return easeInQuad((2*t)-1)/2 + 0.5;
+}
+
+/**
+ * Easing equation function for a cubic (t^3) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInCubic(qreal t)
+{
+    return t*t*t;
+}
+
+/**
+ * Easing equation function for a cubic (t^3) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutCubic(qreal t)
+{
+    t-=1.0;
+    return t*t*t + 1;
+}
+
+/**
+ * Easing equation function for a cubic (t^3) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInOutCubic(qreal t)
+{
+    t*=2.0;
+    if(t < 1) {
+        return 0.5*t*t*t;
+    } else {
+        t -= qreal(2.0);
+        return 0.5*(t*t*t + 2);
+    }
+}
+
+/**
+ * Easing equation function for a cubic (t^3) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutInCubic(qreal t)
+{
+    if (t < 0.5) return easeOutCubic (2*t)/2;
+    return easeInCubic(2*t - 1)/2 + 0.5;
+}
+
+/**
+ * Easing equation function for a quartic (t^4) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInQuart(qreal t)
+{
+    return t*t*t*t;
+}
+
+/**
+ * Easing equation function for a quartic (t^4) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutQuart(qreal t)
+{
+    t-= qreal(1.0);
+    return - (t*t*t*t- 1);
+}
+
+/**
+ * Easing equation function for a quartic (t^4) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInOutQuart(qreal t)
+{
+    t*=2;
+    if (t < 1) return 0.5*t*t*t*t;
+    else {
+        t -= 2.0f;
+        return -0.5 * (t*t*t*t- 2);
+    }
+}
+
+/**
+ * Easing equation function for a quartic (t^4) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutInQuart(qreal t)
+{
+    if (t < 0.5) return easeOutQuart (2*t)/2;
+    return easeInQuart(2*t-1)/2 + 0.5;
+}
+
+/**
+ * Easing equation function for a quintic (t^5) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInQuint(qreal t)
+{
+    return t*t*t*t*t;
+}
+
+/**
+ * Easing equation function for a quintic (t^5) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutQuint(qreal t)
+{
+    t-=1.0;
+    return t*t*t*t*t + 1;
+}
+
+/**
+ * Easing equation function for a quintic (t^5) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInOutQuint(qreal t)
+{
+    t*=2.0;
+    if (t < 1) return 0.5*t*t*t*t*t;
+    else {
+        t -= 2.0;
+        return 0.5*(t*t*t*t*t + 2);
+    }
+}
+
+/**
+ * Easing equation function for a quintic (t^5) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutInQuint(qreal t)
+{
+    if (t < 0.5) return easeOutQuint (2*t)/2;
+    return easeInQuint(2*t - 1)/2 + 0.5;
+}
+
+/**
+ * Easing equation function for a sinusoidal (sin(t)) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInSine(qreal t)
+{
+    return (t == 1.0) ? 1.0 : -::cos(t * M_PI_2) + 1.0;
+}
+
+/**
+ * Easing equation function for a sinusoidal (sin(t)) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutSine(qreal t)
+{
+    return ::sin(t* M_PI_2);
+}
+
+/**
+ * Easing equation function for a sinusoidal (sin(t)) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInOutSine(qreal t)
+{
+    return -0.5 * (::cos(M_PI*t) - 1);
+}
+
+/**
+ * Easing equation function for a sinusoidal (sin(t)) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutInSine(qreal t)
+{
+    if (t < 0.5) return easeOutSine (2*t)/2;
+    return easeInSine(2*t - 1)/2 + 0.5;
+}
+
+/**
+ * Easing equation function for an exponential (2^t) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInExpo(qreal t)
+{
+    return (t==0 || t == 1.0) ? t : ::qPow(2.0, 10 * (t - 1)) - qreal(0.001);
+}
+
+/**
+ * Easing equation function for an exponential (2^t) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutExpo(qreal t)
+{
+    return (t==1.0) ? 1.0 : 1.001 * (-::qPow(2.0f, -10 * t) + 1);
+}
+
+/**
+ * Easing equation function for an exponential (2^t) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInOutExpo(qreal t)
+{
+    if (t==0.0) return qreal(0.0);
+    if (t==1.0) return qreal(1.0);
+    t*=2.0;
+    if (t < 1) return 0.5 * ::qPow(qreal(2.0), 10 * (t - 1)) - 0.0005;
+    return 0.5 * 1.0005 * (-::qPow(qreal(2.0), -10 * (t - 1)) + 2);
+}
+
+/**
+ * Easing equation function for an exponential (2^t) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutInExpo(qreal t)
+{
+    if (t < 0.5) return easeOutExpo (2*t)/2;
+    return easeInExpo(2*t - 1)/2 + 0.5;
+}
+
+/**
+ * Easing equation function for a circular (sqrt(1-t^2)) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInCirc(qreal t)
+{
+    return -(::sqrt(1 - t*t) - 1);
+}
+
+/**
+ * Easing equation function for a circular (sqrt(1-t^2)) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutCirc(qreal t)
+{
+    t-= qreal(1.0);
+    return ::sqrt(1 - t* t);
+}
+
+/**
+ * Easing equation function for a circular (sqrt(1-t^2)) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeInOutCirc(qreal t)
+{
+    t*=qreal(2.0);
+    if (t < 1) {
+        return -0.5 * (::sqrt(1 - t*t) - 1);
+    } else {
+        t -= qreal(2.0);
+        return 0.5 * (::sqrt(1 - t*t) + 1);
+    }
+}
+
+/**
+ * Easing equation function for a circular (sqrt(1-t^2)) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @return		The correct value.
+ */
+static qreal easeOutInCirc(qreal t)
+{
+    if (t < 0.5) return easeOutCirc (2*t)/2;
+    return easeInCirc(2*t - 1)/2 + 0.5;
+}
+
+static qreal easeInElastic_helper(qreal t, qreal b, qreal c, qreal d, qreal a, qreal p)
+{
+    if (t==0) return b;
+    qreal t_adj = (qreal)t / (qreal)d;
+    if (t_adj==1) return b+c;
+
+    qreal s;
+    if(a < ::fabs(c)) {
+        a = c;
+        s = p / 4.0f;
+    } else {
+        s = p / (2 * M_PI) * ::asin(c / a);
+    }
+
+    t_adj -= 1.0f;
+    return -(a*::qPow(2.0f,10*t_adj) * ::sin( (t_adj*d-s)*(2*M_PI)/p )) + b;
+}
+
+/**
+ * Easing equation function for an elastic (exponentially decaying sine wave) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param a		Amplitude.
+ * @param p		Period.
+ * @return		The correct value.
+ */
+static qreal easeInElastic(qreal t, qreal a, qreal p)
+{
+    return easeInElastic_helper(t, 0, 1, 1, a, p);
+}
+
+static qreal easeOutElastic_helper(qreal t, qreal /*b*/, qreal c, qreal /*d*/, qreal a, qreal p)
+{
+    if (t==0) return 0;
+    if (t==1) return c;
+
+    qreal s;
+    if(a < c) {
+        a = c;
+        s = p / 4.0f;
+    } else {
+        s = p / (2 * M_PI) * ::asin(c / a);
+    }
+
+    return (a*::qPow(2.0f,-10*t) * ::sin( (t-s)*(2*M_PI)/p ) + c);
+}
+
+/**
+ * Easing equation function for an elastic (exponentially decaying sine wave) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param a		Amplitude.
+ * @param p		Period.
+ * @return		The correct value.
+ */
+static qreal easeOutElastic(qreal t, qreal a, qreal p)
+{
+    return easeOutElastic_helper(t, 0, 1, 1, a, p);
+}
+
+/**
+ * Easing equation function for an elastic (exponentially decaying sine wave) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param a		Amplitude.
+ * @param p		Period.
+ * @return		The correct value.
+ */
+static qreal easeInOutElastic(qreal t, qreal a, qreal p)
+{
+    if (t==0) return 0.0;
+    t*=2.0;
+    if (t==2) return 1.0;
+
+    qreal s;
+    if(a < 1.0) {
+        a = 1.0;
+        s = p / 4.0f;
+    } else {
+        s = p / (2 * M_PI) * ::asin(1.0 / a);
+    }
+
+    if (t < 1) return -.5*(a*::qPow(2.0f,10*(t-1)) * ::sin( (t-1-s)*(2*M_PI)/p ));
+    return a*::qPow(2.0f,-10*(t-1)) * ::sin( (t-1-s)*(2*M_PI)/p )*.5 + 1.0;
+}
+
+/**
+ * Easing equation function for an elastic (exponentially decaying sine wave) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param a		Amplitude.
+ * @param p		Period.
+ * @return		The correct value.
+ */
+static qreal easeOutInElastic(qreal t, qreal a, qreal p)
+{
+    if (t < 0.5) return easeOutElastic_helper(t*2, 0, 0.5, 1.0, a, p);
+    return easeInElastic_helper(2*t - 1.0, 0.5, 0.5, 1.0, a, p);
+}
+
+/**
+ * Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param s		Overshoot ammount: higher s means greater overshoot (0 produces cubic easing with no overshoot, and the default value of 1.70158 produces an overshoot of 10 percent).
+ * @return		The correct value.
+ */
+static qreal easeInBack(qreal t, qreal s)
+{
+    return t*t*((s+1)*t - s);
+}
+
+/**
+ * Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param s		Overshoot ammount: higher s means greater overshoot (0 produces cubic easing with no overshoot, and the default value of 1.70158 produces an overshoot of 10 percent).
+ * @return		The correct value.
+ */
+static qreal easeOutBack(qreal t, qreal s)
+{
+    t-= qreal(1.0);
+    return t*t*((s+1)*t+ s) + 1;
+}
+
+/**
+ * Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param s		Overshoot ammount: higher s means greater overshoot (0 produces cubic easing with no overshoot, and the default value of 1.70158 produces an overshoot of 10 percent).
+ * @return		The correct value.
+ */
+static qreal easeInOutBack(qreal t, qreal s)
+{
+    t *= 2.0;
+    if (t < 1) {
+        s *= 1.525f;
+        return 0.5*(t*t*((s+1)*t - s));
+    } else {
+        t -= 2;
+        s *= 1.525f;
+        return 0.5*(t*t*((s+1)*t+ s) + 2);
+    }
+}
+
+/**
+ * Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param s		Overshoot ammount: higher s means greater overshoot (0 produces cubic easing with no overshoot, and the default value of 1.70158 produces an overshoot of 10 percent).
+ * @return		The correct value.
+ */
+static qreal easeOutInBack(qreal t, qreal s)
+{
+    if (t < 0.5) return easeOutBack (2*t, s)/2;
+    return easeInBack(2*t - 1, s)/2 + 0.5;
+}
+
+static qreal easeOutBounce_helper(qreal t, qreal c, qreal a)
+{
+    if (t == 1.0) return c;
+    if (t < (4/11.0)) {
+        return c*(7.5625*t*t);
+    } else if (t < (8/11.0)) {
+        t -= (6/11.0);
+        return -a * (1. - (7.5625*t*t + .75)) + c;
+    } else if (t < (10/11.0)) {
+        t -= (9/11.0);
+        return -a * (1. - (7.5625*t*t + .9375)) + c;
+    } else {
+        t -= (21/22.0);
+        return -a * (1. - (7.5625*t*t + .984375)) + c;
+    }
+}
+
+/**
+ * Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out: decelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param a		Amplitude.
+ * @return		The correct value.
+ */
+static qreal easeOutBounce(qreal t, qreal a)
+{
+    return easeOutBounce_helper(t, 1, a);
+}
+
+/**
+ * Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in: accelerating from zero velocity.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param a		Amplitude.
+ * @return		The correct value.
+ */
+static qreal easeInBounce(qreal t, qreal a)
+{
+    return 1.0 - easeOutBounce_helper(1.0-t, 1.0, a);
+}
+
+
+/**
+ * Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out: acceleration until halfway, then deceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param a		Amplitude.
+ * @return		The correct value.
+ */
+static qreal easeInOutBounce(qreal t, qreal a)
+{
+    if (t < 0.5) return easeInBounce (2*t, a)/2;
+    else return (t == 1.0) ? 1.0 : easeOutBounce (2*t - 1, a)/2 + 0.5;
+}
+
+/**
+ * Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out/in: deceleration until halfway, then acceleration.
+ *
+ * @param t		Current time (in frames or seconds).
+ * @param a		Amplitude.
+ * @return		The correct value.
+ */
+static qreal easeOutInBounce(qreal t, qreal a)
+{
+    if (t < 0.5) return easeOutBounce_helper(t*2, 0.5, a);
+    return 1.0 - easeOutBounce_helper (2.0-2*t, 0.5, a);
+}
+
+static inline qreal qt_sinProgress(qreal value)
+{
+    return qSin((value * M_PI) - M_PI_2) / 2 + qreal(0.5);
+}
+
+static inline qreal qt_smoothBeginEndMixFactor(qreal value)
+{
+    return qMin(qMax(1 - value * 2 + qreal(0.3), qreal(0.0)), qreal(1.0));
+}
+
+// SmoothBegin blends Smooth and Linear Interpolation.
+// Progress 0 - 0.3      : Smooth only
+// Progress 0.3 - ~ 0.5  : Mix of Smooth and Linear
+// Progress ~ 0.5  - 1   : Linear only
+
+/**
+ * Easing function that starts growing slowly, then increases in speed. At the end of the curve the speed will be constant.
+ */
+static qreal easeInCurve(qreal t)
+{
+    const qreal sinProgress = qt_sinProgress(t);
+    const qreal mix = qt_smoothBeginEndMixFactor(t);
+    return sinProgress * mix + t * (1 - mix);
+}
+
+/**
+ * Easing function that starts growing steadily, then ends slowly. The speed will be constant at the beginning of the curve.
+ */
+static qreal easeOutCurve(qreal t)
+{
+    const qreal sinProgress = qt_sinProgress(t);
+    const qreal mix = qt_smoothBeginEndMixFactor(1 - t);
+    return sinProgress * mix + t * (1 - mix);
+}
+
+/**
+ * Easing function where the value grows sinusoidally. Note that the calculated  end value will be 0 rather than 1.
+ */
+static qreal easeSineCurve(qreal t)
+{
+    return (qSin(((t * M_PI * 2)) - M_PI_2) + 1) / 2;
+}
+
+/**
+ * Easing function where the value grows cosinusoidally. Note that the calculated start value will be 0.5 and the end value will be 0.5
+ * contrary to the usual 0 to 1 easing curve.
+ */
+static qreal easeCosineCurve(qreal t)
+{
+    return (qCos(((t * M_PI * 2)) - M_PI_2) + 1) / 2;
+}
+
diff --git a/src/3rdparty/easing/legal.qdoc b/src/3rdparty/easing/legal.qdoc
new file mode 100644
index 0000000..25f67e1
--- /dev/null
+++ b/src/3rdparty/easing/legal.qdoc
@@ -0,0 +1,35 @@
+/*!
+\page legal-easing.html
+\title Easing Equations by Robert Penner
+\ingroup animation
+
+\legalese
+\code
+Copyright (c) 2001 Robert Penner
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the author nor the names of contributors may be used
+      to endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+\endcode
+\endlegalese
+*/
diff --git a/src/corelib/animation/animation.pri b/src/corelib/animation/animation.pri
new file mode 100644
index 0000000..cb7850c
--- /dev/null
+++ b/src/corelib/animation/animation.pri
@@ -0,0 +1,25 @@
+# Qt core animation module
+
+HEADERS += \
+        animation/qabstractanimation.h \
+        animation/qabstractanimation_p.h \
+        animation/qvariantanimation.h \
+        animation/qvariantanimation_p.h \
+        animation/qpropertyanimation.h \
+        animation/qpropertyanimation_p.h \
+        animation/qanimationgroup.h \
+        animation/qanimationgroup_p.h \
+        animation/qsequentialanimationgroup.h \
+        animation/qsequentialanimationgroup_p.h \
+        animation/qparallelanimationgroup.h \
+        animation/qparallelanimationgroup_p.h \
+        animation/qpauseanimation.h
+
+SOURCES += \
+        animation/qabstractanimation.cpp \
+        animation/qvariantanimation.cpp \
+        animation/qpropertyanimation.cpp \
+        animation/qanimationgroup.cpp \
+        animation/qsequentialanimationgroup.cpp \
+        animation/qparallelanimationgroup.cpp \
+        animation/qpauseanimation.cpp
diff --git a/src/corelib/animation/qabstractanimation.cpp b/src/corelib/animation/qabstractanimation.cpp
new file mode 100644
index 0000000..94a94d1
--- /dev/null
+++ b/src/corelib/animation/qabstractanimation.cpp
@@ -0,0 +1,759 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QAbstractAnimation
+    \ingroup animation
+    \brief The QAbstractAnimation class is the base of all animations.
+    \since 4.6
+
+    The class defines the functions for the functionality shared by
+    all animations. By inheriting this class, you can create custom
+    animations that plug into the rest of the animation framework.
+
+    The progress of an animation is given by its current time
+    (currentTime()), which is measured in milliseconds from the start
+    of the animation (0) to its end (duration()). The value is updated
+    automatically while the animation is running. It can also be set
+    directly with setCurrentTime().
+
+    At any point an animation is in one of three states:
+    \l{QAbstractAnimation::}{Running},
+    \l{QAbstractAnimation::}{Stopped}, or
+    \l{QAbstractAnimation::}{Paused}--as defined by the
+    \l{QAbstractAnimation::}{State} enum. The current state can be
+    changed by calling start(), stop(), pause(), or resume(). An
+    animation will always reset its \l{currentTime()}{current time}
+    when it is started. If paused, it will continue with the same
+    current time when resumed. When an animation is stopped, it cannot
+    be resumed, but will keep its current time (until started again).
+    QAbstractAnimation will emit stateChanged() whenever its state
+    changes.
+
+    An animation can loop any number of times by setting the loopCount
+    property. When an animation's current time reaches its duration(),
+    it will reset the current time and keep running. A loop count of 1
+    (the default value) means that the animation will run one time.
+    Note that a duration of -1 means that the animation will run until
+    stopped; the current time will increase indefinitely. When the
+    current time equals duration() and the animation is in its
+    final loop, the \l{QAbstractAnimation::}{Stopped} state is
+    entered, and the finished() signal is emitted.
+
+    QAbstractAnimation provides pure virtual functions used by
+    subclasses to track the progress of the animation: duration() and
+    updateCurrentTime(). The duration() function lets you report a
+    duration for the animation (as discussed above). The current time
+    is delivered by the animation framework through calls to
+    updateCurrentTime(). By reimplementing this function, you can
+    track the animation progress. Note that neither the interval
+    between calls nor the number of calls to this function are
+    defined; though, it will normally be 60 updates per second.
+
+    By reimplementing updateState(), you can track the animation's
+    state changes, which is particularly useful for animations that
+    are not driven by time.
+
+    \sa QVariantAnimation, QPropertyAnimation, QAnimationGroup, {The Animation Framework}
+*/
+
+/*!
+    \enum QAbstractAnimation::DeletionPolicy
+
+    \value KeepWhenStopped The animation will not be deleted when stopped.
+    \value DeleteWhenStopped The animation will be automatically deleted when
+    stopped.
+*/
+
+/*!
+    \fn QAbstractAnimation::finished()
+
+    QAbstractAnimation emits this signal after the animation has stopped and
+    has reached the end.
+
+    This signal is emitted after stateChanged().
+
+    \sa stateChanged()
+*/
+
+/*!
+    \fn QAbstractAnimation::stateChanged(QAbstractAnimation::State oldState, QAbstractAnimation::State newState)
+
+    QAbstractAnimation emits this signal whenever the state of the animation has
+    changed from \a oldState to \a newState. This signal is emitted after the virtual
+    updateState() function is called.
+
+    \sa updateState()
+*/
+
+/*!
+    \fn QAbstractAnimation::currentLoopChanged(int currentLoop)
+
+    QAbstractAnimation emits this signal whenever the current loop
+    changes. \a currentLoop is the current loop.
+
+    \sa currentLoop(), loopCount()
+*/
+
+/*!
+    \fn QAbstractAnimation::directionChanged(QAbstractAnimation::Direction newDirection);
+
+    QAbstractAnimation emits this signal whenever the direction has been
+    changed. \a newDirection is the new direction.
+
+    \sa direction
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qabstractanimation.h"
+#include "qanimationgroup.h"
+#include <QtCore/qdebug.h>
+
+#include "qabstractanimation_p.h"
+
+#include <QtCore/qmath.h>
+#include <QtCore/qthreadstorage.h>
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qpointer.h>
+
+#define DEFAULT_TIMER_INTERVAL 16
+
+QT_BEGIN_NAMESPACE
+
+Q_GLOBAL_STATIC(QThreadStorage<QUnifiedTimer *>, unifiedTimer);
+
+QUnifiedTimer::QUnifiedTimer() : QObject(), lastTick(0), timingInterval(DEFAULT_TIMER_INTERVAL), consistentTiming(false)
+{
+}
+
+QUnifiedTimer *QUnifiedTimer::instance()
+{
+    QUnifiedTimer *inst;
+    if (!unifiedTimer()->hasLocalData()) {
+        inst = new QUnifiedTimer;
+        unifiedTimer()->setLocalData(inst);
+    } else {
+        inst = unifiedTimer()->localData();
+    }
+    return inst;
+}
+
+void QUnifiedTimer::updateRecentlyStartedAnimations()
+{
+    if (animationsToStart.isEmpty())
+        return;
+
+    animations += animationsToStart;
+    updateTimer(); //we make sure we start the timer there
+
+    animationsToStart.clear();
+}
+
+/*
+  defines the timing interval. Default is DEFAULT_TIMER_INTERVAL
+*/
+void QUnifiedTimer::setTimingInterval(int interval)
+{
+    timingInterval = interval;
+    if (animationTimer.isActive()) {
+        //we changed the timing interval
+        animationTimer.start(timingInterval, this);
+    }
+}
+
+/*
+   this allows to have a consistent timer interval at each tick from the timer
+   not taking the real time that passed into account.
+*/
+void QUnifiedTimer::setConsistentTiming(bool b)
+{
+    consistentTiming = b;
+}
+
+int QUnifiedTimer::elapsedTime() const
+{
+    return lastTick;
+}
+
+void QUnifiedTimer::timerEvent(QTimerEvent *event)
+{
+    //this is simply the time we last received a tick
+    const int oldLastTick = lastTick;
+    if (time.isValid())
+        lastTick = consistentTiming ? oldLastTick + timingInterval : time.elapsed();
+
+    //we transfer the waiting animations into the "really running" state
+    updateRecentlyStartedAnimations();
+
+    if (event->timerId() == startStopAnimationTimer.timerId()) {
+        startStopAnimationTimer.stop();
+        if (animations.isEmpty()) {
+            animationTimer.stop();
+            time = QTime();
+        } else {
+            animationTimer.start(timingInterval, this);
+            lastTick = 0;
+            time.start();
+        }
+    } else if (event->timerId() == animationTimer.timerId()) {
+        const int delta = lastTick - oldLastTick;
+        for (int i = 0; i < animations.count(); ++i) {
+            QAbstractAnimation *animation = animations.at(i);
+            int elapsed = QAbstractAnimationPrivate::get(animation)->totalCurrentTime
+                + (animation->direction() == QAbstractAnimation::Forward ? delta : -delta);
+            animation->setCurrentTime(elapsed);
+        }
+    }
+}
+
+void QUnifiedTimer::updateTimer()
+{
+    //we delay the call to start and stop for the animation timer so that if you
+    //stop and start animations in batch you don't stop/start the timer too often.
+    if (!startStopAnimationTimer.isActive())
+        startStopAnimationTimer.start(0, this); // we delay the actual start of the animation
+}
+
+void QUnifiedTimer::registerAnimation(QAbstractAnimation *animation)
+{
+    if (animations.contains(animation) ||animationsToStart.contains(animation))
+        return;
+    animationsToStart << animation;
+    updateTimer();
+}
+
+void QUnifiedTimer::unregisterAnimation(QAbstractAnimation *animation)
+{
+    animations.removeAll(animation);
+    animationsToStart.removeAll(animation);
+    updateTimer();
+}
+
+
+void QAbstractAnimationPrivate::setState(QAbstractAnimation::State newState)
+{
+    Q_Q(QAbstractAnimation);
+    if (state == newState)
+        return;
+
+    QAbstractAnimation::State oldState = state;
+    int oldCurrentTime = currentTime;
+    int oldCurrentLoop = currentLoop;
+    QAbstractAnimation::Direction oldDirection = direction;
+
+    state = newState;
+
+    QPointer<QAbstractAnimation> guard(q);
+
+    guard->updateState(oldState, newState);
+
+    //this is to be safe if updateState changes the state
+    if (state == oldState)
+        return;
+
+    // Notify state change
+    if (guard)
+        emit guard->stateChanged(oldState, newState);
+
+    // Enter running state.
+    switch (state)
+    {
+    case QAbstractAnimation::Paused:
+    case QAbstractAnimation::Running:
+        {
+            // Rewind
+            if (oldState == QAbstractAnimation::Stopped) {
+                if (guard) {
+                    if (direction == QAbstractAnimation::Forward)
+                        q->setCurrentTime(0);
+                    else
+                        q->setCurrentTime(loopCount == -1 ? q->duration() : q->totalDuration());
+                }
+
+                // Check if the setCurrentTime() function called stop().
+                // This can happen for a 0-duration animation
+                if (state == QAbstractAnimation::Stopped)
+                    return;
+            }
+
+            // Register timer if our parent is not running.
+            if (state == QAbstractAnimation::Running && guard) {
+                if (!group || group->state() == QAbstractAnimation::Stopped) {
+                    QUnifiedTimer::instance()->registerAnimation(q);
+                }
+            } else {
+                //new state is paused
+                QUnifiedTimer::instance()->unregisterAnimation(q);
+            }
+        }
+        break;
+    case QAbstractAnimation::Stopped:
+        // Leave running state.
+        int dura = q->duration();
+        if (deleteWhenStopped && guard)
+            q->deleteLater();
+
+        QUnifiedTimer::instance()->unregisterAnimation(q);
+
+        if (dura == -1 || loopCount < 0
+            || (oldDirection == QAbstractAnimation::Forward && (oldCurrentTime * (oldCurrentLoop + 1)) == (dura * loopCount))
+            || (oldDirection == QAbstractAnimation::Backward && oldCurrentTime == 0)) {
+                if (guard)
+                    emit q->finished();
+        }
+        break;
+    }
+
+}
+
+/*!
+    Constructs the QAbstractAnimation base class, and passes \a parent to
+    QObject's constructor.
+
+    \sa QVariantAnimation, QAnimationGroup
+*/
+QAbstractAnimation::QAbstractAnimation(QObject *parent)
+    : QObject(*new QAbstractAnimationPrivate, 0)
+{
+    // Allow auto-add on reparent
+    setParent(parent);
+}
+
+/*!
+    \internal
+*/
+QAbstractAnimation::QAbstractAnimation(QAbstractAnimationPrivate &dd, QObject *parent)
+    : QObject(dd, 0)
+{
+    // Allow auto-add on reparent
+   setParent(parent);
+}
+
+/*!
+    Stops the animation if it's running, then destroys the
+    QAbstractAnimation. If the animation is part of a QAnimationGroup, it is
+    automatically removed before it's destroyed.
+*/
+QAbstractAnimation::~QAbstractAnimation()
+{
+    Q_D(QAbstractAnimation);
+    //we can't call stop here. Otherwise we get pure virtual calls
+    if (d->state != Stopped) {
+        QAbstractAnimation::State oldState = d->state;
+        d->state = Stopped;
+        emit stateChanged(oldState, d->state);
+        QUnifiedTimer::instance()->unregisterAnimation(this);
+    }
+}
+
+/*!
+    \property QAbstractAnimation::state
+    \brief state of the animation.
+
+    This property describes the current state of the animation. When the
+    animation state changes, QAbstractAnimation emits the stateChanged()
+    signal.
+*/
+QAbstractAnimation::State QAbstractAnimation::state() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->state;
+}
+
+/*!
+    If this animation is part of a QAnimationGroup, this function returns a
+    pointer to the group; otherwise, it returns 0.
+
+    \sa QAnimationGroup::addAnimation()
+*/
+QAnimationGroup *QAbstractAnimation::group() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->group;
+}
+
+/*!
+    \enum QAbstractAnimation::State
+
+    This enum describes the state of the animation.
+
+    \value Stopped The animation is not running. This is the initial state
+    of QAbstractAnimation, and the state QAbstractAnimation reenters when finished. The current
+    time remain unchanged until either setCurrentTime() is
+    called, or the animation is started by calling start().
+
+    \value Paused The animation is paused (i.e., temporarily
+    suspended). Calling resume() will resume animation activity.
+
+    \value Running The animation is running. While control is in the event
+    loop, QAbstractAnimation will update its current time at regular intervals,
+    calling updateCurrentTime() when appropriate.
+
+    \sa state(), stateChanged()
+*/
+
+/*!
+    \enum QAbstractAnimation::Direction
+
+    This enum describes the direction of the animation when in \l Running state.
+
+    \value Forward The current time of the animation increases with time (i.e.,
+    moves from 0 and towards the end / duration).
+
+    \value Backward The current time of the animation decreases with time (i.e.,
+    moves from the end / duration and towards 0).
+
+    \sa direction
+*/
+
+/*!
+    \property QAbstractAnimation::direction
+    \brief the direction of the animation when it is in \l Running
+    state.
+
+    This direction indicates whether the time moves from 0 towards the
+    animation duration, or from the value of the duration and towards 0 after
+    start() has been called.
+
+    By default, this property is set to \l Forward.
+*/
+QAbstractAnimation::Direction QAbstractAnimation::direction() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->direction;
+}
+void QAbstractAnimation::setDirection(Direction direction)
+{
+    Q_D(QAbstractAnimation);
+    if (d->direction == direction)
+        return;
+
+    d->direction = direction;
+    if (state() == Stopped) {
+        if (direction == Backward) {
+            d->currentTime = duration();
+            d->currentLoop = d->loopCount - 1;
+        } else {
+            d->currentTime = 0;
+            d->currentLoop = 0;
+        }
+    }
+    updateDirection(direction);
+    emit directionChanged(direction);
+}
+
+/*!
+    \property QAbstractAnimation::duration
+    \brief the duration of the animation.
+
+    If the duration is -1, it means that the duration is undefined.
+    In this case, loopCount is ignored.
+*/
+
+/*!
+    \property QAbstractAnimation::loopCount
+    \brief the loop count of the animation
+
+    This property describes the loop count of the animation as an integer.
+    By default this value is 1, indicating that the animation
+    should run once only, and then stop. By changing it you can let the
+    animation loop several times. With a value of 0, the animation will not
+    run at all, and with a value of -1, the animation will loop forever
+    until stopped.
+    It is not supported to have loop on an animation that has an undefined
+    duration. It will only run once.
+*/
+int QAbstractAnimation::loopCount() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->loopCount;
+}
+void QAbstractAnimation::setLoopCount(int loopCount)
+{
+    Q_D(QAbstractAnimation);
+    d->loopCount = loopCount;
+}
+
+/*!
+    \property QAbstractAnimation::currentLoop
+    \brief the current loop of the animation
+
+    This property describes the current loop of the animation. By default,
+    the animation's loop count is 1, and so the current loop will
+    always be 0. If the loop count is 2 and the animation runs past its
+    duration, it will automatically rewind and restart at current time 0, and
+    current loop 1, and so on.
+
+    When the current loop changes, QAbstractAnimation emits the
+    currentLoopChanged() signal.
+*/
+int QAbstractAnimation::currentLoop() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->currentLoop;
+}
+
+/*!
+    \fn virtual int QAbstractAnimation::duration() const = 0
+
+    This pure virtual function returns the duration of the animation, and
+    defines for how long QAbstractAnimation should update the current
+    time. This duration is local, and does not include the loop count.
+
+    A return value of -1 indicates that the animation has no defined duration;
+    the animation should run forever until stopped. This is useful for
+    animations that are not time driven, or where you cannot easily predict
+    its duration (e.g., event driven audio playback in a game).
+
+    If the animation is a parallel QAnimationGroup, the duration will be the longest
+    duration of all its animations. If the animation is a sequential QAnimationGroup,
+    the duration will be the sum of the duration of all its animations.
+    \sa loopCount
+*/
+
+/*!
+    Returns the total and effective duration of the animation, including the
+    loop count.
+
+    \sa duration(), currentTime
+*/
+int QAbstractAnimation::totalDuration() const
+{
+    Q_D(const QAbstractAnimation);
+    if (d->loopCount < 0)
+        return -1;
+    int dura = duration();
+    if (dura == -1)
+        return -1;
+    return dura * d->loopCount;
+}
+
+/*!
+    \property QAbstractAnimation::currentTime
+    \brief the current time and progress of the animation
+
+    This property describes the animation's current time. You can change the
+    current time by calling setCurrentTime, or you can call start() and let
+    the animation run, setting the current time automatically as the animation
+    progresses.
+
+    The animation's current time starts at 0, and ends at duration(). If the
+    animation's loopCount is larger than 1, the current time will rewind and
+    start at 0 again for the consecutive loops. If the animation has a pause.
+    currentTime will also include the duration of the pause.
+
+    \sa loopCount
+ */
+int QAbstractAnimation::currentTime() const
+{
+    Q_D(const QAbstractAnimation);
+    return d->currentTime;
+}
+void QAbstractAnimation::setCurrentTime(int msecs)
+{
+    Q_D(QAbstractAnimation);
+    msecs = qMax(msecs, 0);
+
+    // Calculate new time and loop.
+    int dura = duration();
+    int totalDura = (d->loopCount < 0 || dura == -1) ? -1 : dura * d->loopCount;
+    if (totalDura != -1)
+        msecs = qMin(totalDura, msecs);
+    d->totalCurrentTime = msecs;
+
+    // Update new values.
+    int oldLoop = d->currentLoop;
+    d->currentLoop = ((dura <= 0) ? 0 : (msecs / dura));
+    if (d->currentLoop == d->loopCount) {
+        //we're at the end
+        d->currentTime = qMax(0, dura);
+        d->currentLoop = qMax(0, d->loopCount - 1);
+    } else {
+        if (d->direction == Forward) {
+            d->currentTime = (dura <= 0) ? msecs : (msecs % dura);
+        } else {
+            d->currentTime = (dura <= 0) ? msecs : ((msecs - 1) % dura) + 1;
+            if (d->currentTime == dura)
+                --d->currentLoop;
+        }
+    }
+
+    updateCurrentTime(msecs);
+    if (d->currentLoop != oldLoop)
+        emit currentLoopChanged(d->currentLoop);
+
+    // All animations are responsible for stopping the animation when their
+    // own end state is reached; in this case the animation is time driven,
+    // and has reached the end.
+    if ((d->direction == Forward && d->totalCurrentTime == totalDura)
+        || (d->direction == Backward && d->totalCurrentTime == 0)) {
+        stop();
+    }
+}
+
+/*!
+    Starts the animation. The \a policy argument says whether or not the
+    animation should be deleted when it's done. When the animation starts, the
+    stateChanged() signal is emitted, and state() returns Running. When control
+    reaches the event loop, the animation will run by itself, periodically
+    calling updateCurrentTime() as the animation progresses.
+
+    If the animation is currently stopped or has already reached the end,
+    calling start() will rewind the animation and start again from the beginning.
+    When the animation reaches the end, the animation will either stop, or
+    if the loop level is more than 1, it will rewind and continue from the beginning.
+
+    If the animation is already running, this function does nothing.
+
+    \sa stop(), state()
+*/
+void QAbstractAnimation::start(DeletionPolicy policy)
+{
+    Q_D(QAbstractAnimation);
+    if (d->state == Running)
+        return;
+    d->setState(Running);
+    d->deleteWhenStopped = policy;
+}
+
+/*!
+    Stops the animation. When the animation is stopped, it emits the stateChanged()
+    signal, and state() returns Stopped. The current time is not changed.
+
+    If the animation stops by itself after reaching the end (i.e.,
+    currentTime() == duration() and currentLoop() > loopCount() - 1), the
+    finished() signal is emitted.
+
+    \sa start(), state()
+ */
+void QAbstractAnimation::stop()
+{
+    Q_D(QAbstractAnimation);
+
+    d->setState(Stopped);
+}
+
+/*!
+    Pauses the animation. When the animation is paused, state() returns Paused.
+    The currenttime will remain unchanged until resume() or start() is called.
+    If you want to continue from the current time, call resume().
+
+
+    \sa start(), state(), resume()
+ */
+void QAbstractAnimation::pause()
+{
+    Q_D(QAbstractAnimation);
+    if (d->state == Stopped) {
+        qWarning("QAbstractAnimation::pause: Cannot pause a stopped animation");
+        return;
+    }
+
+    d->setState(Paused);
+}
+
+/*!
+    Resumes the animation after it was paused. When the animation is resumed,
+    it emits the resumed() and stateChanged() signals. The currenttime is not
+    changed.
+
+    \sa start(), pause(), state()
+ */
+void QAbstractAnimation::resume()
+{
+    Q_D(QAbstractAnimation);
+    if (d->state != Paused) {
+        qWarning("QAbstractAnimation::resume: "
+                 "Cannot resume an animation that is not paused");
+        return;
+    }
+
+    d->setState(Running);
+}
+
+/*!
+    \reimp
+*/
+bool QAbstractAnimation::event(QEvent *event)
+{
+    return QObject::event(event);
+}
+
+/*!
+    \fn virtual void QAbstractAnimation::updateCurrentTime(int msecs) = 0;
+
+    This pure virtual function is called every time the animation's current
+    time changes. The \a msecs argument is the current time.
+
+    \sa updateState()
+*/
+
+/*!
+    This virtual function is called by QAbstractAnimation when the state
+    of the animation is changed from \a oldState to \a newState.
+
+    \sa start(), stop(), pause(), resume()
+*/
+void QAbstractAnimation::updateState(QAbstractAnimation::State oldState,
+                                     QAbstractAnimation::State newState)
+{
+    Q_UNUSED(oldState);
+    Q_UNUSED(newState);
+}
+
+/*!
+    This virtual function is called by QAbstractAnimation when the direction
+    of the animation is changed. The \a direction argument is the new direction.
+
+    \sa setDirection(), direction()
+*/
+void QAbstractAnimation::updateDirection(QAbstractAnimation::Direction direction)
+{
+    Q_UNUSED(direction);
+}
+
+
+QT_END_NAMESPACE
+
+#include "moc_qabstractanimation.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qabstractanimation.h b/src/corelib/animation/qabstractanimation.h
new file mode 100644
index 0000000..d6d50dc
--- /dev/null
+++ b/src/corelib/animation/qabstractanimation.h
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTANIMATION_H
+#define QABSTRACTANIMATION_H
+
+#include <QtCore/qobject.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QAnimationGroup;
+class QSequentialAnimationGroup;
+
+class QAbstractAnimationPrivate;
+class Q_CORE_EXPORT QAbstractAnimation : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(State state READ state NOTIFY stateChanged)
+    Q_PROPERTY(int loopCount READ loopCount WRITE setLoopCount)
+    Q_PROPERTY(int currentTime READ currentTime WRITE setCurrentTime)
+    Q_PROPERTY(int currentLoop READ currentLoop NOTIFY currentLoopChanged)
+    Q_PROPERTY(Direction direction READ direction WRITE setDirection NOTIFY directionChanged)
+    Q_PROPERTY(int duration READ duration)
+
+public:
+    enum Direction {
+        Forward,
+        Backward
+    };
+
+    enum State {
+        Stopped,
+        Paused,
+        Running
+    };
+
+    enum DeletionPolicy {
+        KeepWhenStopped = 0,
+        DeleteWhenStopped
+    };
+
+    QAbstractAnimation(QObject *parent = 0);
+    virtual ~QAbstractAnimation();
+
+    State state() const;
+
+    QAnimationGroup *group() const;
+
+    Direction direction() const;
+    void setDirection(Direction direction);
+
+    int loopCount() const;
+    void setLoopCount(int loopCount);
+    int currentLoop() const;
+
+    virtual int duration() const = 0;
+    int totalDuration() const;
+
+    int currentTime() const;
+
+Q_SIGNALS:
+    void finished();
+    void stateChanged(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void currentLoopChanged(int currentLoop);
+    void directionChanged(QAbstractAnimation::Direction);
+
+public Q_SLOTS:
+    void start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped);
+    void pause();
+    void resume();
+    void stop();
+    void setCurrentTime(int msecs);
+
+protected:
+    QAbstractAnimation(QAbstractAnimationPrivate &dd, QObject *parent = 0);
+    bool event(QEvent *event);
+
+    virtual void updateCurrentTime(int msecs) = 0;
+    virtual void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    virtual void updateDirection(QAbstractAnimation::Direction direction);
+
+private:
+    Q_DISABLE_COPY(QAbstractAnimation)
+    Q_DECLARE_PRIVATE(QAbstractAnimation)
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QABSTRACTANIMATION_H
diff --git a/src/corelib/animation/qabstractanimation_p.h b/src/corelib/animation/qabstractanimation_p.h
new file mode 100644
index 0000000..e64554c
--- /dev/null
+++ b/src/corelib/animation/qabstractanimation_p.h
@@ -0,0 +1,136 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTANIMATION_P_H
+#define QABSTRACTANIMATION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qbasictimer.h>
+#include <QtCore/qdatetime.h>
+#include <QtCore/qtimer.h>
+#include <private/qobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QAnimationGroup;
+class QAbstractAnimation;
+class QAbstractAnimationPrivate : public QObjectPrivate
+{
+public:
+    QAbstractAnimationPrivate()
+        : state(QAbstractAnimation::Stopped),
+          direction(QAbstractAnimation::Forward),
+          deleteWhenStopped(false),
+          totalCurrentTime(0),
+          currentTime(0),
+          loopCount(1),
+          currentLoop(0),
+          group(0)
+    {
+    }
+
+    virtual ~QAbstractAnimationPrivate() {}
+
+    static QAbstractAnimationPrivate *get(QAbstractAnimation *q)
+    {
+        return q->d_func();
+    }
+
+    QAbstractAnimation::State state;
+    QAbstractAnimation::Direction direction;
+    bool deleteWhenStopped;
+    void setState(QAbstractAnimation::State state);
+
+    int totalCurrentTime;
+    int currentTime;
+    int loopCount;
+    int currentLoop;
+
+    QAnimationGroup *group;
+
+private:
+    Q_DECLARE_PUBLIC(QAbstractAnimation)
+};
+
+
+class Q_CORE_EXPORT QUnifiedTimer : public QObject
+{
+private:
+    QUnifiedTimer();
+
+public:
+    static QUnifiedTimer *instance();
+
+    void registerAnimation(QAbstractAnimation *animation);
+    void unregisterAnimation(QAbstractAnimation *animation);
+
+    void setTimingInterval(int interval);
+    void setConsistentTiming(bool consistent);
+
+    int elapsedTime() const;
+
+protected:
+    void timerEvent(QTimerEvent *);
+    void updateTimer();
+
+private:
+    void updateRecentlyStartedAnimations();
+
+    QBasicTimer animationTimer, startStopAnimationTimer;
+    QTime time;
+    int lastTick;
+    int timingInterval;
+    bool consistentTiming;
+    QList<QAbstractAnimation*> animations, animationsToStart;
+};
+
+QT_END_NAMESPACE
+#endif
diff --git a/src/corelib/animation/qanimationgroup.cpp b/src/corelib/animation/qanimationgroup.cpp
new file mode 100644
index 0000000..ed06eff
--- /dev/null
+++ b/src/corelib/animation/qanimationgroup.cpp
@@ -0,0 +1,309 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QAnimationGroup
+    \brief The QAnimationGroup class is an abstract base class for groups of animations.
+    \since 4.6
+    \ingroup animation
+
+    An animation group is a container for animations (subclasses of
+    QAbstractAnimation). A group is usually responsible for managing
+    the \l{QAbstractAnimation::State}{state} of its animations, i.e.,
+    it decides when to start, stop, resume, and pause them. Currently,
+    Qt provides two such groups: QParallelAnimationGroup and
+    QSequentialAnimationGroup. Look up their class descriptions for
+    details.
+
+    Since QAnimationGroup inherits from QAbstractAnimation, you can
+    combine groups, and easily construct complex animation graphs.
+    You can query QAbstractAnimation for the group it belongs to
+    (using the \l{QAbstractAnimation::}{group()} function).
+
+    To start a top-level animation group, you simply use the
+    \l{QAbstractAnimation::}{start()} function from
+    QAbstractAnimation. By a top-level animation group, we think of a
+    group that itself is not contained within another group. Starting
+    sub groups directly is not supported, and may lead to unexpected
+    behavior.
+
+    \omit OK, we'll put in a snippet on this here \endomit
+
+    QAnimationGroup provides methods for adding and retrieving
+    animations. Besides that, you can remove animations by calling
+    remove(), and clear the animation group by calling
+    clearAnimations(). You may keep track of changes in the group's
+    animations by listening to QEvent::ChildAdded and
+    QEvent::ChildRemoved events.
+
+    \omit OK, let's find a snippet here as well. \endomit
+
+    QAnimationGroup takes ownership of the animations it manages, and
+    ensures that they are deleted when the animation group is deleted.
+
+    You can also use a \l{The State Machine Framework}{state machine}
+    to create complex animations. The framework provides a special
+    state, QAnimationState, that plays an animation upon entry and
+    transitions to a new state when the animation has finished
+    playing. This technique can also be combined with using animation
+    groups.
+
+    \sa QAbstractAnimation, QVariantAnimation, {The Animation Framework}
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qanimationgroup.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qcoreevent.h>
+#include "qanimationgroup_p.h"
+
+QT_BEGIN_NAMESPACE
+
+
+/*!
+    Constructs a QAnimationGroup.
+    \a parent is passed to QObject's constructor.
+*/
+QAnimationGroup::QAnimationGroup(QObject *parent)
+    : QAbstractAnimation(*new QAnimationGroupPrivate, parent)
+{
+}
+
+/*!
+    \internal
+*/
+QAnimationGroup::QAnimationGroup(QAnimationGroupPrivate &dd, QObject *parent)
+    : QAbstractAnimation(dd, parent)
+{
+}
+
+/*!
+    Destroys the animation group. It will also destroy all its animations.
+*/
+QAnimationGroup::~QAnimationGroup()
+{
+}
+
+/*!
+    Returns a pointer to the animation at \a index in this group. This
+    function is useful when you need access to a particular animation.  \a
+    index is between 0 and animationCount() - 1.
+
+    \sa animationCount(), indexOfAnimation()
+*/
+QAbstractAnimation *QAnimationGroup::animationAt(int index) const
+{
+    Q_D(const QAnimationGroup);
+
+    if (index < 0 || index >= d->animations.size()) {
+        qWarning("QAnimationGroup::animationAt: index is out of bounds");
+        return 0;
+    }
+
+    return d->animations.at(index);
+}
+
+
+/*!
+    Returns the number of animations managed by this group.
+
+    \sa indexOfAnimation(), addAnimation(), animationAt()
+*/
+int QAnimationGroup::animationCount() const
+{
+    Q_D(const QAnimationGroup);
+    return d->animations.size();
+}
+
+/*!
+    Returns the index of \a animation. The returned index can be passed
+    to the other functions that take an index as an argument.
+
+    \sa insertAnimationAt(), animationAt(), takeAnimationAt()
+*/
+int QAnimationGroup::indexOfAnimation(QAbstractAnimation *animation) const
+{
+    Q_D(const QAnimationGroup);
+    return d->animations.indexOf(animation);
+}
+
+/*!
+    Adds \a animation to this group. This will call insertAnimationAt with
+    index equals to animationCount().
+
+    \note The group takes ownership of the animation.
+
+    \sa removeAnimation()
+*/
+void QAnimationGroup::addAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QAnimationGroup);
+    insertAnimationAt(d->animations.count(), animation);
+}
+
+/*!
+    Inserts \a animation into this animation group at \a index.
+    If \a index is 0 the animation is inserted at the beginning.
+    If \a index is animationCount(), the animation is inserted at the end.
+
+    \note The group takes ownership of the animation.
+
+    \sa takeAnimationAt(), addAnimation(), indexOfAnimation(), removeAnimation()
+*/
+void QAnimationGroup::insertAnimationAt(int index, QAbstractAnimation *animation)
+{
+    Q_D(QAnimationGroup);
+
+    if (index < 0 || index > d->animations.size()) {
+        qWarning("QAnimationGroup::insertAnimationAt: index is out of bounds");
+        return;
+    }
+
+    if (QAnimationGroup *oldGroup = animation->group())
+        oldGroup->removeAnimation(animation);
+
+    d->animations.insert(index, animation);
+    QAbstractAnimationPrivate::get(animation)->group = this;
+    // this will make sure that ChildAdded event is sent to 'this'
+    animation->setParent(this);
+    d->animationInsertedAt(index);
+}
+
+/*!
+    Removes \a animation from this group. The ownership of \a animation is
+    transferred to the caller.
+
+    \sa takeAnimationAt(), insertAnimationAt(), addAnimation()
+*/
+void QAnimationGroup::removeAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QAnimationGroup);
+
+    if (!animation) {
+        qWarning("QAnimationGroup::remove: cannot remove null animation");
+        return;
+    }
+    int index = d->animations.indexOf(animation);
+    if (index == -1) {
+        qWarning("QAnimationGroup::remove: animation is not part of this group");
+        return;
+    }
+
+    takeAnimationAt(index);
+}
+
+/*!
+    Returns the animation at \a index and removes it from the animation group.
+
+    \note The ownership of the animation is transferred to the caller.
+
+    \sa removeAnimation(), addAnimation(), insertAnimation(), indexOfAnimation()
+*/
+QAbstractAnimation *QAnimationGroup::takeAnimationAt(int index)
+{
+    Q_D(QAnimationGroup);
+    if (index < 0 || index >= d->animations.size()) {
+        qWarning("QAnimationGroup::takeAnimationAt: no animation at index %d", index);
+        return 0;
+    }
+    QAbstractAnimation *animation = d->animations.at(index);
+    QAbstractAnimationPrivate::get(animation)->group = 0;
+    // ### removing from list before doing setParent to avoid inifinite recursion
+    // in ChildRemoved event
+    d->animations.removeAt(index);
+    animation->setParent(0);
+    d->animationRemovedAt(index);
+    return animation;
+}
+
+/*!
+    Removes and deletes all animations in this animation group, and resets the current
+    time to 0.
+
+    \sa addAnimation(), removeAnimation()
+*/
+void QAnimationGroup::clearAnimations()
+{
+    Q_D(QAnimationGroup);
+    qDeleteAll(d->animations);
+}
+
+/*!
+    \reimp
+*/
+bool QAnimationGroup::event(QEvent *event)
+{
+    Q_D(QAnimationGroup);
+    if (event->type() == QEvent::ChildAdded) {
+        QChildEvent *childEvent = static_cast<QChildEvent *>(event);
+        if (QAbstractAnimation *a = qobject_cast<QAbstractAnimation *>(childEvent->child())) {
+            if (a->group() != this)
+                addAnimation(a);
+        }
+    } else if (event->type() == QEvent::ChildRemoved) {
+        QChildEvent *childEvent = static_cast<QChildEvent *>(event);
+        QAbstractAnimation *a = static_cast<QAbstractAnimation *>(childEvent->child());
+        // You can only rely on the child being a QObject because in the QEvent::ChildRemoved
+        // case it might be called from the destructor.
+        int index = d->animations.indexOf(a);
+        if (index != -1)
+            takeAnimationAt(index);
+    }
+    return QAbstractAnimation::event(event);
+}
+
+
+void QAnimationGroupPrivate::animationRemovedAt(int index)
+{
+    Q_Q(QAnimationGroup);
+    Q_UNUSED(index);
+    if (animations.isEmpty()) {
+        currentTime = 0;
+        q->stop();
+    }
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qanimationgroup.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qanimationgroup.h b/src/corelib/animation/qanimationgroup.h
new file mode 100644
index 0000000..263bc38
--- /dev/null
+++ b/src/corelib/animation/qanimationgroup.h
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANIMATIONGROUP_H
+#define QANIMATIONGROUP_H
+
+#include <QtCore/qabstractanimation.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QAnimationGroupPrivate;
+class Q_CORE_EXPORT QAnimationGroup : public QAbstractAnimation
+{
+    Q_OBJECT
+
+public:
+    QAnimationGroup(QObject *parent = 0);
+    ~QAnimationGroup();
+
+    QAbstractAnimation *animationAt(int index) const;
+    int animationCount() const;
+    int indexOfAnimation(QAbstractAnimation *animation) const;
+    void addAnimation(QAbstractAnimation *animation);
+    void insertAnimationAt(int index, QAbstractAnimation *animation);
+    void removeAnimation(QAbstractAnimation *animation);
+    QAbstractAnimation *takeAnimationAt(int index);
+    void clearAnimations();
+
+protected:
+    QAnimationGroup(QAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+
+private:
+    Q_DISABLE_COPY(QAnimationGroup)
+    Q_DECLARE_PRIVATE(QAnimationGroup)
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif //QANIMATIONGROUP_H
diff --git a/src/corelib/animation/qanimationgroup_p.h b/src/corelib/animation/qanimationgroup_p.h
new file mode 100644
index 0000000..a7bd0fa
--- /dev/null
+++ b/src/corelib/animation/qanimationgroup_p.h
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANIMATIONGROUP_P_H
+#define QANIMATIONGROUP_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qanimationgroup.h"
+
+#include <QtCore/qlist.h>
+
+#include "qabstractanimation_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QAnimationGroupPrivate : public QAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QAnimationGroup)
+public:
+    QAnimationGroupPrivate()
+    { }
+
+    virtual void animationInsertedAt(int index) { Q_UNUSED(index) };
+    virtual void animationRemovedAt(int index);
+
+    QList<QAbstractAnimation *> animations;
+};
+
+QT_END_NAMESPACE
+
+#endif //QANIMATIONGROUP_P_H
diff --git a/src/corelib/animation/qparallelanimationgroup.cpp b/src/corelib/animation/qparallelanimationgroup.cpp
new file mode 100644
index 0000000..13f6073
--- /dev/null
+++ b/src/corelib/animation/qparallelanimationgroup.cpp
@@ -0,0 +1,316 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QParallelAnimationGroup
+    \brief The QParallelAnimationGroup class provides a parallel group of animations.
+    \since 4.6
+    \ingroup animation
+
+    QParallelAnimationGroup--a \l{QAnimationGroup}{container for
+    animations}--starts all its animations when it is
+    \l{QAbstractAnimation::start()}{started} itself, i.e., runs all
+    animations in parallel. The animation group finishes when the
+    longest lasting animation has finished.
+
+    You can treat QParallelAnimation as any other QAbstractAnimation,
+    e.g., pause, resume, or add it to other animation groups.
+
+    \code
+        QParallelAnimationGroup *group = new QParallelAnimationGroup;
+        group->addAnimation(anim1);
+        group->addAnimation(anim2);
+
+        group->start();
+    \endcode
+
+    In this example, \c anim1 and \c anim2 are two
+    \l{QPropertyAnimation}s that have already been set up.
+
+    \sa QAnimationGroup, QPropertyAnimation, {The Animation Framework}
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qparallelanimationgroup.h"
+#include "qparallelanimationgroup_p.h"
+//#define QANIMATION_DEBUG
+QT_BEGIN_NAMESPACE
+
+/*!
+    Constructs a QParallelAnimationGroup.
+    \a parent is passed to QObject's constructor.
+*/
+QParallelAnimationGroup::QParallelAnimationGroup(QObject *parent)
+    : QAnimationGroup(*new QParallelAnimationGroupPrivate, parent)
+{
+}
+
+/*!
+    \internal
+*/
+QParallelAnimationGroup::QParallelAnimationGroup(QParallelAnimationGroupPrivate &dd,
+                                                 QObject *parent)
+    : QAnimationGroup(dd, parent)
+{
+}
+
+/*!
+    Destroys the animation group. It will also destroy all its animations.
+*/
+QParallelAnimationGroup::~QParallelAnimationGroup()
+{
+}
+
+/*!
+    \reimp
+*/
+int QParallelAnimationGroup::duration() const
+{
+    Q_D(const QParallelAnimationGroup);
+    int ret = 0;
+
+    for (int i = 0; i < d->animations.size(); ++i) {
+        QAbstractAnimation *animation = d->animations.at(i);
+        const int currentDuration = animation->totalDuration();
+        if (currentDuration == -1)
+            return -1; // Undetermined length
+
+        ret = qMax(ret, currentDuration);
+    }
+
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+void QParallelAnimationGroup::updateCurrentTime(int)
+{
+    Q_D(QParallelAnimationGroup);
+    if (d->animations.isEmpty())
+        return;
+
+    if (d->currentLoop > d->lastLoop) {
+        // simulate completion of the loop
+        int dura = duration();
+        if (dura > 0) {
+            foreach (QAbstractAnimation *animation, d->animations) {
+                animation->setCurrentTime(dura);   // will stop
+            }
+        }
+    } else if (d->currentLoop < d->lastLoop) {
+        // simulate completion of the loop seeking backwards
+        foreach (QAbstractAnimation *animation, d->animations) {
+            animation->setCurrentTime(0);
+            animation->stop();
+        }
+    }
+
+    bool timeFwd = ((d->currentLoop == d->lastLoop && d->currentTime >= d->lastCurrentTime)
+                   || d->currentLoop > d->lastLoop);
+#ifdef QANIMATION_DEBUG
+    qDebug("QParallellAnimationGroup %5d: setCurrentTime(%d), loop:%d, last:%d, timeFwd:%d, lastcurrent:%d, %d",
+        __LINE__, d->currentTime, d->currentLoop, d->lastLoop, timeFwd, d->lastCurrentTime, state());
+#endif
+    // finally move into the actual time of the current loop
+    foreach (QAbstractAnimation *animation, d->animations) {
+        const int dura = animation->totalDuration();
+        if (dura == -1 && d->isUncontrolledAnimationFinished(animation))
+            continue;
+        if (dura == -1 || (d->currentTime <= dura && dura != 0)
+            || (dura == 0 && d->currentLoop != d->lastLoop)) {
+            switch (state()) {
+            case Running:
+                animation->start();
+                break;
+            case Paused:
+                animation->pause();
+                break;
+            case Stopped:
+            default:
+                break;
+            }
+        }
+
+        if (dura <= 0) {
+            if (dura == -1)
+                animation->setCurrentTime(d->currentTime);
+            continue;
+        }
+
+        if ((timeFwd && d->lastCurrentTime <= dura)
+            || (!timeFwd && d->currentTime <= dura))
+                animation->setCurrentTime(d->currentTime);
+        if (d->currentTime > dura)
+            animation->stop();
+    }
+    d->lastLoop = d->currentLoop;
+    d->lastCurrentTime = d->currentTime;
+}
+
+/*!
+    \reimp
+*/
+void QParallelAnimationGroup::updateState(QAbstractAnimation::State oldState,
+                                          QAbstractAnimation::State newState)
+{
+    Q_D(QParallelAnimationGroup);
+    QAnimationGroup::updateState(oldState, newState);
+
+    switch (newState) {
+    case Stopped:
+        foreach (QAbstractAnimation *animation, d->animations)
+            animation->stop();
+        d->disconnectUncontrolledAnimations();
+        break;
+    case Paused:
+        foreach (QAbstractAnimation *animation, d->animations)
+            animation->pause();
+        break;
+    case Running:
+        d->connectUncontrolledAnimations();
+        foreach (QAbstractAnimation *animation, d->animations) {
+            animation->stop();
+            animation->setDirection(d->direction);
+            animation->start();
+        }
+        break;
+    }
+}
+
+void QParallelAnimationGroupPrivate::_q_uncontrolledAnimationFinished()
+{
+    Q_Q(QParallelAnimationGroup);
+
+    QAbstractAnimation *animation = qobject_cast<QAbstractAnimation *>(q->sender());
+    Q_ASSERT(animation);
+
+    int uncontrolledRunningCount = 0;
+    if (animation->duration() == -1 || animation->loopCount() < 0) {
+        QHash<QAbstractAnimation *, int>::iterator it = uncontrolledFinishTime.begin();
+        while (it != uncontrolledFinishTime.end()) {
+            if (it.key() == animation) {
+                *it = animation->currentTime();
+            }
+            if (it.value() == -1)
+                ++uncontrolledRunningCount;
+            ++it;
+        }
+    }
+
+    if (uncontrolledRunningCount > 0)
+        return;
+
+    int maxDuration = 0;
+    foreach (QAbstractAnimation *a, animations)
+        maxDuration = qMax(maxDuration, a->totalDuration());
+
+    if (currentTime >= maxDuration)
+        q->stop();
+}
+
+void QParallelAnimationGroupPrivate::disconnectUncontrolledAnimations()
+{
+    Q_Q(QParallelAnimationGroup);
+
+    QHash<QAbstractAnimation *, int>::iterator it = uncontrolledFinishTime.begin();
+    while (it != uncontrolledFinishTime.end()) {
+        QObject::disconnect(it.key(), SIGNAL(finished()), q, SLOT(_q_uncontrolledAnimationFinished()));
+        ++it;
+    }
+
+    uncontrolledFinishTime.clear();
+}
+
+void QParallelAnimationGroupPrivate::connectUncontrolledAnimations()
+{
+    Q_Q(QParallelAnimationGroup);
+
+    foreach (QAbstractAnimation *animation, animations) {
+        if (animation->duration() == -1 || animation->loopCount() < 0) {
+            uncontrolledFinishTime[animation] = -1;
+            QObject::connect(animation, SIGNAL(finished()), q, SLOT(_q_uncontrolledAnimationFinished()));
+        }
+    }
+}
+
+bool QParallelAnimationGroupPrivate::isUncontrolledAnimationFinished(QAbstractAnimation *anim) const
+{
+    return uncontrolledFinishTime.value(anim, -1) >= 0;
+}
+
+/*!
+    \reimp
+*/
+void QParallelAnimationGroup::updateDirection(QAbstractAnimation::Direction direction)
+{
+    Q_D(QParallelAnimationGroup);
+    //we need to update the direction of the current animation
+    if (state() != Stopped) {
+        foreach(QAbstractAnimation *anim, d->animations) {
+            anim->setDirection(direction);
+        }
+    } else {
+        if (direction == Forward) {
+            d->lastLoop = 0;
+            d->lastCurrentTime = 0;
+        } else {
+            // Looping backwards with loopCount == -1 does not really work well...
+            d->lastLoop = (d->loopCount == -1 ? 0 : d->loopCount - 1);
+            d->lastCurrentTime = duration();
+        }
+    }
+}
+
+/*!
+    \reimp
+*/
+bool QParallelAnimationGroup::event(QEvent *event)
+{
+    return QAnimationGroup::event(event);
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qparallelanimationgroup.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qparallelanimationgroup.h b/src/corelib/animation/qparallelanimationgroup.h
new file mode 100644
index 0000000..57a8146
--- /dev/null
+++ b/src/corelib/animation/qparallelanimationgroup.h
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPARALLELANIMATIONGROUP_H
+#define QPARALLELANIMATIONGROUP_H
+
+#include <QtCore/qanimationgroup.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QParallelAnimationGroupPrivate;
+class Q_CORE_EXPORT QParallelAnimationGroup : public QAnimationGroup
+{
+    Q_OBJECT
+
+public:
+    QParallelAnimationGroup(QObject *parent = 0);
+    ~QParallelAnimationGroup();
+
+    int duration() const;
+
+protected:
+    QParallelAnimationGroup(QParallelAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+
+    void updateCurrentTime(int msecs);
+    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void updateDirection(QAbstractAnimation::Direction direction);
+
+private:
+    Q_DISABLE_COPY(QParallelAnimationGroup)
+    Q_DECLARE_PRIVATE(QParallelAnimationGroup)
+    Q_PRIVATE_SLOT(d_func(), void _q_uncontrolledAnimationFinished())
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPARALLELANIMATIONGROUP
diff --git a/src/corelib/animation/qparallelanimationgroup_p.h b/src/corelib/animation/qparallelanimationgroup_p.h
new file mode 100644
index 0000000..f36d972
--- /dev/null
+++ b/src/corelib/animation/qparallelanimationgroup_p.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPARALLELANIMATIONGROUP_P_H
+#define QPARALLELANIMATIONGROUP_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qparallelanimationgroup.h"
+#include "qanimationgroup_p.h"
+#include <QtCore/QHash>
+
+QT_BEGIN_NAMESPACE
+
+class QParallelAnimationGroupPrivate : public QAnimationGroupPrivate
+{
+    Q_DECLARE_PUBLIC(QParallelAnimationGroup)
+public:
+    QParallelAnimationGroupPrivate()
+        : lastLoop(0), lastCurrentTime(0)
+    {
+    }
+
+    QHash<QAbstractAnimation*, int> uncontrolledFinishTime;
+    int lastLoop;
+    int lastCurrentTime;
+
+    bool isUncontrolledAnimationFinished(QAbstractAnimation *anim) const;
+    void connectUncontrolledAnimations();
+    void disconnectUncontrolledAnimations();
+
+    // private slot
+    void _q_uncontrolledAnimationFinished();
+};
+
+QT_END_NAMESPACE
+
+#endif //QPARALLELANIMATIONGROUP_P_H
diff --git a/src/corelib/animation/qpauseanimation.cpp b/src/corelib/animation/qpauseanimation.cpp
new file mode 100644
index 0000000..b175f0c
--- /dev/null
+++ b/src/corelib/animation/qpauseanimation.cpp
@@ -0,0 +1,154 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QPauseAnimation
+    \brief The QPauseAnimation class provides a pause for QSequentialAnimationGroup.
+    \since 4.6
+    \ingroup animation
+
+    If you wish to introduce a delay between animations in a
+    QSequentialAnimationGroup, you can insert a QPauseAnimation. This
+    class does not animate anything, but does not
+    \l{QAbstractAnimation::finished()}{finish} before a specified
+    number of milliseconds have elapsed from when it was started. You
+    specify the duration of the pause in the constructor. It can also
+    be set directly with setDuration().
+
+    It is not necessary to construct a QPauseAnimation yourself.
+    QSequentialAnimationGroup provides the convenience functions
+    \l{QSequentialAnimationGroup::}{addPause()} and
+    \l{QSequentialAnimationGroup::}{insertPauseAt()}. These functions
+    simply take the number of milliseconds the pause should last.
+
+    \sa QSequentialAnimationGroup
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qpauseanimation.h"
+#include "qabstractanimation_p.h"
+
+
+QT_BEGIN_NAMESPACE
+
+class QPauseAnimationPrivate : public QAbstractAnimationPrivate
+{
+public:
+    QPauseAnimationPrivate() : QAbstractAnimationPrivate(), duration(0)
+    {
+    }
+
+    int duration;
+};
+
+/*!
+    Constructs a QPauseAnimation.
+    \a parent is passed to QObject's constructor.
+    The default duration is 0.
+*/
+
+QPauseAnimation::QPauseAnimation(QObject *parent) : QAbstractAnimation(*new QPauseAnimationPrivate, parent)
+{
+}
+
+/*!
+    Constructs a QPauseAnimation.
+    \a msecs is the duration of the pause.
+    \a parent is passed to QObject's constructor.
+*/
+
+QPauseAnimation::QPauseAnimation(int msecs, QObject *parent) : QAbstractAnimation(*new QPauseAnimationPrivate, parent)
+{
+    setDuration(msecs);
+}
+
+/*!
+    Destroys the pause animation.
+*/
+QPauseAnimation::~QPauseAnimation()
+{
+}
+
+/*!
+    \property QPauseAnimation::duration
+    \brief the duration of the pause.
+
+    The duration of the pause. The duration should not be negative.
+*/
+int QPauseAnimation::duration() const
+{
+    Q_D(const QPauseAnimation);
+    return d->duration;
+}
+
+void QPauseAnimation::setDuration(int msecs)
+{
+    if (msecs < 0) {
+        qWarning("QPauseAnimation::setDuration: cannot set a negative duration");
+        return;
+    }
+    Q_D(QPauseAnimation);
+    d->duration = msecs;
+}
+
+/*!
+    \reimp
+ */
+bool QPauseAnimation::event(QEvent *e)
+{
+    return QAbstractAnimation::event(e);
+}
+
+/*!
+    \reimp
+ */
+void QPauseAnimation::updateCurrentTime(int msecs)
+{
+    Q_UNUSED(msecs);
+}
+
+
+QT_END_NAMESPACE
+
+#include "moc_qpauseanimation.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qpauseanimation.h b/src/corelib/animation/qpauseanimation.h
new file mode 100644
index 0000000..cb6e041
--- /dev/null
+++ b/src/corelib/animation/qpauseanimation.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPAUSEANIMATION_P_H
+#define QPAUSEANIMATION_P_H
+
+#include <QtCore/qanimationgroup.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QPauseAnimationPrivate;
+
+class Q_CORE_EXPORT QPauseAnimation : public QAbstractAnimation
+{
+    Q_OBJECT
+    Q_PROPERTY(int duration READ duration WRITE setDuration)
+public:
+    QPauseAnimation(QObject *parent = 0);
+    QPauseAnimation(int msecs, QObject *parent = 0);
+    ~QPauseAnimation();
+
+    int duration() const;
+    void setDuration(int msecs);
+
+protected:
+    bool event(QEvent *e);
+    void updateCurrentTime(int msecs);
+
+private:
+    Q_DISABLE_COPY(QPauseAnimation)
+    Q_DECLARE_PRIVATE(QPauseAnimation)
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPAUSEANIMATION_P_H
diff --git a/src/corelib/animation/qpropertyanimation.cpp b/src/corelib/animation/qpropertyanimation.cpp
new file mode 100644
index 0000000..9a17049
--- /dev/null
+++ b/src/corelib/animation/qpropertyanimation.cpp
@@ -0,0 +1,316 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QPropertyAnimation
+    \brief The QPropertyAnimation class animates Qt properties
+    \since 4.6
+    \ingroup animation
+
+    QPropertyAnimation interpolates over \l{Qt's Property System}{Qt
+    properties}. As property values are stored in \l{QVariant}s, the
+    class inherits QVariantAnimation, and supports animation of the
+    same \l{QVariant::Type}{variant types} as its super class.
+
+    A class declaring properties must be a QObject. To make it
+    possible to animate a property, it must provide a setter (so that
+    QPropertyAnimation can set the property's value). Note that this
+    makes it possible to animate many of Qt's widgets. Let's look at
+    an example:
+
+    \code
+        QPropertyAnimation animation(myWidget, "geometry");
+        animation.setDuration(10000);
+        animation.setStartValue(QRect(0, 0, 100, 30));
+        animation.setEndValue(QRect(250, 250, 100, 30));
+
+        animation.start();
+    \endcode
+
+    The property name and the QObject instance of which property
+    should be animated are passed to the constructor. You can then
+    specify the start and end value of the property. The procedure is
+    equal for properties in classes you have implemented
+    yourself--just check with QVariantAnimation that your QVariant
+    type is supported.
+
+    The QVariantAnimation class description explains how to set up the
+    animation in detail. Note, however, that if a start value is not
+    set, the property will start at the value it had when the
+    QPropertyAnimation instance was created.
+
+    QPropertyAnimation works like a charm on its own. For complex
+    animations that, for instance, contain several objects,
+    QAnimationGroup is provided. An animation group is an animation
+    that can contain other animations, and that can manage when its
+    animations are played. Look at QParallelAnimationGroup for an
+    example.
+
+    \sa QVariantAnimation, QAnimationGroup, {The Animation Framework}
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qpropertyanimation.h"
+#include "qanimationgroup.h"
+#include <QtCore/qdebug.h>
+
+#include "qpropertyanimation_p.h"
+
+#include <QtCore/qmath.h>
+#include <QtCore/qmutex.h>
+
+QT_BEGIN_NAMESPACE
+
+typedef QPair<QObject *, QByteArray> QPropertyAnimationPair;
+typedef QHash<QPropertyAnimationPair, QPropertyAnimation*> QPropertyAnimationHash;
+Q_GLOBAL_STATIC(QPropertyAnimationHash, _q_runningAnimations);
+Q_GLOBAL_STATIC_WITH_ARGS(QMutex, guardHashLock, (QMutex::Recursive) )
+
+void QPropertyAnimationPrivate::updateMetaProperty()
+{
+    if (!target || propertyName.isEmpty())
+        return;
+
+    if (hasMetaProperty == 0 && !property.isValid()) {
+        const QMetaObject *mo = target->metaObject();
+        propertyIndex = mo->indexOfProperty(propertyName);
+        if (propertyIndex != -1) {
+            hasMetaProperty = 1;
+            property = mo->property(propertyIndex);
+            propertyType = property.userType();
+        } else {
+            if (!target->dynamicPropertyNames().contains(propertyName))
+                qWarning("QPropertyAnimation: you're trying to animate a non-existing property %s of your QObject", propertyName.constData());
+            hasMetaProperty = 2;
+        }
+    }
+
+    if (property.isValid())
+        convertValues(propertyType);
+}
+
+void QPropertyAnimationPrivate::updateProperty(const QVariant &newValue)
+{
+    if (!target || state == QAbstractAnimation::Stopped)
+        return;
+
+    if (hasMetaProperty == 1) {
+        if (newValue.userType() == propertyType) {
+          //no conversion is needed, we directly call the QObject::qt_metacall
+          void *data = const_cast<void*>(newValue.constData());
+          target->qt_metacall(QMetaObject::WriteProperty, propertyIndex, &data);
+        } else {
+          property.write(target, newValue);
+        }
+    } else {
+        target->setProperty(propertyName.constData(), newValue);
+    }
+}
+
+void QPropertyAnimationPrivate::_q_targetDestroyed()
+{
+    Q_Q(QPropertyAnimation);
+    //we stop here so that this animation is removed from the global hash
+    q->stop();
+    target = 0;
+}
+
+/*!
+    Construct a QPropertyAnimation object. \a parent is passed to QObject's
+    constructor.
+*/
+QPropertyAnimation::QPropertyAnimation(QObject *parent)
+    : QVariantAnimation(*new QPropertyAnimationPrivate, parent)
+{
+}
+
+/*!
+    Construct a QPropertyAnimation object. \a parent is passed to QObject's
+    constructor. The animation changes the property \a propertyName on \a
+    target. The default duration is 250ms.
+
+    \sa targetObject, propertyName
+*/
+QPropertyAnimation::QPropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent)
+    : QVariantAnimation(*new QPropertyAnimationPrivate, parent)
+{
+    setTargetObject(target);
+    setPropertyName(propertyName);
+}
+
+/*!
+    Destroys the QPropertyAnimation instance.
+ */
+QPropertyAnimation::~QPropertyAnimation()
+{
+    stop();
+}
+
+/*!
+    \property QPropertyAnimation::targetObject
+    \brief the target QObject for this animation.
+
+    This property defines the target QObject for this animation.
+ */
+QObject *QPropertyAnimation::targetObject() const
+{
+    Q_D(const QPropertyAnimation);
+    return d->target;
+}
+
+void QPropertyAnimation::setTargetObject(QObject *target)
+{
+    Q_D(QPropertyAnimation);
+    if (d->target == target)
+        return;
+
+    if (d->state != QAbstractAnimation::Stopped) {
+        qWarning("QPropertyAnimation::setTargetObject: you can't change the target of a running animation");
+        return;
+    }
+
+    //we need to get notified when the target is destroyed
+    if (d->target)
+        disconnect(d->target, SIGNAL(destroyed()), this, SLOT(_q_targetDestroyed()));
+
+    if (target)
+        connect(target, SIGNAL(destroyed()), SLOT(_q_targetDestroyed()));
+
+    d->target = target;
+    d->hasMetaProperty = 0;
+    d->updateMetaProperty();
+}
+
+/*!
+    \property QPropertyAnimation::propertyName
+    \brief the target property name for this animation
+
+    This property defines the target property name for this animation. The
+    property name is required for the animation to operate.
+ */
+QByteArray QPropertyAnimation::propertyName() const
+{
+    Q_D(const QPropertyAnimation);
+    return d->propertyName;
+}
+
+void QPropertyAnimation::setPropertyName(const QByteArray &propertyName)
+{
+    Q_D(QPropertyAnimation);
+    if (d->state != QAbstractAnimation::Stopped) {
+        qWarning("QPropertyAnimation::setPropertyName: you can't change the property name of a running animation");
+        return;
+    }
+
+    d->propertyName = propertyName;
+    d->hasMetaProperty = 0;
+    d->updateMetaProperty();
+}
+
+
+/*!
+    \reimp
+ */
+bool QPropertyAnimation::event(QEvent *event)
+{
+    return QVariantAnimation::event(event);
+}
+
+/*!
+    This virtual function is called by QVariantAnimation whenever the current value
+    changes. \a value is the new, updated value. It updates the current value
+    of the property on the target object.
+
+    \sa currentValue, currentTime
+ */
+void QPropertyAnimation::updateCurrentValue(const QVariant &value)
+{
+    Q_D(QPropertyAnimation);
+    d->updateProperty(value);
+}
+
+/*!
+    \reimp
+
+    If the startValue is not defined when the state of the animation changes from Stopped to Running,
+    the current property value is used as the initial value for the animation.
+*/
+void QPropertyAnimation::updateState(QAbstractAnimation::State oldState,
+                                     QAbstractAnimation::State newState)
+{
+    Q_D(QPropertyAnimation);
+
+    if (!d->target) {
+        qWarning("QPropertyAnimation::updateState: Changing state of an animation without target");
+        return;
+    }
+
+    QVariantAnimation::updateState(oldState, newState);
+    QMutexLocker locker(guardHashLock());
+    QPropertyAnimationHash * hash = _q_runningAnimations();
+    QPropertyAnimationPair key(d->target, d->propertyName);
+    if (newState == Running) {
+        d->updateMetaProperty();
+        QPropertyAnimation *oldAnim = hash->value(key, 0);
+        if (oldAnim) {
+            // try to stop the top level group
+            QAbstractAnimation *current = oldAnim;
+            while (current->group() && current->state() != Stopped)
+                current = current->group();
+            current->stop();
+        }
+        hash->insert(key, this);
+
+        // update the default start value
+        if (oldState == Stopped) {
+            d->setDefaultStartValue(d->target->property(d->propertyName.constData()));
+        }
+    } else if (hash->value(key) == this) {
+        hash->remove(key);
+    }
+}
+
+#include "moc_qpropertyanimation.cpp"
+
+QT_END_NAMESPACE
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qpropertyanimation.h b/src/corelib/animation/qpropertyanimation.h
new file mode 100644
index 0000000..5b06bd2
--- /dev/null
+++ b/src/corelib/animation/qpropertyanimation.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROPERTYANIMATION_H
+#define QPROPERTYANIMATION_H
+
+#include <QtCore/qvariantanimation.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QPropertyAnimationPrivate;
+class Q_CORE_EXPORT QPropertyAnimation : public QVariantAnimation
+{
+    Q_OBJECT
+    Q_PROPERTY(QByteArray propertyName READ propertyName WRITE setPropertyName)
+    Q_PROPERTY(QObject* targetObject READ targetObject WRITE setTargetObject)
+
+public:
+    QPropertyAnimation(QObject *parent = 0);
+    QPropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = 0);
+    ~QPropertyAnimation();
+
+    QObject *targetObject() const;
+    void setTargetObject(QObject *target);
+
+    QByteArray propertyName() const;
+    void setPropertyName(const QByteArray &propertyName);
+
+protected:
+    bool event(QEvent *event);
+
+    void updateCurrentValue(const QVariant &value);
+    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    Q_PRIVATE_SLOT(d_func(), void _q_targetDestroyed());
+private:
+    Q_DISABLE_COPY(QPropertyAnimation)
+    Q_DECLARE_PRIVATE(QPropertyAnimation)
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QPROPERTYANIMATION_H
diff --git a/src/corelib/animation/qpropertyanimation_p.h b/src/corelib/animation/qpropertyanimation_p.h
new file mode 100644
index 0000000..b51d039
--- /dev/null
+++ b/src/corelib/animation/qpropertyanimation_p.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROPERTYANIMATION_P_H
+#define QPROPERTYANIMATION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qpropertyanimation.h"
+#include <QtCore/qmetaobject.h>
+
+#include "qvariantanimation_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPropertyAnimationPrivate : public QVariantAnimationPrivate
+{
+   Q_DECLARE_PUBLIC(QPropertyAnimation)
+public:
+    QPropertyAnimationPrivate()
+        : target(0), propertyType(0), propertyIndex(0), hasMetaProperty(false)
+    {
+    }
+
+    void _q_targetDestroyed();
+
+    QObject *target;
+
+    //for the QProperty
+    QMetaProperty property;
+    int propertyType;
+    int propertyIndex;
+
+    int hasMetaProperty;
+    QByteArray propertyName;
+    void updateProperty(const QVariant &);
+    void updateMetaProperty();
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/animation/qsequentialanimationgroup.cpp b/src/corelib/animation/qsequentialanimationgroup.cpp
new file mode 100644
index 0000000..14814a7
--- /dev/null
+++ b/src/corelib/animation/qsequentialanimationgroup.cpp
@@ -0,0 +1,594 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QSequentialAnimationGroup
+    \brief The QSequentialAnimationGroup class provides a sequential group of animations.
+    \since 4.6
+    \ingroup animation
+
+    QSequentialAnimationGroup is a QAnimationGroup that runs its
+    animations in sequence, i.e., it starts one animation after
+    another has finished playing. The animations are played in the
+    order they are added to the group (using
+    \l{QAnimationGroup::}{addAnimation()} or
+    \l{QAnimationGroup::}{insertAnimationAt()}). The animation group
+    finishes when its last animation has finished.
+
+    At each moment there is at most one animation that is active in
+    the group; it is returned by currentAnimation(). An empty group
+    has no current animation.
+
+    A sequential animation group can be treated as any other
+    animation, i.e., it can be started, stopped, and added to other
+    groups. You can also call addPause() or insertPauseAt() to add a
+    pause to a sequential animation group.
+
+    \code
+        QSequentialAnimationGroup group;
+
+        group.addAnimation(anim1);
+        group.addAnimation(anim2);
+
+        group.start();
+    \endcode
+
+    In this example, \c anim1 and \c anim2 are two already set up
+    \l{QPropertyAnimation}s.
+
+    \sa QAnimationGroup, QAbstractAnimation, {The Animation Framework}
+*/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qsequentialanimationgroup.h"
+#include "qsequentialanimationgroup_p.h"
+
+#include "qpauseanimation.h"
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+
+
+bool QSequentialAnimationGroupPrivate::atEnd() const
+{
+    // we try to detect if we're at the end of the group
+    //this is true if the following conditions are true:
+    // 1. we're in the last loop
+    // 2. the direction is forward
+    // 3. the current animation is the last one
+    // 4. the current animation has reached its end
+    const int animTotalCurrentTime = QAbstractAnimationPrivate::get(currentAnimation)->totalCurrentTime;
+    return (currentLoop == loopCount - 1
+        && direction == QAbstractAnimation::Forward
+        && currentAnimation == animations.last()
+        && animTotalCurrentTime == animationActualTotalDuration(currentAnimationIndex));
+}
+
+int QSequentialAnimationGroupPrivate::animationActualTotalDuration(int index) const
+{
+    QAbstractAnimation *anim = animations.at(index);
+    int ret = anim->totalDuration();
+    if (ret == -1 && actualDuration.size() > index)
+        ret = actualDuration.at(index); //we can try the actual duration there
+    return ret;
+}
+
+QSequentialAnimationGroupPrivate::AnimationIndex QSequentialAnimationGroupPrivate::indexForTime(int msecs) const
+{
+    Q_Q(const QSequentialAnimationGroup);
+    Q_ASSERT(!animations.isEmpty());
+
+    AnimationIndex ret;
+    int duration = 0;
+
+    // in case duration is -1, currentLoop will always be 0
+    ret.timeOffset = currentLoop * q->duration();
+
+    for (int i = 0; i < animations.size(); ++i) {
+        duration = animationActualTotalDuration(i);
+
+        // 'animation' is the current animation if one of these reasons is true:
+        // 1. it's duration is undefined
+        // 2. it ends after msecs
+        // 3. it is the last animation (this can happen in case there is at least 1 uncontrolled animation)
+        // 4. it ends exactly in msecs and the direction is backwards
+        if (duration == -1 || msecs < (ret.timeOffset + duration)
+            || (msecs == (ret.timeOffset + duration) && direction == QAbstractAnimation::Backward)) {
+            ret.index = i;
+            return ret;
+        }
+
+        // 'animation' has a non-null defined duration and is not the one at time 'msecs'.
+        ret.timeOffset += duration;
+    }
+
+    // this can only happen when one of those conditions is true:
+    // 1. the duration of the group is undefined and we passed its actual duration
+    // 2. there are only 0-duration animations in the group
+    ret.timeOffset -= duration;
+    ret.index = animations.size() - 1;
+    return ret;
+}
+
+void QSequentialAnimationGroupPrivate::restart()
+{
+    // restarting the group by making the first/last animation the current one
+    if (direction == QAbstractAnimation::Forward) {
+        lastLoop = 0;
+        if (currentAnimationIndex == 0)
+            activateCurrentAnimation();
+        else
+            setCurrentAnimation(0);
+    } else { // direction == QAbstractAnimation::Backward
+        lastLoop = loopCount - 1;
+        int index = animations.size() - 1;
+        if (currentAnimationIndex == index)
+            activateCurrentAnimation();
+        else
+            setCurrentAnimation(index);
+    }
+}
+
+/*!
+    \internal
+    This manages advancing the execution of a group running forwards (time has gone forward),
+    which is the same behaviour for rewinding the execution of a group running backwards
+    (time has gone backward).
+*/
+void QSequentialAnimationGroupPrivate::advanceForwards(const AnimationIndex &newAnimationIndex)
+{
+    if (lastLoop < currentLoop) {
+        // we need to fast forward to the end
+        for (int i = currentAnimationIndex; i < animations.size(); ++i) {
+            QAbstractAnimation *anim = animations.at(i);
+            setCurrentAnimation(i, true);
+            anim->setCurrentTime(animationActualTotalDuration(i));
+        }
+        // this will make sure the current animation is reset to the beginning
+        if (animations.size() == 1)
+            // we need to force activation because setCurrentAnimation will have no effect
+            activateCurrentAnimation();
+        else
+            setCurrentAnimation(0, true);
+    }
+
+    // and now we need to fast forward from the current position to
+    for (int i = currentAnimationIndex; i < newAnimationIndex.index; ++i) {     //### WRONG,
+        QAbstractAnimation *anim = animations.at(i);
+        setCurrentAnimation(i, true);
+        anim->setCurrentTime(animationActualTotalDuration(i));
+    }
+    // setting the new current animation will happen later
+}
+
+/*!
+    \internal
+    This manages rewinding the execution of a group running forwards (time has gone forward),
+    which is the same behaviour for advancing the execution of a group running backwards
+    (time has gone backward).
+*/
+void QSequentialAnimationGroupPrivate::rewindForwards(const AnimationIndex &newAnimationIndex)
+{
+    if (lastLoop > currentLoop) {
+        // we need to fast rewind to the beginning
+        for (int i = currentAnimationIndex; i >= 0 ; --i) {
+            QAbstractAnimation *anim = animations.at(i);
+            setCurrentAnimation(i, true);
+            anim->setCurrentTime(0);
+        }
+        // this will make sure the current animation is reset to the end
+        if (animations.size() == 1)
+            // we need to force activation because setCurrentAnimation will have no effect
+            activateCurrentAnimation();
+        else
+            setCurrentAnimation(animations.count() - 1, true);
+    }
+
+    // and now we need to fast rewind from the current position to
+    for (int i = currentAnimationIndex; i > newAnimationIndex.index; --i) {
+        QAbstractAnimation *anim = animations.at(i);
+        setCurrentAnimation(i, true);
+        anim->setCurrentTime(0);
+    }
+    // setting the new current animation will happen later
+}
+
+/*!
+    \fn QSequentialAnimationGroup::currentAnimationChanged(QAbstractAnimation *current)
+
+    QSequentialAnimationGroup emits this signal when currentAnimation
+    has been changed. \a current is the current animation.
+
+    \sa currentAnimation()
+*/
+
+
+/*!
+    Constructs a QSequentialAnimationGroup.
+    \a parent is passed to QObject's constructor.
+*/
+QSequentialAnimationGroup::QSequentialAnimationGroup(QObject *parent)
+    : QAnimationGroup(*new QSequentialAnimationGroupPrivate, parent)
+{
+}
+
+/*!
+    \internal
+*/
+QSequentialAnimationGroup::QSequentialAnimationGroup(QSequentialAnimationGroupPrivate &dd,
+                                                     QObject *parent)
+    : QAnimationGroup(dd, parent)
+{
+}
+
+/*!
+    Destroys the animation group. It will also destroy all its animations.
+*/
+QSequentialAnimationGroup::~QSequentialAnimationGroup()
+{
+}
+
+/*!
+    Adds a pause of \a msecs to this animation group.
+    The pause is considered as a special type of animation, thus count() will be
+    increased by one.
+    \sa insertPauseAt(), QAnimationGroup::addAnimation()
+*/
+QPauseAnimation *QSequentialAnimationGroup::addPause(int msecs)
+{
+    QPauseAnimation *pause = new QPauseAnimation(msecs);
+    addAnimation(pause);
+    return pause;
+}
+
+/*!
+    Inserts a pause of \a msecs milliseconds at \a index in this animation
+    group.
+
+    \sa addPause(), QAnimationGroup::insertAnimationAt()
+*/
+QPauseAnimation *QSequentialAnimationGroup::insertPauseAt(int index, int msecs)
+{
+    Q_D(const QSequentialAnimationGroup);
+
+    if (index < 0 || index > d->animations.size()) {
+        qWarning("QSequentialAnimationGroup::insertPauseAt: index is out of bounds");
+        return 0;
+    }
+
+    QPauseAnimation *pause = new QPauseAnimation(msecs);
+    insertAnimationAt(index, pause);
+    return pause;
+}
+
+
+/*!
+    \property QSequentialAnimationGroup::currentAnimation
+    Returns the animation in the current time.
+
+    \sa currentAnimationChanged()
+*/
+QAbstractAnimation *QSequentialAnimationGroup::currentAnimation() const
+{
+    Q_D(const QSequentialAnimationGroup);
+    return d->currentAnimation;
+}
+
+/*!
+    \reimp
+*/
+int QSequentialAnimationGroup::duration() const
+{
+    Q_D(const QSequentialAnimationGroup);
+    int ret = 0;
+
+    for (int i = 0; i < d->animations.size(); ++i) {
+        QAbstractAnimation *animation = d->animations.at(i);
+        const int currentDuration = animation->totalDuration();
+        if (currentDuration == -1)
+            return -1; // Undetermined length
+
+        ret += currentDuration;
+    }
+
+    return ret;
+}
+
+/*!
+    \reimp
+*/
+void QSequentialAnimationGroup::updateCurrentTime(int msecs)
+{
+    Q_D(QSequentialAnimationGroup);
+    if (!d->currentAnimation)
+        return;
+
+    const QSequentialAnimationGroupPrivate::AnimationIndex newAnimationIndex = d->indexForTime(msecs);
+
+    // remove unneeded animations from actualDuration list
+    while (newAnimationIndex.index < d->actualDuration.size())
+        d->actualDuration.removeLast();
+
+    // newAnimationIndex.index is the new current animation
+    if (d->lastLoop < d->currentLoop
+        || (d->lastLoop == d->currentLoop && d->currentAnimationIndex < newAnimationIndex.index)) {
+            // advancing with forward direction is the same as rewinding with backwards direction
+            d->advanceForwards(newAnimationIndex);
+    } else if (d->lastLoop > d->currentLoop
+        || (d->lastLoop == d->currentLoop && d->currentAnimationIndex > newAnimationIndex.index)) {
+            // rewinding with forward direction is the same as advancing with backwards direction
+            d->rewindForwards(newAnimationIndex);
+    }
+
+    d->setCurrentAnimation(newAnimationIndex.index);
+
+    const int newCurrentTime = msecs - newAnimationIndex.timeOffset;
+
+    if (d->currentAnimation) {
+        d->currentAnimation->setCurrentTime(newCurrentTime);
+        if (d->atEnd()) {
+            //we make sure that we don't exceed the duration here
+            d->currentTime += QAbstractAnimationPrivate::get(d->currentAnimation)->totalCurrentTime - newCurrentTime;
+            stop();
+        }
+    } else {
+        //the only case where currentAnimation could be null
+        //is when all animations have been removed
+        Q_ASSERT(d->animations.isEmpty());
+        d->currentTime = 0;
+        stop();
+    }
+
+    d->lastLoop = d->currentLoop;
+}
+
+/*!
+    \reimp
+*/
+void QSequentialAnimationGroup::updateState(QAbstractAnimation::State oldState,
+                                            QAbstractAnimation::State newState)
+{
+    Q_D(QSequentialAnimationGroup);
+    QAnimationGroup::updateState(oldState, newState);
+
+    if (!d->currentAnimation)
+        return;
+
+    switch (newState) {
+    case Stopped:
+        d->currentAnimation->stop();
+        break;
+    case Paused:
+        if (oldState == d->currentAnimation->state()
+            && oldState == QSequentialAnimationGroup::Running) {
+                d->currentAnimation->pause();
+            }
+        else
+            d->restart();
+        break;
+    case Running:
+        if (oldState == d->currentAnimation->state()
+            && oldState == QSequentialAnimationGroup::Paused)
+            d->currentAnimation->start();
+        else
+            d->restart();
+        break;
+    }
+}
+
+/*!
+    \reimp
+*/
+void QSequentialAnimationGroup::updateDirection(QAbstractAnimation::Direction direction)
+{
+    Q_D(QSequentialAnimationGroup);
+    // we need to update the direction of the current animation
+    if (state() != Stopped && d->currentAnimation)
+        d->currentAnimation->setDirection(direction);
+}
+
+/*!
+    \reimp
+*/
+bool QSequentialAnimationGroup::event(QEvent *event)
+{
+    return QAnimationGroup::event(event);
+}
+
+void QSequentialAnimationGroupPrivate::setCurrentAnimation(int index, bool intermediate)
+{
+    Q_Q(QSequentialAnimationGroup);
+
+    index = qMin(index, animations.count() - 1);
+
+    if (index == -1) {
+        Q_ASSERT(animations.isEmpty());
+        currentAnimationIndex = -1;
+        currentAnimation = 0;
+        return;
+    }
+
+    // need these two checks below because this func can be called after the current animation
+    // has been removed
+    if (index == currentAnimationIndex && animations.at(index) == currentAnimation)
+        return;
+
+    // stop the old current animation
+    if (currentAnimation)
+        currentAnimation->stop();
+
+    currentAnimation = animations.at(index);
+    currentAnimationIndex = index;
+
+    emit q->currentAnimationChanged(currentAnimation);
+
+    activateCurrentAnimation(intermediate);
+}
+
+void QSequentialAnimationGroupPrivate::activateCurrentAnimation(bool intermediate)
+{
+    Q_Q(QSequentialAnimationGroup);
+
+    if (!currentAnimation)
+        return;
+
+    if (state == QSequentialAnimationGroup::Stopped)
+        return;
+
+    currentAnimation->stop();
+
+    // we ensure the direction is consistent with the group's direction
+    currentAnimation->setDirection(direction);
+
+    // connects to the finish signal of uncontrolled animations
+    if (currentAnimation->totalDuration() == -1)
+        QObject::connect(currentAnimation, SIGNAL(finished()), q, SLOT(_q_uncontrolledAnimationFinished()));
+
+    currentAnimation->start();
+    if (!intermediate && state == QSequentialAnimationGroup::Paused)
+        currentAnimation->pause();
+}
+
+void QSequentialAnimationGroupPrivate::_q_uncontrolledAnimationFinished()
+{
+    Q_Q(QSequentialAnimationGroup);
+    Q_ASSERT(qobject_cast<QAbstractAnimation *>(q->sender()) == currentAnimation);
+
+    // we trust the duration returned by the animation
+    while (actualDuration.size() < (currentAnimationIndex + 1))
+        actualDuration.append(-1);
+    actualDuration[currentAnimationIndex] = currentAnimation->currentTime();
+
+    QObject::disconnect(currentAnimation, SIGNAL(finished()), q, SLOT(_q_uncontrolledAnimationFinished()));
+
+    if ((direction == QAbstractAnimation::Forward && currentAnimation == animations.last())
+        || (direction == QAbstractAnimation::Backward && currentAnimationIndex == 0)) {
+        // we don't handle looping of a group with undefined duration
+        q->stop();
+    } else if (direction == QAbstractAnimation::Forward) {
+        // set the current animation to be the next one
+        setCurrentAnimation(currentAnimationIndex + 1);
+    } else {
+        // set the current animation to be the previous one
+        setCurrentAnimation(currentAnimationIndex - 1);
+    }
+}
+
+/*!
+    \internal
+    This method is called whenever an animation is added to
+    the group at index \a index.
+    Note: We only support insertion after the current animation
+*/
+void QSequentialAnimationGroupPrivate::animationInsertedAt(int index)
+{
+    if (currentAnimation == 0)
+        setCurrentAnimation(0); // initialize the current animation
+
+    if (currentAnimationIndex == index
+        && currentAnimation->currentTime() == 0 && currentAnimation->currentLoop() == 0) {
+            //in this case we simply insert an animation before the current one has actually started
+            setCurrentAnimation(index);
+    }
+
+    //we update currentAnimationIndex in case it has changed (the animation pointer is still valid)
+    currentAnimationIndex = animations.indexOf(currentAnimation);
+
+    if (index < currentAnimationIndex || currentLoop != 0) {
+        qWarning("QSequentialGroup::insertAnimationAt only supports to add animations after the current one.");
+        return; //we're not affected because it is added after the current one
+    }
+}
+
+/*!
+    \internal
+    This method is called whenever an animation is removed from
+    the group at index \a index. The animation is no more listed when this
+    method is called.
+*/
+void QSequentialAnimationGroupPrivate::animationRemovedAt(int index)
+{
+    Q_Q(QSequentialAnimationGroup);
+    QAnimationGroupPrivate::animationRemovedAt(index);
+
+    Q_ASSERT(currentAnimation); // currentAnimation should always be set
+
+    if (actualDuration.size() > index)
+        actualDuration.removeAt(index);
+
+    const int currentIndex = animations.indexOf(currentAnimation);
+    if (currentIndex == -1) {
+        //we're removing the current animation, let's update it to another one
+        if (index < animations.count())
+            setCurrentAnimation(index); //let's try to take the next one
+        else if (index > 0)
+            setCurrentAnimation(index - 1);
+        else// case all animations were removed
+            setCurrentAnimation(-1);
+    } else if (currentAnimationIndex > index) {
+        currentAnimationIndex--;
+    }
+
+    // duration of the previous animations up to the current animation
+    currentTime = 0;
+    for (int i = 0; i < currentAnimationIndex; ++i) {
+        const int current = animationActualTotalDuration(i);
+        currentTime += current;
+    }
+
+    if (currentIndex != -1) {
+        //the current animation is not the one being removed
+        //so we add its current time to the current time of this group
+        currentTime += QAbstractAnimationPrivate::get(currentAnimation)->totalCurrentTime;
+    }
+
+    //let's also update the total current time
+    totalCurrentTime = currentTime + loopCount * q->duration();
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qsequentialanimationgroup.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qsequentialanimationgroup.h b/src/corelib/animation/qsequentialanimationgroup.h
new file mode 100644
index 0000000..4701a76
--- /dev/null
+++ b/src/corelib/animation/qsequentialanimationgroup.h
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSEQUENTIALANIMATIONGROUP_H
+#define QSEQUENTIALANIMATIONGROUP_H
+
+#include <QtCore/qanimationgroup.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QPauseAnimation;
+class QSequentialAnimationGroupPrivate;
+
+class Q_CORE_EXPORT QSequentialAnimationGroup : public QAnimationGroup
+{
+    Q_OBJECT
+    Q_PROPERTY(QAbstractAnimation* currentAnimation READ currentAnimation NOTIFY currentAnimationChanged)
+
+public:
+    QSequentialAnimationGroup(QObject *parent = 0);
+    ~QSequentialAnimationGroup();
+
+    QPauseAnimation *addPause(int msecs);
+    QPauseAnimation *insertPauseAt(int index, int msecs);
+
+    QAbstractAnimation *currentAnimation() const;
+    int duration() const;
+
+Q_SIGNALS:
+    void currentAnimationChanged(QAbstractAnimation *current);
+
+protected:
+    QSequentialAnimationGroup(QSequentialAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+
+    void updateCurrentTime(int msecs);
+    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+    void updateDirection(QAbstractAnimation::Direction direction);
+
+private:
+    Q_DISABLE_COPY(QSequentialAnimationGroup)
+    Q_DECLARE_PRIVATE(QSequentialAnimationGroup)
+    Q_PRIVATE_SLOT(d_func(), void _q_uncontrolledAnimationFinished())
+};
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif //QSEQUENTIALANIMATIONGROUP_H
diff --git a/src/corelib/animation/qsequentialanimationgroup_p.h b/src/corelib/animation/qsequentialanimationgroup_p.h
new file mode 100644
index 0000000..3ac90f8
--- /dev/null
+++ b/src/corelib/animation/qsequentialanimationgroup_p.h
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QSEQUENTIALANIMATIONGROUP_P_H
+#define QSEQUENTIALANIMATIONGROUP_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qsequentialanimationgroup.h"
+#include "qanimationgroup_p.h"
+
+
+QT_BEGIN_NAMESPACE
+
+class QSequentialAnimationGroupPrivate : public QAnimationGroupPrivate
+{
+    Q_DECLARE_PUBLIC(QSequentialAnimationGroup)
+public:
+    QSequentialAnimationGroupPrivate()
+        : currentAnimation(0), currentAnimationIndex(-1), lastLoop(0)
+    { }
+
+
+    struct AnimationIndex
+    {
+        AnimationIndex() : index(0), timeOffset(0) {}
+        // index points to the animation at timeOffset, skipping 0 duration animations.
+        // Note that the index semantic is slightly different depending on the direction.
+        int index; // the index of the animation in timeOffset
+        int timeOffset; // time offset when the animation at index starts.
+    };
+
+    int animationActualTotalDuration(int index) const;
+    AnimationIndex indexForTime(int msecs) const;
+
+    void setCurrentAnimation(int index, bool intermediate = false);
+    void activateCurrentAnimation(bool intermediate = false);
+
+    void animationInsertedAt(int index);
+    void animationRemovedAt(int index);
+
+    bool atEnd() const;
+
+    QAbstractAnimation *currentAnimation;
+    int currentAnimationIndex;
+
+    // this is the actual duration of uncontrolled animations
+    // it helps seeking and even going forward
+    QList<int> actualDuration;
+
+    void restart();
+    int lastLoop;
+
+    // handle time changes
+    void rewindForwards(const AnimationIndex &newAnimationIndex);
+    void advanceForwards(const AnimationIndex &newAnimationIndex);
+
+    // private slot
+    void _q_uncontrolledAnimationFinished();
+};
+
+QT_END_NAMESPACE
+
+#endif //QSEQUENTIALANIMATIONGROUP_P_H
diff --git a/src/corelib/animation/qvariantanimation.cpp b/src/corelib/animation/qvariantanimation.cpp
new file mode 100644
index 0000000..a6834bb
--- /dev/null
+++ b/src/corelib/animation/qvariantanimation.cpp
@@ -0,0 +1,644 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT_NO_ANIMATION
+
+#include "qvariantanimation.h"
+#include "qvariantanimation_p.h"
+
+#include <QtCore/QRect>
+#include <QtCore/QLineF>
+#include <QtCore/QLine>
+#include <QtCore/QReadWriteLock>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QVariantAnimation
+    \ingroup animation
+    \brief The QVariantAnimation class provides an abstract base class for animations.
+    \since 4.6
+
+    This class is part of \l{The Animation Framework}. It serves as a
+    base class for property and item animations, with functions for
+    shared functionality.
+
+    QVariantAnimation cannot be used directly as it is an abstract
+    class; it does not implement
+    \l{QAbstractAnimation::}{updateCurrentValue()} from
+    QAbstractAnimation. The class performs interpolation over
+    \l{QVariant}s, but leaves using the interpolated values to its
+    subclasses. Currently, Qt provides QPropertyAnimation, which
+    animates Qt \l{Qt's Property System}{properties}. See the
+    QPropertyAnimation class description if you wish to animate such
+    properties.
+
+    You can then set start and end values for the property by calling
+    setStartValue() and setEndValue(), and finally call start() to
+    start the animation. QVariantAnimation will interpolate the
+    property of the target object and emit valueChanged(). To react to
+    a change in the current value you have to reimplement the
+    updateCurrentValue() virtual function.
+
+    It is also possible to set values at specified steps situated
+    between the start and end value. The interpolation will then
+    touch these points at the specified steps. Note that the start and
+    end values are defined as the key values at 0.0 and 1.0.
+
+    There are two ways to affect how QVariantAnimation interpolates
+    the values. You can set an easing curve by calling
+    setEasingCurve(), and configure the duration by calling
+    setDuration(). You can change how the QVariants are interpolated
+    by creating a subclass of QVariantAnimation, and reimplementing
+    the virtual interpolated() function.
+
+    Subclassing QVariantAnimation can be an alternative if you have
+    \l{QVariant}s that you do not wish to declare as Qt properties.
+    Note, however, that you in most cases will be better off declaring
+    your QVariant as a property.
+
+    Not all QVariant types are supported. Below is a list of currently
+    supported QVariant types:
+
+    \list
+        \o \l{QMetaType::}{Int}
+        \o \l{QMetaType::}{Double}
+        \o \l{QMetaType::}{Float}
+        \o \l{QMetaType::}{QLine}
+        \o \l{QMetaType::}{QLineF}
+        \o \l{QMetaType::}{QPoint}
+        \o \l{QMetaType::}{QSize}
+        \o \l{QMetaType::}{QSizeF}
+        \o \l{QMetaType::}{QRect}
+        \o \l{QMetaType::}{QRectF}
+    \endlist
+
+    If you need to interpolate other variant types, including custom
+    types, you have to implement interpolation for these yourself.
+    You do this by reimplementing interpolated(), which returns
+    interpolation values for the value being interpolated.
+
+    \omit We need some snippets around here. \endomit
+
+    \sa QPropertyAnimation, QAbstractAnimation, {The Animation Framework}
+*/
+
+/*!
+    \fn void QVariantAnimation::valueChanged(const QVariant &value)
+
+    QVariantAnimation emits this signal whenever the current \a value changes.
+
+    \sa currentValue, startValue, endValue
+*/
+
+static bool animationValueLessThan(const QVariantAnimation::KeyValue &p1, const QVariantAnimation::KeyValue &p2)
+{
+    return p1.first < p2.first;
+}
+
+template<> Q_INLINE_TEMPLATE QRect _q_interpolate(const QRect &f, const QRect &t, qreal progress)
+{
+    QRect ret;
+    ret.setCoords(_q_interpolate(f.left(), t.left(), progress),
+                  _q_interpolate(f.top(), t.top(), progress),
+                  _q_interpolate(f.right(), t.right(), progress),
+                  _q_interpolate(f.bottom(), t.bottom(), progress));
+    return ret;
+}
+
+template<> Q_INLINE_TEMPLATE QRectF _q_interpolate(const QRectF &f, const QRectF &t, qreal progress)
+{
+    qreal x1, y1, w1, h1;
+    f.getRect(&x1, &y1, &w1, &h1);
+    qreal x2, y2, w2, h2;
+    t.getRect(&x2, &y2, &w2, &h2);
+    return QRectF(_q_interpolate(x1, x2, progress), _q_interpolate(y1, y2, progress),
+                  _q_interpolate(w1, w2, progress), _q_interpolate(h1, h2, progress));
+}
+
+template<> Q_INLINE_TEMPLATE QLine _q_interpolate(const QLine &f, const QLine &t, qreal progress)
+{
+    return QLine( _q_interpolate(f.p1(), t.p1(), progress), _q_interpolate(f.p2(), t.p2(), progress));
+}
+
+template<> Q_INLINE_TEMPLATE QLineF _q_interpolate(const QLineF &f, const QLineF &t, qreal progress)
+{
+    return QLineF( _q_interpolate(f.p1(), t.p1(), progress), _q_interpolate(f.p2(), t.p2(), progress));
+}
+
+void QVariantAnimationPrivate::convertValues(int t)
+{
+    //this ensures that all the keyValues are of type t
+    for (int i = 0; i < keyValues.count(); ++i) {
+        QVariantAnimation::KeyValue &pair = keyValues[i];
+        if (pair.second.userType() != t)
+            pair.second.convert(static_cast<QVariant::Type>(t));
+    }
+    interpolator = 0; // if the type changed we need to update the interpolator
+}
+
+/*!
+    \internal
+    The goal of this function is to update the currentInterval member. As a consequence, we also
+    need to update the currentValue.
+    Set \a force to true to always recalculate the interval.
+*/
+void QVariantAnimationPrivate::recalculateCurrentInterval(bool force/*=false*/)
+{
+    // can't interpolate if we have only 1 key value
+    if (keyValues.count() <= 1)
+        return;
+
+    const qreal progress = easing.valueForProgress(((duration == 0) ? qreal(1) : qreal(currentTime) / qreal(duration)));
+
+    if (force || progress < currentInterval.start.first || progress > currentInterval.end.first) {
+        //let's update currentInterval
+        QVariantAnimation::KeyValues::const_iterator itStart = qLowerBound(keyValues.constBegin(),
+                                                                           keyValues.constEnd(),
+                                                                           qMakePair(progress, QVariant()),
+                                                                           animationValueLessThan);
+        QVariantAnimation::KeyValues::const_iterator itEnd = itStart;
+
+        // If we are at the end we should continue to use the last keyValues in case of extrapolation (progress > 1.0).
+        // This is because the easing function can return a value slightly outside the range [0, 1]
+        if (itStart != keyValues.constEnd()) {
+            // this can't happen because we always prepend the default start value there
+            if (itStart == keyValues.constBegin()) {
+                ++itEnd;
+            } else {
+                --itStart;
+            }
+
+            // update all the values of the currentInterval
+            currentInterval.start = *itStart;
+            currentInterval.end = *itEnd;
+        }
+    }
+    setCurrentValueForProgress(progress);
+}
+
+void QVariantAnimationPrivate::setCurrentValueForProgress(const qreal progress)
+{
+    Q_Q(QVariantAnimation);
+
+    const qreal startProgress = currentInterval.start.first;
+    const qreal endProgress = currentInterval.end.first;
+    const qreal localProgress = (progress - startProgress) / (endProgress - startProgress);
+
+    QVariant ret = q->interpolated(currentInterval.start.second,
+                                   currentInterval.end.second,
+                                   localProgress);
+    qSwap(currentValue, ret);
+    q->updateCurrentValue(currentValue);
+    if ((connectedSignals & changedSignalMask) && currentValue != ret) {
+        //the value has changed
+        emit q->valueChanged(currentValue);
+    }
+}
+
+QVariant QVariantAnimationPrivate::valueAt(qreal step) const
+{
+    QVariantAnimation::KeyValues::const_iterator result =
+        qBinaryFind(keyValues.begin(), keyValues.end(), qMakePair(step, QVariant()), animationValueLessThan);
+    if (result != keyValues.constEnd())
+        return result->second;
+
+    return QVariant();
+}
+
+void QVariantAnimationPrivate::setValueAt(qreal step, const QVariant &value)
+{
+    if (step < qreal(0.0) || step > qreal(1.0)) {
+        qWarning("QVariantAnimation::setValueAt: invalid step = %f", step);
+        return;
+    }
+
+    QVariantAnimation::KeyValue pair(step, value);
+
+    QVariantAnimation::KeyValues::iterator result = qLowerBound(keyValues.begin(), keyValues.end(), pair, animationValueLessThan);
+    if (result == keyValues.end() || result->first != step) {
+        keyValues.insert(result, pair);
+    } else {
+        if (value.isValid())
+            result->second = value; // replaces the previous value
+        else if (step == 0 && !hasStartValue && defaultStartValue.isValid())
+            result->second = defaultStartValue; // resets to the default start value
+        else
+            keyValues.erase(result); // removes the previous value
+    }
+
+    recalculateCurrentInterval(/*force=*/true);
+}
+
+void QVariantAnimationPrivate::setDefaultStartValue(const QVariant &value)
+{
+    defaultStartValue = value;
+    if (!hasStartValue)
+      setValueAt(0, value);
+}
+
+/*!
+    Construct a QVariantAnimation object. \a parent is passed to QAbstractAnimation's
+    constructor.
+*/
+QVariantAnimation::QVariantAnimation(QObject *parent) : QAbstractAnimation(*new QVariantAnimationPrivate, parent)
+{
+   d_func()->init();
+}
+
+/*!
+    \internal
+*/
+QVariantAnimation::QVariantAnimation(QVariantAnimationPrivate &dd, QObject *parent) : QAbstractAnimation(dd, parent)
+{
+   d_func()->init();
+}
+
+/*!
+    Destroys the animation.
+*/
+QVariantAnimation::~QVariantAnimation()
+{
+}
+
+/*!
+    \property QVariantAnimation::easingCurve
+    \brief the easing curve of the animation
+
+    This property defines the easing curve of the animation. By
+    default, a linear easing curve is used, resulting in linear
+    interpolation. Other curves are provided, for instance,
+    QEasingCurve::InCirc, which provides a circular entry curve.
+    Another example is QEasingCurve::InOutElastic, which provides an
+    elastic effect on the values of the interpolated variant.
+
+    The easing curve is used with the interpolator, the interpolated()
+    virtual function, the animation's duration, and iterationCount, to
+    control how the current value changes as the animation progresses.
+*/
+QEasingCurve QVariantAnimation::easingCurve() const
+{
+    Q_D(const QVariantAnimation);
+    return d->easing;
+}
+
+void QVariantAnimation::setEasingCurve(const QEasingCurve &easing)
+{
+    Q_D(QVariantAnimation);
+    d->easing = easing;
+    d->recalculateCurrentInterval();
+}
+
+Q_GLOBAL_STATIC(QVector<QVariantAnimation::Interpolator>, registeredInterpolators)
+Q_GLOBAL_STATIC(QReadWriteLock, registeredInterpolatorsLock)
+
+/*!
+    \fn void qRegisterAnimationInterpolator(QVariant (*func)(const T &from, const T &to, qreal progress))
+    \relates QVariantAnimation
+    \threadsafe
+
+    Registers a custom interpolator \a func for the template type \c{T}.
+    The interpolator has to be registered before the animation is constructed.
+    To unregister (and use the default interpolator) set \a func to 0.
+ */
+
+/*!
+    \internal
+    \typedef QVariantAnimation::Interpolator
+
+    This is a typedef for a pointer to a function with the following
+    signature:
+    \code
+    QVariant myInterpolator(const QVariant &from, const QVariant &to, qreal progress);
+    \endcode
+
+*/
+
+/*! \internal
+ * Registers a custom interpolator \a func for the specific \a interpolationType.
+ * The interpolator has to be registered before the animation is constructed.
+ * To unregister (and use the default interpolator) set \a func to 0.
+ */
+void QVariantAnimation::registerInterpolator(QVariantAnimation::Interpolator func, int interpolationType)
+{
+    // will override any existing interpolators
+    QWriteLocker locker(registeredInterpolatorsLock());
+    if (int(interpolationType) >= registeredInterpolators()->count())
+        registeredInterpolators()->resize(int(interpolationType) + 1);
+    registeredInterpolators()->replace(interpolationType, func);
+}
+
+
+template<typename T> static inline QVariantAnimation::Interpolator castToInterpolator(QVariant (*func)(const T &from, const T &to, qreal progress))
+{
+     return reinterpret_cast<QVariantAnimation::Interpolator>(func);
+}
+
+QVariantAnimation::Interpolator QVariantAnimationPrivate::getInterpolator(int interpolationType)
+{
+    QReadLocker locker(registeredInterpolatorsLock());
+    QVariantAnimation::Interpolator ret = 0;
+    if (interpolationType < registeredInterpolators()->count()) {
+        ret = registeredInterpolators()->at(interpolationType);
+        if (ret) return ret;
+    }
+
+    switch(interpolationType)
+    {
+    case QMetaType::Int:
+        return castToInterpolator(_q_interpolateVariant<int>);
+    case QMetaType::Double:
+        return castToInterpolator(_q_interpolateVariant<double>);
+    case QMetaType::Float:
+        return castToInterpolator(_q_interpolateVariant<float>);
+    case QMetaType::QLine:
+        return castToInterpolator(_q_interpolateVariant<QLine>);
+    case QMetaType::QLineF:
+        return castToInterpolator(_q_interpolateVariant<QLineF>);
+    case QMetaType::QPoint:
+        return castToInterpolator(_q_interpolateVariant<QPoint>);
+    case QMetaType::QPointF:
+        return castToInterpolator(_q_interpolateVariant<QPointF>);
+    case QMetaType::QSize:
+        return castToInterpolator(_q_interpolateVariant<QSize>);
+    case QMetaType::QSizeF:
+        return castToInterpolator(_q_interpolateVariant<QSizeF>);
+    case QMetaType::QRect:
+        return castToInterpolator(_q_interpolateVariant<QRect>);
+    case QMetaType::QRectF:
+        return castToInterpolator(_q_interpolateVariant<QRectF>);
+    default:
+        return 0; //this type is not handled
+    }
+}
+
+/*!
+    \property QVariantAnimation::duration
+    \brief the duration of the animation
+
+    This property describes the duration in milliseconds of the
+    animation. The default duration is 250 milliseconds.
+
+    \sa QAbstractAnimation::duration()
+ */
+int QVariantAnimation::duration() const
+{
+    Q_D(const QVariantAnimation);
+    return d->duration;
+}
+
+void QVariantAnimation::setDuration(int msecs)
+{
+    Q_D(QVariantAnimation);
+    if (msecs < 0) {
+        qWarning("QVariantAnimation::setDuration: cannot set a negative duration");
+        return;
+    }
+    if (d->duration == msecs)
+        return;
+    d->duration = msecs;
+    d->recalculateCurrentInterval();
+}
+
+/*!
+    \property QVariantAnimation::startValue
+    \brief the optional start value of the animation
+
+    This property describes the optional start value of the animation. If
+    omitted, or if a null QVariant is assigned as the start value, the
+    animation will use the current position of the end when the animation
+    is started.
+
+    \sa endValue
+*/
+QVariant QVariantAnimation::startValue() const
+{
+    return keyValueAt(0);
+}
+
+void QVariantAnimation::setStartValue(const QVariant &value)
+{
+    setKeyValueAt(0, value);
+}
+
+/*!
+    \property QVariantAnimation::endValue
+    \brief the end value of the animation
+
+    This property describes the end value of the animation.
+
+    \sa startValue
+ */
+QVariant QVariantAnimation::endValue() const
+{
+    return keyValueAt(1);
+}
+
+void QVariantAnimation::setEndValue(const QVariant &value)
+{
+    setKeyValueAt(1, value);
+}
+
+
+/*!
+    Returns the key frame value for the given \a step. The given \a step
+    must be in the range 0 to 1. If there is no KeyValue for \a step,
+    it returns an invalid QVariant.
+
+    \sa keyValues(), setKeyValueAt()
+*/
+QVariant QVariantAnimation::keyValueAt(qreal step) const
+{
+    Q_D(const QVariantAnimation);
+    if (step == 0 && !d->hasStartValue)
+        return QVariant(); //special case where we don't have an explicit startValue
+
+    return d->valueAt(step);
+}
+
+/*!
+    \typedef QVariantAnimation::KeyValue
+
+    This is a typedef for QPair<qreal, QVariant>.
+*/
+/*!
+    \typedef QVariantAnimation::KeyValues
+
+    This is a typedef for QVector<KeyValue>
+*/
+
+/*!
+    Creates a key frame at the given \a step with the given \a value.
+    The given \a step must be in the range 0 to 1.
+
+    \sa setKeyValues(), keyValueAt()
+*/
+void QVariantAnimation::setKeyValueAt(qreal step, const QVariant &value)
+{
+    Q_D(QVariantAnimation);
+    if (step == 0)
+        d->hasStartValue = value.isValid();
+    d->setValueAt(step, value);
+}
+
+/*!
+    Returns the key frames of this animation.
+
+    \sa keyValueAt(), setKeyValues()
+*/
+QVariantAnimation::KeyValues QVariantAnimation::keyValues() const
+{
+    Q_D(const QVariantAnimation);
+    QVariantAnimation::KeyValues ret = d->keyValues;
+    //in case we added the default start value, we remove it
+    if (!d->hasStartValue && !ret.isEmpty() && ret.at(0).first == 0)
+        ret.remove(0);
+    return ret;
+}
+
+/*!
+    Replaces the current set of key frames with the given \a keyValues.
+    the step of the key frames must be in the range 0 to 1.
+
+    \sa keyValues(), keyValueAt()
+*/
+void QVariantAnimation::setKeyValues(const KeyValues &keyValues)
+{
+    Q_D(QVariantAnimation);
+    d->keyValues = keyValues;
+    qSort(d->keyValues.begin(), d->keyValues.end(), animationValueLessThan);
+    d->hasStartValue = !d->keyValues.isEmpty() && d->keyValues.at(0).first == 0;
+    d->recalculateCurrentInterval(/*force=*/true);
+}
+
+/*!
+    \property QVariantAnimation::currentValue
+    \brief the current value of the animation.
+
+    This property describes the current value; an interpolated value
+    between the \l{startValue}{start value} and the \l{endValue}{end
+    value}, using the current time for progress. The value itself is
+    obtained from interpolated(), which is called repeatedly as the
+    animation is running.
+
+    QVariantAnimation calls the virtual updateCurrentValue() function
+    when the current value changes. This is particularly useful for
+    subclasses that need to track updates. For example,
+    QPropertyAnimation uses this function to animate Qt \l{Qt's
+    Property System}{properties}.
+
+    \sa startValue, endValue
+*/
+QVariant QVariantAnimation::currentValue() const
+{
+    Q_D(const QVariantAnimation);
+    if (!d->currentValue.isValid())
+        const_cast<QVariantAnimationPrivate*>(d)->recalculateCurrentInterval();
+    return d->currentValue;
+}
+
+/*!
+    \reimp
+ */
+bool QVariantAnimation::event(QEvent *event)
+{
+    return QAbstractAnimation::event(event);
+}
+
+/*!
+    \reimp
+*/
+void QVariantAnimation::updateState(QAbstractAnimation::State oldState,
+                                    QAbstractAnimation::State newState)
+{
+    Q_UNUSED(oldState);
+    Q_UNUSED(newState);
+}
+
+/*!
+
+    This virtual function returns the linear interpolation between
+    variants \a from and \a to, at \a progress, usually a value
+    between 0 and 1. You can reimplement this function in a subclass
+    of QVariantAnimation to provide your own interpolation algorithm.
+
+    Note that in order for the interpolation to work with a
+    QEasingCurve that return a value smaller than 0 or larger than 1
+    (such as QEasingCurve::InBack) you should make sure that it can
+    extrapolate. If the semantic of the datatype does not allow
+    extrapolation this function should handle that gracefully.
+
+    You should call the QVariantAnimation implementation of this
+    function if you want your class to handle the types already
+    supported by Qt (see class QVariantAnimation description for a
+    list of supported types).
+
+    \sa QEasingCurve
+ */
+QVariant QVariantAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
+{
+    Q_D(const QVariantAnimation);
+    if (d->interpolator == 0) {
+        if (from.userType() == to.userType())
+            d->interpolator = QVariantAnimationPrivate::getInterpolator(from.userType());
+        if (d->interpolator == 0) //no interpolator found
+            return QVariant();
+    }
+
+    return d->interpolator(from.constData(), to.constData(), progress);
+}
+
+/*!
+    \reimp
+ */
+void QVariantAnimation::updateCurrentTime(int msecs)
+{
+    Q_D(QVariantAnimation);
+    Q_UNUSED(msecs);
+    d->recalculateCurrentInterval();
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qvariantanimation.cpp"
+
+#endif //QT_NO_ANIMATION
diff --git a/src/corelib/animation/qvariantanimation.h b/src/corelib/animation/qvariantanimation.h
new file mode 100644
index 0000000..5b90930
--- /dev/null
+++ b/src/corelib/animation/qvariantanimation.h
@@ -0,0 +1,130 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANIMATION_H
+#define QANIMATION_H
+
+#include <QtCore/qeasingcurve.h>
+#include <QtCore/qabstractanimation.h>
+#include <QtCore/qvector.h>
+#include <QtCore/qvariant.h>
+#include <QtCore/qpair.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+#ifndef QT_NO_ANIMATION
+
+class QVariantAnimationPrivate;
+class Q_CORE_EXPORT QVariantAnimation : public QAbstractAnimation
+{
+    Q_OBJECT
+    Q_PROPERTY(QVariant startValue READ startValue WRITE setStartValue)
+    Q_PROPERTY(QVariant endValue READ endValue WRITE setEndValue)
+    Q_PROPERTY(QVariant currentValue READ currentValue NOTIFY currentValueChanged)
+    Q_PROPERTY(int duration READ duration WRITE setDuration)
+    Q_PROPERTY(QEasingCurve easingCurve READ easingCurve WRITE setEasingCurve)
+
+public:
+    typedef QPair<qreal, QVariant> KeyValue;
+    typedef QVector<KeyValue> KeyValues;
+
+    QVariantAnimation(QObject *parent = 0);
+    ~QVariantAnimation();
+
+    QVariant startValue() const;
+    void setStartValue(const QVariant &value);
+
+    QVariant endValue() const;
+    void setEndValue(const QVariant &value);
+
+    QVariant keyValueAt(qreal step) const;
+    void setKeyValueAt(qreal step, const QVariant &value);
+
+    KeyValues keyValues() const;
+    void setKeyValues(const KeyValues &values);
+
+    QVariant currentValue() const;
+
+    int duration() const;
+    void setDuration(int msecs);
+
+    QEasingCurve easingCurve() const;
+    void setEasingCurve(const QEasingCurve &easing);
+
+    typedef QVariant (*Interpolator)(const void *from, const void *to, qreal progress);
+
+Q_SIGNALS:
+    void valueChanged(const QVariant &value);
+
+protected:
+    QVariantAnimation(QVariantAnimationPrivate &dd, QObject *parent = 0);
+    bool event(QEvent *event);
+
+    void updateCurrentTime(int msecs);
+    void updateState(QAbstractAnimation::State oldState, QAbstractAnimation::State newState);
+
+    virtual void updateCurrentValue(const QVariant &value) = 0;
+    virtual QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const;
+
+private:
+    template <typename T> friend void qRegisterAnimationInterpolator(QVariant (*func)(const T &, const T &, qreal));
+    static void registerInterpolator(Interpolator func, int interpolationType);
+
+    Q_DISABLE_COPY(QVariantAnimation)
+    Q_DECLARE_PRIVATE(QVariantAnimation)
+};
+
+template <typename T>
+static void qRegisterAnimationInterpolator(QVariant (*func)(const T &from, const T &to, qreal progress)) {
+    QVariantAnimation::registerInterpolator(reinterpret_cast<QVariantAnimation::Interpolator>(func), qMetaTypeId<T>());
+}
+
+#endif //QT_NO_ANIMATION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif //QANIMATION_H
diff --git a/src/corelib/animation/qvariantanimation_p.h b/src/corelib/animation/qvariantanimation_p.h
new file mode 100644
index 0000000..0d296db
--- /dev/null
+++ b/src/corelib/animation/qvariantanimation_p.h
@@ -0,0 +1,130 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANIMATION_P_H
+#define QANIMATION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of QIODevice. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qvariantanimation.h"
+#include <QtCore/qeasingcurve.h>
+#include <QtCore/qmetaobject.h>
+#include <QtCore/qvector.h>
+
+#include "qabstractanimation_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QVariantAnimationPrivate : public QAbstractAnimationPrivate
+{
+    Q_DECLARE_PUBLIC(QVariantAnimation)
+public:
+
+    QVariantAnimationPrivate() : duration(250), hasStartValue(false)
+    {
+    }
+
+    void init()
+    {
+        //we keep the mask so that we emit valueChanged only when needed (for performance reasons)
+        changedSignalMask = (1 << q_func()->metaObject()->indexOfSignal("valueChanged(QVariant)"));
+        currentInterval.start.first = currentInterval.end.first = 2; //will force the initial refresh
+        interpolator = 0;
+    }
+
+    static QVariantAnimationPrivate *get(QVariantAnimation *q)
+    {
+        return q->d_func();
+    }
+
+    void setDefaultStartValue(const QVariant &value);
+
+    int duration;
+    QEasingCurve easing;
+
+    QVariantAnimation::KeyValues keyValues;
+    QVariant currentValue;
+    QVariant defaultStartValue;
+    bool hasStartValue;
+
+    //this is used to keep track of the KeyValue interval in which we currently are
+    struct
+    {
+        QVariantAnimation::KeyValue start, end;
+    } currentInterval;
+
+    mutable QVariantAnimation::Interpolator interpolator;
+
+    quint32 changedSignalMask;
+
+    void setCurrentValueForProgress(const qreal progress);
+    void recalculateCurrentInterval(bool force=false);
+    void setValueAt(qreal, const QVariant &);
+    QVariant valueAt(qreal step) const;
+    void convertValues(int t);
+
+    static QVariantAnimation::Interpolator getInterpolator(int interpolationType);
+};
+
+//this should make the interpolation faster
+template<typename T> inline T _q_interpolate(const T &f, const T &t, qreal progress)
+{
+    return T(f + (t - f) * progress);
+}
+
+template<typename T > inline QVariant _q_interpolateVariant(const T &from, const T &to, qreal progress)
+{
+    return _q_interpolate(from, to, progress);
+}
+
+
+QT_END_NAMESPACE
+
+#endif //QANIMATION_P_H
diff --git a/src/corelib/corelib.pro b/src/corelib/corelib.pro
index f99d57f..db51d43 100644
--- a/src/corelib/corelib.pro
+++ b/src/corelib/corelib.pro
@@ -5,6 +5,7 @@ DEFINES   += QT_BUILD_CORE_LIB QT_NO_USING_NAMESPACE
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x67000000
 
 include(../qbase.pri)
+include(animation/animation.pri)
 include(arch/arch.pri)
 include(concurrent/concurrent.pri)
 include(global/global.pri)
@@ -14,6 +15,7 @@ include(io/io.pri)
 include(plugin/plugin.pri)
 include(kernel/kernel.pri)
 include(codecs/codecs.pri)
+include(statemachine/statemachine.pri)
 include(xml/xml.pri)
 
 mac|darwin:LIBS += -framework ApplicationServices
diff --git a/src/corelib/kernel/kernel.pri b/src/corelib/kernel/kernel.pri
index 68649a6..ecef555 100644
--- a/src/corelib/kernel/kernel.pri
+++ b/src/corelib/kernel/kernel.pri
@@ -12,7 +12,7 @@ HEADERS += \
 	kernel/qcoreevent.h \
 	kernel/qmetaobject.h \
 	kernel/qmetatype.h \
-        kernel/qmimedata.h \
+	kernel/qmimedata.h \
 	kernel/qobject.h \
 	kernel/qobjectdefs.h \
 	kernel/qsignalmapper.h \
@@ -27,8 +27,8 @@ HEADERS += \
         kernel/qvariant_p.h \
         kernel/qmetaobject_p.h \
         kernel/qobject_p.h \
-        kernel/qcoreglobaldata_p.h \
-        kernel/qsharedmemory.h \
+	kernel/qcoreglobaldata_p.h \
+	kernel/qsharedmemory.h \
         kernel/qsharedmemory_p.h \
         kernel/qsystemsemaphore.h \
         kernel/qsystemsemaphore_p.h \
@@ -43,7 +43,7 @@ SOURCES += \
 	kernel/qcoreevent.cpp \
 	kernel/qmetaobject.cpp \
 	kernel/qmetatype.cpp \
-        kernel/qmimedata.cpp \
+	kernel/qmimedata.cpp \
 	kernel/qobject.cpp \
 	kernel/qobjectcleanuphandler.cpp \
 	kernel/qsignalmapper.cpp \
diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp
index 11a2d3c..d6b0174 100644
--- a/src/corelib/kernel/qcoreevent.cpp
+++ b/src/corelib/kernel/qcoreevent.cpp
@@ -264,6 +264,8 @@ QT_BEGIN_NAMESPACE
     \omitvalue NetworkReplyUpdated
     \omitvalue FutureCallOut
     \omitvalue CocoaRequestModal
+    \omitvalue Wrapped
+    \omitvalue Signal
 */
 
 /*!
diff --git a/src/corelib/kernel/qcoreevent.h b/src/corelib/kernel/qcoreevent.h
index fa472e6..18188a8 100644
--- a/src/corelib/kernel/qcoreevent.h
+++ b/src/corelib/kernel/qcoreevent.h
@@ -44,6 +44,7 @@
 
 #include <QtCore/qnamespace.h>
 #include <QtCore/qbytearray.h>
+#include <QtCore/qobjectdefs.h>
 
 QT_BEGIN_HEADER
 
@@ -54,7 +55,9 @@ QT_MODULE(Core)
 class QEventPrivate;
 class Q_CORE_EXPORT QEvent           // event base class
 {
+    Q_GADGET
     QDOC_PROPERTY(bool accepted READ isAccepted WRITE setAccepted)
+    Q_ENUMS(Type)
 public:
     enum Type {
         /*
@@ -266,7 +269,10 @@ public:
         CocoaRequestModal = 190,                // Internal for requesting an application modal Cocoa Window
         MacGLClearDrawable = 191,               // Internal Cocoa, the window has changed, so we must clear
 
-        // 512 reserved for Qt Jambi's MetaCall event
+        Signal = 192,
+        Wrapped = 193,
+
+	// 512 reserved for Qt Jambi's MetaCall event
         // 513 reserved for Qt Jambi's DeleteOnMainThread event
 
         User = 1000,                            // first user event id
diff --git a/src/corelib/statemachine/qabstractstate.cpp b/src/corelib/statemachine/qabstractstate.cpp
new file mode 100644
index 0000000..942722f
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate.cpp
@@ -0,0 +1,202 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qabstractstate.h"
+#include "qabstractstate_p.h"
+#include "qstate.h"
+#include "qstate_p.h"
+#include "qstatemachine.h"
+#include "qstatemachine_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QAbstractState
+
+  \brief The QAbstractState class is the base class of states of a QStateMachine.
+
+  \since 4.6
+  \ingroup statemachine
+
+  The QAbstractState class is the abstract base class of states that are part
+  of a QStateMachine. It defines the interface that all state objects have in
+  common. QAbstractState is part of \l{The State Machine Framework}.
+
+  The entered() signal is emitted when the state has been entered. The
+  exited() signal is emitted when the state has been exited.
+
+  The parentState() function returns the state's parent state. The machine()
+  function returns the state machine that the state is part of.
+
+  \section1 Subclassing
+
+  The onEntry() function is called when the state is entered; reimplement this
+  function to perform custom processing when the state is entered.
+
+  The onExit() function is called when the state is exited; reimplement this
+  function to perform custom processing when the state is exited.
+*/
+
+QAbstractStatePrivate::QAbstractStatePrivate()    
+{
+}
+
+QAbstractStatePrivate *QAbstractStatePrivate::get(QAbstractState *q)
+{
+    return q->d_func();
+}
+
+QStateMachine *QAbstractStatePrivate::machine() const
+{
+    Q_Q(const QAbstractState);
+    QObject *par = q->parent();
+    while (par != 0) {
+        if (QStateMachine *mach = qobject_cast<QStateMachine*>(par))
+            return mach;
+        par = par->parent();
+    }
+    return 0;
+}
+
+void QAbstractStatePrivate::callOnEntry(QEvent *e)
+{
+    Q_Q(QAbstractState);
+    q->onEntry(e);
+}
+
+void QAbstractStatePrivate::callOnExit(QEvent *e)
+{
+    Q_Q(QAbstractState);
+    q->onExit(e);
+}
+
+void QAbstractStatePrivate::emitEntered()
+{
+    Q_Q(QAbstractState);
+    emit q->entered();
+}
+
+void QAbstractStatePrivate::emitExited()
+{
+    Q_Q(QAbstractState);
+    emit q->exited();
+}
+
+/*!
+  Constructs a new state with the given \a parent state.
+*/
+QAbstractState::QAbstractState(QState *parent)
+    : QObject(*new QAbstractStatePrivate, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QAbstractState::QAbstractState(QAbstractStatePrivate &dd, QState *parent)
+    : QObject(dd, parent)
+{
+}
+
+/*!
+  Destroys this state.
+*/
+QAbstractState::~QAbstractState()
+{
+}
+
+/*!
+  Returns this state's parent state, or 0 if the state has no parent state.
+*/
+QState *QAbstractState::parentState() const
+{
+    return qobject_cast<QState*>(parent());
+}
+
+/*!
+  Returns the state machine that this state is part of, or 0 if the state is
+  not part of a state machine.
+*/
+QStateMachine *QAbstractState::machine() const
+{
+    Q_D(const QAbstractState);
+    return d->machine();
+}
+
+/*!
+  \fn QAbstractState::onExit(QEvent *event)
+
+  This function is called when the state is exited. The given \a event is what
+  caused the state to be exited. Reimplement this function to perform custom
+  processing when the state is exited.
+*/
+
+/*!
+  \fn QAbstractState::onEntry(QEvent *event)
+
+  This function is called when the state is entered. The given \a event is
+  what caused the state to be entered. Reimplement this function to perform
+  custom processing when the state is entered.
+*/
+
+/*!
+  \fn QAbstractState::entered()
+
+  This signal is emitted when the state has been entered (after onEntry() has
+  been called).
+*/
+
+/*!
+  \fn QAbstractState::exited()
+
+  This signal is emitted when the state has been exited (after onExit() has
+  been called).
+*/
+
+/*!
+  \reimp
+*/
+bool QAbstractState::event(QEvent *e)
+{
+    return QObject::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qabstractstate.h b/src/corelib/statemachine/qabstractstate.h
new file mode 100644
index 0000000..d0ebb52
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTSTATE_H
+#define QABSTRACTSTATE_H
+
+#include <QtCore/qobject.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QState;
+class QStateMachine;
+
+class QAbstractStatePrivate;
+class Q_CORE_EXPORT QAbstractState : public QObject
+{
+    Q_OBJECT
+public:
+    ~QAbstractState();
+
+    QState *parentState() const;
+    QStateMachine *machine() const;
+
+Q_SIGNALS:
+    void entered();
+    void exited();
+
+protected:
+    QAbstractState(QState *parent = 0);
+
+    virtual void onEntry(QEvent *event) = 0;
+    virtual void onExit(QEvent *event) = 0;
+
+    bool event(QEvent *e);
+
+protected:
+    QAbstractState(QAbstractStatePrivate &dd, QState *parent);
+
+private:
+    Q_DISABLE_COPY(QAbstractState)
+    Q_DECLARE_PRIVATE(QAbstractState)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qabstractstate_p.h b/src/corelib/statemachine/qabstractstate_p.h
new file mode 100644
index 0000000..2aad47e
--- /dev/null
+++ b/src/corelib/statemachine/qabstractstate_p.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTSTATE_P_H
+#define QABSTRACTSTATE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QStateMachine;
+
+class QAbstractState;
+class Q_CORE_EXPORT QAbstractStatePrivate
+    : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QAbstractState)
+
+public:
+    QAbstractStatePrivate();
+
+    static QAbstractStatePrivate *get(QAbstractState *q);
+
+    QStateMachine *machine() const;
+
+    void callOnEntry(QEvent *e);
+    void callOnExit(QEvent *e);
+
+    void emitEntered();
+    void emitExited();
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qabstracttransition.cpp b/src/corelib/statemachine/qabstracttransition.cpp
new file mode 100644
index 0000000..dfcafeb
--- /dev/null
+++ b/src/corelib/statemachine/qabstracttransition.cpp
@@ -0,0 +1,342 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qabstracttransition.h"
+#include "qabstracttransition_p.h"
+#include "qabstractstate.h"
+#include "qstate.h"
+#include "qstatemachine.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QAbstractTransition
+
+  \brief The QAbstractTransition class is the base class of transitions between QAbstractState objects.
+
+  \since 4.6
+  \ingroup statemachine
+
+  The QAbstractTransition class is the abstract base class of transitions
+  between states (QAbstractState objects) of a
+  QStateMachine. QAbstractTransition is part of \l{The State Machine
+  Framework}.
+
+  The sourceState() function returns the source of the transition. The
+  targetStates() function returns the targets of the transition. The machine()
+  function returns the state machine that the transition is part of.
+
+  Transitions can cause animations to be played. Use the addAnimation()
+  function to add an animation to the transition.
+
+  \section1 Subclassing
+
+  The eventTest() function is called by the state machine to determine whether
+  an event should trigger the transition. In your reimplementation you
+  typically check the event type and cast the event object to the proper type,
+  and check that one or more properties of the event meet your criteria.
+
+  The onTransition() function is called when the transition is triggered;
+  reimplement this function to perform custom processing for the transition.
+*/
+
+/*!
+    \property QAbstractTransition::sourceState
+
+    \brief the source state (parent) of this transition
+*/
+
+/*!
+    \property QAbstractTransition::targetState
+
+    \brief the target state of this transition
+*/
+
+/*!
+    \property QAbstractTransition::targetStates
+
+    \brief the target states of this transition
+
+    If multiple states are specified, all must be descendants of the same
+    parallel group state.
+*/
+
+QAbstractTransitionPrivate::QAbstractTransitionPrivate()
+{
+}
+
+QAbstractTransitionPrivate *QAbstractTransitionPrivate::get(QAbstractTransition *q)
+{
+    return q->d_func();
+}
+
+QStateMachine *QAbstractTransitionPrivate::machine() const
+{
+    Q_Q(const QAbstractTransition);
+    QObject *par = q->parent();
+    while (par != 0) {
+        if (QStateMachine *mach = qobject_cast<QStateMachine*>(par))
+            return mach;
+        par = par->parent();
+    }
+    return 0;
+}
+
+bool QAbstractTransitionPrivate::callEventTest(QEvent *e)
+{
+    Q_Q(QAbstractTransition);
+    return q->eventTest(e);
+}
+
+void QAbstractTransitionPrivate::callOnTransition(QEvent *e)
+{
+    Q_Q(QAbstractTransition);
+    q->onTransition(e);
+}
+
+QState *QAbstractTransitionPrivate::sourceState() const
+{
+    Q_Q(const QAbstractTransition);
+    return qobject_cast<QState*>(q->parent());
+}
+
+/*!
+  Constructs a new QAbstractTransition object with the given \a sourceState.
+*/
+QAbstractTransition::QAbstractTransition(QState *sourceState)
+    : QObject(*new QAbstractTransitionPrivate, sourceState)
+{
+}
+
+/*!
+  Constructs a new QAbstractTransition object with the given \a targets and \a
+  sourceState.
+*/
+QAbstractTransition::QAbstractTransition(const QList<QAbstractState*> &targets,
+                                         QState *sourceState)
+    : QObject(*new QAbstractTransitionPrivate, sourceState)
+{
+    setTargetStates(targets);
+}
+
+/*!
+  \internal
+*/
+QAbstractTransition::QAbstractTransition(QAbstractTransitionPrivate &dd,
+                                         QState *parent)
+    : QObject(dd, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QAbstractTransition::QAbstractTransition(QAbstractTransitionPrivate &dd,
+                                         const QList<QAbstractState*> &targets,
+                                         QState *parent)
+    : QObject(dd, parent)
+{
+    setTargetStates(targets);
+}
+
+/*!
+  Destroys this transition.
+*/
+QAbstractTransition::~QAbstractTransition()
+{
+}
+
+/*!
+  Returns the source state of this transition, or 0 if this transition has no
+  source state.
+*/
+QState *QAbstractTransition::sourceState() const
+{
+    Q_D(const QAbstractTransition);
+    return d->sourceState();
+}
+
+/*!
+  Returns the target state of this transition, or 0 if the transition has no
+  target.
+*/
+QAbstractState *QAbstractTransition::targetState() const
+{
+    Q_D(const QAbstractTransition);
+    if (d->targetStates.isEmpty())
+        return 0;
+    return d->targetStates.first();
+}
+
+/*!
+  Sets the \a target state of this transition.
+*/
+void QAbstractTransition::setTargetState(QAbstractState* target)
+{
+    Q_D(QAbstractTransition);
+    if (!target)
+        d->targetStates.clear();
+    else
+        setTargetStates(QList<QAbstractState*>() << target);
+}
+
+/*!
+  Returns the target states of this transition, or an empty list if this
+  transition has no target states.
+*/
+QList<QAbstractState*> QAbstractTransition::targetStates() const
+{
+    Q_D(const QAbstractTransition);
+    QList<QAbstractState*> result;
+    for (int i = 0; i < d->targetStates.size(); ++i) {
+        QAbstractState *target = d->targetStates.at(i);
+        if (target)
+            result.append(target);
+    }
+    return result;
+}
+
+/*!
+  Sets the target states of this transition to be the given \a targets.
+*/
+void QAbstractTransition::setTargetStates(const QList<QAbstractState*> &targets)
+{
+    Q_D(QAbstractTransition);
+
+    for (int i=0; i<targets.size(); ++i) {
+        QAbstractState *target = targets.at(i);
+        if (!target) {
+            qWarning("QAbstractTransition::setTargetStates: target state(s) cannot be null");
+            return;
+        }
+        if (target->machine() != 0 && target->machine()->rootState() == target) {
+            qWarning("QAbstractTransition::setTargetStates: root state cannot be target of transition");
+            return;
+        }
+    }
+
+    d->targetStates.clear();
+    for (int i = 0; i < targets.size(); ++i)
+        d->targetStates.append(targets.at(i));
+}
+
+/*!
+  Returns the state machine that this transition is part of, or 0 if the
+  transition is not part of a state machine.
+*/
+QStateMachine *QAbstractTransition::machine() const
+{
+    Q_D(const QAbstractTransition);
+    return d->machine();
+}
+
+#ifndef QT_NO_ANIMATION
+
+/*!
+  Adds the given \a animation to this transition.
+  The transition does not take ownership of the animation.
+
+  \sa removeAnimation(), animations()
+*/
+void QAbstractTransition::addAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QAbstractTransition);
+    if (!animation) {
+        qWarning("QAbstractTransition::addAnimation: cannot add null animation");
+        return;
+    }
+    d->animations.append(animation);
+}
+
+/*!
+  Removes the given \a animation from this transition.
+
+  \sa addAnimation()
+*/
+void QAbstractTransition::removeAnimation(QAbstractAnimation *animation)
+{
+    Q_D(QAbstractTransition);
+    if (!animation) {
+        qWarning("QAbstractTransition::removeAnimation: cannot remove null animation");
+        return;
+    }
+    d->animations.removeOne(animation);
+}
+
+/*!
+  Returns the list of animations associated with this transition, or an empty
+  list if it has no animations.
+
+  \sa addAnimation()
+*/
+QList<QAbstractAnimation*> QAbstractTransition::animations() const
+{
+    Q_D(const QAbstractTransition);
+    return d->animations;
+}
+
+#endif
+
+/*!
+  \fn QAbstractTransition::eventTest(QEvent *event)
+
+  This function is called to determine whether the given \a event should cause
+  this transition to trigger. Reimplement this function and return true if the
+  event should trigger the transition, otherwise return false.
+*/
+
+/*!
+  \fn QAbstractTransition::onTransition(QEvent *event)
+
+  This function is called when the transition is triggered. The given \a event
+  is what caused the transition to trigger. Reimplement this function to
+  perform custom processing when the transition is triggered.
+*/
+
+/*!
+  \reimp
+*/
+bool QAbstractTransition::event(QEvent *e)
+{
+    return QObject::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qabstracttransition.h b/src/corelib/statemachine/qabstracttransition.h
new file mode 100644
index 0000000..c63d55a
--- /dev/null
+++ b/src/corelib/statemachine/qabstracttransition.h
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTTRANSITION_H
+#define QABSTRACTTRANSITION_H
+
+#include <QtCore/qobject.h>
+
+#include <QtCore/qlist.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QEvent;
+class QAbstractState;
+class QState;
+class QStateMachine;
+
+#ifndef QT_NO_ANIMATION
+class QAbstractAnimation;
+#endif
+
+class QAbstractTransitionPrivate;
+class Q_CORE_EXPORT QAbstractTransition : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QState* sourceState READ sourceState)
+    Q_PROPERTY(QAbstractState* targetState READ targetState WRITE setTargetState)
+    Q_PROPERTY(QList<QAbstractState*> targetStates READ targetStates WRITE setTargetStates)
+public:
+    QAbstractTransition(QState *sourceState = 0);
+    QAbstractTransition(const QList<QAbstractState*> &targets, QState *sourceState = 0);
+    virtual ~QAbstractTransition();
+
+    QState *sourceState() const;
+    QAbstractState *targetState() const;
+    void setTargetState(QAbstractState* target);
+    QList<QAbstractState*> targetStates() const;
+    void setTargetStates(const QList<QAbstractState*> &targets);
+
+    QStateMachine *machine() const;
+
+#ifndef QT_NO_ANIMATION
+    void addAnimation(QAbstractAnimation *animation);
+    void removeAnimation(QAbstractAnimation *animation);
+    QList<QAbstractAnimation*> animations() const;
+#endif
+
+protected:
+    virtual bool eventTest(QEvent *event) = 0;
+
+    virtual void onTransition(QEvent *event) = 0;
+
+    bool event(QEvent *e);
+
+protected:
+    QAbstractTransition(QAbstractTransitionPrivate &dd, QState *parent);
+    QAbstractTransition(QAbstractTransitionPrivate &dd,
+                        const QList<QAbstractState*> &targets, QState *parent);
+
+private:
+    Q_DISABLE_COPY(QAbstractTransition)
+    Q_DECLARE_PRIVATE(QAbstractTransition)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qabstracttransition_p.h b/src/corelib/statemachine/qabstracttransition_p.h
new file mode 100644
index 0000000..f067984
--- /dev/null
+++ b/src/corelib/statemachine/qabstracttransition_p.h
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QABSTRACTTRANSITION_P_H
+#define QABSTRACTTRANSITION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qobject_p.h>
+
+#include <QtCore/qlist.h>
+#include <QtCore/qpointer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QAbstractState;
+class QState;
+class QStateMachine;
+
+class QAbstractTransition;
+class Q_CORE_EXPORT QAbstractTransitionPrivate
+    : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QAbstractTransition)
+public:
+    QAbstractTransitionPrivate();
+
+    static QAbstractTransitionPrivate *get(QAbstractTransition *q);
+
+    bool callEventTest(QEvent *e);
+    void callOnTransition(QEvent *e);
+    QState *sourceState() const;
+    QStateMachine *machine() const;
+
+    QList<QPointer<QAbstractState> > targetStates;
+
+#ifndef QT_NO_ANIMATION
+    QList<QAbstractAnimation*> animations;
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/statemachine/qeventtransition.cpp b/src/corelib/statemachine/qeventtransition.cpp
new file mode 100644
index 0000000..74eb577
--- /dev/null
+++ b/src/corelib/statemachine/qeventtransition.cpp
@@ -0,0 +1,282 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qeventtransition.h"
+#include "qeventtransition_p.h"
+#include "qwrappedevent.h"
+#include "qstate.h"
+#include "qstate_p.h"
+#include "qstatemachine.h"
+#include "qstatemachine_p.h"
+#include <qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QEventTransition
+
+  \brief The QEventTransition class provides a QObject-specific transition for Qt events.
+
+  \since 4.6
+  \ingroup statemachine
+
+  A QEventTransition object binds an event to a particular QObject.
+  QEventTransition is part of \l{The State Machine Framework}.
+
+  Example:
+
+  \code
+  QPushButton *button = ...;
+  QState *s1 = ...;
+  QState *s2 = ...;
+  // If in s1 and the button receives an Enter event, transition to s2
+  QEventTransition *enterTransition = new QEventTransition(button, QEvent::Enter);
+  enterTransition->setTargetState(s2);
+  s1->addTransition(enterTransition);
+  // If in s2 and the button receives an Exit event, transition back to s1
+  QEventTransition *leaveTransition = new QEventTransition(button, QEvent::Leave);
+  leaveTransition->setTargetState(s1);
+  s2->addTransition(leaveTransition);
+  \endcode
+
+  \section1 Subclassing
+
+  When reimplementing the eventTest() function, you should first call the base
+  implementation to verify that the event is a QWrappedEvent for the proper
+  object and event type. You may then cast the event to a QWrappedEvent and
+  get the original event by calling QWrappedEvent::event(), and perform
+  additional checks on that object.
+
+  \sa QState::addTransition()
+*/
+
+/*!
+    \property QEventTransition::eventObject
+
+    \brief the event source that this event transition is associated with
+*/
+
+/*!
+    \property QEventTransition::eventType
+
+    \brief the type of event that this event transition is associated with
+*/
+QEventTransitionPrivate::QEventTransitionPrivate()
+{
+    object = 0;
+    eventType = QEvent::None;
+    registered = false;
+}
+
+QEventTransitionPrivate *QEventTransitionPrivate::get(QEventTransition *q)
+{
+    return q->d_func();
+}
+
+void QEventTransitionPrivate::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)
+    : QAbstractTransition(*new QEventTransitionPrivate, sourceState)
+{
+}
+
+/*!
+  Constructs a new QEventTransition object associated with events of the given
+  \a type for the given \a object, and with the given \a sourceState.
+*/
+QEventTransition::QEventTransition(QObject *object, QEvent::Type type,
+                                   QState *sourceState)
+    : QAbstractTransition(*new QEventTransitionPrivate, sourceState)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  Constructs a new QEventTransition object associated with events of the given
+  \a type for the given \a object. The transition has the given \a targets and
+  \a sourceState.
+*/
+QEventTransition::QEventTransition(QObject *object, QEvent::Type type,
+                                   const QList<QAbstractState*> &targets,
+                                   QState *sourceState)
+    : QAbstractTransition(*new QEventTransitionPrivate, targets, sourceState)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  \internal
+*/
+QEventTransition::QEventTransition(QEventTransitionPrivate &dd, QState *parent)
+    : QAbstractTransition(dd, parent)
+{
+}
+
+/*!
+  \internal
+*/
+QEventTransition::QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                                   QEvent::Type type, QState *parent)
+    : QAbstractTransition(dd, parent)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  \internal
+*/
+QEventTransition::QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                                   QEvent::Type type, const QList<QAbstractState*> &targets,
+                                   QState *parent)
+    : QAbstractTransition(dd, targets, parent)
+{
+    Q_D(QEventTransition);
+    d->registered = false;
+    d->object = object;
+    d->eventType = type;
+}
+
+/*!
+  Destroys this QObject event transition.
+*/
+QEventTransition::~QEventTransition()
+{
+}
+
+/*!
+  Returns the event type that this event transition is associated with.
+*/
+QEvent::Type QEventTransition::eventType() const
+{
+    Q_D(const QEventTransition);
+    return d->eventType;
+}
+
+/*!
+  Sets the event \a type that this event transition is associated with.
+*/
+void QEventTransition::setEventType(QEvent::Type type)
+{
+    Q_D(QEventTransition);
+    if (d->eventType == type)
+        return;
+    d->eventType = type;
+    d->invalidate();
+}
+
+/*!
+  Returns the event source associated with this event transition.
+*/
+QObject *QEventTransition::eventObject() const
+{
+    Q_D(const QEventTransition);
+    return d->object;
+}
+
+/*!
+  Sets the event source associated with this event transition to be the given
+  \a object.
+*/
+void QEventTransition::setEventObject(QObject *object)
+{
+    Q_D(QEventTransition);
+    if (d->object == object)
+        return;
+    d->object = object;
+    d->invalidate();
+}
+
+/*!
+  \reimp
+*/
+bool QEventTransition::eventTest(QEvent *event)
+{
+    Q_D(const QEventTransition);
+    if (event->type() == QEvent::Wrapped) {
+        QWrappedEvent *we = static_cast<QWrappedEvent*>(event);
+        return (we->object() == d->object)
+            && (we->event()->type() == d->eventType);
+    }
+    return false;
+}
+
+/*!
+  \reimp
+*/
+void QEventTransition::onTransition(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+bool QEventTransition::event(QEvent *e)
+{
+    return QAbstractTransition::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qeventtransition.h b/src/corelib/statemachine/qeventtransition.h
new file mode 100644
index 0000000..3530bdd
--- /dev/null
+++ b/src/corelib/statemachine/qeventtransition.h
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEVENTTRANSITION_H
+#define QEVENTTRANSITION_H
+
+#include <QtCore/qabstracttransition.h>
+#include <QtCore/qcoreevent.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QEventTransitionPrivate;
+class Q_CORE_EXPORT QEventTransition : public QAbstractTransition
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* eventObject READ eventObject WRITE setEventObject)
+    Q_PROPERTY(QEvent::Type eventType READ eventType WRITE setEventType)
+public:
+    QEventTransition(QState *sourceState = 0);
+    QEventTransition(QObject *object, QEvent::Type type, QState *sourceState = 0);
+    QEventTransition(QObject *object, QEvent::Type type,
+                     const QList<QAbstractState*> &targets, QState *sourceState = 0);
+    ~QEventTransition();
+
+    QObject *eventObject() const;
+    void setEventObject(QObject *object);
+
+    QEvent::Type eventType() const;
+    void setEventType(QEvent::Type type);
+
+protected:
+    bool eventTest(QEvent *event);
+    void onTransition(QEvent *event);
+
+    bool event(QEvent *e);
+
+protected:
+    QEventTransition(QEventTransitionPrivate &dd, QState *parent);
+    QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                     QEvent::Type type, QState *parent);
+    QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                     QEvent::Type type, const QList<QAbstractState*> &targets,
+                     QState *parent);
+
+private:
+    Q_DISABLE_COPY(QEventTransition)
+    Q_DECLARE_PRIVATE(QEventTransition)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qeventtransition_p.h b/src/corelib/statemachine/qeventtransition_p.h
new file mode 100644
index 0000000..fca8c0d
--- /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 "qabstracttransition_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEventTransition;
+class Q_CORE_EXPORT QEventTransitionPrivate : public QAbstractTransitionPrivate
+{
+    Q_DECLARE_PUBLIC(QEventTransition)
+public:
+    QEventTransitionPrivate();
+
+    static QEventTransitionPrivate *get(QEventTransition *q);
+
+    void 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..0980336
--- /dev/null
+++ b/src/corelib/statemachine/qfinalstate.cpp
@@ -0,0 +1,134 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qfinalstate.h"
+#include "qabstractstate_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QFinalState
+
+  \brief The QFinalState class provides a final state.
+
+  \since 4.6
+  \ingroup statemachine
+
+  A final state is used to communicate that (part of) a QStateMachine has
+  finished its work. When a final top-level state is entered, the state
+  machine's \l{QStateMachine::finished()}{finished}() signal is emitted. In
+  general, when a final substate (a child of a QState) is entered, the parent
+  state's \l{QState::finished()}{finished}() signal is emitted.  QFinalState
+  is part of \l{The State Machine Framework}.
+
+  To use a final state, you create a QFinalState object and add a transition
+  to it from another state. Example:
+
+  \code
+  QPushButton button;
+
+  QStateMachine machine;
+  QState *s1 = new QState();
+  QFinalState *s2 = new QFinalState();
+  s1->addTransition(&button, SIGNAL(clicked()), s2);
+  machine.addState(s1);
+  machine.addState(s2);
+
+  QObject::connect(&machine, SIGNAL(finished()), QApplication::instance(), SLOT(quit()));
+  machine.setInitialState(s1);
+  machine.start();
+  \endcode
+
+  \sa QStateMachine::finished(), QState::finished()
+*/
+
+class QFinalStatePrivate : public QAbstractStatePrivate
+{
+    Q_DECLARE_PUBLIC(QFinalState)
+
+public:
+    QFinalStatePrivate();
+};
+
+QFinalStatePrivate::QFinalStatePrivate()
+{
+}
+
+/*!
+  Constructs a new QFinalState object with the given \a parent state.
+*/
+QFinalState::QFinalState(QState *parent)
+    : QAbstractState(*new QFinalStatePrivate, parent)
+{
+}
+
+/*!
+  Destroys this final state.
+*/
+QFinalState::~QFinalState()
+{
+}
+
+/*!
+  \reimp
+*/
+void QFinalState::onEntry(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+void QFinalState::onExit(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+bool QFinalState::event(QEvent *e)
+{
+    return QAbstractState::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qfinalstate.h b/src/corelib/statemachine/qfinalstate.h
new file mode 100644
index 0000000..fa68394
--- /dev/null
+++ b/src/corelib/statemachine/qfinalstate.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFINALSTATE_H
+#define QFINALSTATE_H
+
+#include <QtCore/qabstractstate.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QFinalStatePrivate;
+class Q_CORE_EXPORT QFinalState : public QAbstractState
+{
+    Q_OBJECT
+public:
+    QFinalState(QState *parent = 0);
+    ~QFinalState();
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+
+    bool event(QEvent *e);
+
+private:
+    Q_DISABLE_COPY(QFinalState)
+    Q_DECLARE_PRIVATE(QFinalState)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qhistorystate.cpp b/src/corelib/statemachine/qhistorystate.cpp
new file mode 100644
index 0000000..517faa8
--- /dev/null
+++ b/src/corelib/statemachine/qhistorystate.cpp
@@ -0,0 +1,223 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qhistorystate.h"
+#include "qhistorystate_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QHistoryState
+
+  \brief The QHistoryState class provides a means of returning to a previously active substate.
+
+  \since 4.6
+  \ingroup statemachine
+
+  A history state is a pseudo-state that represents the child state that the
+  parent state was in the last time the parent state was exited. A transition
+  with a history state as its target is in fact a transition to one of the
+  other child states of the parent state. QHistoryState is part of \l{The
+  State Machine Framework}.
+
+  Use the setDefaultState() function to set the state that should be entered
+  if the parent state has never been entered.  Example:
+
+  \code
+  QStateMachine machine;
+
+  QState *s1 = new QState();
+  QState *s11 = new QState(s1);
+  QState *s12 = new QState(s1);
+
+  QHistoryState *s1h = new QHistoryState(s1);
+  s1h->setDefaultState(s11);
+
+  machine.addState(s1);
+
+  QState *s2 = new QState();
+  machine.addState(s2);
+
+  QPushButton *button = new QPushButton();
+  // Clicking the button will cause the state machine to enter the child state
+  // that s1 was in the last time s1 was exited, or the history state's default
+  // state if s1 has never been entered.
+  s1->addTransition(button, SIGNAL(clicked()), s1h);
+  \endcode
+
+  By default a history state is shallow, meaning that it won't remember nested
+  states. This can be configured through the historyType property.
+*/
+
+/*!
+  \property QHistoryState::defaultState
+
+  \brief the default state of this history state
+*/
+
+/*!
+  \property QHistoryState::historyType
+
+  \brief the type of history that this history state records
+
+  The default value of this property is QHistoryState::ShallowHistory.
+*/
+
+/*!
+  \enum QHistoryState::HistoryType
+
+  This enum specifies the type of history that a QHistoryState records.
+
+  \value ShallowHistory Only the immediate child states of the parent state
+  are recorded. In this case a transition with the history state as its
+  target will end up in the immediate child state that the parent was in the
+  last time it was exited. This is the default.
+
+  \value DeepHistory Nested states are recorded. In this case a transition
+  with the history state as its target will end up in the most deeply nested
+  descendant state the parent was in the last time it was exited.
+*/
+
+QHistoryStatePrivate::QHistoryStatePrivate()
+    : defaultState(0)
+{
+}
+
+QHistoryStatePrivate *QHistoryStatePrivate::get(QHistoryState *q)
+{
+    return q->d_func();
+}
+
+/*!
+  Constructs a new shallow history state with the given \a parent state.
+*/
+QHistoryState::QHistoryState(QState *parent)
+    : QAbstractState(*new QHistoryStatePrivate, parent)
+{
+    Q_D(QHistoryState);
+    d->historyType = ShallowHistory;
+}
+/*!
+  Constructs a new history state of the given \a type, with the given \a
+  parent state.
+*/
+QHistoryState::QHistoryState(HistoryType type, QState *parent)
+    : QAbstractState(*new QHistoryStatePrivate, parent)
+{
+    Q_D(QHistoryState);
+    d->historyType = type;
+}
+
+/*!
+  Destroys this history state.
+*/
+QHistoryState::~QHistoryState()
+{
+}
+
+/*!
+  Returns this history state's default state.  The default state indicates the
+  state to transition to if the parent state has never been entered before.
+*/
+QAbstractState *QHistoryState::defaultState() const
+{
+    Q_D(const QHistoryState);
+    return d->defaultState;
+}
+
+/*!
+  Sets this history state's default state to be the given \a state.
+  \a state must be a sibling of this history state.
+*/
+void QHistoryState::setDefaultState(QAbstractState *state)
+{
+    Q_D(QHistoryState);
+    if (state && state->parentState() != parentState()) {
+        qWarning("QHistoryState::setDefaultState: state %p does not belong "
+                 "to this history state's group (%p)", state, parentState());
+        return;
+    }
+    d->defaultState = state;
+}
+
+/*!
+  Returns the type of history that this history state records.
+*/
+QHistoryState::HistoryType QHistoryState::historyType() const
+{
+    Q_D(const QHistoryState);
+    return d->historyType;
+}
+
+/*!
+  Sets the \a type of history that this history state records.
+*/
+void QHistoryState::setHistoryType(HistoryType type)
+{
+    Q_D(QHistoryState);
+    d->historyType = type;
+}
+
+/*!
+  \reimp
+*/
+void QHistoryState::onEntry(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+void QHistoryState::onExit(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+/*!
+  \reimp
+*/
+bool QHistoryState::event(QEvent *e)
+{
+    return QAbstractState::event(e);
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/statemachine/qhistorystate.h b/src/corelib/statemachine/qhistorystate.h
new file mode 100644
index 0000000..a0682bd
--- /dev/null
+++ b/src/corelib/statemachine/qhistorystate.h
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QHISTORYSTATE_H
+#define QHISTORYSTATE_H
+
+#include <QtCore/qabstractstate.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QHistoryStatePrivate;
+class Q_CORE_EXPORT QHistoryState : public QAbstractState
+{
+    Q_OBJECT
+    Q_PROPERTY(QAbstractState* defaultState READ defaultState WRITE setDefaultState)
+    Q_PROPERTY(HistoryType historyType READ historyType WRITE setHistoryType)
+    Q_ENUMS(HistoryType)
+public:
+    enum HistoryType {
+        ShallowHistory,
+        DeepHistory
+    };
+
+    QHistoryState(QState *parent = 0);
+    QHistoryState(HistoryType type, QState *parent = 0);
+    ~QHistoryState();
+
+    QAbstractState *defaultState() const;
+    void setDefaultState(QAbstractState *state);
+
+    HistoryType historyType() const;
+    void setHistoryType(HistoryType type);
+
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+
+    bool event(QEvent *e);
+
+private:
+    Q_DISABLE_COPY(QHistoryState)
+    Q_DECLARE_PRIVATE(QHistoryState)
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/corelib/statemachine/qhistorystate_p.h b/src/corelib/statemachine/qhistorystate_p.h
new file mode 100644
author	Kent Hansen <khansen@trolltech.com>	2009-05-22 11:11:41 (GMT)
committer	Kent Hansen <khansen@trolltech.com>	2009-05-22 11:11:41 (GMT)
commit	1a709fbe25a2446a9b311ded88aec5565258f3ac (patch)
tree	0c7b0a5fbd94b7a4d59666f671fc8f995153161b /src
parent	5a734e4657161e0877b32181df35a56241b21de4 (diff)
download	Qt-1a709fbe25a2446a9b311ded88aec5565258f3ac.zip Qt-1a709fbe25a2446a9b311ded88aec5565258f3ac.tar.gz Qt-1a709fbe25a2446a9b311ded88aec5565258f3ac.tar.bz2