En esta página

Qt State Machine Guía de C++

El marco de trabajo de la máquina de estados proporciona clases para crear y ejecutar grafos de estados. Esta página ilustra las características clave del marco de trabajo en C++.

Clases de C++ en el marco de trabajo State Machine

Para ver la lista completa de clases de C++ del marco de trabajo de la máquina de estados, consulta Qt State Machine C++ Classes

Una máquina de estados sencilla

Para demostrar la funcionalidad básica de la API de State Machine, veamos un pequeño ejemplo: una máquina de estados con tres estados, s1, s2 y s3. La máquina de estados se controla mediante un único QPushButton; al hacer clic en el botón, la máquina pasa a otro estado. Inicialmente, la máquina de estados se encuentra en el estado s1. El diagrama de estados de esta máquina es el siguiente:

Tres estados s1, s2 y s3 que cambian al pulsar el botón

El siguiente fragmento de código muestra el código necesario para crear dicha máquina de estados. En primer lugar, creamos la máquina de estados y los estados:

    QStateMachine machine;
    QState *s1 = new QState();
    QState *s2 = new QState();
    QState *s3 = new QState();

A continuación, creamos las transiciones utilizando la función ` QState::addTransition()`:

    s1->addTransition(button, &QPushButton::clicked, s2);
    s2->addTransition(button, &QPushButton::clicked, s3);
    s3->addTransition(button, &QPushButton::clicked, s1);

A continuación, añadimos los estados a la máquina y establecemos su estado inicial:

    machine.addState(s1);
    machine.addState(s2);
    machine.addState(s3);
    machine.setInitialState(s1);

Por último, iniciamos la máquina de estados:

    machine.start();

La máquina de estados se ejecuta de forma asíncrona, es decir, pasa a formar parte del bucle de eventos de tu aplicación.

Realizar tareas útiles al entrar y salir de un estado

La máquina de estados anterior simplemente pasa de un estado a otro, sin realizar ninguna operación. La función ` QState::assignProperty()` se puede utilizar para que un estado establezca una propiedad de un ` QObject ` al entrar en él. En el siguiente fragmento de código, se especifica para cada estado el valor que debe asignarse a la propiedad de texto de un ` QLabel`:

    s1->assignProperty(label, "text", "In state s1");
    s2->assignProperty(label, "text", "In state s2");
    s3->assignProperty(label, "text", "In state s3");

Al entrar en cualquiera de los estados, el texto de la etiqueta se modificará en consecuencia.

La señal « QState::entered()» se emite al entrar en el estado, y la señal « QState::exited()» se emite al salir del mismo. En el siguiente fragmento de código, se llamará a la ranura « showMaximized()» del botón al entrar en el estado « s3 », y se llamará a la ranura « showMinimized()» del botón al salir de « s3 »:

    QObject::connect(s3, &QState::entered, button, &QPushButton:showMaximized);
    QObject::connect(s3, &QState::exited, button, &QPushButton::showMinimized);

Los estados personalizados pueden reimplementar QAbstractState::onEntry() y QAbstractState::onExit().

Máquinas de estados que finalizan

La máquina de estados definida en la sección anterior nunca termina. Para que una máquina de estados pueda terminar, debe tener un estado final de nivel superior (objeto `QFinalState `). Cuando la máquina de estados entra en un estado final de nivel superior, emitirá la señal ` QStateMachine::finished()` y se detendrá.

Todo lo que hay que hacer para introducir un estado final en el grafo es crear un objeto ` QFinalState ` y utilizarlo como destino de una o más transiciones.

Compartir transiciones agrupando estados

Supongamos que queremos que el usuario pueda salir de la aplicación en cualquier momento haciendo clic en un botón «Salir». Para ello, debemos crear un estado final y convertirlo en el destino de una transición asociada a la señal clicked() del botón «Salir». Podríamos añadir una transición desde cada uno de los estados s1, s2 y s3; sin embargo, esto parece redundante, y además habría que acordarse de añadir dicha transición desde cada nuevo estado que se añada en el futuro.

Podemos conseguir el mismo comportamiento (es decir, que al hacer clic en el botón «Salir» se salga de la máquina de estados, independientemente del estado en el que se encuentre) agrupando los estados s1, s2 y s3. Para ello, se crea un nuevo estado de nivel superior y se hacen que los tres estados originales sean hijos del nuevo estado. El siguiente diagrama muestra la nueva máquina de estados.

