The engine supports various decoupled schemes for interaction between objects at the foundation of the whole class hierarchy.
Object class defines methods for message passing and for event propagation.
Message between objects are carried out by telegrams whose dispatching is managed by a singleton of the
MessageDispatcher::dispatchMessage(delayInMilliseconds, sender, receiver, messageEnum, extraInfoPointer);
If the delay argument is zero, the message is delivered at the moment of the dispatch request. If a value greater than zero is passed as the first argument, then the message will be delivered once the delay expires.
Delayed messages must always be sent between objects that you know will be alive at the moment of delivery. Therefore you need to make sure to cancel any delayed messages in the destructor of each class that uses them. This is done with the
Object’s handleMessage method can be overrode to specify each class’ behavior.
States don’t override the handleMessage method, instead, they define a processMessage method that is called by the
StateMachine class and can be overrode by derived class for specialization. The
StateMachine’s owner must receive the
Telegram by overriding the
Object’s handleMessage method and then forward the telegram by calling the
StateMachine handleMessage method.
The engine supports event propagation at the
Object level too.
To listen for an event, add a listener with the following code:
Object::addEventListener(triggerObject, listener, eventListenerMethod, eventCode);
To fire an event, call the following code:
The removal of listeners is the responsibility of the client code. To remove a listener use one of the following:
Object::removeEventListener(triggerObject, listener, method, eventCode);
Beware: During the processing of an event it is illegal to modify the firer’s event list by adding or removing event listeners to it, or by deleting the firer. If any of that happens, the engine will trigger an exception.
# Message propagation
The Container implements a passMessage method that allows the propagation of a message to all its descendants. For example, to propagate a message through all the descendants of a Stage use the following call:
Container::propagateMessage(stage, Container::onPropagatedMessage, message);
Then, to react to the message, override the following method in your class:
bool Container::handlePropagatedMessage(int message);
Message propagation stops when handlePropagatedMessage returns true.