Classes
struct	Op

struct	TimeLine

Public Types
typedef QHash< QDeclarativeTimeLineObject *, TimeLine >	Ops

Public Functions
void	add (QDeclarativeTimeLineObject &, const Op &)

int	advance (int)

	QDeclarativeTimeLinePrivate (QDeclarativeTimeLine *)

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

Public Variables
bool	clockRunning

int	length

Ops	ops

int	order

int	prevTime

QDeclarativeTimeLine *	q

int	syncAdj

QDeclarativeTimeLine::SyncMode	syncMode

int	syncPoint

QList< QPair< int, Update > > *	updateQueue

Detailed Description

Definition at line 66 of file qdeclarativetimeline.cpp.

Typedefs

◆ Ops

typedef QHash<QDeclarativeTimeLineObject *, TimeLine> QDeclarativeTimeLinePrivate::Ops

Definition at line 115 of file qdeclarativetimeline.cpp.

Constructors and Destructors

◆ QDeclarativeTimeLinePrivate()

QDeclarativeTimeLinePrivate::QDeclarativeTimeLinePrivate ( QDeclarativeTimeLine * parent )

Definition at line 134 of file qdeclarativetimeline.cpp.

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

Functions

◆ add()

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

Definition at line 139 of file qdeclarativetimeline.cpp.

Referenced by QDeclarativeTimeLine::accel(), QDeclarativeTimeLine::accelDistance(), QDeclarativeTimeLine::callback(), QDeclarativeTimeLine::move(), QDeclarativeTimeLine::moveBy(), QDeclarativeTimeLine::pause(), and QDeclarativeTimeLine::set().

 {
     if (g._t && g._t != q) {
         qWarning() << "QDeclarativeTimeLine: Cannot modify a QDeclarativeTimeLineValue owned by"
                    << "another timeline.";
         return;
     }
     g._t = q;
 
     Ops::Iterator iter = ops.find(&g);
     if (iter == ops.end()) {
         iter = ops.insert(&g, TimeLine());
         if (syncPoint > 0)
             q->pause(g, syncPoint);
     }
     if (!iter->ops.isEmpty() &&
        o.type == Op::Pause &&
        iter->ops.last().type == Op::Pause) {
         iter->ops.last().length += o.length;
         iter->length += o.length;
     } else {
         iter->ops.append(o);
         iter->length += o.length;
     }
 
     if (iter->length > length)
         length = iter->length;
 
     if (!clockRunning) {
         q->stop();
         prevTime = 0;
         clockRunning = true;
 
         if (syncMode == QDeclarativeTimeLine::LocalSync)  {
             syncAdj = -1;
         } else {
             syncAdj = 0;
         }
         q->start();
 /*        q->tick(0);
         if (syncMode == QDeclarativeTimeLine::LocalSync)  {
             syncAdj = -1;
         } else {
             syncAdj = 0;
         }
         */
     }
 }

◆ advance()

int QDeclarativeTimeLinePrivate::advance ( int t )

Definition at line 741 of file qdeclarativetimeline.cpp.

