← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/corelib/tools/qeasingcurve.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/corelib/tools/qeasingcurve.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
4
** All rights reserved.
 
5
** Contact: Nokia Corporation (qt-info@nokia.com)
 
6
**
 
7
** This file is part of the QtCore module of the Qt Toolkit.
 
8
**
 
9
** $QT_BEGIN_LICENSE:LGPL$
 
10
** No Commercial Usage
 
11
** This file contains pre-release code and may not be distributed.
 
12
** You may use this file in accordance with the terms and conditions
 
13
** contained in the Technology Preview License Agreement accompanying
 
14
** this package.
 
15
**
 
16
** GNU Lesser General Public License Usage
 
17
** Alternatively, this file may be used under the terms of the GNU Lesser
 
18
** General Public License version 2.1 as published by the Free Software
 
19
** Foundation and appearing in the file LICENSE.LGPL included in the
 
20
** packaging of this file.  Please review the following information to
 
21
** ensure the GNU Lesser General Public License version 2.1 requirements
 
22
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
23
**
 
24
** In addition, as a special exception, Nokia gives you certain additional
 
25
** rights.  These rights are described in the Nokia Qt LGPL Exception
 
26
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
27
**
 
28
** If you have questions regarding the use of this file, please contact
 
29
** Nokia at qt-info@nokia.com.
 
30
**
 
31
**
 
32
**
 
33
**
 
34
**
 
35
**
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
 
 
42
/*
 
43
 
 
44
| *property* | *Used for type* |
 
45
| period     | QEasingCurve::{In,Out,InOut,OutIn}Elastic |
 
46
| amplitude  | QEasingCurve::{In,Out,InOut,OutIn}Bounce, QEasingCurve::{In,Out,InOut,OutIn}Elastic |
 
47
| overshoot  | QEasingCurve::{In,Out,InOut,OutIn}Back   |
 
48
 
 
49
*/
 
50
 
 
51
 
 
52
 
 
53
 
 
54
/*!
 
55
    \class QEasingCurve
 
56
    \since 4.6
 
57
    \ingroup animation
 
58
    \brief The QEasingCurve class provides easing curves for controlling animation.
 
59
 
 
60
    Easing curves describe a function that controls how the speed of the interpolation
 
61
    between 0 and 1 should be. Easing curves allow transitions from
 
62
    one value to another to appear more natural than a simple constant speed would allow.
 
63
    The QEasingCurve class is usually used in conjunction with the QVariantAnimation and
 
64
    QPropertyAnimation classes but can be used on its own. It is usually used to accelerate
 
65
    the interpolation from zero velocity (ease in) or decelerate to zero velocity (ease out).
 
66
    Ease in and ease out can also be combined in the same easing curve.
 
67
 
 
68
    To calculate the speed of the interpolation, the easing curve provides the function
 
69
    valueForProgress(), where the \a progress argument specifies the progress of the
 
70
    interpolation: 0 is the start value of the interpolation, 1 is the end value of the
 
71
    interpolation. The returned value is the effective progress of the interpolation.
 
72
    If the returned value is the same as the input value for all input values the easing
 
73
    curve is a linear curve. This is the default behaviour.
 
74
 
 
75
    For example,
 
76
    \code
 
77
    QEasingCurve easing(QEasingCurve::InOutQuad);
 
78
 
 
79
    for(qreal t = 0.0; t < 1.0; t+=0.1)
 
80
        qWarning() << "Effective progress" << t << " is
 
81
                   << easing.valueForProgress(t);
 
82
    \endcode
 
83
    will print the effective progress of the interpolation between 0 and 1.
 
84
 
 
85
    When using a QPropertyAnimation, the associated easing curve will be used to control the
 
86
    progress of the interpolation between startValue and endValue:
 
87
    \code
 
88
    QPropertyAnimation animation;
 
89
    animation.setStartValue(0);
 
90
    animation.setEndValue(1000);
 
91
    animation.setDuration(1000);
 
92
    animation.setEasingCurve(QEasingCurve::InOutQuad);
 
93
    \endcode
 
94
 */
 
