Cours sur l’utilisation de QHistoryState du framework QStateMachine

Cette fonction, membre de QStateMachine, nous permet d’envoyer un événement, créé avec la classe QEvent, directement vers la machine à états. Cet événement pourra être traité avec la fonction eventTest d’une classe héritant de QAbstractTransition. La mise en œuvre étant complexe, elle sera détaillée dans l’étape 01.

void QStateMachine::postEvent( QEvent *event, 
        QStateMachine::EventPriority priority = NormalPriority )

Cette classe permet d'utiliser un événement émis par la souris comme déclencheur dans une ou plusieurs transitions pour commander la machine à états. Dans les tests du cours, nous utiliserons la classe QEventTransition, qui est plus adaptée aux objets GraphicsItem. Néanmoins, vous trouverez un sujet d’étude avec le projet test Bonus01, basé sur l’exemple Qt Event Transitions et modifié en utilisant la classe QMouseEventTransition.

De même que dans les cours précédents, le constructeur de la classe met en place l’image du fond et deux objets graphiques pour le test.

Un objet cible qui sera composé de deux images :

• un témoin qui peut prendre quatre couleurs différentes ;
• un contacteur qui change la couleur du témoin à chaque passage. Vous observerez que ce contacteur disparaît après le premier contact et réapparaît à chaque nouveau trajet du curseur. La raison vous sera donnée dans le paragraphe de la classe cible.

ObjetImage *tmptemoin = new ObjetImage();
    addItem( tmptemoin );
    cible = new Cible( tmptemoin,  460, 350 );
    addItem( cible );

Un objet déclencheur correspond à l’image du curseur se déplaçant de gauche à droite.

declencheur = new Declencheur( cible );
    addItem( declencheur );
    declencheur->hide();

La scène est définie au moment de l’appel à sa fonction InitialiserScene à la fin du constructeur de la classe Fenetre, point réel de démarrage du logiciel de test. Cette fonction initialise et démarre la machine à états, propre à la gestion de la classe Scene et les éléments de contrôles, bouton et ligne info.

void Scene::InitialiserScene( QToolButton *quitterlejeu, QLineEdit *linformation )
{
    linformation->setText("mise en place");
    QStateMachine *machine = new QStateMachine( this );
    ZoneAnime *zoneanime = new ZoneAnime( this, machine );
    QFinalState *final = new QFinalState( machine );
    zoneanime→addTransition( quitterlejeu, SIGNAL(clicked()), final );
    connect( machine, SIGNAL(finished()), qApp, SLOT(quit()) );
    machine→setInitialState( zoneanime );
    machine->start();
}

L’animation de l’objet déclencheur, c’est-à-dire le graphique mobile du curseur, est amorcée dans la fonction DemarrerScene :

void Scene::DemarrerScene()
{
    setFocusItem( declencheur, Qt::OtherFocusReason );
    declencheur->Initialiser();
    declencheur->BougeToi();
}

Jusque-là, nous avons côtoyé des contrées que nous connaissons bien, et nous avons cheminé sans être déconcertés. Le contexte est maintenant établi, nous pouvons commencer les nouveautés par la description de la classe Cible.

La machine de cette classe gère quatre états symbolisés chacun par une couleur, et la transition d’un état à l’autre est activée par un contact entre le déclencheur et la cible, comme décrit précédemment.

Dans ce diagramme, l’index couleur, incrémenté lorsqu’il y a contact, est traité par une classe héritière de QEvent que nous n’avons pas encore utilisée dans ces cours, ou pour être plus juste, nous l’avons un peu utilisée, mais seulement en tant que paramètre dans la fonction onEntry des classes d’états et de transitions. Avant de décrire cette nouvelle classe, regardons en quoi elle nous sera utile. Quand le contact est opéré, il nous faut déclencher une transition pour changer la couleur du témoin, jusqu’à présent nous envoyions l’ordre soit par l’émission d’un signal, soit par action sur les touches du clavier. Cette fois, nous allons programmer notre événement directement dans la machine en utilisant la fonction postEvent de QStateMachine.

IV-B-1. Classe EvntPerso▲

