64 lines
2.5 KiB
Plaintext
64 lines
2.5 KiB
Plaintext
|
|
/**
|
|
\class Listener
|
|
|
|
Derive your class from a Listener<EvType>, to give it the
|
|
ability to hear (i.e. receive, listen to) events of type
|
|
EvType. EvType is a fundamental type (bool, int, float,
|
|
etc), a struct or a class of your choice. You must define
|
|
Listener<EvType>::processEvent() in your Listener<EvType>
|
|
subclass. You call listenForEvents() on your listener
|
|
instance (at least once) for it to be able to hear (i.e.
|
|
receive) any EvType event, and you call ignoreEvents() on
|
|
the instance so it will no longer receive events of type
|
|
EvType.
|
|
|
|
\note
|
|
- Do not assume that the Listeners will receive the generated event in
|
|
the same order as they registered.
|
|
- A class can listen to more than one type of event by inheriting
|
|
from more than one type of listener. Calling listenForEvents()
|
|
then is done by specifying which listenForEvents() to call, e.g.
|
|
\code
|
|
class YourListener:
|
|
public Listener<TicEvent>, public Listener<TacEvent>
|
|
{
|
|
public:
|
|
YourListener() {
|
|
Listener<TicEvent>::listenForEvents();
|
|
Listener<TacEvent>::listenForEvents();
|
|
}
|
|
protected:
|
|
virtual void processEvent(const TicEvent& event) {...}
|
|
virtual void processEvent(const TacEvent& event) {...}
|
|
};
|
|
\endcode
|
|
- If a subclass of your class must also process an event, remember
|
|
that because its processEvent is virtual, it will be the first
|
|
one called. Therefore it should call its base class method:
|
|
\code
|
|
struct TicEvent {...};
|
|
class YourListener: public Listener<TicEvent> {...};
|
|
class DerivedListener: public YourListener
|
|
{
|
|
public:
|
|
// ...
|
|
protected:
|
|
virtual void processEvent(const TicEvent& event)
|
|
{
|
|
// give parent class a chance to process event
|
|
YourListener::processEvent(event);
|
|
// do our stuff ...
|
|
}
|
|
};
|
|
\endcode
|
|
- ignoreThisEvent(): You can call it (from inside
|
|
processEvent()) to tell EventSender<EvType> that you will be ignoring
|
|
the event received. This can be a useful way to signify an error in
|
|
the data sent by the event generator. Just keep in mind that the
|
|
generator of the event may not actually check whether any listener
|
|
ignored the event (it may not care).
|
|
|
|
|
|
*/
|