Estado s1, que contiene tres subestados (s11, s12 y s13) que alternan al pulsar el botón.

Los tres estados originales se han renombrado como s11, s12 y s13 para reflejar que ahora son hijos del nuevo estado de nivel superior, s1. Los estados hijos heredan implícitamente las transiciones de su estado padre. Esto significa que ahora basta con añadir una única transición desde s1 al estado final s2. Los nuevos estados añadidos a s1 también heredarán automáticamente esta transición.

Lo único que hay que hacer para agrupar estados es especificar el estado padre adecuado al crear el estado. También hay que especificar cuál de los estados hijos es el inicial (es decir, en qué estado hijo debe entrar la máquina de estados cuando el estado padre es el destino de una transición).

    QState *s1 = new QState();
    QState *s11 = new QState(s1);
    QState *s12 = new QState(s1);
    QState *s13 = new QState(s1);
    s1->setInitialState(s11);
    machine.addState(s1);
    QFinalState *s2 = new QFinalState();
    s1->addTransition(quitButton, &QPushButton::clicked, s2);
    machine.addState(s2);
    machine.setInitialState(s1);

    QObject::connect(&machine, &QStateMachine::finished,
                     QCoreApplication::instance(), &QCoreApplication::quit);

En este caso, queremos que la aplicación se cierre cuando la máquina de estados haya terminado, por lo que la señal « finished()» de la máquina está conectada a la ranura « quit()» de la aplicación.

Un estado hijo puede anular una transición heredada. Por ejemplo, el siguiente código añade una transición que, en la práctica, hace que se ignore el botón «Salir» cuando la máquina de estados se encuentra en el estado s12.

    s12->addTransition(quitButton, &QPushButton::clicked, s12);

Una transición puede tener cualquier estado como destino; es decir, el estado de destino no tiene por qué estar en el mismo nivel de la jerarquía de estados que el estado de origen.

Uso de los estados del historial para guardar y restaurar el estado actual

Imaginemos que queremos añadir un mecanismo de «interrupción» al ejemplo comentado en la sección anterior; el usuario debería poder hacer clic en un botón para que la máquina de estados realice alguna tarea no relacionada, tras lo cual la máquina de estados debería reanudar lo que estuviera haciendo antes (es decir, volver al estado anterior, que en este caso es uno de s11, s12 y s13 ).

Este comportamiento se puede modelar fácilmente utilizando estados de historial. Un estado de historial (objetoQHistoryState ) es un pseudoestado que representa el estado hijo en el que se encontraba el estado padre la última vez que se salió de este.

Un estado de historial se crea como hijo del estado para el que deseamos registrar el estado hijo actual; cuando la máquina de estados detecta la presencia de dicho estado en tiempo de ejecución, registra automáticamente el estado hijo actual (real) al salir del estado padre. Una transición al estado de historial es, de hecho, una transición al estado hijo que la máquina de estados había guardado previamente; la máquina de estados «reenvía» automáticamente la transición al estado hijo real.

El siguiente diagrama muestra la máquina de estados tras haber añadido el mecanismo de interrupción.

Estado s1 con subestados y estado histórico; al pulsar el botón de interrupción, se pasa al estado s3, que vuelve al estado histórico s1 una vez finalizado.

El código siguiente muestra cómo se puede implementar; en este ejemplo, simplemente mostramos un cuadro de mensaje al entrar en « s3 » y, a continuación, volvemos inmediatamente al estado hijo anterior, « s1 », a través del estado del historial.

    QHistoryState *s1h = new QHistoryState(s1);

    QState *s3 = new QState();
    s3->assignProperty(label, "text", "In s3");
    QMessageBox *mbox = new QMessageBox(mainWindow);
    mbox->addButton(QMessageBox::Ok);
    mbox->setText("Interrupted!");
    mbox->setIcon(QMessageBox::Information);
    QObject::connect(s3, &QState::entered, mbox, &QMessageBox::exec);
    s3->addTransition(s1h);
    machine.addState(s3);

    s1->addTransition(interruptButton, &QPushButton::clicked, s3);

