Inheritance diagram for QDeclarativeSpringAnimationPrivate:

Classes
struct	SpringAnimation

Public Types
typedef QTickAnimationProxy< QDeclarativeSpringAnimationPrivate, &QDeclarativeSpringAnimationPrivate::tick >	Clock

enum	Mode { Track, Velocity, Spring }

Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Public Functions
bool	animate (const QDeclarativeProperty &property, SpringAnimation &animation, int elapsed)

	QDeclarativeSpringAnimationPrivate ()

void	tick (int time)

void	updateMode ()

Public Functions inherited from QDeclarativePropertyAnimationPrivate
void	init ()

	QDeclarativePropertyAnimationPrivate ()

Public Functions inherited from QDeclarativeAbstractAnimationPrivate
void	commence ()

	QDeclarativeAbstractAnimationPrivate ()

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Variables
QHash< QDeclarativeProperty, SpringAnimation >	activeAnimations

Clock *	clock

qreal	damping

qreal	epsilon

bool	haveModulus: 1

int	lastTime

qreal	mass

qreal	maxVelocity

Mode	mode

qreal	modulus

qreal	spring

bool	useMass: 1

qreal	velocityms

Public Variables inherited from QDeclarativePropertyAnimationPrivate
QDeclarativeStateActions *	actions

QString	defaultProperties

bool	defaultToInterpolatorType:1

QList< QObject * >	exclude

QVariant	from

bool	fromIsDefined:1

bool	fromSourced

QVariantAnimation::Interpolator	interpolator

int	interpolatorType

QString	properties

QString	propertyName

bool	rangeIsSet:1

QObject *	target

QList< QObject * >	targets

QVariant	to

bool	toIsDefined:1

QDeclarativeBulkValueAnimator *	va

Public Variables inherited from QDeclarativeAbstractAnimationPrivate
bool	alwaysRunToEnd:1

bool	avoidPropertyValueSourceStart:1

bool	componentComplete:1

bool	connectedTimeLine:1

QDeclarativeProperty	defaultProperty

bool	disableUserControl:1

QDeclarativeAnimationGroup *	group

int	loopCount

bool	paused:1

bool	registered:1

bool	running:1

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Additional Inherited Members
Static Public Functions inherited from QDeclarativePropertyAnimationPrivate
static void	convertVariant (QVariant &variant, int type)

static QVariant	interpolateVariant (const QVariant &from, const QVariant &to, qreal progress)

Static Public Functions inherited from QDeclarativeAbstractAnimationPrivate
static QDeclarativeProperty	createProperty (QObject obj, const QString &str, QObject infoObj)

Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Detailed Description

Definition at line 57 of file qdeclarativespringanimation.cpp.

Typedefs

◆ Clock

typedef QTickAnimationProxy<QDeclarativeSpringAnimationPrivate, &QDeclarativeSpringAnimationPrivate::tick> QDeclarativeSpringAnimationPrivate::Clock

Definition at line 104 of file qdeclarativespringanimation.cpp.

Enumerations

◆ Mode

enum QDeclarativeSpringAnimationPrivate::Mode

Enumerator
Track
Velocity
Spring

Definition at line 86 of file qdeclarativespringanimation.cpp.

               {
         Track,
         Velocity,
         Spring
     };

Constructors and Destructors

◆ QDeclarativeSpringAnimationPrivate()

QDeclarativeSpringAnimationPrivate::QDeclarativeSpringAnimationPrivate ( )

inline

Definition at line 93 of file qdeclarativespringanimation.cpp.

           : maxVelocity(0), velocityms(0), lastTime(0)
           , mass(1.0), spring(0.), damping(0.), epsilon(0.01)
           , modulus(0.0), useMass(false), haveModulus(false)
           , mode(Track), clock(0)
     { }

Functions

◆ animate()

bool QDeclarativeSpringAnimationPrivate::animate	(	const QDeclarativeProperty &	property,
		SpringAnimation &	animation,
		int	elapsed
	)

Definition at line 138 of file qdeclarativespringanimation.cpp.

