QAbstractAnimation Class
La clase `QAbstractAnimation` es la base de todas las animaciones. Más información...
| Encabezado: | #include <QAbstractAnimation> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Heredado de: | QObject |
| Heredado por: |
- Lista de todos los miembros, incluidos los heredados
- QAbstractAnimation forma parte del marco de animación.
Tipos públicos
| enum | DeletionPolicy { KeepWhenStopped, DeleteWhenStopped } |
| enum | Direction { Forward, Backward } |
| enum | State { Stopped, Paused, Running } |
Propiedades
|
Funciones públicas
| QAbstractAnimation(QObject *parent = nullptr) | |
| virtual | ~QAbstractAnimation() |
| QBindable<int> | bindableCurrentLoop() const |
| QBindable<int> | bindableCurrentTime() |
| QBindable<QAbstractAnimation::Direction> | bindableDirection() |
| QBindable<int> | bindableLoopCount() |
| QBindable<QAbstractAnimation::State> | bindableState() const |
| int | currentLoop() const |
| int | currentLoopTime() const |
| int | currentTime() const |
| QAbstractAnimation::Direction | direction() const |
| virtual int | duration() const = 0 |
| QAnimationGroup * | group() const |
| int | loopCount() const |
| void | setDirection(QAbstractAnimation::Direction direction) |
| void | setLoopCount(int loopCount) |
| QAbstractAnimation::State | state() const |
| int | totalDuration() const |
Ranuras públicas
| void | pause() |
| void | resume() |
| void | setCurrentTime(int msecs) |
| void | setPaused(bool paused) |
| void | start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped) |
| void | stop() |
Señales
| void | currentLoopChanged(int currentLoop) |
| void | directionChanged(QAbstractAnimation::Direction newDirection) |
| void | finished() |
| void | stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) |
Funciones protegidas
| virtual void | updateCurrentTime(int currentTime) = 0 |
| virtual void | updateDirection(QAbstractAnimation::Direction direction) |
| virtual void | updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) |
Funciones protegidas reimplementadas
| virtual bool | event(QEvent *event) override |
Descripción detallada
La clase define las funciones para la funcionalidad compartida por todas las animaciones. Al heredar de esta clase, puedes crear animaciones personalizadas que se integren en el resto del marco de animaciones.
El progreso de una animación viene dado por su tiempo actual (currentLoopTime()), que se mide en milisegundos desde el inicio de la animación (0) hasta su final (duration()). El valor se actualiza automáticamente mientras se ejecuta la animación. También se puede establecer directamente con setCurrentTime().
En cualquier momento, una animación se encuentra en uno de estos tres estados: ` Running`, ` Stopped` o ` Paused`, tal y como se definen en la enumeración ` State `. El estado actual se puede cambiar llamando a ` start()`, ` stop()`, ` pause()` o ` resume()`. Una animación siempre restablecerá su « current time » al iniciarse. Si se pausa, continuará con el mismo tiempo actual al reanudarse. Cuando se detiene una animación, no se puede reanudar, pero mantendrá su tiempo actual (hasta que se vuelva a iniciar). QAbstractAnimation emitirá stateChanged() cada vez que cambie su estado.
Una animación puede repetirse tantas veces como se desee configurando la propiedad loopCount. Cuando el tiempo actual de una animación alcanza su duration(), restablecerá el tiempo actual y seguirá ejecutándose. Un recuento de repeticiones de 1 (el valor por defecto) significa que la animación se ejecutará una sola vez. Ten en cuenta que una duración de -1 significa que la animación se ejecutará hasta que se detenga; el tiempo actual aumentará indefinidamente. Cuando el tiempo actual es igual a duration() y la animación se encuentra en su último bucle, se entra en el estado Stopped y se emite la señal finished().
QAbstractAnimation proporciona funciones virtuales puras que utilizan las subclases para realizar un seguimiento del progreso de la animación: duration() y updateCurrentTime(). La función duration() permite indicar una duración para la animación (tal y como se ha comentado anteriormente). El marco de trabajo de animación llama a updateCurrentTime() cuando cambia la hora actual. Al reimplementar esta función, se puede realizar un seguimiento del progreso de la animación. Ten en cuenta que ni el intervalo entre llamadas ni el número de llamadas a esta función están definidos; no obstante, normalmente será de 60 actualizaciones por segundo.
Al reimplementar updateState(), puedes realizar un seguimiento de los cambios de estado de la animación, lo cual resulta especialmente útil para animaciones que no se rigen por el tiempo.
Véase también QVariantAnimation, QPropertyAnimation, QAnimationGroup y El marco de trabajo de animación.
Documentación sobre los tipos de miembros
enum QAbstractAnimation::DeletionPolicy
| Constante | Valor | Descripción |
|---|---|---|
QAbstractAnimation::KeepWhenStopped | 0 | La animación no se eliminará al detenerse. |
QAbstractAnimation::DeleteWhenStopped | 1 | La animación se eliminará automáticamente al detenerse. |
enum QAbstractAnimation::Direction
Esta enumeración describe la dirección de la animación cuando se encuentra en el estado « Running ».
| Constante | Valor | Descripción |
|---|---|---|
QAbstractAnimation::Forward | 0 | El tiempo actual de la animación aumenta con el paso del tiempo (es decir, avanza desde 0 hacia el final o la duración). |
QAbstractAnimation::Backward | 1 | El tiempo actual de la animación disminuye con el paso del tiempo (es decir, se desplaza desde el final o la duración hacia 0). |
Véase también direction.
enum QAbstractAnimation::State
Esta enumeración describe el estado de la animación.
| Constante | Valor | Descripción |
|---|---|---|
QAbstractAnimation::Stopped | 0 | La animación no se está ejecutando. Este es el estado inicial de ` QAbstractAnimation`, y el estado ` QAbstractAnimation ` se vuelve a alcanzar una vez finalizada. La hora actual permanece sin cambios hasta que se llame a ` setCurrentTime()` o se inicie la animación llamando a ` start()`. |
QAbstractAnimation::Paused | 1 | La animación está en pausa (es decir, suspendida temporalmente). Al llamar a resume() se reanudará la animación. |
QAbstractAnimation::Running | 2 | La animación se está ejecutando. Mientras el control se encuentra en el bucle de eventos, QAbstractAnimation actualizará su hora actual a intervalos regulares, llamando a updateCurrentTime() cuando sea necesario. |
Véase también state() y stateChanged().
Documentación de propiedades
[bindable read-only] currentLoop : int
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Esta propiedad indica el bucle actual de la animación
Esta propiedad describe el bucle actual de la animación. Por defecto, el recuento de bucles de la animación es 1, por lo que el bucle actual siempre será 0. Si el recuento de bucles es 2 y la animación supera su duración, se rebobinará automáticamente y se reiniciará con el tiempo actual 0 y el bucle actual 1, y así sucesivamente.
Cuando cambia el bucle actual, « QAbstractAnimation » emite la señal « currentLoopChanged()».
Funciones de acceso:
| int | currentLoop() const |
Señal del notificador:
| void | currentLoopChanged(int currentLoop) |
[bindable] currentTime : int
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Esta propiedad contiene la hora actual y el progreso de la animación
Esta propiedad describe el tiempo actual de la animación. Puedes cambiar el tiempo actual llamando a `setCurrentTime()`, o bien puedes llamar a ` start()` y dejar que la animación se ejecute, de modo que el tiempo actual se establezca automáticamente a medida que avanza la animación.
La hora actual de la animación comienza en 0 y termina en totalDuration().
Nota: Se pueden vincular otras propiedades a `currentTime`, pero no se recomienda establecer enlaces con ella. A medida que avanza la animación, `currentTime` se actualiza automáticamente, lo que cancela sus enlaces.
Funciones de acceso:
| int | currentTime() const |
| void | setCurrentTime(int msecs) |
Véanse también loopCount y currentLoopTime().
[bindable] direction : Direction
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Esta propiedad contiene la dirección de la animación cuando se encuentra en el estado « Running ».
Esta dirección indica si el tiempo avanza desde 0 hacia la duración de la animación, o desde el valor de la duración hacia 0 después de que se haya llamado a « start()».
De forma predeterminada, esta propiedad está establecida en « Forward ».
Funciones de acceso:
| QAbstractAnimation::Direction | direction() const |
| void | setDirection(QAbstractAnimation::Direction direction) |
Señal de notificador:
| void | directionChanged(QAbstractAnimation::Direction newDirection) |
[read-only] duration : int
Esta propiedad indica la duración de la animación.
Si la duración es -1, significa que la duración no está definida. En este caso, se ignora « loopCount ».
Funciones de acceso:
| virtual int | duration() const = 0 |
[bindable] loopCount : int
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Esta propiedad contiene el número de repeticiones de la animación
Esta propiedad describe el número de repeticiones de la animación como un número entero. Por defecto, este valor es 1, lo que indica que la animación debe ejecutarse una sola vez y, a continuación, detenerse. Al modificarlo, puedes hacer que la animación se repita varias veces. Con un valor de 0, la animación no se ejecutará en absoluto, y con un valor de -1, la animación se repetirá indefinidamente hasta que se detenga. No se admite la repetición en una animación cuya duración no esté definida. Solo se ejecutará una vez.
Funciones de acceso:
| int | loopCount() const |
| void | setLoopCount(int loopCount) |
[bindable read-only] state : State
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Estado de la animación.
Esta propiedad describe el estado actual de la animación. Cuando cambia el estado de la animación, QAbstractAnimation emite la señal stateChanged().
Nota: Las actualizacionesdel estado pueden provocar actualizaciones de la propiedad ` currentTime `, lo que, a su vez, puede cancelar sus enlaces. Por lo tanto, hay que tener cuidado al establecer enlaces a la propiedad ` currentTime ` cuando se prevea que el estado de la animación vaya a cambiar.
Funciones de acceso:
| QAbstractAnimation::State | state() const |
Señal del notificador:
| void | stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) |
Documentación de las funciones de miembro
QAbstractAnimation::QAbstractAnimation(QObject *parent = nullptr)
Crea la clase base `QAbstractAnimation` y pasa ` parent ` al constructor de ` QObject`.
Véase también QVariantAnimation y QAnimationGroup.
[virtual noexcept] QAbstractAnimation::~QAbstractAnimation()
Detiene la animación si está en ejecución y, a continuación, destruye el objeto ` QAbstractAnimation`. Si la animación forma parte de un ` QAnimationGroup`, se elimina automáticamente antes de que se destruya.
[signal] void QAbstractAnimation::currentLoopChanged(int currentLoop)
QAbstractAnimation Emite esta señal cada vez que cambia el bucle de corriente. currentLoop es el bucle de corriente.
Nota: Señalde notificador para la propiedad currentLoop.
Véase también ` currentLoop()` y ` loopCount()`.
int QAbstractAnimation::currentLoopTime() const
Devuelve la hora actual dentro del bucle actual. Puede oscilar entre 0 y duration().
Véase también duration() y currentTime.
[signal] void QAbstractAnimation::directionChanged(QAbstractAnimation::Direction newDirection)
QAbstractAnimation emite esta señal cada vez que se cambia de dirección. ` newDirection ` es la nueva dirección.
Nota: Señalde notificador para la propiedad direction.
Véase también direction.
[pure virtual] int QAbstractAnimation::duration() const
Esta función virtual pura devuelve la duración de la animación y define durante cuánto tiempo « QAbstractAnimation » debe actualizar la hora actual. Esta duración es local y no incluye el recuento de repeticiones.
Un valor de retorno de -1 indica que la animación no tiene una duración definida; la animación debería ejecutarse indefinidamente hasta que se detenga. Esto resulta útil para animaciones que no están controladas por el tiempo o en las que no es fácil predecir su duración (por ejemplo, la reproducción de audio controlada por eventos en un videojuego).
Si la animación es un « QAnimationGroup » en paralelo, la duración será la mayor de todas sus animaciones. Si la animación es un « QAnimationGroup » secuencial, la duración será la suma de las duraciones de todas sus animaciones.
Nota: Funcióngetter para la propiedad «duration».
Véase también loopCount.
[override virtual protected] bool QAbstractAnimation::event(QEvent *event)
Reimplementa: QObject::event(QEvent *e).
[signal] void QAbstractAnimation::finished()
QAbstractAnimation Emite esta señal una vez que la animación se ha detenido y ha llegado al final.
Esta señal se emite tras la llamada a stateChanged().
Véase también stateChanged().
QAnimationGroup *QAbstractAnimation::group() const
Si esta animación forma parte de un « QAnimationGroup », esta función devuelve un puntero al grupo; en caso contrario, devuelve un « nullptr ».
Véase también ` QAnimationGroup::addAnimation()`.
[slot] void QAbstractAnimation::pause()
Pone en pausa la animación. Cuando la animación está en pausa, la función ` state()` devuelve «Paused». El valor de ` currentTime ` permanecerá sin cambios hasta que se llame a ` resume()` o ` start()`. Si deseas continuar desde el momento actual, llama a ` resume()`.
Véanse también « start()», « state()» y « resume()».
[slot] void QAbstractAnimation::resume()
Reanuda la animación tras haberla pausado. Cuando se reanuda la animación, emite la señal stateChanged(). La propiedad currentTime no se modifica.
Véase también start(), pause() y state().
[slot] void QAbstractAnimation::setPaused(bool paused)
Si paused es verdadero, la animación se detiene. Si paused es falso, la animación se reanuda.
Véase también state(), pause() y resume().
[slot] void QAbstractAnimation::start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped)
Inicia la animación. El argumento ` policy ` indica si la animación debe eliminarse o no una vez finalizada. Cuando se inicia la animación, se emite la señal ` stateChanged()` y ` state()` devuelve «Running». Cuando el control llega al bucle de eventos, la animación se ejecutará por sí sola, llamando periódicamente a ` updateCurrentTime()` a medida que avanza la animación.
Si la animación está actualmente detenida o ya ha llegado al final, llamar a start() rebobinará la animación y la reiniciará desde el principio. Cuando la animación llegue al final, se detendrá o, si el nivel de bucle es superior a 1, se rebobinará y continuará desde el principio.
Si la animación ya se está ejecutando, esta función no hace nada.
Véase también stop() y state().
[signal] void QAbstractAnimation::stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
QAbstractAnimation Emite esta señal cada vez que el estado de la animación cambia de « oldState » a « newState ». Esta señal se emite tras la llamada a la función virtual ` updateState()`.
Nota: Señalde notificador para la propiedad state.
Véase también ` updateState()`.
[slot] void QAbstractAnimation::stop()
Detiene la animación. Cuando la animación se detiene, emite la señal ` stateChanged()`, y ` state()` devuelve «Stopped». La hora actual no se modifica.
Si la animación se detiene por sí sola tras llegar al final (es decir, currentLoopTime() == duration() y currentLoop() > loopCount() - 1), se emite la señal finished().
Véanse también start() y state().
int QAbstractAnimation::totalDuration() const
Devuelve la duración total y efectiva de la animación, incluido el número de repeticiones.
Nota: Si el número de repeticiones es muy elevado, o si la duración de una sola repetición es demasiado larga, la duración total puede ser demasiado grande para caber en un ` int`. En tal caso, el valor se satura a ` INT_MAX`.
Véase también ` duration()` y ` currentTime`.
[pure virtual protected] void QAbstractAnimation::updateCurrentTime(int currentTime)
Esta función virtual pura se invoca cada vez que cambia la propiedad « currentTime » de la animación.
Véase también updateState().
[virtual protected] void QAbstractAnimation::updateDirection(QAbstractAnimation::Direction direction)
QAbstractAnimation llama a esta función virtual cuando cambia la dirección de la animación. El argumento direction es la nueva dirección.
Véanse también setDirection() y direction().
[virtual protected] void QAbstractAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
QAbstractAnimation llama a esta función virtual cuando el estado de la animación pasa de oldState a newState.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.