1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 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 QtDeclarative 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 #include "private/qdeclarativetimeline_p_p.h"

    43 

    44 #include <QDebug>

    45 #include <QMutex>

    46 #include <QThread>

    47 #include <QWaitCondition>

    48 #include <QEvent>

    49 #include <QCoreApplication>

    50 #include <QEasingCurve>

    51 #include <QTime>

    52 

    53 QT_BEGIN_NAMESPACE

    54 

    55 struct Update {

    56     Update(QDeclarativeTimeLineValue *_g, qreal _v)

    57         : g(_g), v(_v) {}

    58     Update(const QDeclarativeTimeLineCallback &_e)

    59         : g(0), v(0), e(_e) {}

    60 

    61     QDeclarativeTimeLineValue *g;

    62     qreal v;

    63     QDeclarativeTimeLineCallback e;

    64 };

    65 

    66 struct QDeclarativeTimeLinePrivate

    67 {

    68     QDeclarativeTimeLinePrivate(QDeclarativeTimeLine *);

    69 

    70     struct Op {

    71         enum Type {

    72             Pause,

    73             Set,

    74             Move,

    75             MoveBy,

    76             Accel,

    77             AccelDistance,

    78             Execute

    79         };

    80         Op() {}

    81         Op(Type t, int l, qreal v, qreal v2, int o, 

    82            const QDeclarativeTimeLineCallback &ev = QDeclarativeTimeLineCallback(), const QEasingCurve &es = QEasingCurve())

    83             : type(t), length(l), value(v), value2(v2), order(o), event(ev),

    84               easing(es) {}

    85         Op(const Op &o)

    86             : type(o.type), length(o.length), value(o.value), value2(o.value2),

    87               order(o.order), event(o.event), easing(o.easing) {}

    88         Op &operator=(const Op &o) {

    89             type = o.type; length = o.length; value = o.value; 

    90             value2 = o.value2; order = o.order; event = o.event; 

    91             easing = o.easing;

    92             return *this;

    93         }

    94 

    95         Type type;

    96         int length;

    97         qreal value;

    98         qreal value2;

    99 

   100         int order;

   101         QDeclarativeTimeLineCallback event;

   102         QEasingCurve easing;

   103     };

   104     struct TimeLine

   105     {

   106         TimeLine() : length(0), consumedOpLength(0), base(0.) {}

   107         QList<Op> ops;

   108         int length;

   109         int consumedOpLength;

   110         qreal base;

   111     };

   112 

   113     int length;

   114     int syncPoint;

   115     typedef QHash<QDeclarativeTimeLineObject *, TimeLine> Ops;

   116     Ops ops;

   117     QDeclarativeTimeLine *q;

   118 

   119     void add(QDeclarativeTimeLineObject &, const Op &);

   120     qreal value(const Op &op, int time, qreal base, bool *) const;

   121 

   122     int advance(int);

   123 

   124     bool clockRunning;

   125     int prevTime;

   126 

   127     int order;

   128 

   129     QDeclarativeTimeLine::SyncMode syncMode;

   130     int syncAdj;

   131     QList<QPair<int, Update> > *updateQueue;

   132 };

   133 

   134 QDeclarativeTimeLinePrivate::QDeclarativeTimeLinePrivate(QDeclarativeTimeLine *parent)

   135 : length(0), syncPoint(0), q(parent), clockRunning(false), prevTime(0), order(0), syncMode(QDeclarativeTimeLine::LocalSync), syncAdj(0), updateQueue(0)

   136 {

   137 }

   138 

   139 void QDeclarativeTimeLinePrivate::add(QDeclarativeTimeLineObject &g, const Op &o)

   140 {

   141     if (g._t && g._t != q) {

   142         qWarning() << "QDeclarativeTimeLine: Cannot modify a QDeclarativeTimeLineValue owned by"

   143                    << "another timeline.";

   144         return;

   145     }

   146     g._t = q;

   147 

   148     Ops::Iterator iter = ops.find(&g);

   149     if (iter == ops.end()) {

   150         iter = ops.insert(&g, TimeLine());

   151         if (syncPoint > 0)

   152             q->pause(g, syncPoint);

   153     }

   154     if (!iter->ops.isEmpty() &&

   155        o.type == Op::Pause &&

   156        iter->ops.last().type == Op::Pause) {

   157         iter->ops.last().length += o.length;

   158         iter->length += o.length;

   159     } else {

   160         iter->ops.append(o);

   161         iter->length += o.length;

   162     }

   163 

   164     if (iter->length > length)

   165         length = iter->length;

   166 

   167     if (!clockRunning) {

   168         q->stop();

   169         prevTime = 0;

   170         clockRunning = true;

   171 

   172         if (syncMode == QDeclarativeTimeLine::LocalSync)  {

   173             syncAdj = -1;

   174         } else {

   175             syncAdj = 0;

   176         }

   177         q->start();

   178 /*        q->tick(0);

   179         if (syncMode == QDeclarativeTimeLine::LocalSync)  {

   180             syncAdj = -1;

   181         } else {

   182             syncAdj = 0;

   183         }

   184         */

   185     }

   186 }

   187 

   188 qreal QDeclarativeTimeLinePrivate::value(const Op &op, int time, qreal base, bool *changed) const

   189 {

   190     Q_ASSERT(time >= 0);

   191     Q_ASSERT(time <= op.length);

   192     *changed = true;

   193 

   194     switch(op.type) {

   195         case Op::Pause:

   196             *changed = false;

   197             return base;

   198         case Op::Set:

   199             return op.value;

   200         case Op::Move:

   201             if (time == 0) {

   202                 return base;

   203             } else if (time == (op.length)) {

   204                 return op.value;

   205             } else {

   206                 qreal delta = op.value - base;

   207                 qreal pTime = (qreal)(time) / (qreal)op.length;

   208                 if (op.easing.type() == QEasingCurve::Linear)

   209                     return base + delta * pTime;

   210                 else

   211                     return base + delta * op.easing.valueForProgress(pTime);

   212             }

   213         case Op::MoveBy:

   214             if (time == 0) {

   215                 return base;

   216             } else if (time == (op.length)) {

   217                 return base + op.value;

   218             } else {

   219                 qreal delta = op.value;

   220                 qreal pTime = (qreal)(time) / (qreal)op.length;

   221                 if (op.easing.type() == QEasingCurve::Linear)

   222                     return base + delta * pTime;

   223                 else

   224                     return base + delta * op.easing.valueForProgress(pTime);

   225             }

   226         case Op::Accel:

   227             if (time == 0) {

   228                 return base;

   229             } else {

   230                 qreal t = (qreal)(time) / 1000.0f;

   231                 qreal delta = op.value * t + 0.5f * op.value2 * t * t;

   232                 return base + delta;

   233             }

   234         case Op::AccelDistance:

   235             if (time == 0) {

   236                 return base;

   237             } else if (time == (op.length)) {

   238                 return base + op.value2;

   239             } else {

   240                 qreal t = (qreal)(time) / 1000.0f;

   241                 qreal accel = -1.0f * 1000.0f * op.value / (qreal)op.length;

   242                 qreal delta = op.value * t + 0.5f * accel * t * t;

   243                 return base + delta;

   244 

   245             }

   246         case Op::Execute:

   247             op.event.d0(op.event.d1);

   248             *changed = false;

   249             return -1;

   250     }

   251 

   252     return base;

   253 }

   254 

   255 /*!

   256     \internal

   257     \class QDeclarativeTimeLine

   258     \brief The QDeclarativeTimeLine class provides a timeline for controlling animations.

   259 

   260     QDeclarativeTimeLine is similar to QTimeLine except:

   261     \list

   262     \i It updates QDeclarativeTimeLineValue instances directly, rather than maintaining a single

   263     current value.

   264 

   265     For example, the following animates a simple value over 200 milliseconds:

   266     \code

   267     QDeclarativeTimeLineValue v(<starting value>);

   268     QDeclarativeTimeLine tl;

   269     tl.move(v, 100., 200);

   270     tl.start()

   271     \endcode

   272 

   273     If your program needs to know when values are changed, it can either

   274     connect to the QDeclarativeTimeLine's updated() signal, or inherit from QDeclarativeTimeLineValue

   275     and reimplement the QDeclarativeTimeLineValue::setValue() method.

   276 

   277     \i Supports multiple QDeclarativeTimeLineValue, arbitrary start and end values and allows

   278     animations to be strung together for more complex effects.

   279 

   280     For example, the following animation moves the x and y coordinates of

   281     an object from wherever they are to the position (100, 100) in 50

   282     milliseconds and then further animates them to (100, 200) in 50

   283     milliseconds:

   284 

   285     \code

   286     QDeclarativeTimeLineValue x(<starting value>);

   287     QDeclarativeTimeLineValue y(<starting value>);

   288 

   289     QDeclarativeTimeLine tl;

   290     tl.start();

   291 

   292     tl.move(x, 100., 50);

   293     tl.move(y, 100., 50);

   294     tl.move(y, 200., 50);

   295     \endcode

   296 

   297     \i All QDeclarativeTimeLine instances share a single, synchronized clock.

   298 

   299     Actions scheduled within the same event loop tick are scheduled

   300     synchronously against each other, regardless of the wall time between the

   301     scheduling.  Synchronized scheduling applies both to within the same

   302     QDeclarativeTimeLine and across separate QDeclarativeTimeLine's within the same process.

   303 

   304     \endlist

   305 

   306     Currently easing functions are not supported.

   307 */

   308 

   309 

   310 /*!

   311     Construct a new QDeclarativeTimeLine with the specified \a parent.

   312 */

   313 QDeclarativeTimeLine::QDeclarativeTimeLine(QObject *parent)

   314 : QAbstractAnimation(parent)

   315 {

   316     d = new QDeclarativeTimeLinePrivate(this);

   317 }

   318 

   319 /*!

   320     Destroys the time line.  Any inprogress animations are canceled, but not

   321     completed.

   322 */

   323 QDeclarativeTimeLine::~QDeclarativeTimeLine()

   324 {

   325     for (QDeclarativeTimeLinePrivate::Ops::Iterator iter = d->ops.begin();

   326             iter != d->ops.end();

   327             ++iter)

   328         iter.key()->_t = 0;

   329 

   330     delete d; d = 0;

   331 }

   332 

   333 /*!

   334     \enum QDeclarativeTimeLine::SyncMode

   335  */

   336 

   337 /*!

   338     Return the timeline's synchronization mode.

   339  */

   340 QDeclarativeTimeLine::SyncMode QDeclarativeTimeLine::syncMode() const

   341 {

   342     return d->syncMode;

   343 }

   344 

   345 /*!

   346     Set the timeline's synchronization mode to \a syncMode.

   347  */

   348 void QDeclarativeTimeLine::setSyncMode(SyncMode syncMode)

   349 {

   350     d->syncMode = syncMode;

   351 }

   352 

   353 /*!

   354     Pause \a obj for \a time milliseconds.

   355 */

   356 void QDeclarativeTimeLine::pause(QDeclarativeTimeLineObject &obj, int time)

   357 {

   358     if (time <= 0) return;

   359     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::Pause, time, 0., 0., d->order++);

   360     d->add(obj, op);

   361 }

   362 

   363 /*!

   364     Execute the \a event.

   365  */

   366 void QDeclarativeTimeLine::callback(const QDeclarativeTimeLineCallback &callback)

   367 {

   368     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::Execute, 0, 0, 0., d->order++, callback);

   369     d->add(*callback.callbackObject(), op);

   370 }

   371 

   372 /*!

   373     Set the \a value of \a timeLineValue.

   374 */

   375 void QDeclarativeTimeLine::set(QDeclarativeTimeLineValue &timeLineValue, qreal value)

   376 {

   377     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::Set, 0, value, 0., d->order++);

   378     d->add(timeLineValue, op);

   379 }

   380 

   381 /*!

   382     Decelerate \a timeLineValue from the starting \a velocity to zero at the

   383     given \a acceleration rate.  Although the \a acceleration is technically

   384     a deceleration, it should always be positive.  The QDeclarativeTimeLine will ensure

   385     that the deceleration is in the opposite direction to the initial velocity.

   386 */

   387 int QDeclarativeTimeLine::accel(QDeclarativeTimeLineValue &timeLineValue, qreal velocity, qreal acceleration)

   388 {

   389     if (acceleration == 0.0f)

   390         return -1;

   391 

   392     if ((velocity > 0.0f) == (acceleration > 0.0f))

   393         acceleration = acceleration * -1.0f;

   394 

   395     int time = static_cast<int>(-1000 * velocity / acceleration);

   396 

   397     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::Accel, time, velocity, acceleration, d->order++);

   398     d->add(timeLineValue, op);

   399 

   400     return time;

   401 }

   402 

   403 /*!

   404     \overload

   405 

   406     Decelerate \a timeLineValue from the starting \a velocity to zero at the

   407     given \a acceleration rate over a maximum distance of maxDistance.

   408 

   409     If necessary, QDeclarativeTimeLine will reduce the acceleration to ensure that the

   410     entire operation does not require a move of more than \a maxDistance.

   411     \a maxDistance should always be positive.

   412 */

   413 int QDeclarativeTimeLine::accel(QDeclarativeTimeLineValue &timeLineValue, qreal velocity, qreal acceleration, qreal maxDistance)

   414 {

   415     if (maxDistance == 0.0f || acceleration == 0.0f)

   416         return -1;

   417 

   418     Q_ASSERT(acceleration > 0.0f && maxDistance > 0.0f);

   419 

   420     qreal maxAccel = (velocity * velocity) / (2.0f * maxDistance);

   421     if (maxAccel > acceleration)

   422         acceleration = maxAccel;

   423 

   424     if ((velocity > 0.0f) == (acceleration > 0.0f))

   425         acceleration = acceleration * -1.0f;

   426 

   427     int time = static_cast<int>(-1000 * velocity / acceleration);

   428 

   429     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::Accel, time, velocity, acceleration, d->order++);

   430     d->add(timeLineValue, op);

   431 

   432     return time;

   433 }

   434 

   435 /*!

   436     Decelerate \a timeLineValue from the starting \a velocity to zero over the given

   437     \a distance.  This is like accel(), but the QDeclarativeTimeLine calculates the exact

   438     deceleration to use.

   439 

   440     \a distance should be positive.

   441 */

   442 int QDeclarativeTimeLine::accelDistance(QDeclarativeTimeLineValue &timeLineValue, qreal velocity, qreal distance)

   443 {

   444     if (distance == 0.0f || velocity == 0.0f)

   445         return -1;

   446 

   447     Q_ASSERT((distance >= 0.0f) == (velocity >= 0.0f));

   448 

   449     int time = static_cast<int>(1000 * (2.0f * distance) / velocity);

   450 

   451     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::AccelDistance, time, velocity, distance, d->order++);

   452     d->add(timeLineValue, op);

   453 

   454     return time;

   455 }

   456 

   457 /*!

   458     Linearly change the \a timeLineValue from its current value to the given

   459     \a destination value over \a time milliseconds.

   460 */

   461 void QDeclarativeTimeLine::move(QDeclarativeTimeLineValue &timeLineValue, qreal destination, int time)

   462 {

   463     if (time <= 0) return;

   464     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::Move, time, destination, 0.0f, d->order++);

   465     d->add(timeLineValue, op);

   466 }

   467 

   468 /*!

   469     Change the \a timeLineValue from its current value to the given \a destination

   470     value over \a time milliseconds using the \a easing curve.

   471  */

   472 void QDeclarativeTimeLine::move(QDeclarativeTimeLineValue &timeLineValue, qreal destination, const QEasingCurve &easing, int time)

   473 {

   474     if (time <= 0) return;

   475     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::Move, time, destination, 0.0f, d->order++, QDeclarativeTimeLineCallback(), easing);

   476     d->add(timeLineValue, op);

   477 }

   478 

   479 /*!

   480     Linearly change the \a timeLineValue from its current value by the \a change amount

   481     over \a time milliseconds.

   482 */

   483 void QDeclarativeTimeLine::moveBy(QDeclarativeTimeLineValue &timeLineValue, qreal change, int time)

   484 {

   485     if (time <= 0) return;

   486     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::MoveBy, time, change, 0.0f, d->order++);

   487     d->add(timeLineValue, op);

   488 }

   489 

   490 /*!

   491     Change the \a timeLineValue from its current value by the \a change amount over

   492     \a time milliseconds using the \a easing curve.

   493  */

   494 void QDeclarativeTimeLine::moveBy(QDeclarativeTimeLineValue &timeLineValue, qreal change, const QEasingCurve &easing, int time)

   495 {

   496     if (time <= 0) return;

   497     QDeclarativeTimeLinePrivate::Op op(QDeclarativeTimeLinePrivate::Op::MoveBy, time, change, 0.0f, d->order++, QDeclarativeTimeLineCallback(), easing);

   498     d->add(timeLineValue, op);

   499 }

   500 

   501 /*!

   502     Cancel (but don't complete) all scheduled actions for \a timeLineValue.

   503 */

   504 void QDeclarativeTimeLine::reset(QDeclarativeTimeLineValue &timeLineValue)

   505 {

   506     if (!timeLineValue._t)

   507         return;

   508     if (timeLineValue._t != this) {

   509         qWarning() << "QDeclarativeTimeLine: Cannot reset a QDeclarativeTimeLineValue owned by another timeline.";

   510         return;

   511     }

   512     remove(&timeLineValue);

   513     timeLineValue._t = 0;

   514 }

   515 

   516 int QDeclarativeTimeLine::duration() const

   517 {

   518     return -1;

   519 }

   520 

   521 /*!

   522     Synchronize the end point of \a timeLineValue to the endpoint of \a syncTo

   523     within this timeline.

   524 

   525     Following operations on \a timeLineValue in this timeline will be scheduled after

   526     all the currently scheduled actions on \a syncTo are complete.  In

   527     psuedo-code this is equivalent to:

   528     \code

   529     QDeclarativeTimeLine::pause(timeLineValue, min(0, length_of(syncTo) - length_of(timeLineValue)))

   530     \endcode

   531 */

   532 void QDeclarativeTimeLine::sync(QDeclarativeTimeLineValue &timeLineValue, QDeclarativeTimeLineValue &syncTo)

   533 {

   534     QDeclarativeTimeLinePrivate::Ops::Iterator iter = d->ops.find(&syncTo);

   535     if (iter == d->ops.end())

   536         return;

   537     int length = iter->length;

   538 

   539     iter = d->ops.find(&timeLineValue);

   540     if (iter == d->ops.end()) {

   541         pause(timeLineValue, length);

   542     } else {

   543         int glength = iter->length;

   544         pause(timeLineValue, length - glength);

   545     }

   546 }

   547 

   548 /*!

   549     Synchronize the end point of \a timeLineValue to the endpoint of the longest

   550     action cursrently scheduled in the timeline.

   551 

   552     In psuedo-code, this is equivalent to:

   553     \code

   554     QDeclarativeTimeLine::pause(timeLineValue, length_of(timeline) - length_of(timeLineValue))

   555     \endcode

   556 */

   557 void QDeclarativeTimeLine::sync(QDeclarativeTimeLineValue &timeLineValue)

   558 {

   559     QDeclarativeTimeLinePrivate::Ops::Iterator iter = d->ops.find(&timeLineValue);

   560     if (iter == d->ops.end()) {

   561         pause(timeLineValue, d->length);

   562     } else {

   563         pause(timeLineValue, d->length - iter->length);

   564     }

   565 }

   566 

   567 /*

   568     Synchronize all currently and future scheduled values in this timeline to

   569     the longest action currently scheduled.

   570 

   571     For example:

   572     \code

   573     value1->setValue(0.);

   574     value2->setValue(0.);

   575     value3->setValue(0.);

   576     QDeclarativeTimeLine tl;

   577     ...

   578     tl.move(value1, 10, 200);

   579     tl.move(value2, 10, 100);

   580     tl.sync();

   581     tl.move(value2, 20, 100);

   582     tl.move(value3, 20, 100);

   583     \endcode

   584 

   585     will result in:

   586 

   587     \table

   588     \header \o \o 0ms \o 50ms \o 100ms \o 150ms \o 200ms \o 250ms \o 300ms

   589     \row \o value1 \o 0 \o 2.5 \o 5.0 \o 7.5 \o 10 \o 10 \o 10

   590     \row \o value2 \o 0 \o 5.0 \o 10.0 \o 10.0 \o 10.0 \o 15.0 \o 20.0

   591     \row \o value2 \o 0 \o 0 \o 0 \o 0 \o 0 \o 10.0 \o 20.0

   592     \endtable

   593 */

   594 

   595 /*void QDeclarativeTimeLine::sync()

   596 {

   597     for (QDeclarativeTimeLinePrivate::Ops::Iterator iter = d->ops.begin();

   598             iter != d->ops.end();

   599             ++iter)

   600         pause(*iter.key(), d->length - iter->length);

   601     d->syncPoint = d->length;

   602 }*/

   603 

   604 /*! 

   605     \internal 

   606 

   607     Temporary hack.

   608  */

   609 void QDeclarativeTimeLine::setSyncPoint(int sp)

   610 {

   611     d->syncPoint = sp;

   612 }

   613 

   614 /*! 

   615     \internal 

   616  

   617     Temporary hack.

   618  */

   619 int QDeclarativeTimeLine::syncPoint() const

   620 {

   621     return d->syncPoint;

   622 }

   623 

   624 /*!

   625     Returns true if the timeline is active.  An active timeline is one where

   626     QDeclarativeTimeLineValue actions are still pending.

   627 */

   628 bool QDeclarativeTimeLine::isActive() const

   629 {

   630     return !d->ops.isEmpty();

   631 }

   632 

   633 /*!

   634     Completes the timeline.  All queued actions are played to completion, and then discarded.  For example,

   635     \code

   636     QDeclarativeTimeLineValue v(0.);

   637     QDeclarativeTimeLine tl;

   638     tl.move(v, 100., 1000.);

   639     // 500 ms passes

   640     // v.value() == 50.

   641     tl.complete();

   642     // v.value() == 100.

   643     \endcode

   644 */

   645 void QDeclarativeTimeLine::complete()

   646 {

   647     d->advance(d->length);

   648 }

   649 

   650 /*!

   651     Resets the timeline.  All queued actions are discarded and QDeclarativeTimeLineValue's retain their current value. For example,

   652     \code

   653     QDeclarativeTimeLineValue v(0.);

   654     QDeclarativeTimeLine tl;

   655     tl.move(v, 100., 1000.);

   656     // 500 ms passes

   657     // v.value() == 50.

   658     tl.clear();

   659     // v.value() == 50.

   660     \endcode

   661 */

   662 void QDeclarativeTimeLine::clear()

   663 {

   664     for (QDeclarativeTimeLinePrivate::Ops::ConstIterator iter = d->ops.begin(); iter != d->ops.end(); ++iter)

   665         iter.key()->_t = 0;

   666     d->ops.clear();

   667     d->length = 0;

   668     d->syncPoint = 0;

   669     //XXX need stop here?

   670 }

   671 

   672 int QDeclarativeTimeLine::time() const

   673 {

   674     return d->prevTime;

   675 }

   676 

   677 /*!

   678     \fn void QDeclarativeTimeLine::updated()

   679 

   680     Emitted each time the timeline modifies QDeclarativeTimeLineValues.  Even if multiple

   681     QDeclarativeTimeLineValues are changed, this signal is only emitted once for each clock tick.

   682 */

   683 

   684 void QDeclarativeTimeLine::updateCurrentTime(int v)

   685 {

   686     if (d->syncAdj == -1)

   687         d->syncAdj = v;

   688     v -= d->syncAdj;

   689 

   690     int timeChanged = v - d->prevTime;

   691 #if 0

   692     if (!timeChanged)

   693         return;

   694 #endif

   695     d->prevTime = v;

   696     d->advance(timeChanged);

   697     emit updated();

   698 

   699     // Do we need to stop the clock?

   700     if (d->ops.isEmpty()) {

   701         stop();

   702         d->prevTime = 0;

   703         d->clockRunning = false;

   704         emit completed();

   705     } /*else if (pauseTime > 0) {

   706         GfxClock::cancelClock();

   707         d->prevTime = 0;

   708         GfxClock::pauseFor(pauseTime);

   709         d->syncAdj = 0;

   710         d->clockRunning = false;

   711     }*/ else if (/*!GfxClock::isActive()*/ state() != Running) {

   712         stop();

   713         d->prevTime = 0;

   714         d->clockRunning = true;

   715         d->syncAdj = 0;

   716         start();

   717     }

   718 }

   719 

   720 bool operator<(const QPair<int, Update> &lhs,

   721                const QPair<int, Update> &rhs)

   722 {

   723     return lhs.first < rhs.first;

   724 }

   725 

   726 int QDeclarativeTimeLinePrivate::advance(int t)

   727 {

   728     int pauseTime = -1;

   729 

   730     // XXX - surely there is a more efficient way?

   731     do {

   732         pauseTime = -1;

   733         // Minimal advance time

   734         int advanceTime = t;

   735         for (Ops::Iterator iter = ops.begin(); iter != ops.end(); ++iter) {

   736             TimeLine &tl = *iter;

   737             Op &op = tl.ops.first();

   738             int length = op.length - tl.consumedOpLength;

   739                 

   740             if (length < advanceTime) {

   741                 advanceTime = length;

   742                 if (advanceTime == 0)

   743                     break;

   744             }

   745         }

   746         t -= advanceTime;

   747 

   748         // Process until then.  A zero length advance time will only process 

   749         // sets.

   750         QList<QPair<int, Update> > updates;

   751 

   752         for (Ops::Iterator iter = ops.begin(); iter != ops.end(); ) {

   753             QDeclarativeTimeLineValue *v = static_cast<QDeclarativeTimeLineValue *>(iter.key());

   754             TimeLine &tl = *iter;

   755             Q_ASSERT(!tl.ops.isEmpty());

   756 

   757             do {

   758                 Op &op = tl.ops.first();

   759                 if (advanceTime == 0 && op.length != 0)

   760                     continue;

   761 

   762                 if (tl.consumedOpLength == 0 && 

   763                    op.type != Op::Pause && 

   764                    op.type != Op::Execute)

   765                     tl.base = v->value();

   766 

   767                 if ((tl.consumedOpLength + advanceTime) == op.length) {

   768                     if (op.type == Op::Execute) {

   769                         updates << qMakePair(op.order, Update(op.event));

   770                     } else {

   771                         bool changed = false;

   772                         qreal val = value(op, op.length, tl.base, &changed);

   773                         if (changed)

   774                             updates << qMakePair(op.order, Update(v, val));

   775                     }

   776                     tl.length -= qMin(advanceTime, tl.length);

   777                     tl.consumedOpLength = 0;

   778                     tl.ops.removeFirst();

   779                 } else {

   780                     tl.consumedOpLength += advanceTime;

   781                     bool changed = false;

   782                     qreal val = value(op, tl.consumedOpLength, tl.base, &changed);

   783                     if (changed)

   784                         updates << qMakePair(op.order, Update(v, val));

   785                     tl.length -= qMin(advanceTime, tl.length);

   786                     break;

   787                 }

   788 

   789             } while(!tl.ops.isEmpty() && advanceTime == 0 && tl.ops.first().length == 0);

   790 

   791 

   792             if (tl.ops.isEmpty()) {

   793                 iter = ops.erase(iter);

   794                 v->_t = 0;

   795             } else {

   796                 if (tl.ops.first().type == Op::Pause && pauseTime != 0) {

   797                     int opPauseTime = tl.ops.first().length - tl.consumedOpLength;

   798                     if (pauseTime == -1 || opPauseTime < pauseTime)

   799                         pauseTime = opPauseTime;

   800                 } else {

   801                     pauseTime = 0;

   802                 }

   803                 ++iter;

   804             }

   805         }

   806 

   807         length -= qMin(length, advanceTime);

   808         syncPoint -= advanceTime;

   809 

   810         qSort(updates.begin(), updates.end());

   811         updateQueue = &updates;

   812         for (int ii = 0; ii < updates.count(); ++ii) {

   813             const Update &v = updates.at(ii).second;

   814             if (v.g) {

   815                 v.g->setValue(v.v);

   816             } else {

   817                 v.e.d0(v.e.d1);

   818             }

   819         }

   820         updateQueue = 0;

   821     } while(t);

   822 

   823     return pauseTime;

   824 }

   825 

   826 void QDeclarativeTimeLine::remove(QDeclarativeTimeLineObject *v)

   827 {

   828     QDeclarativeTimeLinePrivate::Ops::Iterator iter = d->ops.find(v);

   829     Q_ASSERT(iter != d->ops.end());

   830 

   831     int len = iter->length;

   832     d->ops.erase(iter);

   833     if (len == d->length) {

   834         // We need to recalculate the length

   835         d->length = 0;

   836         for (QDeclarativeTimeLinePrivate::Ops::Iterator iter = d->ops.begin();

   837                 iter != d->ops.end();

   838                 ++iter) {

   839 

   840             if (iter->length > d->length)

   841                 d->length = iter->length;

   842 

   843         }

   844     }

   845     if (d->ops.isEmpty()) {

   846         stop();

   847         d->clockRunning = false;

   848     } else if (/*!GfxClock::isActive()*/ state() != Running) {

   849         stop();

   850         d->prevTime = 0;

   851         d->clockRunning = true;

   852 

   853         if (d->syncMode == QDeclarativeTimeLine::LocalSync) {

   854             d->syncAdj = -1;

   855         } else {

   856             d->syncAdj = 0;

   857         }

   858         start();

   859     }

   860 

   861     if (d->updateQueue) {

   862         for (int ii = 0; ii < d->updateQueue->count(); ++ii) {

   863             if (d->updateQueue->at(ii).second.g == v ||

   864                d->updateQueue->at(ii).second.e.callbackObject() == v) {

   865                 d->updateQueue->removeAt(ii);

   866                 --ii;

   867             }

   868         }

   869     }

   870 

   871 

   872 }

   873 

   874 /*!

   875     \internal

   876     \class QDeclarativeTimeLineValue

   877     \brief The QDeclarativeTimeLineValue class provides a value that can be modified by QDeclarativeTimeLine.

   878 */

   879 

   880 /*!

   881     \fn QDeclarativeTimeLineValue::QDeclarativeTimeLineValue(qreal value = 0)

   882 

   883     Construct a new QDeclarativeTimeLineValue with an initial \a value.

   884 */

   885 

   886 /*!

   887     \fn qreal QDeclarativeTimeLineValue::value() const

   888 

   889     Return the current value.

   890 */

   891 

   892 /*!

   893     \fn void QDeclarativeTimeLineValue::setValue(qreal value)

   894 

   895     Set the current \a value.

   896 */

   897 

   898 /*!

   899     \fn QDeclarativeTimeLine *QDeclarativeTimeLineValue::timeLine() const

   900 

   901     If a QDeclarativeTimeLine is operating on this value, return a pointer to it,

   902     otherwise return null.

   903 */

   904 

   905 

   906 QDeclarativeTimeLineObject::QDeclarativeTimeLineObject()

   907 : _t(0)

   908 {

   909 }

   910 

   911 QDeclarativeTimeLineObject::~QDeclarativeTimeLineObject()

   912 {

   913     if (_t) {

   914         _t->remove(this);

   915         _t = 0;

   916     }

   917 }

   918 

   919 QDeclarativeTimeLineCallback::QDeclarativeTimeLineCallback()

   920 : d0(0), d1(0), d2(0)

   921 {

   922 }

   923 

   924 QDeclarativeTimeLineCallback::QDeclarativeTimeLineCallback(QDeclarativeTimeLineObject *b, Callback f, void *d)

   925 : d0(f), d1(d), d2(b)

   926 {

   927 }

   928 

   929 QDeclarativeTimeLineCallback::QDeclarativeTimeLineCallback(const QDeclarativeTimeLineCallback &o)

   930 : d0(o.d0), d1(o.d1), d2(o.d2)

   931 {

   932 }

   933 

   934 QDeclarativeTimeLineCallback &QDeclarativeTimeLineCallback::operator=(const QDeclarativeTimeLineCallback &o)

   935 {

   936     d0 = o.d0;

   937     d1 = o.d1;

   938     d2 = o.d2;

   939     return *this;

   940 }

   941 

   942 QDeclarativeTimeLineObject *QDeclarativeTimeLineCallback::callbackObject() const

   943 {

   944     return d2;

   945 }

   946 

   947 QT_END_NAMESPACE