1 files changed, 846 insertions, 0 deletions

diff --git a/src/declarative/timeline/gfxeasing.cpp b/src/declarative/timeline/gfxeasing.cpp
new file mode 100644
index 0000000..c89ba88
--- /dev/null
+++ b/src/declarative/timeline/gfxeasing.cpp
@@ -0,0 +1,846 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative 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 "gfxeasing.h"
+#include <math.h>
+#include <QHash>
+#include <QPainter>
+#include <QVariant>
+#include <QDebug>
+#include <QStringList>
+#include <QMouseEvent>
+#include "gfxtimeline.h"
+
+
+QT_BEGIN_NAMESPACE
+typedef QHash<QString, qreal> GfxEasingProperties;
+class GfxEasingFunction
+{
+public:
+    virtual ~GfxEasingFunction() {}
+    virtual float value(float t, float b, float c, float d) = 0;
+    virtual GfxEasingFunction *copy() const = 0;
+};
+
+#include "../3rdparty/easing.cpp"
+
+struct ElasticEase : public GfxEasingFunction
+{
+    enum Type { In, Out };
+    ElasticEase(Type t) : _t(t), _p(0.0f), _a(0.0f) {}
+
+    Type _t;
+    qreal _p;
+    qreal _a;
+
+    GfxEasingFunction *copy() const
+    {
+        ElasticEase *rv = new ElasticEase(_t);
+        rv->_p = _p;
+        rv->_a = _a;
+        return rv;
+    }
+
+    float value(float t, float b, float c, float d)
+    {
+        if (t==0) return b;
+        float t_adj = (float)t / (float)d;
+        if (t_adj==1) return b+c;
+
+        qreal p = _p?_p:(d * 0.3f);
+
+        qreal a;
+        qreal s;
+
+        if(!_a || _a < ::fabs(c)) {
+            a = c;
+            s = p / 4.0f;
+        } else {
+            a = _a;
+            s = p / (2 * M_PI) * ::asin(c / a);
+        }
+
+        if(_t == In) 
+            t_adj -= 1.0f;
+
+        return (a*::pow(2,-10*t_adj) * ::sin( (t_adj*d-s)*(2*M_PI)/p ) + c + b);
+    }
+};
+
+struct BounceEase : public GfxEasingFunction
+{
+    enum Type { In, Out };
+    BounceEase(Type t) : _t(t), _a(-1.0) {}
+
+    Type _t;
+    qreal _a;
+
+    GfxEasingFunction *copy() const
+    {
+        BounceEase *rv = new BounceEase(_t);
+        rv->_t = _t;
+        rv->_a = _a;
+        return rv;
+    }
+
+    float value(float t, float b, float c, float d)
+    {
+        if(In == _t)
+            return c - bounce(d - t, 0, c, d) + b;
+        else
+            return bounce(t, b, c, d);
+    }
+
+    float bounce(float t, float b, float c, float d)
+    {
+        float t_adj = (float)t / (float)d;
+        float amp = (_a == -1.0)?c:_a;
+        if ((t_adj) < (1/2.75)) {
+            if(c == 0. && _a != -1.0) {
+                t_adj -= (0.5f/2.75f);
+                return -amp * (1. - (30.25*t_adj*t_adj)) + b;
+            } else {
+                return c*(7.5625*t_adj*t_adj) + b;
+            }
+        } else if (t_adj < (2/2.75)) {
+            t_adj -= (1.5f/2.75f);
+            return -amp * (1. - (7.5625*t_adj*t_adj + .75)) + (b + c);
+        } else if (t_adj < (2.5/2.75)) {
+            t_adj -= (2.25f/2.75f);
+            return -amp * (1. - (7.5625*t_adj*t_adj + .9375)) + (b + c);
+        } else {
+            t_adj -= (2.65f/2.75f);
+            return -amp * (1. - (7.5625*t_adj*t_adj + .984375)) + (b + c);
+        }
+    }
+};
+
+static GfxEasingFunction *easeInElasticC(const GfxEasingProperties &p)
+{
+    ElasticEase *rv = new ElasticEase(ElasticEase::In);
+    rv->_p = p[QLatin1String("period")];
+    rv->_a = p[QLatin1String("amplitude")];
+    return rv;
+}
+
+
+static GfxEasingFunction *easeOutElasticC(const GfxEasingProperties &p)
+{
+    ElasticEase *rv = new ElasticEase(ElasticEase::Out);
+    rv->_p = p[QLatin1String("period")];
+    rv->_a = p[QLatin1String("amplitude")];
+    return rv;
+}
+
+static GfxEasingFunction *easeOutBounceC(const GfxEasingProperties &p)
+{
+    BounceEase *rv = new BounceEase(BounceEase::Out);
+    rv->_a = p[QLatin1String("amplitude")];
+    return rv;
+}
+
+static GfxEasingFunction *easeInBounceC(const GfxEasingProperties &p)
+{
+    BounceEase *rv = new BounceEase(BounceEase::Out);
+    rv->_a = p[QLatin1String("amplitude")];
+    return rv;
+}
+
+
+struct SimpleConfig : public GfxEasingFunction
+{
+    GfxEasing::Function func;
+
+    float value(float t, float b, float c, float d)
+    {
+        return func(t, b, c, d);
+    }
+
+    GfxEasingFunction *copy() const
+    {
+        SimpleConfig *rv = new SimpleConfig;
+        rv->func = func;
+        return rv;
+    }
+};
+
+GfxEasing::Function curveToFunc(GfxEasing::Curve curve)
+{
+    switch(curve)
+    {
+    case GfxEasing::None:
+        return &easeNone;
+    case GfxEasing::InQuad:
+        return &easeInQuad;
+    case GfxEasing::OutQuad:
+        return &easeOutQuad;
+    case GfxEasing::InOutQuad:
+        return &easeInOutQuad;
+    case GfxEasing::OutInQuad:
+        return &easeOutInQuad;
+    case GfxEasing::InCubic:
+        return &easeInCubic;
+    case GfxEasing::OutCubic:
+        return &easeOutCubic;
+    case GfxEasing::InOutCubic:
+        return &easeInOutCubic;
+    case GfxEasing::OutInCubic:
+        return &easeOutInCubic;
+    case GfxEasing::InQuart:
+        return &easeInQuart;
+    case GfxEasing::OutQuart:
+        return &easeOutQuart;
+    case GfxEasing::InOutQuart:
+        return &easeInOutQuart;
+    case GfxEasing::OutInQuart:
+        return &easeOutInQuart;
+    case GfxEasing::InQuint:
+        return &easeInQuint;
+    case GfxEasing::OutQuint:
+        return &easeOutQuint;
+    case GfxEasing::InOutQuint:
+        return &easeInOutQuint;
+    case GfxEasing::OutInQuint:
+        return &easeOutInQuint;
+    case GfxEasing::InSine:
+        return &easeInSine;
+    case GfxEasing::OutSine:
+        return &easeOutSine;
+    case GfxEasing::InOutSine:
+        return &easeInOutSine;
+    case GfxEasing::OutInSine:
+        return &easeOutInSine;
+    case GfxEasing::InExpo:
+        return &easeInExpo;
+    case GfxEasing::OutExpo:
+        return &easeOutExpo;
+    case GfxEasing::InOutExpo:
+        return &easeInOutExpo;
+    case GfxEasing::OutInExpo:
+        return &easeOutInExpo;
+    case GfxEasing::InCirc:
+        return &easeInCirc;
+    case GfxEasing::OutCirc:
+        return &easeOutCirc;
+    case GfxEasing::InOutCirc:
+        return &easeInOutCirc;
+    case GfxEasing::OutInCirc:
+        return &easeOutInCirc;
+    case GfxEasing::InElastic:
+        return &easeInElastic;
+    case GfxEasing::OutElastic:
+        return &easeOutElastic;
+    case GfxEasing::InOutElastic:
+        return &easeInOutElastic;
+    case GfxEasing::OutInElastic:
+        return &easeOutInElastic;
+    case GfxEasing::InBack:
+        return &easeInBack;
+    case GfxEasing::OutBack:
+        return &easeOutBack;
+    case GfxEasing::InOutBack:
+        return &easeInOutBack;
+    case GfxEasing::OutInBack:
+        return &easeOutInBack;
+    case GfxEasing::InBounce:
+        return &easeInBounce;
+    case GfxEasing::OutBounce:
+        return &easeOutBounce;
+    case GfxEasing::InOutBounce:
+        return &easeInOutBounce;
+    case GfxEasing::OutInBounce:
+        return &easeOutInBounce;
+    default:
+        return 0;
+    };
+}
+
+struct NameFunctionMap : public QHash<QString, GfxEasing::Function>
+{
+    NameFunctionMap()
+    {
+        insert(QLatin1String("easeNone"), easeNone);
+        insert(QLatin1String("easeInQuad"), easeInQuad);
+        insert(QLatin1String("easeOutQuad"), easeOutQuad);
+        insert(QLatin1String("easeInOutQuad"), easeInOutQuad);
+        insert(QLatin1String("easeOutInQuad"), easeOutInQuad);
+        insert(QLatin1String("easeInCubic"), easeInCubic);
+        insert(QLatin1String("easeOutCubic"), easeOutCubic);
+        insert(QLatin1String("easeInOutCubic"), easeInOutCubic);
+        insert(QLatin1String("easeOutInCubic"), easeOutInCubic);
+        insert(QLatin1String("easeInQuart"), easeInQuart);
+        insert(QLatin1String("easeOutQuart"), easeOutQuart);
+        insert(QLatin1String("easeInOutQuart"), easeInOutQuart);
+        insert(QLatin1String("easeOutInQuart"), easeOutInQuart);
+        insert(QLatin1String("easeInQuint"), easeInQuint);
+        insert(QLatin1String("easeOutQuint"), easeOutQuint);
+        insert(QLatin1String("easeInOutQuint"), easeInOutQuint);
+        insert(QLatin1String("easeOutInQuint"), easeOutInQuint);
+        insert(QLatin1String("easeInSine"), easeInSine);
+        insert(QLatin1String("easeOutSine"), easeOutSine);
+        insert(QLatin1String("easeInOutSine"), easeInOutSine);
+        insert(QLatin1String("easeOutInSine"), easeOutInSine);
+        insert(QLatin1String("easeInExpo"), easeInExpo);
+        insert(QLatin1String("easeOutExpo"), easeOutExpo);
+        insert(QLatin1String("easeInOutExpo"), easeInOutExpo);
+        insert(QLatin1String("easeOutInExpo"), easeOutInExpo);
+        insert(QLatin1String("easeInCirc"), easeInCirc);
+        insert(QLatin1String("easeOutCirc"), easeOutCirc);
+        insert(QLatin1String("easeInOutCirc"), easeInOutCirc);
+        insert(QLatin1String("easeOutInCirc"), easeOutInCirc);
+        insert(QLatin1String("easeInElastic"), easeInElastic);
+        insert(QLatin1String("easeOutElastic"), easeOutElastic);
+        insert(QLatin1String("easeInOutElastic"), easeInOutElastic);
+        insert(QLatin1String("easeOutInElastic"), easeOutInElastic);
+        insert(QLatin1String("easeInBack"), easeInBack);
+        insert(QLatin1String("easeOutBack"), easeOutBack);
+        insert(QLatin1String("easeInOutBack"), easeInOutBack);
+        insert(QLatin1String("easeOutInBack"), easeOutInBack);
+        insert(QLatin1String("easeInBounce"), easeInBounce);
+        insert(QLatin1String("easeOutBounce"), easeOutBounce);
+        insert(QLatin1String("easeInOutBounce"), easeInOutBounce);
+        insert(QLatin1String("easeOutInBounce"), easeOutInBounce);
+    }
+};
+Q_GLOBAL_STATIC(NameFunctionMap, nameFunctionMap);
+
+typedef GfxEasingFunction *(*ConfigurableFunction)(const GfxEasingProperties &);
+struct ConfigFunctionMap : public QHash<QString, ConfigurableFunction>
+{
+    ConfigFunctionMap()
+    {
+        insert(QLatin1String("easeInElastic"), easeInElasticC);
+        insert(QLatin1String("easeOutElastic"), easeOutElasticC);
+        insert(QLatin1String("easeInBounce"), easeInBounceC);
+        insert(QLatin1String("easeOutBounce"), easeOutBounceC);
+    }
+};
+Q_GLOBAL_STATIC(ConfigFunctionMap, configFunctionMap);
+
+/*!
+    \class GfxEasing
+    \ingroup animation
+    \brief The GfxEasing class provides easing curves for controlling animation.
+
+    Easing curves describe a function that controls how a value changes over
+    time.  Easing curves allow transitions from one value to another to appear
+    more natural than a simple linear motion would allow.  The GfxEasing class
+    is usually used in conjunction with the GfxTimeLine class, but can be used
+    on its own.
+
+    To calculate the value at a given time, the easing curve function requires
+    the starting value, the final value and the total time to change from the
+    starting to the final value.  When using the GfxEasing class with
+    GfxTimeLine, these values are supplied by the GfxTimeLine.  When using
+    the GfxEasing class on its own, the programmer must specify them using
+    the GfxEasing::setFrom(), GfxEasing::setTo() and GfxEasing::setLength()
+    methods, or by passing them explicitly to the GfxEasing::valueAt() method.
+
+    For example,
+    \code
+    GfxEasing easing(GfxEasing::InOutQuad);
+    easing.setFrom(0);
+    easing.setTo(1000);
+    easing.setLength(1000);
+
+    for(int milliseconds = 0; milliseconds < 1000; ++milliseconds)
+        qWarning() << "Value at" << milliseconds << "milliseconds is
+                   << easing.valueAt(milliseconds);
+    \endcode
+    will print the value at each millisecond for an InOutQuad transition from
+    0 to 1000 over 1 second.
+
+    When using a GfxTimeLine, the values are communicated implicitly.
+    \code
+    GfxTimeLine timeline;
+    GfxValue value(0);
+
+    timeline.move(value, 1000, GfxEasing(GfxEasing::InOutQuad), 1000);
+    \endcode
+    In this case, any values set using the previous setter methods would be
+    ignored.
+ */
+
+/*!
+    \qmlproperty string NumericAnimation::easing
+    \brief the easing curve used for the transition.
+
+    Available values are:
+
+    \list
+    \i \e easeNone - Easing equation function for a simple linear tweening, with no easing.
+    \i \e easeInQuad - Easing equation function for a quadratic (t^2) easing in: accelerating from zero velocity.
+    \i \e easeOutQuad - Easing equation function for a quadratic (t^2) easing out: decelerating to zero velocity.
+    \i \e easeInOutQuad - Easing equation function for a quadratic (t^2) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInQuad - Easing equation function for a quadratic (t^2) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeInCubic - Easing equation function for a cubic (t^3) easing in: accelerating from zero velocity.
+    \i \e easeOutCubic - Easing equation function for a cubic (t^3) easing out: decelerating from zero velocity.
+    \i \e easeInOutCubic - Easing equation function for a cubic (t^3) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInCubic - Easing equation function for a cubic (t^3) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeInQuart - Easing equation function for a quartic (t^4) easing in: accelerating from zero velocity.
+    \i \e easeOutQuart - Easing equation function for a quartic (t^4) easing out: decelerating from zero velocity.
+    \i \e easeInOutQuart - Easing equation function for a quartic (t^4) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInQuart - Easing equation function for a quartic (t^4) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeInQuint - Easing equation function for a quintic (t^5) easing in: accelerating from zero velocity.
+    \i \e easeOutQuint - Easing equation function for a quintic (t^5) easing out: decelerating from zero velocity.
+    \i \e easeInOutQuint - Easing equation function for a quintic (t^5) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInQuint - Easing equation function for a quintic (t^5) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeInSine - Easing equation function for a sinusoidal (sin(t)) easing in: accelerating from zero velocity.
+    \i \e easeOutSine - Easing equation function for a sinusoidal (sin(t)) easing out: decelerating from zero velocity.
+    \i \e easeInOutSine - Easing equation function for a sinusoidal (sin(t)) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInSine - Easing equation function for a sinusoidal (sin(t)) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeInExpo - Easing equation function for an exponential (2^t) easing in: accelerating from zero velocity.
+    \i \e easeOutExpo - Easing equation function for an exponential (2^t) easing out: decelerating from zero velocity.
+    \i \e easeInOutExpo - Easing equation function for an exponential (2^t) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInExpo - Easing equation function for an exponential (2^t) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeInCirc - Easing equation function for a circular (sqrt(1-t^2)) easing in: accelerating from zero velocity.
+    \i \e easeOutCirc - Easing equation function for a circular (sqrt(1-t^2)) easing out: decelerating from zero velocity.
+    \i \e easeInOutCirc - Easing equation function for a circular (sqrt(1-t^2)) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInCirc - Easing equation function for a circular (sqrt(1-t^2)) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeInElastic - Easing equation function for an elastic (exponentially decaying sine wave) easing in: accelerating from zero velocity.  The peak amplitude can be set with the \i amplitude parameter, and the period of decay by the \i period parameter.
+    \i \e easeOutElastic - Easing equation function for an elastic (exponentially decaying sine wave) easing out: decelerating from zero velocity.  The peak amplitude can be set with the \i amplitude parameter, and the period of decay by the \i period parameter.
+    \i \e easeInOutElastic - Easing equation function for an elastic (exponentially decaying sine wave) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInElastic - Easing equation function for an elastic (exponentially decaying sine wave) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeInBack - Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in: accelerating from zero velocity.
+    \i \e easeOutBack - Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out: decelerating from zero velocity.
+    \i \e easeInOutBack - Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInBack - Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out/in: deceleration until halfway, then acceleration.
+    \i \e easeOutBounce - Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out: decelerating from zero velocity.
+    \i \e easeInBounce - Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in: accelerating from zero velocity.
+    \i \e easeInOutBounce - Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out: acceleration until halfway, then deceleration.
+    \i \e easeOutInBounce - Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out/in: deceleration until halfway, then acceleration.
+    \endlist
+*/
+
+/*!
+    \enum GfxEasing::Curve
+
+    The type of easing curve.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::None 
+    Easing equation function for a simple linear tweening, with no easing.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InQuad 
+    Easing equation function for a quadratic (t^2) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutQuad 
+    Easing equation function for a quadratic (t^2) easing out: decelerating to zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutQuad 
+    Easing equation function for a quadratic (t^2) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInQuad 
+    Easing equation function for a quadratic (t^2) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InCubic 
+    Easing equation function for a cubic (t^3) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutCubic 
+    Easing equation function for a cubic (t^3) easing out: decelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutCubic 
+    Easing equation function for a cubic (t^3) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInCubic 
+    Easing equation function for a cubic (t^3) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InQuart 
+    Easing equation function for a quartic (t^4) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutQuart 
+    Easing equation function for a quartic (t^4) easing out: decelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutQuart 
+    Easing equation function for a quartic (t^4) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInQuart 
+    Easing equation function for a quartic (t^4) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InQuint 
+    Easing equation function for a quintic (t^5) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutQuint 
+    Easing equation function for a quintic (t^5) easing out: decelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutQuint 
+    Easing equation function for a quintic (t^5) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInQuint 
+    Easing equation function for a quintic (t^5) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InSine 
+    Easing equation function for a sinusoidal (sin(t)) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutSine 
+    Easing equation function for a sinusoidal (sin(t)) easing out: decelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutSine 
+    Easing equation function for a sinusoidal (sin(t)) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInSine 
+    Easing equation function for a sinusoidal (sin(t)) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InExpo 
+    Easing equation function for an exponential (2^t) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutExpo 
+    Easing equation function for an exponential (2^t) easing out: decelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutExpo 
+    Easing equation function for an exponential (2^t) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInExpo 
+    Easing equation function for an exponential (2^t) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InCirc 
+    Easing equation function for a circular (sqrt(1-t^2)) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutCirc 
+    Easing equation function for a circular (sqrt(1-t^2)) easing out: decelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutCirc 
+    Easing equation function for a circular (sqrt(1-t^2)) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInCirc 
+    Easing equation function for a circular (sqrt(1-t^2)) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InElastic 
+    Easing equation function for an elastic (exponentially decaying sine wave) easing in: accelerating from zero velocity.  The peak amplitude can be set with the \i amplitude parameter, and the period of decay by the \i period parameter.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutElastic 
+    Easing equation function for an elastic (exponentially decaying sine wave) easing out: decelerating from zero velocity.  The peak amplitude can be set with the \i amplitude parameter, and the period of decay by the \i period parameter.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutElastic 
+    Easing equation function for an elastic (exponentially decaying sine wave) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInElastic 
+    Easing equation function for an elastic (exponentially decaying sine wave) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InBack 
+    Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutBack 
+    Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out: decelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutBack 
+    Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInBack 
+    Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out/in: deceleration until halfway, then acceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutBounce 
+    Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out: decelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InBounce 
+    Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in: accelerating from zero velocity.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::InOutBounce 
+    Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out: acceleration until halfway, then deceleration.
+*/
+/*!
+    \var GfxEasing::Curve GfxEasing::OutInBounce 
+    Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out/in: deceleration until halfway, then acceleration.
+*/
+
+/*!
+    Construct a linear easing object.  This is equivalent to \c {GfxEasing(GfxEasing::None)}.
+ */
+GfxEasing::GfxEasing()
+: _config(0), _func(&easeNone), _b(0.), _c(1.), _d(1.)
+{
+}
+
+/*!
+    Construct an easing object with the given \a curve.
+ */
+GfxEasing::GfxEasing(Curve curve)
+: _config(0), _func(0), _b(0.), _c(1.), _d(1.)
+{
+    _func = curveToFunc(curve);
+    if(!_func) {
+        qWarning("GfxEasing: Invalid curve type %d", curve);
+        _func = &easeNone;
+    }
+}
+
+/*!
+    Construct an easing object with the given \a curve.  If \a curve does not
+    describe a legal curve, a linear easing object is constructed.
+
+    Curve names have the form
+    \c {ease<CurveName>[(<arg>: <arg value>[, <arg2>: <arg value>])]}.  The
+    \i CurveName is equivalent to the GfxEasing::Curve enum name.  Some more
+    advanced curves can take arguments to further refine their behaviour.  Where
+    applicable, these parameters are described in the corresponding
+    GfxEasing::Curve value documentation.
+
+    For example,
+    \code
+    GfxEasing easing("easeInOutQuad");
+    GfxEasing easing2("easeInElastic(period: 5, amplitude: 100)");
+    \endcode
+ */
+GfxEasing::GfxEasing(const QString &curve)
+: _config(0), _func(&easeNone), _b(0.), _c(1.), _d(1.)
+{
+    if(curve.contains(QLatin1Char('('))) {
+        QString easeName = curve.trimmed();
+        GfxEasingProperties prop;
+        if(!easeName.endsWith(QLatin1Char(')'))) {
+            qWarning("GfxEasing: Unmatched perenthesis in easing function '%s'",
+                     curve.toLatin1().constData());
+            return;
+        }
+
+        int idx = easeName.indexOf(QLatin1Char('('));
+        QString prop_str =
+            easeName.mid(idx + 1, easeName.length() - 1 - idx - 1);
+        easeName = easeName.left(idx);
+
+        QStringList props = prop_str.split(QLatin1Char(','));
+        foreach(QString str, props) {
+            int sep = str.indexOf(QLatin1Char(':'));
+
+            if(sep == -1) {
+                qWarning("GfxEasing: Improperly specified property in easing function '%s'",
+                        curve.toLatin1().constData());
+                return;
+            }
+
+            QString propName = str.left(sep).trimmed();
+            bool isOk;
+            qreal propValue = str.mid(sep + 1).trimmed().toDouble(&isOk);
+
+            if(propName.isEmpty() || !isOk) {
+                qWarning("GfxEasing: Improperly specified property in easing function '%s'",
+                        curve.toLatin1().constData());
+                return;
+            }
+
+            prop.insert(propName, propValue);
+        }
+
+        QHash<QString, ConfigurableFunction>::Iterator iter =
+            configFunctionMap()->find(easeName);
+
+        if(iter != configFunctionMap()->end())
+            _config = (*iter)(prop);
+    } else {
+        if(nameFunctionMap()->contains(curve))
+            _func = *(nameFunctionMap()->find(curve));
+    }
+
+    if(!_func && !_config) {
+        qWarning("GfxEasing: Unknown easing curve '%s'",
+                 curve.toLatin1().constData());
+        _func = &easeNone;
+    }
+}
+
+/*!
+    Construct a copy of \a other.
+ */
+GfxEasing::GfxEasing(const GfxEasing &other)
+: _config(0), _func(other._func), _b(other._b), _c(other._c), _d(other._d)
+{
+    if(other._config) _config = other._config->copy();
+}
+
+/*!
+    Copy \a other.
+ */
+GfxEasing &GfxEasing::operator=(const GfxEasing &other)
+{
+    if(_config) { delete _config; _config = 0; }
+    if(other._config) _config = other._config->copy();
+
+    _func = other._func;
+    _b = other._b;
+    _c = other._c;
+    _d = other._d;
+
+    return *this;
+}
+
+/*!
+    Returns true if this is a linear easing object.
+ */
+bool GfxEasing::isLinear() const
+{
+    return !_config && _func == &easeNone;
+}
+
+/*!
+    Return the starting value for the easing curve.  By default this is 0.
+ */
+qreal GfxEasing::from() const
+{
+    return _b;
+}
+
+/*!
+    Set the starting value for the easing curve to \a from.
+ */
+void GfxEasing::setFrom(qreal from)
+{
+    _b = from;
+}
+
+/*!
+    Return the final value for the easing curve.  By default this is 0.
+ */
+qreal GfxEasing::to() const
+{
+    return _c;
+}
+
+/*!
+    Set the final value for the easing curve to \a to.
+ */
+void GfxEasing::setTo(qreal to)
+{
+    _c = to;
+}
+
+/*!
+    Return the length of the easing curve, in milliseconds.  By default this
+    is 1.
+ */
+qreal GfxEasing::length() const
+{
+    return _d;
+}
+
+/*!
+    Set the \a length of the easing curve, in milliseconds.
+ */
+void GfxEasing::setLength(qreal length)
+{
+    Q_ASSERT(length > 0);
+    _d = length;
+}
+
+/*!
+    Return the value for the easing curve at time \a t milliseconds, based on
+    the parameters returned by GfxEasing::from(), GfxEasing::to() and
+    GfxEasing::length().
+
+    \a t is clamped to (0, GfxEasing::length()).
+ */
+qreal GfxEasing::valueAt(qreal t) const
+{
+    if(t < 0) t = 0;
+    else if(t > length()) t = length();
+
+    if(_config)
+        return _config->value(t, _b, _c - _b, _d);
+    else
+        return _func(t, _b, _c - _b, _d);
+}
+
+/*
+    Return the value for the easing curve at time \a t milliseconds, based on
+    the provided parameters \a from, \a to and \a length.  The values returned
+    from the object's GfxEasing::from(), GfxEasing::to() and GfxEasing::length()
+    methods are ignored.
+
+    \a t is clamped to (0, \a length).
+ */
+qreal GfxEasing::valueAt(qreal t, qreal from, qreal to, qreal length) const
+{
+    if(t < 0) t = 0;
+    else if(t > length) t = length;
+
+    if(_config)
+        return _config->value(t, from, to - from, length);
+    else
+        return _func(t, from, to - from, length);
+}
+
+/*!
+    \internal
+ */
+QStringList GfxEasing::curves()
+{
+    return nameFunctionMap()->keys();
+}
+
+QT_END_NAMESPACE