QAbstractAnimation Class

The QAbstractAnimation class is the base of all animations. More…

List of all members, including inherited members

Public Types

Public Functions

Public Slots

Signals

Protected Functions

Reimplemented Protected Functions

Detailed Description

An animation is something that changes over a time: it has a duration(), a current time between 0 and the duration, and can be started, paused, resumed and stopped. While it runs, the event loop of its thread moves its current time forward about sixty times a second, and each time the animation is told with updateCurrentTime().

The classes that are used most are QPropertyAnimation, which changes a property of an object, and the groups QSequentialAnimationGroup and QParallelAnimationGroup, which run animations one after another or together. To make an animation of another kind, subclass QAbstractAnimation and implement duration() and updateCurrentTime():

class Blink : public QAbstractAnimation {
public:
    int duration() const override { return 1000; }
protected:
    void updateCurrentTime(int time) override { setLamp(time < 500); }
};

An animation can run several times, see setLoopCount(), and backwards, see setDirection(). When it reaches its end it stops and emits finished().

See also QVariantAnimation, QPropertyAnimation and QAnimationGroup.

Differences from Qt

Member Type Documentation

enum QAbstractAnimation::DeletionPolicy

What start() arranges for the time the animation stops.

enum QAbstractAnimation::Direction

The direction in which the current time moves while the animation runs.

enum QAbstractAnimation::State

The states of an animation.

Member Function Documentation

[explicit] QAbstractAnimation::QAbstractAnimation(QObject *parent = nullptr)

Constructs an animation with the given parent. If the parent is a QAnimationGroup, add the animation to it with QAnimationGroup::addAnimation().

[override] QAbstractAnimation::~QAbstractAnimation()

Destroys the animation, after stopping it and taking it out of its group.

int QAbstractAnimation::currentLoop() const

Returns the number of the loop that the animation is in, starting with 0.

See also loopCount() and currentLoopChanged().

[signal] void QAbstractAnimation::currentLoopChanged(int currentLoop)

This signal is emitted when the animation starts another loop, with the number of the loop in currentLoop.

See also currentLoop() and setLoopCount().

int QAbstractAnimation::currentLoopTime() const

Returns the current time inside the current loop, from 0 to duration().

See also currentTime() and currentLoop().

int QAbstractAnimation::currentTime() const

Returns the current time of the animation in milliseconds, counted over all its loops: from 0 to totalDuration().

See also setCurrentTime() and currentLoopTime().

Direction QAbstractAnimation::direction() const

Returns the direction of the animation, which is Forward by default.

See also setDirection().

[signal] void QAbstractAnimation::directionChanged(QAbstractAnimation::Direction newDirection)

This signal is emitted when the direction has changed, with the new direction in newDirection.

See also setDirection().

[virtual] int QAbstractAnimation::duration() const

Returns the duration of one loop of the animation in milliseconds. -1 means that the duration is undefined: the animation runs until it stops itself or is stopped.

See also totalDuration() and loopCount().

[override, protected] bool QAbstractAnimation::event(QEvent *event)

Reimplements QObject::event().

[signal] void QAbstractAnimation::finished()

This signal is emitted when the animation has run to its end and stopped by itself. It is not emitted when stop() ends an animation early, unless the animation has no end of its own: an undefined duration or loops without end.

See also stateChanged() and stop().

QAnimationGroup * QAbstractAnimation::group() const

Returns the group that the animation is in, or nullptr if it is in none. An animation in a group is started, paused and stopped by its group.

See also QAnimationGroup::addAnimation().

int QAbstractAnimation::loopCount() const

Returns the number of times the animation runs before it stops, which is 1 by default. -1 means that it runs until it is stopped.

See also setLoopCount().

[slot] void QAbstractAnimation::pause()

Pauses a running animation: the current time stays where it is until resume() or stop().

See also resume() and setPaused().

[slot] void QAbstractAnimation::resume()

Lets a paused animation go on from where it was paused.

See also pause() and setPaused().

[slot] void QAbstractAnimation::setCurrentTime(int msecs)

Sets the current time of the animation to msecs, a time between 0 and totalDuration(), and updates the animation to that time. The event loop calls this for an animation that runs; a program can call it to move an animation by hand, also one that is paused or stopped. An animation that runs and is put at its end stops.

See also currentTime() and updateCurrentTime().

void QAbstractAnimation::setDirection(Direction direction)

Sets the direction of the animation to direction. An animation that runs goes on from where it is in the new direction. A stopped animation with the direction Backward starts at its end; if it loops without end, it starts at the end of its first loop.

See also direction() and directionChanged().

void QAbstractAnimation::setLoopCount(int loopCount)

Sets the number of times the animation runs to loopCount. With 0 the animation does not run at all, and with -1 it runs until it is stopped.

See also loopCount() and currentLoop().

[slot] void QAbstractAnimation::setPaused(bool paused)

Pauses the animation if paused is true, and resumes it otherwise.

See also pause() and resume().

[slot] void QAbstractAnimation::start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped)

Starts the animation: the state becomes Running, and the event loop moves the current time from the start to the end. With the policy DeleteWhenStopped the animation is deleted when it stops. Starting an animation that runs does nothing; a paused one starts over from the beginning only after stop(), use resume() to go on.

The animation needs the event loop of its thread, as every timer does.

See also stop(), pause() and finished().

State QAbstractAnimation::state() const

Returns the state of the animation.

See also start(), pause(), stop() and stateChanged().

[signal] void QAbstractAnimation::stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)

This signal is emitted when the state of the animation has changed from oldState to newState.

See also updateState().

[slot] void QAbstractAnimation::stop()

Stops the animation. The current time stays where it is, and the next start() begins at the start again. finished() is not emitted, unless the animation has no end of its own.

See also start() and finished().

int QAbstractAnimation::totalDuration() const

Returns the duration of all loops together: duration() times loopCount(). It is -1 if the duration is undefined or the animation loops without end.

See also duration() and currentTime().

[virtual, protected] void QAbstractAnimation::updateCurrentTime(int currentTime)

Called when the current time of the animation has changed, with the time inside the current loop in currentTime. A subclass shows the animation as it is at that time.

See also setCurrentTime() and updateState().

[virtual, protected] void QAbstractAnimation::updateDirection(QAbstractAnimation::Direction direction)

Called when the direction of the animation changes to direction, before directionChanged() is emitted. The default implementation does nothing.

See also setDirection().

[virtual, protected] void QAbstractAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)

Called when the state of the animation changes from oldState to newState, before stateChanged() is emitted. The default implementation does nothing.

See also start(), stop() and pause().