Uso de estados paralelos para evitar una explosión combinatoria de estados

Supongamos que se desea modelar un conjunto de propiedades mutuamente excluyentes de un coche en una única máquina de estados. Digamos que las propiedades que nos interesan son «Limpio» frente a «Sucio» y «En movimiento» frente a «En reposo». Se necesitarían cuatro estados mutuamente excluyentes y ocho transiciones para poder representar todas las combinaciones posibles y moverse libremente entre ellas.

Cuatro estados: limpio/sin movimiento, limpio/en movimiento, sucio/sin movimiento, sucio/en movimiento, con transiciones de «iniciado», «detenido», «limpiado» y «ensuciado»

Si añadiéramos una tercera propiedad (por ejemplo, «rojo» frente a «azul»), el número total de estados se duplicaría, hasta ocho; y si añadiéramos una cuarta propiedad (por ejemplo, «cerrado» frente a «descapotable»), el número total de estados se duplicaría de nuevo, hasta 16.

Al utilizar estados paralelos, el número total de estados y transiciones crece de forma lineal a medida que añadimos más propiedades, en lugar de hacerlo de forma exponencial. Además, se pueden añadir o eliminar estados del estado paralelo sin que ello afecte a ninguno de sus estados hermanos.

Estado paralelo s1 con regiones s11 (limpio/sucio) y s12 (en movimiento/sin movimiento)

Para crear un grupo de estados paralelos, pasa ` QState::ParallelStates ` al constructor ` QState `.

    QState *s1 = new QState(QState::ParallelStates);
    // s11 and s12 will be entered in parallel
    QState *s11 = new QState(s1);
    QState *s12 = new QState(s1);

Al entrar en un grupo de estados paralelos, se accede simultáneamente a todos sus estados hijos. Las transiciones dentro de cada uno de los estados hijos funcionan con normalidad. Sin embargo, cualquiera de los estados hijos puede realizar una transición que salga del estado padre. Cuando esto ocurre, se sale del estado padre y de todos sus estados hijos.

El paralelismo en el marco de la máquina de estados sigue una semántica intercalada. Todas las operaciones paralelas se ejecutarán en un único paso atómico del procesamiento de eventos, por lo que ningún evento puede interrumpir las operaciones paralelas. Sin embargo, los eventos seguirán procesándose secuencialmente, ya que la propia máquina es de un solo hilo. A modo de ejemplo: consideremos la situación en la que hay dos transiciones que salen del mismo grupo de estados paralelos y sus condiciones se cumplen simultáneamente. En este caso, el evento que se procese en último lugar de los dos no tendrá ningún efecto, ya que el primer evento ya habrá provocado que la máquina salga del estado paralelo.

Detección de que un estado compuesto ha finalizado

Un estado hijo puede ser final (un objeto « QFinalState »); cuando se entra en un estado hijo final, el estado padre emite la señal « QState::finished()». El siguiente diagrama muestra un estado compuesto s1 que realiza algún procesamiento antes de entrar en un estado final:

Estado s1, con un subestado de procesamiento que da paso al estado final, lo que activa el paso a s2

Al entrar en el estado final de ` s1 `, ` s1 ` emitirá automáticamente ` finished()`. Utilizamos una transición de señal para que este evento desencadene un cambio de estado:

  s1->addTransition(s1, &QState::finished, s2);

El uso de estados finales en estados compuestos resulta útil cuando se desea ocultar los detalles internos de un estado compuesto; es decir, lo único que el mundo exterior debería poder hacer es entrar en el estado y recibir una notificación cuando este haya completado su trabajo. Se trata de un mecanismo de abstracción y encapsulación muy potente a la hora de construir máquinas de estados complejas (profundamente anidadas). (En el ejemplo anterior, por supuesto, se podría crear una transición directamente desde el estado « done » de « s1 » en lugar de depender de la señal « finished()» de « s1 », pero con la consecuencia de que los detalles de implementación de « s1 » quedarían expuestos y se dependería de ellos).

En el caso de grupos de estados paralelos, la señal QState::finished() se emite cuando todos los estados hijos han entrado en estados finales.

Transiciones sin destino

