Emitting signals from class, if transition in QStateMachine was successful

Question

My problem is the following: I need to create class, which contains QStateMachine instance. This class should have slots through which you could "ask" state machine to make transition to another state. And if transition was successful, my class should emit signal about it. How would I implement this? Class should have ability to emit certain signals according to certain slot invoke. Here is a small example of class:

class MyClass : public QObject
{
    Q_OBJECT
public:
    explicit MyClass(QObject *parent = 0)
    {
        mStateMachine = new QStateMachine(this);
        QState *s1 = new QState(mStateMachine);
        QState *s2 = new QState(mStateMachine);
        QState *s3 = new QState(mStateMachine);

        s1->addTransition(); // Transition to s2
        s2->addTransition(); // Transition to s3
        s3->addTransition(); // Transition to s1

        mStateMachine->setInitialState(s1);
        mStateMachine->start();
    }

signals:
    toS1();
    toS2();
    toS3();

public slots:
    slotToS1()
    {
        /* post event to state machine about
        transition to state s1,
        if transition was successful,
        then emit toS1() signal. */
    };
    slotToS2(){ /* Similar to slotToS1 */};
    slotToS3(){ /* Similar to slotToS1 */};
private:
    QStateMachine *mStateMachine;
}

I would be very grateful for your help!

UPD:
The slots are representing defferent kinds of transitions, so that outer class (that will be using MyClass) could 'ask' for some transition. So, the slot send event or signal to state machine, it looks on event or signal and (if in right state) makes this transition. And I want to notify outer class with certain signal, that asked before slot (transition) was made successfuly.

Kuba hasn't forgotten Monica · Accepted Answer · 2015-07-14T17:59:34.473

To transition on a slot call, you need to somehow bind the slot to a QAbstractTransition. There are two ways of doing it:
- Use a QEventTransition and send a relevant event to trigger it.
- Use a QSignalTransition and use an internal signal to trigger it.
To emit signals on state transitions, you can connect the QAbstractTransition::triggered or QState::entered or QState::exited signals to other signals. Remember, in Qt a connection target can be either a slot or a signal.

Thus, using signal transitions:

class MyClass : public QObject
{
  Q_OBJECT
  QStateMachine machine;
  QState s1, s2;
  Q_SIGNAL void s_go_s1_s2();
  Q_SIGNAL void s_go_s2_s1();
public:
  Q_SIGNAL void transitioned_s1_s2();
  Q_SIGNAL void transitioned_s2_s1();
  Q_SLOT void go_s2_s1() { emit s_go_s2_s1(); }
  Q_SLOT void go_s1_s2() { emit s_go_s1_s2(); }
  explicit MyClass(QObject *parent = 0) : QObject(parent),
    s1(&machine), s2(&machine) {
    auto s1_s2 = s1.addTransition(this, SIGNAL(s_go_s1_s2()), &s2);
    auto s2_s1 = s2.addTransition(this, SIGNAL(s_go_s2_s1()), &s1);
    machine.setInitialState(&s1);
    machine.start();
    connect(s1_s2, &QAbstractTransition::triggered, this, &MyClass:: transitioned_s1_s2);
    connect(s2_s1, &QAbstractTransition::triggered, this, &MyClass:: transitioned_s2_s1);
  }
}

Using event transitions is a bit harder, since the events you're using must be cloneable by the state machine. The core module's state machine only knows how to clone the None and Timer events - see its cloneEvent implementation.

The widgets module adds support for various GUI/Widgets events - see the cloneEvent implementation there. You could, in a pinch, use such GUI events for your own purposes - after all, they are sent to a plain QObject that doesn't interpret them in a special way.

You can provide your own cloneEvent implementation that links with the others.

#include <private/qstatemachine_p.h>

