1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
3 // File: Events_Loop.hxx
4 // Created: Thu Mar 13 2014
5 // Author: Mikhail PONIKAROV
10 #include <Events_Message.h>
11 #include <Events_Listener.h>
17 class Events_MessageGroup;
21 * \brief Base class that manages the receiving and sending of all
22 * not Qt-events in the application.
24 * One per application, initialized on start. Listeners must register in this loop
25 * to get events, called by senders. Sending of events is very fast (just adding to container).
26 * Performing of events is processed in separated thread, so, sender takes
27 * control back immideately.
31 /// map from event ID to sender pointer to listeners that must be called for this
32 std::map<char*, std::map<void*, std::list<Events_Listener*> > > myListeners;
34 /// map from event ID to listeners which must process message without waiting for flush
35 std::map<char*, Events_Listener*> myImmediateListeners;
37 /// map from event ID to groupped messages (accumulated for flush)
38 std::map<char*, std::shared_ptr<Events_Message> > myGroups;
40 ///< set of messages that are flushed right now, so they are not grouped
41 std::set<char*> myFlushed;
43 /// to process flushes or not
46 //! The empty constructor, will be called at startup of the application, only once
47 Events_Loop() : myFlushActive(true) {}
50 ///! Returns the main object of the loop, one per application.
51 EVENTS_EXPORT static Events_Loop* loop();
52 //! Returns the unique event by the given name. Call this method only on initialization of object
53 //! to speedup the events processing without parsing of the string.
54 EVENTS_EXPORT static Events_ID eventByName(const char* theName);
56 //! Allows to send an event
57 //! \param theMessage the enevt message to send
58 //! \param isGroup is true for grouping messages if possible
59 EVENTS_EXPORT void send(const std::shared_ptr<Events_Message>& theMessage, bool isGroup = true);
61 //! Registers (or adds if such listener is already registered) a listener
62 //! that will be called on the event and from the defined sender
63 //! \param theListener the object that will listen (process) the event
64 //! \param theID listen for messages with this ID
65 //! \param theSender listen only for this sender (NULL - listen everybody)
66 //! \param theImmediate for listeners who can not wait (no groupping mechanism is used for it)
67 EVENTS_EXPORT void registerListener(Events_Listener* theListener, const Events_ID theID,
68 void* theSender = 0, bool theImmediate = false);
70 //! Remove the listener from internal maps if it was registered there
71 //! \param theListener a listener
72 EVENTS_EXPORT void removeListener(Events_Listener* theListener);
74 //! Initializes sending of a group-message by the given ID
75 EVENTS_EXPORT void flush(const Events_ID& theID);
77 //! Removes messages with the given ID: they are not needed anymore (UPDATE on close)
78 EVENTS_EXPORT void eraseMessages(const Events_ID& theID);
80 //! Allows to disable flushes: needed in synchronization of document mechanism
81 //! (to synchronize all and only then flush create, update, etc in correct order)
82 //! \param theActivate a state about flushe is active. If false, the flush is disabled
83 //! \return the previous active flush state
84 EVENTS_EXPORT bool activateFlushes(const bool theActivate);
86 //! Clears all collected messages
87 EVENTS_EXPORT void clear(const Events_ID& theID);
89 //! Returns true if the evement is flushed right now
90 EVENTS_EXPORT bool isFlushed(const Events_ID& theID);
91 //! Sets the flag that the event is flished right now
92 EVENTS_EXPORT void setFlushed(const Events_ID& theID, const bool theValue);
94 //! Returns true if a loop accumulated events to be flashed
95 EVENTS_EXPORT bool hasGrouppedEvent(const Events_ID& theID);
98 //! Calls "processEvent" for the given listeners.
99 //! If theFlushedNow for grouped listeners is stores message in listeners.
100 void sendProcessEvent(const std::shared_ptr<Events_Message>& theMessage,
101 std::list<Events_Listener*>& theListeners, const bool theFlushedNow);