QSequentialAnimationGroupPrivate Class Reference

#include <qsequentialanimationgroup_p.h>

Inheritance diagram for QSequentialAnimationGroupPrivate:

Classes
struct	AnimationIndex

Public Functions
void	_q_uncontrolledAnimationFinished ()
void	activateCurrentAnimation (bool intermediate=false)
void	advanceForwards (const AnimationIndex &newAnimationIndex)
	This manages advancing the execution of a group running forwards (time has gone forward), which is the same behaviour for rewinding the execution of a group running backwards (time has gone backward). More...
int	animationActualTotalDuration (int index) const
void	animationInsertedAt (int index)
	This method is called whenever an animation is added to the group at index index. More...
void	animationRemoved (int index, QAbstractAnimation *anim)
	This method is called whenever an animation is removed from the group at index index. More...
bool	atEnd () const
AnimationIndex	indexForCurrentTime () const
	QSequentialAnimationGroupPrivate ()
void	restart ()
void	rewindForwards (const AnimationIndex &newAnimationIndex)
	This manages rewinding the execution of a group running forwards (time has gone forward), which is the same behaviour for advancing the execution of a group running backwards (time has gone backward). More...
void	setCurrentAnimation (int index, bool intermediate=false)
Public Functions inherited from QAnimationGroupPrivate
void	connectUncontrolledAnimation (QAbstractAnimation *anim)
void	disconnectUncontrolledAnimation (QAbstractAnimation *anim)
	QAnimationGroupPrivate ()
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

Public Variables
QList< int >	actualDuration
QAbstractAnimation *	currentAnimation
int	currentAnimationIndex
int	lastLoop
Public Variables inherited from QAnimationGroupPrivate
QList< QAbstractAnimation * >	animations
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 **)
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)

Detailed Description

Definition at line 63 of file qsequentialanimationgroup_p.h.

Constructors and Destructors

QSequentialAnimationGroupPrivate()

QSequentialAnimationGroupPrivate::QSequentialAnimationGroupPrivate ( )

inline

Definition at line 67 of file qsequentialanimationgroup_p.h.

        : currentAnimation(0), currentAnimationIndex(-1), lastLoop(0)
    { }

Functions

_q_uncontrolledAnimationFinished()

void QSequentialAnimationGroupPrivate::_q_uncontrolledAnimationFinished

(

)

Definition at line 496 of file qsequentialanimationgroup.cpp.

{
    Q_Q(QSequentialAnimationGroup);
    Q_ASSERT(qobject_cast<QAbstractAnimation *>(q->sender()) == currentAnimation);

    // we trust the duration returned by the animation
    while (actualDuration.size() < (currentAnimationIndex + 1))
        actualDuration.append(-1);
    actualDuration[currentAnimationIndex] = currentAnimation->currentTime();

    disconnectUncontrolledAnimation(currentAnimation);

    if ((direction == QAbstractAnimation::Forward && currentAnimation == animations.last())
        || (direction == QAbstractAnimation::Backward && currentAnimationIndex == 0)) {
        // we don't handle looping of a group with undefined duration
        q->stop();
    } else if (direction == QAbstractAnimation::Forward) {
        // set the current animation to be the next one
        setCurrentAnimation(currentAnimationIndex + 1);
    } else {
        // set the current animation to be the previous one
        setCurrentAnimation(currentAnimationIndex - 1);
    }
}

activateCurrentAnimation()

void QSequentialAnimationGroupPrivate::activateCurrentAnimation

(

bool

intermediate = false

)

Definition at line 477 of file qsequentialanimationgroup.cpp.

Referenced by advanceForwards(), restart(), and rewindForwards().

{
    if (!currentAnimation || state == QSequentialAnimationGroup::Stopped)
        return;

    currentAnimation->stop();

    // we ensure the direction is consistent with the group's direction
    currentAnimation->setDirection(direction);

    // connects to the finish signal of uncontrolled animations
    if (currentAnimation->totalDuration() == -1)
        connectUncontrolledAnimation(currentAnimation);

    currentAnimation->start();
    if (!intermediate && state == QSequentialAnimationGroup::Paused)
        currentAnimation->pause();
}

advanceForwards()

void QSequentialAnimationGroupPrivate::advanceForwards

(

const AnimationIndex &

newAnimationIndex

)

This manages advancing the execution of a group running forwards (time has gone forward), which is the same behaviour for rewinding the execution of a group running backwards (time has gone backward).

Warning

This function is not part of the public interface.

Definition at line 179 of file qsequentialanimationgroup.cpp.