95
 
 
96
/*!
 
97
    \enum QEasingCurve::Type
 
98
 
 
99
    The type of easing curve.
 
100
 
 
101
    \value Linear       \inlineimage qeasingcurve-linear.png
 
102
                        \br
 
103
                        Easing curve for a linear (t) function:
 
104
                        velocity is constant.
 
105
    \value InQuad       \inlineimage qeasingcurve-inquad.png
 
106
                        \br
 
107
                        Easing curve for a quadratic (t^2) function:
 
108
                        accelerating from zero velocity.
 
109
    \value OutQuad      \inlineimage qeasingcurve-outquad.png
 
110
                        \br
 
111
                        Easing curve for a quadratic (t^2) function:
 
112
                        decelerating to zero velocity.
 
113
    \value InOutQuad    \inlineimage qeasingcurve-inoutquad.png
 
114
                        \br
 
115
                        Easing curve for a quadratic (t^2) function:
 
116
                        acceleration until halfway, then deceleration.
 
117
    \value OutInQuad    \inlineimage qeasingcurve-outinquad.png
 
118
                        \br
 
119
                        Easing curve for a quadratic (t^2) function:
 
120
                        deceleration until halfway, then acceleration.
 
121
    \value InCubic      \inlineimage qeasingcurve-incubic.png
 
122
                        \br
 
123
                        Easing curve for a cubic (t^3) function:
 
124
                        accelerating from zero velocity.
 
125
    \value OutCubic     \inlineimage qeasingcurve-outcubic.png
 
126
                        \br
 
127
                        Easing curve for a cubic (t^3) function:
 
128
                        decelerating from zero velocity.
 
129
    \value InOutCubic   \inlineimage qeasingcurve-inoutcubic.png
 
130
                        \br
 
131
                        Easing curve for a cubic (t^3) function:
 
132
                        acceleration until halfway, then deceleration.
 
133
    \value OutInCubic   \inlineimage qeasingcurve-outincubic.png
 
134
                        \br
 
135
                        Easing curve for a cubic (t^3) function:
 
136
                        deceleration until halfway, then acceleration.
 
137
    \value InQuart      \inlineimage qeasingcurve-inquart.png
 
138
                        \br
 
139
                        Easing curve for a quartic (t^4) function:
 
140
                        accelerating from zero velocity.
 
141
    \value OutQuart     \inlineimage qeasingcurve-outquart.png
 
142
                        \br
 
143
                        Easing curve for a cubic (t^4) function:
 
144
                        decelerating from zero velocity.
 
145
    \value InOutQuart   \inlineimage qeasingcurve-inoutquart.png
 
146
                        \br
 
147
                        Easing curve for a cubic (t^4) function:
 
148
                        acceleration until halfway, then deceleration.
 
149
    \value OutInQuart   \inlineimage qeasingcurve-outinquart.png
 
150
                        \br
 
151
                        Easing curve for a cubic (t^4) function:
 
152
                        deceleration until halfway, then acceleration.
 
153
    \value InQuint      \inlineimage qeasingcurve-inquint.png
 
154
                        \br
 
155
                        Easing curve for a quintic (t^5) easing
 
156
                        in: accelerating from zero velocity.
 
157
    \value OutQuint     \inlineimage qeasingcurve-outquint.png
 
158
                        \br
 
159
                        Easing curve for a cubic (t^5) function:
 
160
                        decelerating from zero velocity.
 
161
    \value InOutQuint   \inlineimage qeasingcurve-inoutquint.png
 
162
                        \br
 
163
                        Easing curve for a cubic (t^5) function:
 
164
                        acceleration until halfway, then deceleration.
 
165
    \value OutInQuint   \inlineimage qeasingcurve-outinquint.png
 
166
                        \br
 
167
                        Easing curve for a cubic (t^5) function:
 
168
                        deceleration until halfway, then acceleration.
 
169
    \value InSine       \inlineimage qeasingcurve-insine.png
 
170
                        \br
 
171
                        Easing curve for a sinusoidal (sin(t)) function:
 
172
                        accelerating from zero velocity.
 
173
    \value OutSine      \inlineimage qeasingcurve-outsine.png
 
174
                        \br
 
175
                        Easing curve for a sinusoidal (sin(t)) function:
 
176
                        decelerating from zero velocity.
 
177
    \value InOutSine    \inlineimage qeasingcurve-inoutsine.png
 
178
                        \br
 
179
                        Easing curve for a sinusoidal (sin(t)) function:
 
180
                        acceleration until halfway, then deceleration.
 
181
    \value OutInSine    \inlineimage qeasingcurve-outinsine.png
 
182
                        \br
 
183
                        Easing curve for a sinusoidal (sin(t)) function:
 
184
                        deceleration until halfway, then acceleration.
 
185
    \value InExpo       \inlineimage qeasingcurve-inexpo.png
 
186
                        \br
 
187
                        Easing curve for an exponential (2^t) function:
 
188
                        accelerating from zero velocity.
 
189
    \value OutExpo      \inlineimage qeasingcurve-outexpo.png
 
190
                        \br
 
191
                        Easing curve for an exponential (2^t) function:
 
192
                        decelerating from zero velocity.
 
193
    \value InOutExpo    \inlineimage qeasingcurve-inoutexpo.png
 
194
                        \br
 
195
                        Easing curve for an exponential (2^t) function:
 
196
                        acceleration until halfway, then deceleration.
 
197
    \value OutInExpo    \inlineimage qeasingcurve-outinexpo.png
 
198
                        \br
 
199
                        Easing curve for an exponential (2^t) function:
 
200
                        deceleration until halfway, then acceleration.
 
201
    \value InCirc       \inlineimage qeasingcurve-incirc.png
 
202
                        \br
 
203
                        Easing curve for a circular (sqrt(1-t^2)) function:
 
204
                        accelerating from zero velocity.
 
205
    \value OutCirc      \inlineimage qeasingcurve-outcirc.png
 
206
                        \br
 
207
                        Easing curve for a circular (sqrt(1-t^2)) function:
 
208
                        decelerating from zero velocity.
 
209
    \value InOutCirc    \inlineimage qeasingcurve-inoutcirc.png
 
210
                        \br
 
211
                        Easing curve for a circular (sqrt(1-t^2)) function:
 
212
                        acceleration until halfway, then deceleration.
 
213
    \value OutInCirc    \inlineimage qeasingcurve-outincirc.png
 
214
                        \br
 
215
                        Easing curve for a circular (sqrt(1-t^2)) function:
 
216
                        deceleration until halfway, then acceleration.
 
217
    \value InElastic    \inlineimage qeasingcurve-inelastic.png
 
218
                        \br
 
219
                        Easing curve for an elastic
 
220
                        (exponentially decaying sine wave) function:
 
221
                        accelerating from zero velocity.  The peak amplitude
 
222
                        can be set with the \e amplitude parameter, and the
 
223
                        period of decay by the \e period parameter.
 
224
    \value OutElastic   \inlineimage qeasingcurve-outelastic.png
 
225
                        \br
 
226
                        Easing curve for an elastic
 
227
                        (exponentially decaying sine wave) function:
 
228
                        decelerating from zero velocity.  The peak amplitude
 
229
                        can be set with the \e amplitude parameter, and the
 
230
                        period of decay by the \e period parameter.
 
231
    \value InOutElastic \inlineimage qeasingcurve-inoutelastic.png
 
232
                        \br
 
233
                        Easing curve for an elastic
 
234
                        (exponentially decaying sine wave) function:
 
235
                        acceleration until halfway, then deceleration.
 
236
    \value OutInElastic \inlineimage qeasingcurve-outinelastic.png
 
237
                        \br
 
238
                        Easing curve for an elastic
 
239
                        (exponentially decaying sine wave) function:
 
240
                        deceleration until halfway, then acceleration.
 
241
    \value InBack       \inlineimage qeasingcurve-inback.png
 
242
                        \br
 
243
                        Easing curve for a back (overshooting
 
244
                        cubic function: (s+1)*t^3 - s*t^2) easing in:
 
245
                        accelerating from zero velocity.
 
246
    \value OutBack      \inlineimage qeasingcurve-outback.png
 
247
                        \br
 
248
                        Easing curve for a back (overshooting
 
249
                        cubic function: (s+1)*t^3 - s*t^2) easing out:
 
250
                        decelerating to zero velocity.
 
251
    \value InOutBack    \inlineimage qeasingcurve-inoutback.png
 
252
                        \br
 
253
                        Easing curve for a back (overshooting
 
254
                        cubic function: (s+1)*t^3 - s*t^2) easing in/out:
 
255
                        acceleration until halfway, then deceleration.
 
256
    \value OutInBack    \inlineimage qeasingcurve-outinback.png
 
257
                        \br
 
258
                        Easing curve for a back (overshooting
 
259
                        cubic easing: (s+1)*t^3 - s*t^2) easing out/in:
 
260
                        deceleration until halfway, then acceleration.
 
261
    \value InBounce     \inlineimage qeasingcurve-inbounce.png
 
262
                        \br
 
263
                        Easing curve for a bounce (exponentially
 
264
                        decaying parabolic bounce) function: accelerating
 
265
                        from zero velocity.
 
266
    \value OutBounce    \inlineimage qeasingcurve-outbounce.png
 
267
                        \br
 
268
                        Easing curve for a bounce (exponentially
 
269
                        decaying parabolic bounce) function: decelerating
 
270
                        from zero velocity.
 
271
    \value InOutBounce  \inlineimage qeasingcurve-inoutbounce.png
 
272
                        \br
 
273
                        Easing curve for a bounce (exponentially
 
274
                        decaying parabolic bounce) function easing in/out:
 
275
                        acceleration until halfway, then deceleration.
 
276
    \value OutInBounce  \inlineimage qeasingcurve-outinbounce.png
 
277
                        \br
 
278
                        Easing curve for a bounce (exponentially
 
279
                        decaying parabolic bounce) function easing out/in:
 
280
                        deceleration until halfway, then acceleration.
 
281
    \omitvalue InCurve
 
282
    \omitvalue OutCurve
 
283
    \omitvalue SineCurve
 
284
    \omitvalue CosineCurve
 
285
    \value Custom       This is returned if the user specified a custom curve type with
 
286
                        setCustomType(). Note that you cannot call setType() with this value,
 
287
                        but type() can return it.
 
288
    \omitvalue NCurveTypes
 
289
*/
 
