src/Events/Events_Loop.h

   1 // File:        Events_Loop.hxx
   2 // Created:     Thu Mar 13 2014
   3 // Author:      Mikhail PONIKAROV
   4
   5 #ifndef Events_Loop_H_
   6 #define Events_Loop_H_
   7
   8 #include <Events_Message.h>
   9 #include <Events_Listener.h>
  10
  11 #include <map>
  12 #include <list>
  13
  14 class Events_MessageGroup;
  15
  16 /**\class Events_Lopp
  17  * \ingroup EventsLoop
  18  * \brief Base class that manages the receiving and sending of all
  19  * not Qt-events in the application.
  20  *
  21  * One per application, initialized on start. Listeners must register in this loop
  22  * to get events, called by senders. Sending of events is very fast (just adding to container).
  23  * Performing of events is processed in separated thread, so, sender takes
  24  * control back immideately.
  25  */
  26 class Events_Loop
  27 {
  28   /// map from event ID to sender pointer to listeners that must be called for this
  29   std::map<char*, std::map<void*, std::list<Events_Listener*> > > myListeners;
  30
  31   /// map from event ID to listeners which must process message without waiting for flush
  32   std::map<char*, Events_Listener*> myImmediateListeners;
  33
  34   /// map from event ID to groupped messages (accumulated on flush)
  35   std::map<char*, boost::shared_ptr<Events_Message> > myGroups;
  36
  37   /// to process flushes or not
  38   bool myFlushActive;
  39
  40   //! The empty constructor, will be called at startup of the application, only once
  41   Events_Loop() : myFlushActive(true) {}
  42
  43  public:
  44   ///! Returns the main object of the loop, one per application.
  45   EVENTS_EXPORT static Events_Loop* loop();
  46   //! Returns the unique event by the given name. Call this method only on initialization of object
  47   //! to speedup the events processing without parsing of the string.
  48   EVENTS_EXPORT static Events_ID eventByName(const char* theName);
  49
  50   //! Allows to send an event
  51   //! \param isGroup is true for grouping messages if possible
  52   EVENTS_EXPORT void send(const boost::shared_ptr<Events_Message>& theMessage, bool isGroup = true);
  53
  54   //! Registers (or adds if such listener is already registered) a listener
  55   //! that will be called on the event and from the defined sender
  56   EVENTS_EXPORT void registerListener(Events_Listener* theListener, const Events_ID theID,
  57                                       void* theSender = 0, bool theImmediate = false);
  58
  59   //! Initializes sending of a group-message by the given ID
  60   EVENTS_EXPORT void flush(const Events_ID& theID);
  61
  62   //! Allows to disable flushes: needed in synchronization of document mechanism
  63   //! (to synchronize all and only then flush create, update, etc in correct order)
  64   EVENTS_EXPORT void activateFlushes(const bool theActivate);
  65 };
  66
  67 #endif