{
    if (lastLoop < currentLoop) {
        // we need to fast forward to the end
        for (int i = currentAnimationIndex; i < animations.size(); ++i) {
            QAbstractAnimation *anim = animations.at(i);
            setCurrentAnimation(i, true);
            anim->setCurrentTime(animationActualTotalDuration(i));
        }
        // this will make sure the current animation is reset to the beginning
        if (animations.size() == 1)
            // we need to force activation because setCurrentAnimation will have no effect
            activateCurrentAnimation();
        else
            setCurrentAnimation(0, true);
    }

    // and now we need to fast forward from the current position to
    for (int i = currentAnimationIndex; i < newAnimationIndex.index; ++i) {     //### WRONG,
        QAbstractAnimation *anim = animations.at(i);
        setCurrentAnimation(i, true);
        anim->setCurrentTime(animationActualTotalDuration(i));
    }
    // setting the new current animation will happen later
}

animationActualTotalDuration()

int QSequentialAnimationGroupPrivate::animationActualTotalDuration

(

int

index

)

const

Definition at line 109 of file qsequentialanimationgroup.cpp.

Referenced by advanceForwards(), atEnd(), and indexForCurrentTime().

{
    QAbstractAnimation *anim = animations.at(index);
    int ret = anim->totalDuration();
    if (ret == -1 && actualDuration.size() > index)
        ret = actualDuration.at(index); //we can try the actual duration there
    return ret;
}

animationInsertedAt()

void QSequentialAnimationGroupPrivate::animationInsertedAt ( int  index )

virtual

This method is called whenever an animation is added to the group at index index.

Warning

This function is not part of the public interface.

Note: We only support insertion after the current animation

Reimplemented from QAnimationGroupPrivate.

Definition at line 530 of file qsequentialanimationgroup.cpp.

{
    if (currentAnimation == 0)
        setCurrentAnimation(0); // initialize the current animation

    if (currentAnimationIndex == index
        && currentAnimation->currentTime() == 0 && currentAnimation->currentLoop() == 0) {
            //in this case we simply insert an animation before the current one has actually started
            setCurrentAnimation(index);
    }

    //we update currentAnimationIndex in case it has changed (the animation pointer is still valid)
    currentAnimationIndex = animations.indexOf(currentAnimation);

    if (index < currentAnimationIndex || currentLoop != 0) {
        qWarning("QSequentialGroup::insertAnimation only supports to add animations after the current one.");
        return; //we're not affected because it is added after the current one
    }
}

animationRemoved()

void QSequentialAnimationGroupPrivate::animationRemoved ( int  index, QAbstractAnimation *  anim  )

virtual

This method is called whenever an animation is removed from the group at index index.

Warning

This function is not part of the public interface. The animation is no more listed when this method is called.

Reimplemented from QAnimationGroupPrivate.

Definition at line 559 of file qsequentialanimationgroup.cpp.

{
    Q_Q(QSequentialAnimationGroup);
    QAnimationGroupPrivate::animationRemoved(index, anim);

    Q_ASSERT(currentAnimation); // currentAnimation should always be set

    if (actualDuration.size() > index)
        actualDuration.removeAt(index);

    const int currentIndex = animations.indexOf(currentAnimation);
    if (currentIndex == -1) {
        //we're removing the current animation

        disconnectUncontrolledAnimation(currentAnimation);

        if (index < animations.count())
            setCurrentAnimation(index); //let's try to take the next one
        else if (index > 0)
            setCurrentAnimation(index - 1);
        else// case all animations were removed
            setCurrentAnimation(-1);
    } else if (currentAnimationIndex > index) {
        currentAnimationIndex--;
    }

    // duration of the previous animations up to the current animation
    currentTime = 0;
    for (int i = 0; i < currentAnimationIndex; ++i) {
        const int current = animationActualTotalDuration(i);
        currentTime += current;
    }

    if (currentIndex != -1) {
        //the current animation is not the one being removed
        //so we add its current time to the current time of this group
        currentTime += QAbstractAnimationPrivate::get(currentAnimation)->totalCurrentTime;
    }

    //let's also update the total current time
    totalCurrentTime = currentTime + loopCount * q->duration();
}

atEnd()

bool QSequentialAnimationGroupPrivate::atEnd

(

)

const

Definition at line 94 of file qsequentialanimationgroup.cpp.

{
    // we try to detect if we're at the end of the group
    //this is true if the following conditions are true:
    // 1. we're in the last loop
    // 2. the direction is forward
    // 3. the current animation is the last one
    // 4. the current animation has reached its end
    const int animTotalCurrentTime = QAbstractAnimationPrivate::get(currentAnimation)->totalCurrentTime;
    return (currentLoop == loopCount - 1
        && direction == QAbstractAnimation::Forward
        && currentAnimation == animations.last()
        && animTotalCurrentTime == animationActualTotalDuration(currentAnimationIndex));
}

indexForCurrentTime()

QSequentialAnimationGroupPrivate::AnimationIndex QSequentialAnimationGroupPrivate::indexForCurrentTime

(

)

const

Definition at line 118 of file qsequentialanimationgroup.cpp.