290
 
 
291
/*!
 
292
    \typedef QEasingCurve::EasingFunction
 
293
 
 
294
    This is a typedef for a pointer to a function with the following
 
295
    signature:
 
296
 
 
297
    \snippet doc/src/snippets/code/src_corelib_tools_qeasingcurve.cpp 0
 
298
*/
 
299
 
 
300
#include "qeasingcurve.h"
 
301
 
 
302
#ifndef QT_NO_DEBUG_STREAM
 
303
#include <QtCore/qdebug.h>
 
304
#include <QtCore/qstring.h>
 
305
#endif
 
306
 
 
307
QT_BEGIN_NAMESPACE
 
308
 
 
309
static bool isConfigFunction(QEasingCurve::Type type)
 
310
{
 
311
    return type >= QEasingCurve::InElastic
 
312
            && type <= QEasingCurve::OutInBounce;
 
313
}
 
314
 
 
315
class QEasingCurveFunction
 
316
{
 
317
public:
 
318
    enum Type { In, Out, InOut, OutIn };
 
319
 
 
320
    QEasingCurveFunction(QEasingCurveFunction::Type type = In, qreal period = 0.3, qreal amplitude = 1.0,
 
321
        qreal overshoot = 1.70158f)
 
322
        : _t(type), _p(period), _a(amplitude), _o(overshoot)
 
323
    { }
 
324
    virtual ~QEasingCurveFunction() {}
 
325
    virtual qreal value(qreal t);
 
326
    virtual QEasingCurveFunction *copy() const;
 
327
    bool operator==(const QEasingCurveFunction& other);
 
328
 
 
329
    Type _t;
 
330
    qreal _p;
 
331
    qreal _a;
 
332
    qreal _o;
 
333
};
 
