QVariantAnimationPrivate Class Reference

#include <qvariantanimation_p.h>

Inheritance diagram for QVariantAnimationPrivate:

Public Functions
void	convertValues (int t)
	QVariantAnimationPrivate ()
void	recalculateCurrentInterval (bool force=false)
	The goal of this function is to update the currentInterval member. More...
void	setCurrentValueForProgress (const qreal progress)
void	setDefaultStartEndValue (const QVariant &value)
void	setValueAt (qreal, const QVariant &)
void	updateInterpolator ()
QVariant	valueAt (qreal step) const
Public Functions inherited from QAbstractAnimationPrivate
	QAbstractAnimationPrivate ()
void	setState (QAbstractAnimation::State state)
virtual	~QAbstractAnimationPrivate ()
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

Static Public Functions
static QVariantAnimationPrivate *	get (QVariantAnimation *q)
static Q_CORE_EXPORT QVariantAnimation::Interpolator	getInterpolator (int interpolationType)
Static Public Functions inherited from QAbstractAnimationPrivate
static QAbstractAnimationPrivate *	get (QAbstractAnimation *q)
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)

Public Variables
struct {
QVariantAnimation::KeyValue   end
QVariantAnimation::KeyValue   start
}	currentInterval
QVariant	currentValue
QVariant	defaultStartEndValue
int	duration
QEasingCurve	easing
QVariantAnimation::Interpolator	interpolator
QVariantAnimation::KeyValues	keyValues
Public Variables inherited from QAbstractAnimationPrivate
int	currentLoop
int	currentTime
bool	deleteWhenStopped
QAbstractAnimation::Direction	direction
QAnimationGroup *	group
bool	hasRegisteredTimer
bool	isGroup
bool	isPause
int	loopCount
QAbstractAnimation::State	state
int	totalCurrentTime
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
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)

Detailed Description

Definition at line 67 of file qvariantanimation_p.h.

Constructors and Destructors

QVariantAnimationPrivate()

QVariantAnimationPrivate::QVariantAnimationPrivate

(

)

Definition at line 207 of file qvariantanimation.cpp.

                                                   : duration(250), interpolator(&defaultInterpolator)
{ }

Functions

convertValues()

void QVariantAnimationPrivate::convertValues

(

int

t

)

Definition at line 210 of file qvariantanimation.cpp.

Referenced by QPropertyAnimationPrivate::updateMetaProperty().

{
    //this ensures that all the keyValues are of type t
    for (int i = 0; i < keyValues.count(); ++i) {
        QVariantAnimation::KeyValue &pair = keyValues[i];
        pair.second.convert(static_cast<QVariant::Type>(t));
    }
    //we also need update to the current interval if needed
    currentInterval.start.second.convert(static_cast<QVariant::Type>(t));
    currentInterval.end.second.convert(static_cast<QVariant::Type>(t));

    //... and the interpolator
    updateInterpolator();
}

get()

static QVariantAnimationPrivate* QVariantAnimationPrivate::get ( QVariantAnimation *  q )

inlinestatic

Definition at line 74 of file qvariantanimation_p.h.

    {
        return q->d_func();
    }

getInterpolator()

QVariantAnimation::Interpolator QVariantAnimationPrivate::getInterpolator ( int  interpolationType )

static

Definition at line 470 of file qvariantanimation.cpp.

Referenced by QDeclarativeNumberAnimation::init(), QDeclarativeColorAnimation::QDeclarativeColorAnimation(), QDeclarativeRotationAnimation::QDeclarativeRotationAnimation(), QDeclarativeVector3dAnimation::QDeclarativeVector3dAnimation(), QDeclarativeRotationAnimation::setDirection(), QDeclarativeAnimationPropertyUpdater::setValue(), and updateInterpolator().

