QScxmlStateMachine Class

Member Function Documentation

[invokable] QStringList QScxmlStateMachine::activeStateNames(bool compress = true) const

Récupère une liste de noms de tous les états actifs.

Lorsqu'un état est actif, tous ses états parents sont actifs par définition. Lorsque compress est true (par défaut), les états parents sont filtrés et seuls les états feuilles sont renvoyés. Lorsque la valeur est false, la liste complète des états actifs est renvoyée.

[invokable] void QScxmlStateMachine::cancelDelayedEvent(const QString &sendId)

Annule un événement retardé avec l'adresse sendId spécifiée.

Crée une connexion du type type à partir de l'événement spécifié par scxmlEventSpec vers functor, qui peut être un foncteur ou une fonction membre de l'objet optionnel context.

L'objet functor du récepteur doit prendre un QScxmlEvent en paramètre.

Contrairement aux spécifications d'événements dans les documents SCXML, les espaces ne sont pas autorisés dans les scxmlEventSpec. Pour se connecter à plusieurs événements avec des préfixes différents, connectToEvent() doit être appelé plusieurs fois.

Renvoie une poignée à la connexion, qui peut être utilisée ultérieurement pour se déconnecter.

QMetaObject::Connection QScxmlStateMachine::connectToEvent(const QString &scxmlEventSpec, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion du type type à partir de l'événement spécifié par scxmlEventSpec vers method dans l'objet receiver. L'objet method du destinataire peut prendre un QScxmlEvent en paramètre. Par exemple :

void mySlot(const QScxmlEvent &event);

Contrairement aux spécifications d'événements dans les documents SCXML, les espaces ne sont pas autorisés dans l'objet scxmlEventSpec. Pour se connecter à plusieurs événements avec des préfixes différents, connectToEvent() doit être appelé plusieurs fois.

Renvoie une poignée de connexion, qui peut être utilisée ultérieurement pour se déconnecter.

scxmlStateName Crée une connexion de l'état spécifié par type à functor, qui peut être un foncteur ou une fonction membre de l'objet optionnel context.

La fonction functor du récepteur doit prendre un argument booléen qui indique si l'état connecté est devenu actif ou inactif.

Renvoie une poignée à la connexion, qui peut être utilisée ultérieurement pour se déconnecter.

QMetaObject::Connection QScxmlStateMachine::connectToState(const QString &scxmlStateName, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion de l'objet type donné de l'état identifié par scxmlStateName à l'objet method dans l'objet receiver. L'objet method du destinataire peut prendre un argument booléen qui indique si l'état connecté est devenu actif ou inactif. Par exemple :

void mySlot(bool active);

Renvoie une poignée à la connexion, qui peut être utilisée ultérieurement pour se déconnecter.

QScxmlDataModel *QScxmlStateMachine::dataModel() const

Renvoie le modèle de données utilisé par la machine à états.

Voir aussi setDataModel().

[signal] void QScxmlStateMachine::finished()

Ce signal est émis lorsque la machine à états atteint un état final de premier niveau.

Voir également running.

[static] QScxmlStateMachine *QScxmlStateMachine::fromData(QIODevice *data, const QString &fileName = QString())

Crée un automate à états en lisant dans le site QIODevice spécifié par data.

Cette méthode renvoie toujours un automate à états. Si des erreurs surviennent lors de la lecture du fichier SCXML, fileName, la machine à états ne peut pas être lancée. Les erreurs peuvent être récupérées en appelant la méthode parseErrors().

Voir aussi parseErrors().

[static] QScxmlStateMachine *QScxmlStateMachine::fromFile(const QString &fileName)

Crée une machine à états à partir du fichier SCXML spécifié par fileName.

Cette méthode renvoie toujours un automate à états. Si des erreurs surviennent lors de la lecture du fichier SCXML, la machine à états ne peut pas être lancée. Les erreurs peuvent être récupérées en appelant la méthode parseErrors().

Voir aussi parseErrors().

[slot] bool QScxmlStateMachine::init()

Initialise la machine à états.

L'initialisation de la machine à états consiste à appeler QScxmlDataModel::setup(), à définir les valeurs initiales des éléments <data> et à exécuter toutes les balises <script> de la balise <scxml>. Les valeurs initiales des données proviennent de la propriété initialValues.

Renvoie false en cas d'erreur d'analyse ou d'échec de l'une des étapes d'initialisation. Retourne true dans le cas contraire.

[invokable] bool QScxmlStateMachine::isActive(const QString &scxmlStateName) const

Renvoie true si l'état spécifié par scxmlStateName est actif, false sinon.

[protected] bool QScxmlStateMachine::isActive(int stateIndex) const

Renvoie true si l'état portant l'ID stateIndex est actif.

Cette méthode fait partie de l'interface avec la représentation compilée des machines à états SCXML. Elle ne doit être utilisée qu'en interne et par les machines à états compilées à partir de documents SCXML.

[invokable] bool QScxmlStateMachine::isDispatchableTarget(const QString &target) const

Renvoie true si un message destiné à target peut être envoyé par cette machine d'état.

Les cibles valides sont

• #_parent pour l'automate d'état parent si l'automate d'état actuel est démarré par <invoke>
• #_internal pour l'automate d'état actuel
• #_scxml_sessionidoù sessionid est l'identifiant de session de l'automate à états actuel
• #_servicenamepour la machine à états actuelle , où servicename est l'ID ou le nom d'un service démarré avec <invoke> par cette machine à états.

bool QScxmlStateMachine::isRunning() const

Renvoie true si la machine à états est en cours d'exécution, false dans le cas contraire.

Voir aussi setRunning() et runningChanged().

[signal] void QScxmlStateMachine::log(const QString &label, const QString &msg)

Ce signal est émis si une balise <log> est utilisée dans le SCXML. label est la valeur de l'attribut label de la balise <log>. msg est la valeur de l'attribut expr évalué de la balise <log>. S'il n'y a pas d'attribut expr, une chaîne nulle sera renvoyée.

[static] template <typename Functor> std::function<void (bool)> QScxmlStateMachine::onEntry(Functor functor)

Retourne un foncteur qui accepte un argument booléen et appelle le functor donné si cet argument est true. Le functor donné ne doit accepter aucun argument.

Ceci est utile pour envelopper des gestionnaires pour connectToState() qui ne doivent être exécutés que lorsque l'état est entré.

[static] std::function<void (bool)> QScxmlStateMachine::onEntry(const QObject *receiver, const char *method)

Renvoie un foncteur qui accepte un argument booléen et appelle la méthode method sur receiver en utilisant QMetaObject::invokeMethod() si cet argument est true et si receiver n'a pas encore été supprimé.

La méthode donnée method ne doit accepter aucun argument. method est le nom de la méthode en clair, non entouré de SIGNAL() ou SLOT().

Ceci est utile pour envelopper des gestionnaires pour connectToState() qui ne doivent être exécutés que lorsque l'état est entré.

[static] template <typename PointerToMemberFunction> std::function<void (bool)> QScxmlStateMachine::onEntry(const typename QtPrivate::FunctionPointer<PointerToMemberFunction>::Object *receiver, PointerToMemberFunction method)

Renvoie un foncteur qui accepte un argument booléen et appelle method sur receiver si cet argument est true et si receiver n'a pas encore été supprimé. Le method donné ne doit accepter aucun argument.

Ceci est utile pour envelopper des gestionnaires pour connectToState() qui ne doivent être exécutés que lorsque l'état est entré.

[static] template <typename Functor> std::function<void (bool)> QScxmlStateMachine::onExit(Functor functor)

Retourne un foncteur qui accepte un argument booléen et appelle le functor donné si cet argument est false. Le functor donné ne doit accepter aucun argument.

Ceci est utile pour envelopper des gestionnaires pour connectToState() qui ne doivent être exécutés que lorsque l'état est quitté.

[static] std::function<void (bool)> QScxmlStateMachine::onExit(const QObject *receiver, const char *method)

Renvoie un foncteur qui accepte un argument booléen et appelle la méthode method sur receiver en utilisant QMetaObject::invokeMethod() si cet argument est false et si receiver n'a pas encore été supprimé.

La méthode donnée method ne doit accepter aucun argument. method est le nom de la méthode en clair, non entouré de SIGNAL(...) ou de SLOT(...).

Ceci est utile pour envelopper les gestionnaires de connectToState() qui ne doivent être exécutés que lorsque l'état est quitté.

[static] template <typename PointerToMemberFunction> std::function<void (bool)> QScxmlStateMachine::onExit(const typename QtPrivate::FunctionPointer<PointerToMemberFunction>::Object *receiver, PointerToMemberFunction method)

Renvoie un foncteur qui accepte un argument booléen et appelle method sur receiver si cet argument est false et si receiver n'a pas encore été supprimé. Le method donné ne doit accepter aucun argument.

Ceci est utile pour envelopper des gestionnaires pour connectToState() qui ne doivent être exécutés que lorsque l'état est quitté.

[signal] void QScxmlStateMachine::reachedStableState()

Ce signal est émis lorsque la file d'attente des événements est vide à la fin d'une étape de la macro ou lorsqu'un état final est atteint.

[signal] void QScxmlStateMachine::runningChanged(bool running)

Ce signal est émis lorsque la propriété running est modifiée avec running comme argument.

void QScxmlStateMachine::setDataModel(QScxmlDataModel *model)

Définit le modèle de données pour cette machine d'état à model. Il existe une relation 1:1 entre les machines d'état et les modèles. Après avoir défini le modèle une fois, vous ne pouvez plus le modifier. Toute nouvelle tentative de définition du modèle à l'aide de cette méthode sera ignorée.

Voir également dataModel().

void QScxmlStateMachine::setRunning(bool running)

Démarre la machine à états si running est true, ou l'arrête dans le cas contraire.

Voir aussi start(), stop(), isRunning() et runningChanged().

[slot] void QScxmlStateMachine::start()

Démarre cette machine à états. Lorsqu'un état final de niveau supérieur est atteint, la machine émet le signal finished().

Voir aussi runningChanged(), setRunning(), stop(), et finished().

[invokable] QStringList QScxmlStateMachine::stateNames(bool compress = true) const

Récupère une liste de noms d'états de tous les états.

Lorsque compress est true (par défaut), les états qui contiennent des états enfants sont filtrés et seuls les états feuilles sont renvoyés. Lorsque la valeur est false, la liste complète de tous les états est renvoyée.

La liste renvoyée ne contient pas les états d'éventuelles machines à états imbriquées.

[slot] void QScxmlStateMachine::stop()

Arrête cette machine d'état. La machine n'exécutera plus de transitions d'état. Sa propriété running est définie sur false.

Voir aussi runningChanged(), start() et setRunning().

[invokable] void QScxmlStateMachine::submitEvent(QScxmlEvent *event)

Soumet l'événement SCXML event à la file d'attente d'événements interne ou externe en fonction de la priorité de l'événement.

Lorsqu'un délai est défini, l'événement sera mis en file d'attente pour livraison une fois le délai écoulé. La machine d'état prend possession de event et le supprime après traitement.

[invokable] void QScxmlStateMachine::submitEvent(const QString &eventName)

Méthode utilitaire permettant de créer et de soumettre un événement externe dont le nom est eventName.

[invokable] void QScxmlStateMachine::submitEvent(const QString &eventName, const QVariant &data)

Méthode utilitaire permettant de créer et de soumettre un événement externe dont le nom est eventName et les données utiles data.