334
 
 
335
qreal QEasingCurveFunction::value(qreal t)
 
336
{
 
337
    return t;
 
338
}
 
339
 
 
340
QEasingCurveFunction *QEasingCurveFunction::copy() const
 
341
{
 
342
    return new QEasingCurveFunction(_t, _p, _a, _o);
 
343
}
 
344
 
 
345
bool QEasingCurveFunction::operator==(const QEasingCurveFunction& other)
 
346
{
 
347
    return _t == other._t &&
 
348
           _p == other._p &&
 
349
           _a == other._a &&
 
350
           _o == other._o;
 
351
}
 
352
 
 
353
QT_BEGIN_INCLUDE_NAMESPACE
 
354
#include "../../3rdparty/easing/easing.cpp"
 
355
QT_END_INCLUDE_NAMESPACE
 
356
 
 
357
class QEasingCurvePrivate
 
358
{
 
359
public:
 
360
    QEasingCurvePrivate()
 
361
        : type(QEasingCurve::Linear),
 
362
          config(0),
 
363
          func(&easeNone)
 
364
    { }
 
365
    ~QEasingCurvePrivate() { delete config; }
 
366
    void setType_helper(QEasingCurve::Type);
 
367
 
 
368
    QEasingCurve::Type type;
 
369
    QEasingCurveFunction *config;
 
370
    QEasingCurve::EasingFunction func;
 
371
};
 
372
 
 
373
struct ElasticEase : public QEasingCurveFunction
 
374
{
 
375
    ElasticEase(Type type)
 
376
        : QEasingCurveFunction(type, qreal(0.3), qreal(1.0))
 
377
    { }
 
378
 
 
379
    QEasingCurveFunction *copy() const
 
380
    {
 
381
        ElasticEase *rv = new ElasticEase(_t);
 
382
        rv->_p = _p;
 
383
        rv->_a = _a;
 
384
        return rv;
 
385
    }
 
386
 
 
387
    qreal value(qreal t)
 
388
    {
 
389
        qreal p = (_p < 0) ? 0.3f : _p;
 
390
        qreal a = (_a < 0) ? 1.0f : _a;
 
391
        switch(_t) {
 
392
        case In:
 
393
            return easeInElastic(t, a, p);
 
394
        case Out:
 
395
            return easeOutElastic(t, a, p);
 
396
        case InOut:
 
397
            return easeInOutElastic(t, a, p);
 
398
        case OutIn:
 
399
            return easeOutInElastic(t, a, p);
 
400
        default:
 
401
            return t;
 
402
        }
 
403
    }
 
404
};
 