{
    QInterpolatorVector *interpolators = registeredInterpolators();
#ifndef QT_NO_THREAD
    QMutexLocker locker(QMutexPool::globalInstanceGet(interpolators));
#endif
    QVariantAnimation::Interpolator ret = 0;
    if (interpolationType < interpolators->count()) {
        ret = interpolators->at(interpolationType);
        if (ret) return ret;
    }

    switch(interpolationType)
    {
    case QMetaType::Int:
        return castToInterpolator(_q_interpolateVariant<int>);
    case QMetaType::UInt:
        return castToInterpolator(_q_interpolateVariant<uint>);
    case QMetaType::Double:
        return castToInterpolator(_q_interpolateVariant<double>);
    case QMetaType::Float:
        return castToInterpolator(_q_interpolateVariant<float>);
    case QMetaType::QLine:
        return castToInterpolator(_q_interpolateVariant<QLine>);
    case QMetaType::QLineF:
        return castToInterpolator(_q_interpolateVariant<QLineF>);
    case QMetaType::QPoint:
        return castToInterpolator(_q_interpolateVariant<QPoint>);
    case QMetaType::QPointF:
        return castToInterpolator(_q_interpolateVariant<QPointF>);
    case QMetaType::QSize:
        return castToInterpolator(_q_interpolateVariant<QSize>);
    case QMetaType::QSizeF:
        return castToInterpolator(_q_interpolateVariant<QSizeF>);
    case QMetaType::QRect:
        return castToInterpolator(_q_interpolateVariant<QRect>);
    case QMetaType::QRectF:
        return castToInterpolator(_q_interpolateVariant<QRectF>);
    default:
        return 0; //this type is not handled
    }
}

recalculateCurrentInterval()

void QVariantAnimationPrivate::recalculateCurrentInterval

(

bool

force = false

)

The goal of this function is to update the currentInterval member.

Warning

This function is not part of the public interface. As a consequence, we also need to update the currentValue. Set force to true to always recalculate the interval.

Definition at line 247 of file qvariantanimation.cpp.

Referenced by setDefaultStartEndValue(), and setValueAt().

{
    // can't interpolate if we don't have at least 2 values
    if ((keyValues.count() + (defaultStartEndValue.isValid() ? 1 : 0)) < 2)
        return;

    const qreal endProgress = (direction == QAbstractAnimation::Forward) ? qreal(1) : qreal(0);
    const qreal progress = easing.valueForProgress(((duration == 0) ? endProgress : qreal(currentTime) / qreal(duration)));

    //0 and 1 are still the boundaries
    if (force || (currentInterval.start.first > 0 && progress < currentInterval.start.first)
        || (currentInterval.end.first < 1 && progress > currentInterval.end.first)) {
        //let's update currentInterval
        QVariantAnimation::KeyValues::const_iterator it = qLowerBound(keyValues.constBegin(),
                                                                      keyValues.constEnd(),
                                                                      qMakePair(progress, QVariant()),
                                                                      animationValueLessThan);
        if (it == keyValues.constBegin()) {
            //the item pointed to by it is the start element in the range
            if (it->first == 0 && keyValues.count() > 1) {
                currentInterval.start = *it;
                currentInterval.end = *(it+1);
            } else {
                currentInterval.start = qMakePair(qreal(0), defaultStartEndValue);
                currentInterval.end = *it;
            }
        } else if (it == keyValues.constEnd()) {
            --it; //position the iterator on the last item
            if (it->first == 1 && keyValues.count() > 1) {
                //we have an end value (item with progress = 1)
                currentInterval.start = *(it-1);
                currentInterval.end = *it;
            } else {
                //we use the default end value here
                currentInterval.start = *it;
                currentInterval.end = qMakePair(qreal(1), defaultStartEndValue);
            }
        } else {
            currentInterval.start = *(it-1);
            currentInterval.end = *it;
        }

        // update all the values of the currentInterval
        updateInterpolator();
    }
    setCurrentValueForProgress(progress);
}

setCurrentValueForProgress()

void QVariantAnimationPrivate::setCurrentValueForProgress

(

const qreal

progress

)

Definition at line 295 of file qvariantanimation.cpp.

Referenced by recalculateCurrentInterval().

{
    Q_Q(QVariantAnimation);

    const qreal startProgress = currentInterval.start.first;
    const qreal endProgress = currentInterval.end.first;
    const qreal localProgress = (progress - startProgress) / (endProgress - startProgress);

    QVariant ret = q->interpolated(currentInterval.start.second,
                                   currentInterval.end.second,
                                   localProgress);
    qSwap(currentValue, ret);
    q->updateCurrentValue(currentValue);
    static QBasicAtomicInt changedSignalIndex = Q_BASIC_ATOMIC_INITIALIZER(0);
    if (!changedSignalIndex) {
        //we keep the mask so that we emit valueChanged only when needed (for performance reasons)
        changedSignalIndex.testAndSetRelaxed(0, signalIndex("valueChanged(QVariant)"));
    }
    if (isSignalConnected(changedSignalIndex) && currentValue != ret) {
        //the value has changed
        emit q->valueChanged(currentValue);
    }
}