EvntPerso::EvntPerso( int vcoul ) : QEvent(QEvent::Type(QEvent::User))
{
    couleur = vcoul;
}
int EvntPerso::ValCouleur()
{
    return couleur;
}

IV-B-2. Classe de transition TransCouleur▲

TransCouleur::TransCouleur( int vcoul)
{
    evtcouleur = vcoul;
}
bool TransCouleur::eventTest(QEvent *evt )
{
    if(evt->type() == QEvent::Type( QEvent::User ))
    {
        return ( evtcouleur == ( (EvntPerso*) evt )->ValCouleur() );
    }
    return false;
}
void TransCouleur::onTransition(QEvent *){}

IV-B-3. Classe EtatCouleur▲

EtatCouleur::EtatCouleur( const QString &ficoul, ObjetImage *vtem, QState *vparent ) : QState(vparent)
{
    temoin  = vtem;
    couleur = ficoul;
}
void EtatCouleur::onEntry(QEvent *)
{
    temoin->hide();
    temoin->ChangeImage(couleur);
    temoin->show();
}

IV-B-4. Constructeur de la classe Cible▲

Cible::Cible( ObjetImage *vtemoin, qreal posx, qreal posy)
{
 temoin = vtemoin;
…
    InitImage(QString(":/motif/cible.png"));
…

    machine = new QStateMachine(this);
    EtatCouleur *Cbleue = new EtatCouleur( ":/motif/bleue.png", temoin, machine);
    EtatCouleur *Crouge = new EtatCouleur( ":/motif/rouge.png", temoin, machine);
    EtatCouleur *Cverte = new EtatCouleur( ":/motif/verte.png", temoin, machine);
    EtatCouleur *Cjaune = new EtatCouleur( ":/motif/jaune.png", temoin, machine);

TransCouleur *JauneVersBleue = new TransCouleur(1);
    Cjaune->addTransition(JauneVersBleue);
        JauneVersBleue->setTargetState(Cbleue);
TransCouleur *BleueVersRouge = new TransCouleur(2);
    Cbleue->addTransition(BleueVersRouge);
        BleueVersRouge->setTargetState(Crouge);
TransCouleur *RougeVersVerte = new TransCouleur(3);
    Crouge->addTransition(RougeVersVerte);
        RougeVersVerte->setTargetState(Cverte);
TransCouleur *VerteVersJaune = new TransCouleur(4);
    Cverte->addTransition(VerteVersJaune);
        VerteVersJaune->setTargetState(Cjaune);

IV-B-5. Mise en œuvre de postEvent▲

void Cible::Change()
{
    indcouleur++;
    if(indcouleur>4)indcouleur=1;
    machine->postEvent(new EvntPerso(indcouleur));
}

Si vous avez lu le premier cours sur l'utilisation du framework QstateMachine, vous remarquerez la similarité avec la classe Predateur du paragraphe VII. Le curseur, en forme de disque jaune, effectue une trajectoire horizontale et sans fin : lorsqu’il atteint le bord droit de la scène, il reprend son parcours depuis son origine. La classe Declencheur réalise cette animation en utilisant les deux objets avance et arret, issus des classes d’états DeplaceDch et ArretDch, reliés par la transition reprend qui est une instance de la classe QSignalTransition.

Quand vous ouvrirez les fichiers sources des deux classes d’état, vous comprendrez, par leur contenu très simple, qu’il est inutile de les commenter.

Nous entrons dans le vif du sujet en analysant le constructeur de la classe Declencheur. Mises de côté les initialisations usuelles, nous créons nos deux états, avance et arrete, puis leur transition reprend qui sera activée par le signal finished, de l’animation du curseur, lorsqu’il atteint le bord droit de la zone. Cette transition est ajoutée à l’état avance et cible l’état arrete.

Declencheur::Declencheur( Cible *vcbl )
{
… 
    machine = new QStateMachine(this);
    DeplaceDch *avance = new DeplaceDch( this, machine);
    ArretDch   *arrete = new ArretDch( this, machine );

    QSignalTransition *reprend = new QSignalTransition( animationdelobjet, SIGNAL(finished()) );
    avance->addTransition(reprend);
      reprend→setTargetState(arrete);

    arrete->addTransition( arrete, SIGNAL( RePositionner()), avance );

    connect( animationdelobjet, SIGNAL(valueChanged(QVariant)), this, SLOT(EnDeplacement()) );

Lorsque l’état arrete est activé, il émet le signal repositionner pour redémarrer le curseur, nous devons donc écrire l’instruction  arrete->addTransition( arrete, SIGNAL( RePositionner()), avance );pour ajouter une transition ciblant l’état avance qui, au signal repositionner, se réactivera pour recommencer le trajet.

La ligne qui suit appelle la fonction EnDeplacement à chaque changement de position du curseur, pour permettre le test de collision.

Nous finissons le constructeur par l’initialisation de la machine machine->setInitialState(avance);, car son déclenchement est provoqué dans la fonction DemarrerScene de la classe Scene.

Nous avons imposé le passage en paramètre du pointeur de l’objet cible dans la définition du constructeur, ceci dans le but de détecter le contact entre notre objet déclencheur et la cible grâce à la fonction SLOT EnDeplacement appelée à chaque mouvement du curseur.

Cette fonction commence par un test sur la visibilité de la cible ; en effet, il serait possible suivant la taille de la cible et celle du curseur associées à la valeur de animationdelobjet->setDuration(2500);que la collision soit validée plusieurs fois de suite. Cette anomalie existait dans le deuxième cours sur les états parallèles, mais elle était laissée telle quelle, car elle n’impactait pas le fonctionnement des tests. Ici, cette déficience fausserait le test, puisque la succession des contacts provoquerait un défilé des états.

void Declencheur::EnDeplacement()
{
    if(pcible->isVisible())
    {
        if( TestCollision() )
        {
            pcible->Change();
            pcible->setVisible(false);
        }
    }
}

Si la collision est réalisée, nous appelons la fonction Change de la classe Cible, où sera provoqué notre événement personnel pour changer la couleur, puis l’image de la cible est rendue invisible jusque la fin du trajet du curseur.

La détection de la collision se réduit à l’utilisation de la fonction collidingItems de la classe QGraphicsItem en utilisant l’intersection des contours :

bool Declencheur::TestCollision()
{
    QList<QGraphicsItem*> lstobjet = collidingItems( Qt::IntersectsItemBoundingRect ) ;
    return (lstobjet.contains(pcible));
}

À chaque démarrage du trajet du curseur, l’état arret appelle la fonction Initialiser qui replace les coordonnées du curseur à leur origine,

void Declencheur::Initialiser()
{
    hide();
    pntfin=QPointF( (scene()->width() - size().width()), 0.5*((scene()->height()) - size().height()) );
    pntdepart=QPointF( 0, 0.5*((scene()->height()) - size().height()) );
    setPos(pntdepart);
    show();
    pcible->setVisible(true);
}

avec, en fin de procédure, la réapparition de la cible pcible->setVisible(true);

Nous en avons terminé avec la mise en place des objets pour l’environnement de test de QHistoryState et nous avons appris à créer un événement dans la programmation pour influencer le fonctionnement de la machine à états. Nous pouvons maintenant passer au test.

Le but est de sauvegarder l’état couleur actif pendant la succession de ces couleurs, et, lorsque nous restaurons l’état sauvé, de faire revenir le témoin à la couleur historisée. Mais ensuite, nous disposons de deux possibilités pour continuer l’enchaînement des états.

La première, nous l’avons utilisée dans la mise en place de l’environnement du test. Le passage d’un EtatCouleur à un autre était assujetti à un index implémenté à chaque contact ; dans ce cas, la série se perpétue en respectant la suite prévue au début par incrémentation de l’index :

Quelle que soit la position du curseur, nous restaurons l’état historique : l’état bleu s’affiche immédiatement à la place de l’état rouge qui était en cours d’activité. Dès que le curseur, qui est toujours en mouvement, produit un contact, l’état vert est réactivé parce que l’état rouge le précède dans la successivité imposée par les index. C’est le cas le plus simple ; toutefois, si nous conservions ce principe, nous risquerions d’être désorientés dans l’observation du test puisque l’état restauré s’intercalerait dans l’enchaînement des états, sans en modifier la chronologie.

La deuxième possibilité est de restaurer l’état et de reprendre le déroulement à compter de cet état :

Quelle que soit la position du curseur, nous restaurons l’état historique : l’état bleu s’affiche. L’état jaune qui était en activé à cet instant est sauvegardé. Au prochain contact, l’état rouge apparaîtra, car il suit l’état bleu, et nous avons imposé que la suite reprenne avec, comme origine, l’état historique. Ce qui nous semblera, dans le déroulement du test, plus logique.

Vous remarquerez que le premier état de restauration est bleu, nous verrons plus loin qu’il faut définir un état historique par défaut pour l’état QHistoryState et, pour notre test, nous définirons l’état bleu.

Pour la suite de cette étape 02, nous chercherons la complication, uniquement pour utiliser des fonctions intéressantes des classes QState et QAbstractState.

Le diagramme de notre machine à états est déterminé comme suit :

Dès lors que l’état QHistoryState doit avoir un état parent, nous créons l’état groupecouleur qui contient les objets de la classe EtatCouleur en plus de l’état historique. Lorsqu’il y a contact, la classe Declencheur commande la procédure Change de la classe Cible qui récupère l’index, que nous avons placé dans les transitions, pour le transmettre à la fonction Machine->postEvent(...);. Vous devez bien noter que le conteneur groupecouleur n’est pas créé dans le but d’un partage de transitions comme nous allons le constater dans l’étude du constructeur de la classe Cible :

Cible::Cible( ObjetImage *vtemoin, qreal posx, qreal posy)
{
...
    machine = new QstateMachine(this);
        groupecouleur = new QState(machine);
    EtatCouleur *Cbleue = new EtatCouleur( ":/motif/bleue.png", temoin, groupecouleur);
    EtatCouleur *Crouge = new EtatCouleur( ":/motif/rouge.png", temoin, groupecouleur);
    EtatCouleur *Cverte = new EtatCouleur( ":/motif/verte.png", temoin, groupecouleur);
    EtatCouleur *Cjaune = new EtatCouleur( ":/motif/jaune.png", temoin, groupecouleur);
    
        lstetat << Cbleue << Crouge << Cverte << Cjaune ;

    groupecouleur->setInitialState(Cbleue);

Les objets EtatCouleur sont déclarés enfant de l’état groupecouleur. Les pointeurs de ces états sont stockés dans une liste typée QList<EtatCouleur*> lstetat;, pour faciliter des test ultérieurs et l’état Cbleue est déclaré comme état initial de groupecouleur.

Dans l’initialisation des transitions, on passe en paramètre l’index de l’état suivant :

TransCouleur *JauneVersBleue = new TransCouleur(1);
    Cjaune->addTransition(JauneVersBleue);
        JauneVersBleue->setTargetState(Cbleue);
TransCouleur *BleueVersRouge = new TransCouleur(2);
    Cbleue->addTransition(BleueVersRouge);
        BleueVersRouge->setTargetState(Crouge);
TransCouleur *RougeVersVerte = new TransCouleur(3);
    Crouge->addTransition(RougeVersVerte);
        RougeVersVerte->setTargetState(Cverte);
TransCouleur *VerteVersJaune = new TransCouleur(4);
    Cverte->addTransition(VerteVersJaune);
        VerteVersJaune->setTargetState(Cjaune);
lsttrans << JauneVersBleue << BleueVersRouge << RougeVersVerte << VerteVersJaune ;

Toutes les transitions sont ajoutées à un état enfant et non à leur parent groupecouleur, car nous ne sommes pas en partage de transitions. Nous constatons qu’à part le paramètre index, ces déclarations sont identiques à celles de la précédente étape 01. De même que les états, nous stockons les pointeurs des objets dans une liste typée QList<TransCouleur*> lsttrans;et nous terminons par l’initialisation de l’état historique et le démarrage de la machine :

historique = new QHistoryState(groupecouleur);
    historique->setDefaultState(Cbleue);
    machine->setInitialState(groupecouleur);
    machine→start();

L’état Cbleue est défini comme état par défaut, il est nécessaire pour que le premier appel à l’état historique ait une restauration en réserve. Sa valeur reste inchangée tout au long de l’existence de l’état historique, sauf si nous en définissons un autre par la fonction setDefaultState. L’état par défaut de l’état historique ne doit pas être confondu avec l’état initial du parent.

V-A-1. Nouvelle fonction Change▲

void Cible::Change()
{
    int  indcouleur=1;
    QSet<QAbstractState*> setdetat = machine->configuration();

setdetat.remove(groupecouleur);
if(!setdetat.isEmpty())
{
   if(lstetat.contains(*setdetat.begin()))
   {

QAbstractState* etatentete = *setdetat.begin();
QList<QAbstractTransition*> lsttransition = ((QState*)etatentete)->transitions();

if(lsttrans.contains(lsttransition.first()))
    indcouleur = ((TransCouleur*)lsttransition.first())->ValCouleur();

void Cible::InitHistorique(QToolButton *histo)
{
    groupecouleur->addTransition(histo, SIGNAL(clicked()), historique);
}

Dans cette étape nous modifions l’état ZoneAnime de la classe Scene en lui ajoutant trois instances de la classe d’états EtatGroupe qui sont chargées de piloter, chacune, un groupe de cibles. Nous activerons un groupe en cliquant sur son nom affiché dans sa zone, ce qui cachera les cibles du groupe en cours et affichera les cibles du groupe activé. Le bouton historique effectuera l’opération sauver/restaurer.

Au démarrage du test, la classe Fenetre organise la classe Scene en sollicitant sa fonction InitialiserScene. Dans celle-ci, après les instructions habituelles pour créer l’objet machine, l’état QFinalState et ses connexions pour quitter le test, nous créons les états groupeA, B et C en leur spécifiant par la suite leur parent commun zoneanime avec l’instructionsetParent.

void Scene::InitialiserScene(QToolButton *quitterletest, QLineEdit *linformation, QToolButton *bhisto )
{
 ...
 QStateMachine *machine =new QStateMachine(this);
 ZoneAnime *zoneanime = new ZoneAnime( this, machine );
 QFinalState *final = new QFinalState(machine);
 zoneanime->addTransition( quitterletest, SIGNAL(clicked()), final );
 connect( machine, SIGNAL(finished()), qApp, SLOT(quit()));

 EtatGroupe *groupeA = new EtatGroupe( QString(":/motif/fondgrpA.png"), 50, 60, this );
 EtatGroupe *groupeB = new EtatGroupe( QString(":/motif/fondgrpB.png"), 50, 320, this );
    EtatGroupe *groupeC = new EtatGroupe( QString(":/motif/fondgrpC.png"), 50, 580, this );
    groupeA->setParent(zoneanime);
    groupeB->setParent(zoneanime);
    groupeC→setParent(zoneanime);

    QEventTransition *okA = new QEventTransition( groupeA->NoGroupe(), QEvent::GraphicsSceneMousePress, zoneanime );
        okA->setTargetState(groupeA);
    QEventTransition *okB = new QEventTransition( groupeB->NoGroupe(), QEvent::GraphicsSceneMousePress, zoneanime );
        okB->setTargetState(groupeB);
    QEventTransition *okC = new QEventTransition( groupeC->NoGroupe(), QEvent::GraphicsSceneMousePress, zoneanime );
        okC→setTargetState(groupeC);

 QHistoryState *historique = new QHistoryState( zoneanime );
 historique->setDefaultState(groupeA);
 zoneanime->addTransition(bhisto, SIGNAL(clicked()), historique);

    zoneanime→setInitialState(groupeA);
    machine->setInitialState(zoneanime);
    machine->start();
}

L’initialisation des transitions entre la souris et les états, avec QEventTransition, réclame le numéro d’entité de l’objet qui provoque cette transition. Puisque l’objet est créé dans la classe état, nous récupérons ce numéro avec une fonction que nous observerons plus loin. Et nous finissons le paramétrage en donnant l’objet état qui contient cette transition, au lieu d’utiliser l’instruction addTransitioncomme auparavant.

En fin de constructeur, nous déterminons l’état historique et la connexion de sa transition au bouton du menu général.

L’état groupe est schématisé ci-dessous, observez que contrairement aux autres étapes, les groupes de cibles sont des objets inclus dans cette classe état.

Dans le constructeur, le paramètre nomfichier doit recevoir l’image du texte du groupe sur laquelle nous cliquerons pour afficher le groupe. Les apparitions et occultations des cibles seront réalisées simplement en changeant la position dans l’axe Z de l’image du fond du groupe de cible, récupéré par pfond = groupecible->NoFond();. Lorsque l’état est activé, onEntry place le fond derrière les cibles, et lorsque nous sortons de l’état, onExit le replace devant.

EtatGroupe::EtatGroupe(const QString &nomfichier, qreal vx, qreal vy , QGraphicsScene *pscene )
{
    groupecible = new GroupeCible( nomfichier, vx, vy, pscene );
    pfond = groupecible->NoFond();
}
void EtatGroupe::onEntry(QEvent *)
{
    pfond->setZValue(2);
}
void EtatGroupe::onExit(QEvent *)
{
    pfond->setZValue(5);
}
QObject *EtatGroupe::NoGroupe()
{
    return static_cast<QObject*>(groupecible);
}

En fin du fichier source, nous plaçons l’instruction utilisée par la création des objets QEventTransition dans le constructeur de la classe Scene exposé précédemment, pour récupérer l’identité de l’objet créé, converti en pointeur QObject.

La classe GroupeCible met en place les trois cibles de la classe EtatGroupe. Sans trop la détailler, car pour nous son constructeur est devenu routinier, nous remarquerons à la fin de son fichier source la fonction InsererBoutonHistorique qui positionne le bouton dans la zone du groupe et envoie le numéro du pointeur de l’objet QToolButton à chacune de ses cibles. De cette façon, chaque action sur ce bouton provoquera dans toutes les cibles du groupe l’activation de son état historique, il y aura donc simultanéité de l’historisation.

void GroupeCible::InsererBoutonHistorique( qreal vx, qreal vy )
{
    QToolButton *btnhisto = new QToolButton;
    QIcon iconetmp;
        iconetmp.addFile(":/general/ouvert.png",QSize(40,40),QIcon::Normal,QIcon::Off );
        iconetmp.addFile(":/general/ferme.png",QSize(40,40),QIcon::Normal,QIcon::On );
    btnhisto->setCheckable(true);
    btnhisto->setIcon(iconetmp);
    btnhisto->setIconSize( QSize (80,80));
    btnhisto->setToolTip("restaure/historise le groupe");
    BoutonDansScene = pscene->addWidget(btnhisto);
    BoutonDansScene->setPos( vx, vy );
    BoutonDansScene->setZValue(3);
    for( int i=0; i<lstcible.size(); ++i ){ lstcible[i]->InitHistorique(btnhisto); }
}

Puisque BoutonDansScene est un QWidget placé dans un objet QGraphicsScene, pour que les événements qui l’affectent soient traités à travers la Scene, nous utilisons la classe QGraphicsProxyWidget pour son typage. Vous trouverez plus de détails sur l’application des insertions de QWidget dans QGraphicsScene avec la documentation de Qt.

La classe Cible contient une zone image qui peut afficher six couleurs représentant chacune un état. Ces états sont reliés l’un à l’autre par une transition déclenchée avec le clic du bouton gauche de la souris dans la zone cible.

Nous remarquons, dans la machine, la présence de l’état groupecouleur qui sert de conteneur pour les six états et l’état historique, puisque QStateMachine ne doit pas contenir d’état historique.

Le début du constructeur de la classe Cible est similaire à ce que nous avons vu jusqu’à présent. L’ajout de l’instructionsetAcceptedMouseButtonsnous permet d’utiliser la souris pour provoquer un événement depuis cet objet, héritier de la classe QGraphicsObject. Vous noterez que l’événement contrôléQEvent::GraphicsSceneMousePressprovoque une alerte « QGraphicsItem::ungrabMouse: not a mouse grabber » dans l’affichage de la sortie de l’application de QtCreator, mais ne perturbe pas le déroulement du test.

Cible::Cible(qreal posx, qreal posy)
{
    …
    setAcceptedMouseButtons( Qt::LeftButton );
    QStateMachine *machine = new QStateMachine(this);
    groupecouleur  = new QState(machine);
    ...
    EtatCouleur *e0 = new EtatCouleur( ":/motif/bleue.png", this, groupecouleur );
...
    EtatCouleur *e5 = new EtatCouleur( ":/motif/mauve.png", this, groupecouleur );
    TransEventSouris *BvR = new TransEventSouris( this, QEvent::GraphicsSceneMousePress, e0 );
        BvR->setTargetState(e1);
…
    TransEventSouris *MvB = new TransEventSouris( this, QEvent::GraphicsSceneMousePress, e5 );
        MvB->setTargetState(e0);
    historique = new QHistoryState(groupecouleur);
    historique→setDefaultState(e0);
    machine->setInitialState(groupecouleur);
    machine->start();
}

Les cinq états de Cible sont définis par la classe EtatCouleur dont les instanciations de e0 à e5 permettront de permuter d’une couleur à la suivante et en continu, grâce à sa fonction onEntry :

void EtatCouleur::onEntry(QEvent *)
{
    temoin->hide();
    temoin->ChangeImage(couleur);
    temoin->show();
    temoin->setFlag( QGraphicsItem::ItemIsFocusable, true );
}

Lors de l’activation, l’image est modifiée par l’entrée dans l’état. N’oublions pas : étant donné que la classe Cible est héritière de la classe QGraphicsObject, pour valider la nouvelle image, un hide et un show sont nécessaires et, de ce fait, il faut rendre l’objet cible « focusable », car cette propriété a été annulée par le hide.

Pour la transition entre états, nous créons la classe TransEventSouris, dérivée de QEventTransition. Cette tribulation n’est pas nécessaire, mais nous permet, si le besoin se fait sentir, de tester sa fonction eventTest.

Dans cette étape une balle défile de haut en bas avec une abscisse différente à chaque parcours. L’appui sur le bouton pause, stoppe le défilement et affiche un message. La fin du message provoque la reprise du défilement, depuis la position de la balle au moment de l’arrêt.

Si vous le souhaitez, en testant les programmes bonus03 et bonus04, vous observerez que dans une utilisation simple de la fonction assignProperty() affectée à un état qui lance une animation, celle-ci continue jusqu’à son aboutissement, même si vous changez d’état en cours de déroulement. C’est pourquoi, dans cette etape04, nous réimplémenterons les fonctions onEntry et onExit pour interrompre et reprendre l’animation dans une classe état que nous examinons de suite.

VIII-A-1. L’état Deplacement▲

Deplacement::Deplacement(ObjetImage *vimage, Scene *vscene, qreal vposx,  QState *vparent ) : QState(vparent)
{
    ...
    animationdelobjet = new QPropertyAnimation( vimage, "pos" );
    animationdelobjet->setDuration(900);
    animationdelobjet->setStartValue(ptdebut);
    animationdelobjet->setEndValue(QPointF(vposx, vscene->height()+vimage→size().height()));
}

void Deplacement::onEntry(QEvent *)
{
    if(animationdelobjet->state()==QAbstractAnimation::Paused)
        animationdelobjet->resume();
    else
        animationdelobjet->start();
}
void Deplacement::onExit(QEvent *)
{
    if(animationdelobjet->state()==QAbstractAnimation::Running)
        animationdelobjet->pause();
    else
    {
        pscene->Comptage();
        animationdelobjet->stop();
    }
}

VIII-A-2. La classe Scene▲

void Scene::InitialiserScene(QToolButton *quitterletest, QLineEdit *linformation, QToolButton *bhisto)
{
 ...
      Deplacement *horz1 = new Deplacement( image, this,  250, zoneanime );
      Deplacement *horz2 = new Deplacement( image, this,  450, zoneanime );
      Deplacement *horz3 = new Deplacement( image, this,  600, zoneanime );
      Deplacement *horz4 = new Deplacement( image, this,  800, zoneanime );
      Deplacement *horz5 = new Deplacement( image, this, 1000, zoneanime );
    QSignalTransition *vers2 = 
                new QSignalTransition( horz1->rtanimation(), SIGNAL(finished()), horz1 );
        vers2->setTargetState(horz2);
    QSignalTransition *vers3 = 
                new QSignalTransition( horz2->rtanimation(), SIGNAL(finished()), horz2 );
        vers3->setTargetState(horz3);
    QSignalTransition *vers4 = 
                new QSignalTransition( horz3->rtanimation(), SIGNAL(finished()), horz3 );
        vers4->setTargetState(horz4);
    QSignalTransition *vers5 =
                new QSignalTransition( horz4->rtanimation(), SIGNAL(finished()), horz4 );
        vers5->setTargetState(horz5);
    QSignalTransition *vers1 = 
                new QSignalTransition( horz5->rtanimation(), SIGNAL(finished()), horz5 );
        vers1->setTargetState(horz1);

    QHistoryState *historique = new QHistoryState( zoneanime );
    
    Pause *etatpause = new Pause( (char*)&resultat, machine );
        etatpause->addTransition( historique );
    zoneanime->addTransition( bhisto, SIGNAL(clicked()), etatpause );
    zoneanime->setInitialState( horz1 );
    machine->setInitialState( zoneanime );
    machine->start();
}

    QState *etatpause = new QState(machine);
        etatpause->addTransition( historique );

    QMessageBox *raz = new QMessageBox();
    raz->addButton( QString("continuer"), QMessageBox::AcceptRole );
    QPushButton *sortir = raz->addButton( QString("quitter"), QMessageBox::NoRole );
    raz->setText("une pause.");

    zoneanime->addTransition(bhisto, SIGNAL(clicked()), etatpause);
    connect( etatpause, SIGNAL(entered()), raz, SLOT(exec()) );
    zoneanime->addTransition( sortir, SIGNAL(clicked()), final );

Dans la déclaration d’une instance de la classe QHistoryState, le paramètre HistoryType peut prendre deux valeurs :

• ShallowHistory qui est la valeur par défaut avec laquelle les états enfants immédiats de l'état parent sont historisés ;
• DeepHistory où les états enfants le plus profondément imbriqués sont enregistrés et restitués.

Dans l’étude du programme test de cette étape, je décris uniquement les instructions créant l’état historique, le reste du test étant une réplique de tout ce que nous avons vu jusque-là.

Avec le diagramme qui suit, l’historique fait, qu’après la pause, les animations reprennent là où elles ont été interrompues.

Puisque l’état vertical est un état parallèle, ses enfants, qui sont exclusifs, sont tous actifs. L’état historique qui est enfant de vertical n’est pas affecté par ce parallélisme, n’oublions pas que c’est un pseudo état.

La séquence d’instructions pour ce test est :

QHistoryState *historique = new QHistoryState( QHistoryState::DeepHistory, vertical );

La valeur du paramètre HistoryType, fixée à DeepHistory, implique une recherche des états actifs dans les imbrications d’états enfants. Dans notre cas, il recherche dans chaque état balle son état enfant en fonctionnement, descente ou montée, afin de le restituer à la reprise.

Si nous modifions le paramètre avec la valeur par défaut, ShallowHistory,

QHistoryState *historique = new QHistoryState( QHistoryState::ShallowHistory, vertical );

Nous obtiendrons, après chaque interruption, un comportement insolite lors de la reprise de l’animation de chaque état, car la recherche d’activité se bornera aux états balle, et comme nous sommes dans un environnement parallèle, leurs propres enfants actifs ne seront pas détectés à la pause.

Pour affiner la compréhension de ce paramètre HistoryType, nous changeons le parent de l’état historique en le plaçant dans l’état zoneanime.

Et nous lui donnons le type DeepHistory.

QHistoryState *historique = new( QHistoryState( QHistoryState::DeepHistory, zoneanime );

Nous obtiendrons le même résultat qu’au premier cas. La commande ira chercher les états actifs dans les enfants de l’état vertical, donc tous puisqu’il est état parallèle, et dans chacun d’eux cherchera l’état descente ou montée en cours.

Avec ce troisième et dernier cours, plus aucun obstacle concernant la classe QStateMachine de la bibliothèque Qt sur les machines à états ne vous résistera. Gardez en mémoire les projets « bonus » ils pourraient vous être utiles comme rampe de lancement pour vos tests.