405
 
 
406
struct BounceEase : public QEasingCurveFunction
 
407
{
 
408
    BounceEase(Type type)
 
409
        : QEasingCurveFunction(type, 0.3f, 1.0f)
 
410
    { }
 
411
 
 
412
    QEasingCurveFunction *copy() const
 
413
    {
 
414
        BounceEase *rv = new BounceEase(_t);
 
415
        rv->_a = _a;
 
416
        return rv;
 
417
    }
 
418
 
 
419
    qreal value(qreal t)
 
420
    {
 
421
        qreal a = (_a < 0) ? 1.0f : _a;
 
422
        switch(_t) {
 
423
        case In:
 
424
            return easeInBounce(t, a);
 
425
        case Out:
 
426
            return easeOutBounce(t, a);
 
427
        case InOut:
 
428
            return easeInOutBounce(t, a);
 
429
        case OutIn:
 
430
            return easeOutInBounce(t, a);
 
431
        default:
 
432
            return t;
 
433
        }
 
434
    }
 
435
};
 
436
 
 
437
struct BackEase : public QEasingCurveFunction
 
438
{
 
439
    BackEase(Type type)
 
440
        : QEasingCurveFunction(type, 0.3f, 1.0f, 1.70158f)
 
441
    { }
 
442
 
 
443
    QEasingCurveFunction *copy() const
 
444
    {
 
445
        BackEase *rv = new BackEase(_t);
 
446
        rv->_o = _o;
 
447
        return rv;
 
448
    }
 
449
 
 
450
    qreal value(qreal t)
 
451
    {
 
452
        qreal o = (_o < 0) ? 1.70158f : _o;
 
453
        switch(_t) {
 
454
        case In:
 
455
            return easeInBack(t, o);
 
456
        case Out:
 
457
            return easeOutBack(t, o);
 
458
        case InOut:
 
459
            return easeInOutBack(t, o);
 
460
        case OutIn:
 
461
            return easeOutInBack(t, o);
 
462
        default:
 
463
            return t;
 
464
        }
 
465
    }
 
466
};
 
467
 
 
468
static QEasingCurve::EasingFunction curveToFunc(QEasingCurve::Type curve)
 
469
{
 
470
    switch(curve) {
 
471
    case QEasingCurve::Linear:
 
472
        return &easeNone;
 
473
    case QEasingCurve::InQuad:
 
474
        return &easeInQuad;
 
475
    case QEasingCurve::OutQuad:
 
476
        return &easeOutQuad;
 
477
    case QEasingCurve::InOutQuad:
 
478
        return &easeInOutQuad;
 
479
    case QEasingCurve::OutInQuad:
 
480
        return &easeOutInQuad;
 
481
    case QEasingCurve::InCubic:
 
482
        return &easeInCubic;
 
483
    case QEasingCurve::OutCubic:
 
484
        return &easeOutCubic;
 
485
    case QEasingCurve::InOutCubic:
 
486
        return &easeInOutCubic;
 
487
    case QEasingCurve::OutInCubic:
 
488
        return &easeOutInCubic;
 
489
    case QEasingCurve::InQuart:
 
490
        return &easeInQuart;
 
491
    case QEasingCurve::OutQuart:
 
492
        return &easeOutQuart;
 
493
    case QEasingCurve::InOutQuart:
 
494
        return &easeInOutQuart;
 
495
    case QEasingCurve::OutInQuart:
 
496
        return &easeOutInQuart;
 
497
    case QEasingCurve::InQuint:
 
498
        return &easeInQuint;
 
499
    case QEasingCurve::OutQuint:
 
500
        return &easeOutQuint;
 
501
    case QEasingCurve::InOutQuint:
 
502
        return &easeInOutQuint;
 
503
    case QEasingCurve::OutInQuint:
 
504
        return &easeOutInQuint;
 
505
    case QEasingCurve::InSine:
 
506
        return &easeInSine;
 
507
    case QEasingCurve::OutSine:
 
508
        return &easeOutSine;
 
509
    case QEasingCurve::InOutSine:
 
510
        return &easeInOutSine;
 
511
    case QEasingCurve::OutInSine:
 
512
        return &easeOutInSine;
 
513
    case QEasingCurve::InExpo:
 
514
        return &easeInExpo;
 
515
    case QEasingCurve::OutExpo:
 
516
        return &easeOutExpo;
 
517
    case QEasingCurve::InOutExpo:
 
518
        return &easeInOutExpo;
 
519
    case QEasingCurve::OutInExpo:
 
520
        return &easeOutInExpo;
 
521
    case QEasingCurve::InCirc:
 
522
        return &easeInCirc;
 
523
    case QEasingCurve::OutCirc:
 
524
        return &easeOutCirc;
 
525
    case QEasingCurve::InOutCirc:
 
526
        return &easeInOutCirc;
 
527
    case QEasingCurve::OutInCirc:
 
528
        return &easeOutInCirc;
 
529
    // Internal for, compatibility with QTimeLine only ??
 
530
    case QEasingCurve::InCurve:
 
531
        return &easeInCurve;
 
532
    case QEasingCurve::OutCurve:
 
533
        return &easeOutCurve;
 
534
    case QEasingCurve::SineCurve:
 
535
        return &easeSineCurve;
 
536
    case QEasingCurve::CosineCurve:
 
537
        return &easeCosineCurve;
 
538
    default:
 
539
        return 0;
 
540
    };
 
541
}
 