setDefaultStartEndValue()

void QVariantAnimationPrivate::setDefaultStartEndValue

(

const QVariant &

value

)

Definition at line 351 of file qvariantanimation.cpp.

Referenced by get().

{
    defaultStartEndValue = value;
    recalculateCurrentInterval(/*force=*/true);
}

setValueAt()

void QVariantAnimationPrivate::setValueAt	(	qreal	step,
		const QVariant &	value
	)

Definition at line 329 of file qvariantanimation.cpp.

{
    if (step < qreal(0.0) || step > qreal(1.0)) {
        qWarning("QVariantAnimation::setValueAt: invalid step = %f", step);
        return;
    }

    QVariantAnimation::KeyValue pair(step, value);

    QVariantAnimation::KeyValues::iterator result = qLowerBound(keyValues.begin(), keyValues.end(), pair, animationValueLessThan);
    if (result == keyValues.end() || result->first != step) {
        keyValues.insert(result, pair);
    } else {
        if (value.isValid())
            result->second = value; // replaces the previous value
        else
            keyValues.erase(result); // removes the previous value
    }

    recalculateCurrentInterval(/*force=*/true);
}

updateInterpolator()

void QVariantAnimationPrivate::updateInterpolator

(

)

Definition at line 225 of file qvariantanimation.cpp.

Referenced by convertValues(), and recalculateCurrentInterval().

{
    int type = currentInterval.start.second.userType();
    if (type == currentInterval.end.second.userType())
        interpolator = getInterpolator(type);
    else
        interpolator = 0;

    //we make sure that the interpolator is always set to something
    if (!interpolator)
        interpolator = &defaultInterpolator;
}

valueAt()

QVariant QVariantAnimationPrivate::valueAt

(

qreal

step

)

const

Definition at line 319 of file qvariantanimation.cpp.

{
    QVariantAnimation::KeyValues::const_iterator result =
        qBinaryFind(keyValues.begin(), keyValues.end(), qMakePair(step, QVariant()), animationValueLessThan);
    if (result != keyValues.constEnd())
        return result->second;

    return QVariant();
}

Properties

currentInterval

struct { ... } QVariantAnimationPrivate::currentInterval

Referenced by convertValues(), recalculateCurrentInterval(), setCurrentValueForProgress(), and updateInterpolator().

currentValue

QVariant QVariantAnimationPrivate::currentValue

Definition at line 82 of file qvariantanimation_p.h.

Referenced by setCurrentValueForProgress().

defaultStartEndValue

QVariant QVariantAnimationPrivate::defaultStartEndValue

Definition at line 83 of file qvariantanimation_p.h.

Referenced by recalculateCurrentInterval(), and setDefaultStartEndValue().

duration

int QVariantAnimationPrivate::duration

Definition at line 92 of file qvariantanimation_p.h.

Referenced by recalculateCurrentInterval().

easing

QEasingCurve QVariantAnimationPrivate::easing

Definition at line 91 of file qvariantanimation_p.h.

Referenced by recalculateCurrentInterval().

end

QVariantAnimation::KeyValue QVariantAnimationPrivate::end

Definition at line 88 of file qvariantanimation_p.h.

interpolator

QVariantAnimation::Interpolator QVariantAnimationPrivate::interpolator

Definition at line 94 of file qvariantanimation_p.h.

Referenced by updateInterpolator().

keyValues

QVariantAnimation::KeyValues QVariantAnimationPrivate::keyValues

Definition at line 93 of file qvariantanimation_p.h.

Referenced by convertValues(), recalculateCurrentInterval(), setValueAt(), and valueAt().

start

QVariantAnimation::KeyValue QVariantAnimationPrivate::start

Definition at line 88 of file qvariantanimation_p.h.

---

The documentation for this class was generated from the following files:

• /src/corelib/animation/qvariantanimation_p.h
• /src/corelib/animation/qvariantanimation.cpp