Una transición no tiene por qué tener un estado de destino. Una transición sin destino puede activarse de la misma forma que cualquier otra transición; la diferencia es que, cuando se activa una transición sin destino, no provoca ningún cambio de estado. Esto te permite reaccionar ante una señal o un evento cuando tu máquina se encuentra en un estado determinado, sin tener que salir de ese estado. Ejemplo:

QStateMachine machine;
QState *s1 = new QState(&machine);

QPushButton button;
QSignalTransition *trans = new QSignalTransition(&button, &QPushButton::clicked);
s1->addTransition(trans);

QMessageBox msgBox;
msgBox.setText("The button was clicked; carry on.");
QObject::connect(trans, QSignalTransition::triggered, &msgBox, &QMessageBox::exec);

machine.setInitialState(s1);

El cuadro de mensaje se mostrará cada vez que se haga clic en el botón, pero la máquina de estados permanecerá en su estado actual (s1). Sin embargo, si el estado de destino se estableciera explícitamente en s1, se saldría de s1 y se volvería a entrar en él cada vez (por ejemplo, se emitirían las señales QAbstractState::entered() y QAbstractState::exited()).

Eventos, transiciones y guardias

Una máquina de estados ( QStateMachine ) ejecuta su propio bucle de eventos. En el caso de las transiciones de señal (objetos `QSignalTransition `), ` QStateMachine ` envía automáticamente un evento de señal ( QStateMachine::SignalEvent ) a sí misma cuando intercepta la señal correspondiente; de forma similar, para las transiciones de evento de guard (objetos ` QObject `, `QEventTransition `), se envía un evento de guard ( QStateMachine::WrappedEvent ).

Puedes enviar tus propios eventos a la máquina de estados utilizando QStateMachine::postEvent().

Al enviar un evento personalizado a la máquina de estados, normalmente también se dispone de una o más transiciones personalizadas que pueden activarse a partir de eventos de ese tipo. Para crear dicha transición, se crea una subclase de QAbstractTransition y se reimplementa eventTest(), donde se comprueba si un evento coincide con el tipo de evento (y, opcionalmente, con otros criterios, como los atributos del objeto del evento).

Aquí definimos nuestro propio tipo de evento personalizado, StringEvent, para enviar cadenas de texto a la máquina de estados:

struct StringEvent : public QEvent
{
    StringEvent(const QString &val)
    : QEvent(QEvent::Type(QEvent::User+1)),
      value(val) {}

    QString value;
};

A continuación, definimos una transición que solo se activa cuando la cadena del evento coincide con una cadena concreta (una transición condicionada ):

class StringTransition : public QAbstractTransition
{
    Q_OBJECT

public:
    StringTransition(const QString &value)
        : m_value(value) {}

protected:
    bool eventTest(QEvent *e) override
    {
        if (e->type() != QEvent::Type(QEvent::User+1)) // StringEvent
            return false;
        StringEvent *se = static_cast<StringEvent*>(e);
        return (m_value == se->value);
    }

    void onTransition(QEvent *) override {}

private:
    QString m_value;
};

En la reimplementación de ` eventTest()`, primero comprobamos si el tipo de evento es el deseado; si es así, convertimos el evento a un ` StringEvent ` y realizamos la comparación de cadenas.

A continuación se muestra un diagrama de estados que utiliza el evento y la transición personalizados:

Estados s1 y s2 con StringTransition para la gestión personalizada de eventos

Así es como se ve la implementación del diagrama de estados:

    QStateMachine machine;
    QState *s1 = new QState();
    QState *s2 = new QState();
    QFinalState *done = new QFinalState();

    StringTransition *t1 = new StringTransition("Hello");
    t1->setTargetState(s2);
    s1->addTransition(t1);
    StringTransition *t2 = new StringTransition("world");
    t2->setTargetState(done);
    s2->addTransition(t2);

    machine.addState(s1);
    machine.addState(s2);
    machine.addState(done);
    machine.setInitialState(s1);

Una vez que la máquina se ha iniciado, podemos enviarle eventos.

    machine.postEvent(new StringEvent("Hello"));
    machine.postEvent(new StringEvent("world"));

Un evento que no sea gestionado por ninguna transición relevante será consumido silenciosamente por la máquina de estados. Puede resultar útil agrupar estados y proporcionar una gestión por defecto de dichos eventos; por ejemplo, tal y como se ilustra en el siguiente diagrama de estados:

Estado s1 con subestados s11 y s12, transiciones de eventos personalizadas y celebración del estado al finalizar

En el caso de diagramas de estados muy anidados, puedes añadir estas transiciones de «reserva» al nivel de granularidad más adecuado.

Uso de la política de restauración para restaurar propiedades automáticamente

En algunas máquinas de estados puede resultar útil centrar la atención en asignar propiedades en los estados, y no en restaurarlas cuando el estado ya no está activo. Si sabes que una propiedad siempre debe restaurarse a su valor inicial cuando la máquina entra en un estado que no le asigna explícitamente un valor, puedes establecer la política de restauración global en QStateMachine::RestoreProperties.

QStateMachine machine;
machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);

Cuando se establece esta política de restauración, la máquina restaurará automáticamente todas las propiedades. Si entra en un estado en el que una propiedad determinada no está establecida, buscará primero en la jerarquía de antecesores para ver si la propiedad está definida allí. Si es así, la propiedad se restablecerá al valor definido por el antepasado más cercano. De lo contrario, se restablecerá a su valor inicial (es decir, el valor de la propiedad antes de que se ejecutaran las asignaciones de propiedades en los estados).

Tomemos el siguiente código:

    QStateMachine machine;
    machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);

    QState *s1 = new QState();
    s1->assignProperty(object, "fooBar", 1.0);
    machine.addState(s1);
    machine.setInitialState(s1);

    QState *s2 = new QState();
    machine.addState(s2);

Supongamos que la propiedad fooBar es 0,0 cuando se inicia la máquina. Cuando la máquina se encuentra en el estado s1, la propiedad será 1,0, ya que el estado le asigna explícitamente este valor. Cuando la máquina se encuentra en el estado s2, no se define explícitamente ningún valor para la propiedad, por lo que se restablecerá implícitamente a 0,0.

Si utilizamos estados anidados, el estado padre define un valor para la propiedad que heredan todos los descendientes que no asignen explícitamente un valor a la propiedad.

    QStateMachine machine;
    machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);

    QState *s1 = new QState();
    s1->assignProperty(object, "fooBar", 1.0);
    machine.addState(s1);
    machine.setInitialState(s1);

    QState *s2 = new QState(s1);
    s2->assignProperty(object, "fooBar", 2.0);
    s1->setInitialState(s2);

    QState *s3 = new QState(s1);

En este caso, s1 tiene dos hijos: s2 y s3. Al entrar en s2, la propiedad fooBar tendrá el valor 2,0, ya que está definido explícitamente para ese estado. Cuando la máquina se encuentra en el estado s3, no hay ningún valor definido para el estado, pero s1 establece la propiedad en 1,0, por lo que este será el valor que se asignará a fooBar.

Animaciones y máquinas de estados

La API de la máquina de estados se integra con el marco de animación (The Animation Framework) para permitir la animación automática de las propiedades a medida que se asignan en los estados.

La máquina de estados proporciona un estado especial que puede reproducir una animación. Un « QState » también puede establecer propiedades al entrar o salir del estado, y este estado de animación especial interpolará entre estos valores cuando se le proporcione un « QPropertyAnimation ».

Podemos asociar una o más animaciones a una transición entre estados utilizando una clase « QSignalTransition » o « QEventTransition ». Ambas clases derivan de « QAbstractTransition », que define la función de conveniencia « addAnimation()», la cual permite añadir una o más animaciones que se activan cuando se produce la transición.

También tenemos la posibilidad de asociar propiedades a los estados en lugar de establecer nosotros mismos los valores iniciales y finales.

Supongamos que tenemos el siguiente código:

    QState *s1 = new QState();
    QState *s2 = new QState();

    s1->assignProperty(button, "geometry", QRectF(0, 0, 50, 50));
    s2->assignProperty(button, "geometry", QRectF(0, 0, 100, 100));

    s1->addTransition(button, &QPushButton::clicked, s2);