542
 
 
543
static QEasingCurveFunction *curveToFunctionObject(QEasingCurve::Type type)
 
544
{
 
545
    QEasingCurveFunction *curveFunc = 0;
 
546
    switch(type) {
 
547
    case QEasingCurve::InElastic:
 
548
        curveFunc = new ElasticEase(ElasticEase::In);
 
549
        break;
 
550
    case QEasingCurve::OutElastic:
 
551
        curveFunc = new ElasticEase(ElasticEase::Out);
 
552
        break;
 
553
    case QEasingCurve::InOutElastic:
 
554
        curveFunc = new ElasticEase(ElasticEase::InOut);
 
555
        break;
 
556
    case QEasingCurve::OutInElastic:
 
557
        curveFunc = new ElasticEase(ElasticEase::OutIn);
 
558
        break;
 
559
    case QEasingCurve::OutBounce:
 
560
        curveFunc = new BounceEase(BounceEase::Out);
 
561
        break;
 
562
    case QEasingCurve::InBounce:
 
563
        curveFunc = new BounceEase(BounceEase::In);
 
564
        break;
 
565
    case QEasingCurve::OutInBounce:
 
566
        curveFunc = new BounceEase(BounceEase::OutIn);
 
567
        break;
 
568
    case QEasingCurve::InOutBounce:
 
569
        curveFunc = new BounceEase(BounceEase::InOut);
 
570
        break;
 
571
    case QEasingCurve::InBack:
 
572
        curveFunc = new BackEase(BackEase::In);
 
573
        break;
 
574
    case QEasingCurve::OutBack:
 
575
        curveFunc = new BackEase(BackEase::Out);
 
576
        break;
 
577
    case QEasingCurve::InOutBack:
 
578
        curveFunc = new BackEase(BackEase::InOut);
 
579
        break;
 
580
    case QEasingCurve::OutInBack:
 
581
        curveFunc = new BackEase(BackEase::OutIn);
 
582
        break;
 
583
    default:
 
584
        curveFunc = new QEasingCurveFunction(QEasingCurveFunction::In, 0.3f, 1.0f, 1.70158f);     // ###
 
585
    }
 
586
 
 
587
    return curveFunc;
 
588
}
 
589
 
 
590
/*!
 
591
    Constructs an easing curve of the given \a type.
 
592
 */
 
593
QEasingCurve::QEasingCurve(Type type)
 
594
    : d_ptr(new QEasingCurvePrivate)
 
595
{
 
596
    setType(type);
 
597
}
 
598
 
 
599
/*!
 
600
    Construct a copy of \a other.
 
601
 */
 
602
QEasingCurve::QEasingCurve(const QEasingCurve &other)
 
603
: d_ptr(new QEasingCurvePrivate)
 
604
{
 
605
    // ### non-atomic, requires malloc on shallow copy
 
606
    *d_ptr = *other.d_ptr;
 
607
    if(other.d_ptr->config)
 
608
        d_ptr->config = other.d_ptr->config->copy();
 
609
}
 
610
 
 
611
/*!
 
612
    Destructor.
 
613
 */
 
614
 
 
615
QEasingCurve::~QEasingCurve()
 
616
{
 
617
    delete d_ptr;
 
618
}
 
619
 
 
620
/*!
 
621
    Copy \a other.
 
622
 */
 
623
QEasingCurve &QEasingCurve::operator=(const QEasingCurve &other)
 