{
    Q_ASSERT(!animations.isEmpty());

    AnimationIndex ret;
    int duration = 0;

    for (int i = 0; i < animations.size(); ++i) {
        duration = animationActualTotalDuration(i);

        // 'animation' is the current animation if one of these reasons is true:
        // 1. it's duration is undefined
        // 2. it ends after msecs
        // 3. it is the last animation (this can happen in case there is at least 1 uncontrolled animation)
        // 4. it ends exactly in msecs and the direction is backwards
        if (duration == -1 || currentTime < (ret.timeOffset + duration)
            || (currentTime == (ret.timeOffset + duration) && direction == QAbstractAnimation::Backward)) {
            ret.index = i;
            return ret;
        }

        // 'animation' has a non-null defined duration and is not the one at time 'msecs'.
        ret.timeOffset += duration;
    }

    // this can only happen when one of those conditions is true:
    // 1. the duration of the group is undefined and we passed its actual duration
    // 2. there are only 0-duration animations in the group
    ret.timeOffset -= duration;
    ret.index = animations.size() - 1;
    return ret;
}

restart()

void QSequentialAnimationGroupPrivate::restart

(

)

Definition at line 151 of file qsequentialanimationgroup.cpp.

{
    // restarting the group by making the first/last animation the current one
    if (direction == QAbstractAnimation::Forward) {
        lastLoop = 0;
        if (currentAnimationIndex == 0)
            activateCurrentAnimation();
        else
            setCurrentAnimation(0);
    } else { // direction == QAbstractAnimation::Backward
        lastLoop = loopCount - 1;
        int index = animations.size() - 1;
        if (currentAnimationIndex == index)
            activateCurrentAnimation();
        else
            setCurrentAnimation(index);
    }
}

rewindForwards()

void QSequentialAnimationGroupPrivate::rewindForwards

(

const AnimationIndex &

newAnimationIndex

)

This manages rewinding the execution of a group running forwards (time has gone forward), which is the same behaviour for advancing the execution of a group running backwards (time has gone backward).

Warning

This function is not part of the public interface.

Definition at line 214 of file qsequentialanimationgroup.cpp.

{
    if (lastLoop > currentLoop) {
        // we need to fast rewind to the beginning
        for (int i = currentAnimationIndex; i >= 0 ; --i) {
            QAbstractAnimation *anim = animations.at(i);
            setCurrentAnimation(i, true);
            anim->setCurrentTime(0);
        }
        // this will make sure the current animation is reset to the end
        if (animations.size() == 1)
            // we need to force activation because setCurrentAnimation will have no effect
            activateCurrentAnimation();
        else
            setCurrentAnimation(animations.count() - 1, true);
    }

    // and now we need to fast rewind from the current position to
    for (int i = currentAnimationIndex; i > newAnimationIndex.index; --i) {
        QAbstractAnimation *anim = animations.at(i);
        setCurrentAnimation(i, true);
        anim->setCurrentTime(0);
    }
    // setting the new current animation will happen later
}

setCurrentAnimation()

void QSequentialAnimationGroupPrivate::setCurrentAnimation	(	int	index,
		bool	intermediate = false
	)

Definition at line 447 of file qsequentialanimationgroup.cpp.

Referenced by advanceForwards(), restart(), and rewindForwards().

{
    Q_Q(QSequentialAnimationGroup);

    index = qMin(index, animations.count() - 1);

    if (index == -1) {
        Q_ASSERT(animations.isEmpty());
        currentAnimationIndex = -1;
        currentAnimation = 0;
        return;
    }

    // need these two checks below because this func can be called after the current animation
    // has been removed
    if (index == currentAnimationIndex && animations.at(index) == currentAnimation)
        return;

    // stop the old current animation
    if (currentAnimation)
        currentAnimation->stop();

    currentAnimation = animations.at(index);
    currentAnimationIndex = index;

    emit q->currentAnimationChanged(currentAnimation);

    activateCurrentAnimation(intermediate);
}

Properties

actualDuration

QList<int> QSequentialAnimationGroupPrivate::actualDuration

Definition at line 97 of file qsequentialanimationgroup_p.h.

Referenced by animationActualTotalDuration().

currentAnimation

QAbstractAnimation* QSequentialAnimationGroupPrivate::currentAnimation

Definition at line 92 of file qsequentialanimationgroup_p.h.

Referenced by atEnd().

currentAnimationIndex

int QSequentialAnimationGroupPrivate::currentAnimationIndex

Definition at line 93 of file qsequentialanimationgroup_p.h.

Referenced by advanceForwards(), atEnd(), restart(), and rewindForwards().

lastLoop

int QSequentialAnimationGroupPrivate::lastLoop

Definition at line 100 of file qsequentialanimationgroup_p.h.

Referenced by advanceForwards(), restart(), and rewindForwards().

---

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

• /src/corelib/animation/qsequentialanimationgroup_p.h
• /src/corelib/animation/qsequentialanimationgroup.cpp