Aquí definimos dos estados de una interfaz de usuario. En s1, el button es pequeño, y en s2 es más grande. Si hacemos clic en el botón para pasar de s1 a s2, la geometría del botón se establecerá inmediatamente al entrar en un estado determinado. Sin embargo, si queremos que la transición sea fluida, lo único que tenemos que hacer es crear una QPropertyAnimation y añadirla al objeto de transición.

    QState *s1 = new QState();
    QState *s2 = new QState();

    s1->assignProperty(button, "geometry", QRectF(0, 0, 50, 50));
    s2->assignProperty(button, "geometry", QRectF(0, 0, 100, 100));

    QSignalTransition *transition = s1->addTransition(button, &QPushButton::clicked, s2);
    transition->addAnimation(new QPropertyAnimation(button, "geometry"));

Añadir una animación para la propiedad en cuestión significa que la asignación de la propiedad ya no surtirá efecto de forma inmediata al entrar en el estado. En su lugar, la animación comenzará a reproducirse al entrar en el estado y animará de forma suave la asignación de la propiedad. Dado que no establecemos el valor inicial ni el valor final de la animación, estos se establecerán de forma implícita. El valor inicial de la animación será el valor actual de la propiedad en el momento en que comience la animación, y el valor final se establecerá en función de las asignaciones de propiedades definidas para el estado.

Si la política de restauración global de la máquina de estados está configurada en QStateMachine::RestoreProperties, también es posible añadir animaciones para las restauraciones de propiedades.

Detección de que se han establecido todas las propiedades en un estado

Cuando se utilizan animaciones para asignar propiedades, un estado ya no define los valores exactos que tendrá una propiedad cuando la máquina se encuentre en dicho estado. Mientras se ejecuta la animación, la propiedad puede tener potencialmente cualquier valor, dependiendo de la animación.

En algunos casos, puede resultar útil poder detectar cuándo se ha asignado realmente a la propiedad el valor definido por un estado.

Supongamos que tenemos el siguiente código:

    QMessageBox *messageBox = new QMessageBox(mainWindow);
    messageBox->addButton(QMessageBox::Ok);
    messageBox->setText("Button geometry has been set!");
    messageBox->setIcon(QMessageBox::Information);

    QState *s1 = new QState();

    QState *s2 = new QState();
    s2->assignProperty(button, "geometry", QRectF(0, 0, 50, 50));
    connect(s2, &QState::entered, messageBox, SLOT(exec()));

    s1->addTransition(button, &QPushButton::clicked, s2);

Al hacer clic en « button », la máquina pasará al estado « s2 », lo que establecerá la geometría del botón y, a continuación, aparecerá un cuadro de mensaje para avisar al usuario de que se ha modificado la geometría.

En el caso normal, en el que no se utilizan animaciones, esto funcionará según lo esperado. Sin embargo, si se establece una animación para la propiedad « geometry » de « button » en la transición entre « s1 » y « s2 », la animación se iniciará al entrar en « s2 », pero la propiedad « geometry » no alcanzará realmente su valor definido antes de que la animación haya terminado de ejecutarse. En este caso, el cuadro de mensaje aparecerá antes de que la geometría del botón se haya establecido realmente.

Para garantizar que el cuadro de mensaje no aparezca hasta que la geometría alcance realmente su valor final, podemos utilizar la señal propertiesAssigned() del estado. La señal propertiesAssigned() se emitirá cuando se asigne a la propiedad su valor final, ya sea de forma inmediata o una vez finalizada la animación.

    QMessageBox *messageBox = new QMessageBox(mainWindow);
    messageBox->addButton(QMessageBox::Ok);
    messageBox->setText("Button geometry has been set!");
    messageBox->setIcon(QMessageBox::Information);

    QState *s1 = new QState();

    QState *s2 = new QState();
    s2->assignProperty(button, "geometry", QRectF(0, 0, 50, 50));

    QState *s3 = new QState();
    connect(s3, &QState::entered, messageBox, SLOT(exec()));

    s1->addTransition(button, &QPushButton::clicked, s2);
    s2->addTransition(s2, &QState::propertiesAssigned, s3);

En este ejemplo, al hacer clic en « button », la máquina entrará en « s2 ». Permanecerá en el estado « s2 » hasta que la propiedad « geometry » se haya establecido en « QRect(0, 0, 50, 50) ». A continuación, pasará al estado « s3 ». Al entrar en « s3 », aparecerá el cuadro de mensaje. Si la transición al estado « s2 » incluye una animación para la propiedad « geometry », la máquina permanecerá en « s2 » hasta que la animación haya terminado de reproducirse. Si no existe dicha animación, simplemente se establecerá la propiedad y se pasará inmediatamente al estado s3.