624
{
 
625
    // ### non-atomic, requires malloc on shallow copy
 
626
    if (d_ptr->config) {
 
627
        delete d_ptr->config;
 
628
        d_ptr->config = 0;
 
629
    }
 
630
 
 
631
    *d_ptr = *other.d_ptr;
 
632
    if(other.d_ptr->config)
 
633
        d_ptr->config = other.d_ptr->config->copy();
 
634
 
 
635
    return *this;
 
636
}
 
637
 
 
638
/*!
 
639
    Compare this easing curve with \a other and returns true if they are
 
640
    equal. It will also compare the properties of a curve.
 
641
 */
 
642
bool QEasingCurve::operator==(const QEasingCurve &other) const
 
643
{
 
644
    bool res = d_ptr->func == other.d_ptr->func
 
645
            && d_ptr->type == other.d_ptr->type;
 
646
    if (res && d_ptr->config && other.d_ptr->config) {
 
647
        // catch the config content
 
648
        res = d_ptr->config->operator==(*(other.d_ptr->config));
 
649
    }
 
650
    return res;
 
651
}
 
652
 
 
653
/*!
 
654
    \fn bool QEasingCurve::operator!=(const QEasingCurve &other) const
 
655
    Compare this easing curve with \a other and returns true if they are not equal.
 
656
    It will also compare the properties of a curve.
 
657
 
 
658
    \sa operator==()
 
659
*/
 
660
 
 
661
/*!
 
662
    Returns the amplitude. This is not applicable for all curve types.
 
663
    It is only applicable for bounce and elastic curves (curves of type()
 
664
    QEasingCurve::InBounce, QEasingCurve::OutBounce, QEasingCurve::InOutBounce,
 
665
    QEasingCurve::OutInBounce, QEasingCurve::InElastic, QEasingCurve::OutElastic,
 
666
    QEasingCurve::InOutElastic or QEasingCurve::OutInElastic).
 
667
 */
 
668
qreal QEasingCurve::amplitude() const
 
669
{
 
670
    return d_ptr->config ? d_ptr->config->_a : 1.0;
 
671
}
 
672
 
 
673
/*!
 
674
    Sets the amplitude to \a amplitude.
 
675
 
 
676
    This will set the amplitude of the bounce or the amplitude of the
 
677
    elastic "spring" effect. The higher the number, the higher the amplitude.
 
678
    \sa amplitude()
 
679
*/
 
680
void QEasingCurve::setAmplitude(qreal amplitude)
 
681
{
 
682
    if (!d_ptr->config)
 
683
        d_ptr->config = curveToFunctionObject(d_ptr->type);
 
684
    d_ptr->config->_a = amplitude;
 
685
}
 
686
 
 
687
/*!
 
688
    Returns the period. This is not applicable for all curve types.
 
689
    It is only applicable if type() is QEasingCurve::InElastic, QEasingCurve::OutElastic,
 
690
    QEasingCurve::InOutElastic or QEasingCurve::OutInElastic.
 
691
 */
 
692
qreal QEasingCurve::period() const
 
693
{
 
694
    return d_ptr->config ? d_ptr->config->_p : 0.3;
 
695
}
 
696
 
 
697
/*!
 
698
    Sets the period to \a period.
 
699
    Setting a small period value will give a high frequency of the curve. A
 
700
    large period will give it a small frequency.
 
701
 
 
702
    \sa period()
 
703
*/
 
704
void QEasingCurve::setPeriod(qreal period)
 
705
{
 
706
    if (!d_ptr->config)
 
707
        d_ptr->config = curveToFunctionObject(d_ptr->type);
 
708
    d_ptr->config->_p = period;
 
709
}
 
710
 
 
711
/*!
 
712
    Returns the overshoot. This is not applicable for all curve types.
 
713
    It is only applicable if type() is QEasingCurve::InBack, QEasingCurve::OutBack,
 
714
    QEasingCurve::InOutBack or QEasingCurve::OutInBack.
 
715
 */
 
716
qreal QEasingCurve::overshoot() const
 
717
{
 
718
    return d_ptr->config ? d_ptr->config->_o : 1.70158f;
 
719
}
 
720
 
 
721
/*!
 
722
    Sets the overshoot to \a overshoot.
 
723
 
 
724
    0 produces no overshoot, and the default value of 1.70158 produces an overshoot of 10 percent.
 
725
 
 
726
    \sa overshoot()
 
727
*/
 
728
void QEasingCurve::setOvershoot(qreal overshoot)
 
729
{
 
730
    if (!d_ptr->config)
 
731
        d_ptr->config = curveToFunctionObject(d_ptr->type);
 
732
    d_ptr->config->_o = overshoot;
 
733
}
 