class MyClass : public QObject
{
  Q_OBJECT
  QStateMachine machine;
  QState s1, s2;
  QEvent e_s1_s2, e_s2_s1;
  QEventTransition s1_s2, s2_s1;
public:
  Q_SIGNAL void transitioned_s1_s2();
  Q_SIGNAL void transitioned_s2_s1();
  Q_SLOT void go_s2_s1() { QCoreApplication::sendEvent(this, &e_s2_s1); }
  Q_SLOT void go_s1_s2() { QCoreApplication::sendEvent(this, &e_s1_s2); }
  explicit MyClass(QObject *parent = 0) : QObject(parent),
    s1(&machine), s2(&machine),
    e_s1_s2((QEvent::Type)(QEvent::User + 1)),
    e_s2_s1((QEvent::Type)(QEvent::User + 2)),
    s1_s2(this, e_s1_s2.type()),
    s2_s1(this, e_s2_s1.type()) {
    s1_s2.setTargetState(&s2);
    s2_s1.setTargetState(&s1);
    s1.addTransition(&s1_s2);
    s2.addTransition(&s2_s1);
    machine.setInitialState(&s1);
    machine.start();
    connect(&s1_s2, &QAbstractTransition::triggered, this, &MyClass::transitioned_s1_s2);
    connect(&s2_s1, &QAbstractTransition::triggered, this, &MyClass::transitioned_s2_s1);
  }
}

static const QStateMachinePrivate::Handler * last_handler = 0;

static QEvent * cloneEvent(QEvent * e) {
  if (e->type() >= QEvent::User && e->type() < QEvent::User+100) {
    return new QEvent(e->type());
  return last_handler->cloneEvent(e);
}

const QStateMachinePrivate::Handler our_handler = {
    cloneEvent
};

void registerHandler() {
  last_handler = QStateMachinePrivate::handler;
  QStateMachinePrivate::handler = &our_handler;
}
Q_CONSTRUCTOR_FUNCTION(registerHandler())

void unregisterHandler() {
  QStateMachinePrivate::handler = last_handler;

}
Q_DESTRUCTOR_FUNCTION(unregisterHandler())

It's not quite my case. I want to fire signals, when transitions are made, but not when entered some state. I've updated the question. — Nazarii Plebanskii, Jul 13 '15 at 22:08
@NazariiPlebanskii You can also use the `triggered` signal of the transition itself, if there are multiple transitions leading to a state. — Kuba hasn't forgotten Monica, Jul 13 '15 at 23:18
When I make the class with event-approach, I've got the next warning message: "QObject event transitions are not supported for custom types". — Nazarii Plebanskii, Jul 14 '15 at 07:55
@NazariiPlebanskii Ah, yes. Well, that's because the silly state machine insists on copying all events, and it doesn't know what to do with the user ones. So it simply ignores the transition. You can appropriate any other Qt event types. Say Enter and Leave events. — Kuba hasn't forgotten Monica, Jul 14 '15 at 17:21
@NazariiPlebanskii I've added code that shows how to teach the state machine to deal with your events. — Kuba hasn't forgotten Monica, Jul 14 '15 at 17:59

score 2 · Answer 2 · edited Mar 24 '22 at 10:28

I have had the same problem in the past and I have found the easiest way was to inherit from QState with your own QState class and implement 2 methods called QState::onEntry(QEvent * event) and QState::onExit(QEvent * event).

This way you are able to emit any signal you like when you exit and when you enter a new state.

Here is and example:

file mystate.h

#include <QState>

class MyState : public QState
{
    Q_OBJECT
public:
    explicit MyState(qint32 stateId, QState * parent = 0);

protected:
    void onEntry(QEvent * event);
    void onExit(QEvent * event);
 
signals:
    void exit(qint32 stateId);
    void enter(qint32 stateId);
  
private: 
    qint32 stateId;  
};

And file mystate.cpp

#include "mystate.h"


MyState::MyState(qint32 stateId, QState *parent)
{
    this->stateId = stateId;
}

void MyState::onEntry(QEvent *event)
{
    emit enter(stateId);
}

void MyState::onExit(QEvent *event)
{
    emit (exit(stateId));
}

This is unnecessary. You can connect the `entered` and `exited` signals to other signals in Qt 4, and use `QObject::sender()` to determine what state was the source of the signal. In Qt 5, you can connect the signals to lambdas that emit signals with the data you desire. — Kuba hasn't forgotten Monica, Jul 13 '15 at 15:21

Emitting signals from class, if transition in QStateMachine was successful

2 Answers2

Linked