Referenced by QDeclarativeSpringAnimationPrivate(), and tick().

 {
     qreal srcVal = animation.to;
 
     bool stop = false;
 
     if (haveModulus) {
         animation.currentValue = fmod(animation.currentValue, modulus);
         srcVal = fmod(srcVal, modulus);
     }
     if (mode == Spring) {
         // Real men solve the spring DEs using RK4.
         // We'll do something much simpler which gives a result that looks fine.
         int count = elapsed / 16;
         for (int i = 0; i < count; ++i) {
             qreal diff = srcVal - animation.currentValue;
             if (haveModulus && qAbs(diff) > modulus / 2) {
                 if (diff < 0)
                     diff += modulus;
                 else
                     diff -= modulus;
             }
             if (useMass)
                 animation.velocity = animation.velocity + (spring * diff - damping * animation.velocity) / mass;
             else
                 animation.velocity = animation.velocity + spring * diff - damping * animation.velocity;
             if (maxVelocity > qreal(0.)) {
                 // limit velocity
                 if (animation.velocity > maxVelocity)
                     animation.velocity = maxVelocity;
                 else if (animation.velocity < -maxVelocity)
                     animation.velocity = -maxVelocity;
             }
             animation.currentValue += animation.velocity * qreal(16.0) / qreal(1000.0);
             if (haveModulus) {
                 animation.currentValue = fmod(animation.currentValue, modulus);
                 if (animation.currentValue < qreal(0.0))
                     animation.currentValue += modulus;
             }
         }
         if (qAbs(animation.velocity) < epsilon && qAbs(srcVal - animation.currentValue) < epsilon) {
             animation.velocity = 0.0;
             animation.currentValue = srcVal;
             stop = true;
         }
     } else {
         qreal moveBy = elapsed * velocityms;
         qreal diff = srcVal - animation.currentValue;
         if (haveModulus && qAbs(diff) > modulus / 2) {
             if (diff < 0)
                 diff += modulus;
             else
                 diff -= modulus;
         }
         if (diff > 0) {
             animation.currentValue += moveBy;
             if (haveModulus)
                 animation.currentValue = fmod(animation.currentValue, modulus);
         } else {
             animation.currentValue -= moveBy;
             if (haveModulus && animation.currentValue < qreal(0.0))
                 animation.currentValue = fmod(animation.currentValue, modulus) + modulus;
         }
         if (lastTime - animation.start >= animation.duration) {
             animation.currentValue = animation.to;
             stop = true;
         }
     }
 
     qreal old_to = animation.to;
 
     QDeclarativePropertyPrivate::write(property, animation.currentValue,
                                        QDeclarativePropertyPrivate::BypassInterceptor |
                                        QDeclarativePropertyPrivate::DontRemoveBinding);
 
     return (stop && old_to == animation.to); // do not stop if we got restarted
 }

◆ tick()

void QDeclarativeSpringAnimationPrivate::tick ( int time )

Definition at line 108 of file qdeclarativespringanimation.cpp.

Referenced by QDeclarativeSpringAnimationPrivate().

 {
     if (mode == Track) {
         clock->stop();
         return;
     }
     int elapsed = time - lastTime;
     if (!elapsed)
         return;
 
     if (mode == Spring) {
         if (elapsed < 16) // capped at 62fps.
             return;
         int count = elapsed / 16;
         lastTime = time - (elapsed - count * 16);
     } else {
         lastTime = time;
     }
 
     QMutableHashIterator<QDeclarativeProperty, SpringAnimation> it(activeAnimations);
     while (it.hasNext()) {
         it.next();
         if (animate(it.key(), it.value(), elapsed))
             it.remove();
     }
 
     if (activeAnimations.isEmpty())
         clock->stop();
 }

◆ updateMode()

void QDeclarativeSpringAnimationPrivate::updateMode ( )

Definition at line 216 of file qdeclarativespringanimation.cpp.

Referenced by QDeclarativeSpringAnimationPrivate().

 {
     if (spring == 0. && maxVelocity == 0.)
         mode = Track;
     else if (spring > 0.)
         mode = Spring;
     else {
         mode = Velocity;
         QHash<QDeclarativeProperty, SpringAnimation>::iterator it;
         for (it = activeAnimations.begin(); it != activeAnimations.end(); ++it) {
             SpringAnimation &animation = *it;
             animation.start = lastTime;
             qreal dist = qAbs(animation.currentValue - animation.to);
             if (haveModulus && dist > modulus / 2)
                 dist = modulus - fmod(dist, modulus);
             animation.duration = dist / velocityms;
         }
     }
 }