734
 
 
735
/*!
 
736
    Returns the type of the easing curve.
 
737
*/
 
738
QEasingCurve::Type QEasingCurve::type() const
 
739
{
 
740
    return d_ptr->type;
 
741
}
 
742
 
 
743
void QEasingCurvePrivate::setType_helper(QEasingCurve::Type newType)
 
744
{
 
745
    qreal amp = -1.0;
 
746
    qreal period = -1.0;
 
747
    qreal overshoot = -1.0;
 
748
 
 
749
    if (config) {
 
750
        amp = config->_a;
 
751
        period = config->_p;
 
752
        overshoot = config->_o;
 
753
        delete config;
 
754
        config = 0;
 
755
    }
 
756
 
 
757
    if (isConfigFunction(newType) || (amp != -1.0) || (period != -1.0) || (overshoot != -1.0)) {
 
758
        config = curveToFunctionObject(newType);
 
759
        if (amp != -1.0)
 
760
            config->_a = amp;
 
761
        if (period != -1.0)
 
762
            config->_p = period;
 
763
        if (overshoot != -1.0)
 
764
            config->_o = overshoot;
 
765
        func = 0;
 
766
    } else if (newType != QEasingCurve::Custom) {
 
767
        func = curveToFunc(newType);
 
768
    }
 
769
    Q_ASSERT((func == 0) == (config != 0));
 
770
    type = newType;
 
771
}
 
772
 
 
773
/*!
 
774
    Sets the type of the easing curve to \a type.
 
775
*/
 
776
void QEasingCurve::setType(Type type)
 
777
{
 
778
    if (d_ptr->type == type)
 
779
        return;
 
780
    if (type < Linear || type >= NCurveTypes - 1) {
 
781
        qWarning("QEasingCurve: Invalid curve type %d", type);
 
782
        return;
 
783
    }
 
784
 
 
785
    d_ptr->setType_helper(type);
 
786
}
 
787
 
 
788
/*!
 
789
    Sets a custom easing curve that is defined by the user in the function \a func.
 
790
    The signature of the function is qreal myEasingFunction(qreal progress),
 
791
    where \e progress and the return value is considered to be normalized between 0 and 1.
 
792
    (In some cases the return value can be outside that range)
 
793
    After calling this function type() will return QEasingCurve::Custom.
 
794
    \a func cannot be zero.
 
795
 
 
796
    \sa customType()
 
797
    \sa valueForProgress()
 
798
*/
 
799
void QEasingCurve::setCustomType(EasingFunction func)
 
800
{
 
801
    if (!func) {
 
802
        qWarning("Function pointer must not be null");
 
803
        return;
 
804
    }
 
805
    d_ptr->func = func;
 
806
    d_ptr->setType_helper(Custom);
 
807
}
 
808
 
 
809
/*!
 
810
    Returns the function pointer to the custom easing curve.
 
811
    If type() does not return QEasingCurve::Custom, this function
 
812
    will return 0.
 
813
*/
 
814
QEasingCurve::EasingFunction QEasingCurve::customType() const
 
815
{
 
816
    return d_ptr->type == Custom ? d_ptr->func : 0;
 
817
}
 
818
 
 
819
/*!
 
820
    Return the effective progress for the easing curve at \a progress.
 
821
    While  \a progress must be between 0 and 1, the returned effective progress
 
822
    can be outside those bounds. For instance, QEasingCurve::InBack will
 
823
    return negative values in the beginning of the function.
 
824
 */
 
825
qreal QEasingCurve::valueForProgress(qreal progress) const
 
826
{
 
827
    progress = qBound<qreal>(0, progress, 1);
 
828
    if (d_ptr->func)
 
829
        return d_ptr->func(progress);
 
830
    else if (d_ptr->config)
 
831
        return d_ptr->config->value(progress);
 
832
    else
 
833
        return progress;
 
834
}
 
835
 
 
836
#ifndef QT_NO_DEBUG_STREAM
 
837
QDebug operator<<(QDebug debug, const QEasingCurve &item)
 
838
{
 
839
    debug << "type:" << item.d_ptr->type
 
840
          << "func:" << item.d_ptr->func;
 
841
    if (item.d_ptr->config) {
 
842
        debug << QString::fromAscii("period:%1").arg(item.d_ptr->config->_p, 0, 'f', 20)
 
843
              << QString::fromAscii("amp:%1").arg(item.d_ptr->config->_a, 0, 'f', 20)
 
844
              << QString::fromAscii("overshoot:%1").arg(item.d_ptr->config->_o, 0, 'f', 20);
 
845
    }
 
846
    return debug;
 
847
}
 
848
#endif
 
849
 
 
850
QT_END_NAMESPACE