Referenced by QDeclarativeTimeLine::complete(), and QDeclarativeTimeLine::updateCurrentTime().

 {
     int pauseTime = -1;
 
     // XXX - surely there is a more efficient way?
     do {
         pauseTime = -1;
         // Minimal advance time
         int advanceTime = t;
         for (Ops::Iterator iter = ops.begin(); iter != ops.end(); ++iter) {
             TimeLine &tl = *iter;
             Op &op = tl.ops.first();
             int length = op.length - tl.consumedOpLength;
                 
             if (length < advanceTime) {
                 advanceTime = length;
                 if (advanceTime == 0)
                     break;
             }
         }
         t -= advanceTime;
 
         // Process until then.  A zero length advance time will only process 
         // sets.
         QList<QPair<int, Update> > updates;
 
         for (Ops::Iterator iter = ops.begin(); iter != ops.end(); ) {
             QDeclarativeTimeLineValue *v = static_cast<QDeclarativeTimeLineValue *>(iter.key());
             TimeLine &tl = *iter;
             Q_ASSERT(!tl.ops.isEmpty());
 
             do {
                 Op &op = tl.ops.first();
                 if (advanceTime == 0 && op.length != 0)
                     continue;
 
                 if (tl.consumedOpLength == 0 && 
                    op.type != Op::Pause && 
                    op.type != Op::Execute)
                     tl.base = v->value();
 
                 if ((tl.consumedOpLength + advanceTime) == op.length) {
                     if (op.type == Op::Execute) {
                         updates << qMakePair(op.order, Update(op.event));
                     } else {
                         bool changed = false;
                         qreal val = value(op, op.length, tl.base, &changed);
                         if (changed)
                             updates << qMakePair(op.order, Update(v, val));
                     }
                     tl.length -= qMin(advanceTime, tl.length);
                     tl.consumedOpLength = 0;
                     tl.ops.removeFirst();
                 } else {
                     tl.consumedOpLength += advanceTime;
                     bool changed = false;
                     qreal val = value(op, tl.consumedOpLength, tl.base, &changed);
                     if (changed)
                         updates << qMakePair(op.order, Update(v, val));
                     tl.length -= qMin(advanceTime, tl.length);
                     break;
                 }
 
             } while(!tl.ops.isEmpty() && advanceTime == 0 && tl.ops.first().length == 0);
 
 
             if (tl.ops.isEmpty()) {
                 iter = ops.erase(iter);
                 v->_t = 0;
             } else {
                 if (tl.ops.first().type == Op::Pause && pauseTime != 0) {
                     int opPauseTime = tl.ops.first().length - tl.consumedOpLength;
                     if (pauseTime == -1 || opPauseTime < pauseTime)
                         pauseTime = opPauseTime;
                 } else {
                     pauseTime = 0;
                 }
                 ++iter;
             }
         }
 
         length -= qMin(length, advanceTime);
         syncPoint -= advanceTime;
 
         qSort(updates.begin(), updates.end());
         updateQueue = &updates;
         for (int ii = 0; ii < updates.count(); ++ii) {
             const Update &v = updates.at(ii).second;
             if (v.g) {
                 v.g->setValue(v.v);
             } else {
                 v.e.d0(v.e.d1);
             }
         }
         updateQueue = 0;
     } while(t);
 
     return pauseTime;
 }

◆ value()

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

Definition at line 188 of file qdeclarativetimeline.cpp.

 {
     Q_ASSERT(time >= 0);
     Q_ASSERT(time <= op.length);
     *changed = true;
 
     switch(op.type) {
         case Op::Pause:
             *changed = false;
             return base;
         case Op::Set:
             return op.value;
         case Op::Move:
             if (time == 0) {
                 return base;
             } else if (time == (op.length)) {
                 return op.value;
             } else {
                 qreal delta = op.value - base;
                 qreal pTime = (qreal)(time) / (qreal)op.length;
                 if (op.easing.type() == QEasingCurve::Linear)
                     return base + delta * pTime;
                 else
                     return base + delta * op.easing.valueForProgress(pTime);
             }
         case Op::MoveBy:
             if (time == 0) {
                 return base;
             } else if (time == (op.length)) {
                 return base + op.value;
             } else {
                 qreal delta = op.value;
                 qreal pTime = (qreal)(time) / (qreal)op.length;
                 if (op.easing.type() == QEasingCurve::Linear)
                     return base + delta * pTime;
                 else
                     return base + delta * op.easing.valueForProgress(pTime);
             }
         case Op::Accel:
             if (time == 0) {
                 return base;
             } else {
                 qreal t = (qreal)(time) / 1000.0f;
                 qreal delta = op.value * t + 0.5f * op.value2 * t * t;
                 return base + delta;
             }
         case Op::AccelDistance:
             if (time == 0) {
                 return base;
             } else if (time == (op.length)) {
                 return base + op.value2;
             } else {
                 qreal t = (qreal)(time) / 1000.0f;
                 qreal accel = -1.0f * 1000.0f * op.value / (qreal)op.length;
                 qreal delta = op.value * t + 0.5f * accel * t * t;
                 return base + delta;
 
             }
         case Op::Execute:
             op.event.d0(op.event.d1);
             *changed = false;
             return -1;
     }
 
     return base;
 }