En cualquier caso, cuando la máquina se encuentra en el estado s3, se garantiza que a la propiedad geometry se le ha asignado el valor definido.

Si la política de restauración global está establecida en QStateMachine::RestoreProperties, el estado no emitirá la señal propertiesAssigned() hasta que estas también se hayan ejecutado.

¿Qué ocurre si se sale de un estado antes de que haya finalizado la animación?

Si un estado tiene asignaciones de propiedades y la transición hacia dicho estado incluye animaciones para dichas propiedades, es posible que se salga del estado antes de que las propiedades hayan sido asignadas a los valores definidos por el estado. Esto ocurre, en particular, cuando hay transiciones de salida del estado que no dependen de la señal ` propertiesAssigned()`, tal y como se describe en la sección anterior.

La API de la máquina de estados garantiza que una propiedad asignada por la máquina de estados:

  • Tiene un valor asignado explícitamente a la propiedad.
  • Se está animando actualmente hacia un valor asignado explícitamente a la propiedad.

Cuando se sale de un estado antes de que finalice la animación, el comportamiento de la máquina de estados depende del estado de destino de la transición. Si el estado de destino asigna explícitamente un valor a la propiedad, no se llevará a cabo ninguna acción adicional. A la propiedad se le asignará el valor definido por el estado de destino.

Si el estado de destino no asigna ningún valor a la propiedad, hay dos opciones: Por defecto, a la propiedad se le asignará el valor definido por el estado del que sale (el valor que se le habría asignado si se hubiera permitido que la animación terminara de reproducirse). Sin embargo, si se ha establecido una política de restauración global, esta tendrá prioridad y la propiedad se restaurará como de costumbre.

Animaciones predeterminadas

Como se ha descrito anteriormente, puedes añadir animaciones a las transiciones para garantizar que las asignaciones de propiedades en el estado de destino se animen. Si se desea que se utilice una animación específica para una propiedad determinada, independientemente de la transición que se elija, se puede añadir como animación predeterminada a la máquina de estados. Esto resulta especialmente útil cuando las propiedades asignadas (o restauradas) por estados específicos se desconocen en el momento de construir la máquina.

QState *s1 = new QState();
QState *s2 = new QState();

s2->assignProperty(object, "fooBar", 2.0);
s1->addTransition(s2);

QStateMachine machine;
machine.setInitialState(s1);
machine.addDefaultAnimation(new QPropertyAnimation(object, "fooBar"));

Cuando la máquina se encuentra en el estado s2, reproducirá la animación predeterminada para la propiedad fooBar, ya que esta propiedad es asignada por s2.

Ten en cuenta que las animaciones establecidas explícitamente en las transiciones tendrán prioridad sobre cualquier animación predeterminada para la propiedad en cuestión.

Anidamiento de máquinas de estados

QStateMachine es una subclase de ` QState`. Esto permite que una máquina de estados sea un estado hijo de otra máquina. ` QStateMachine ` reimplementa ` QState::onEntry()` y llama a ` QStateMachine::start()`, de modo que, al entrar en la máquina de estados hija, esta comience a ejecutarse automáticamente.

La máquina de estados padre trata a la máquina hija como un estado atómico en el algoritmo de la máquina de estados. La máquina de estados hija es autónoma; mantiene su propia cola de eventos y su propia configuración. En particular, hay que tener en cuenta que la función ` configuration()` de la máquina hija no forma parte de la configuración de la máquina padre (solo lo es la propia máquina hija).

Los estados de la máquina de estados secundaria no pueden especificarse como destinos de transiciones en la máquina de estados principal; solo puede hacerlo la propia máquina de estados secundaria. Por el contrario, los estados de la máquina de estados principal no pueden especificarse como destinos de transiciones en la máquina de estados secundaria. La señal finished() de la máquina de estados secundaria puede utilizarse para desencadenar una transición en la máquina principal.

Véase también la Descripción general de «Qt State Machine » y la Guía de QML «Qt State Machine ».

© 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.