1 // Copyright (C) 2014-2019 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #include <Events_Loop.h>
21 #include <Events_MessageGroup.h>
26 Events_Loop* Events_Loop::loop()
28 // initialized on initialization of the application
29 static Events_Loop MAIN_LOOP;
33 Events_ID Events_Loop::eventByName(const char* theName)
35 ///! All events created in this session, uniquely identified by the text and char pointer
36 static std::map<std::string, char*> CREATED_EVENTS;
38 std::string aName(theName);
39 std::map<std::string, char*>::iterator aFound = CREATED_EVENTS.find(aName);
40 if (aFound == CREATED_EVENTS.end()) { //not created yet
42 aResult = _strdup(theName); // copy to make unique internal pointer
44 aResult = strdup(theName); // copy to make unique internal pointer
46 CREATED_EVENTS[aName] = aResult;
48 aResult = aFound->second;
50 return Events_ID(aResult);
53 void Events_Loop::sendProcessEvent(const std::shared_ptr<Events_Message>& theMessage,
54 std::list<Events_Listener*>& theListeners, const bool theFlushedNow)
56 std::list<Events_Listener*>::iterator aL = theListeners.begin();
57 for (; aL != theListeners.end(); aL++) {
58 if (theFlushedNow && (*aL)->groupMessages()) {
59 (*aL)->groupWhileFlush(theMessage);
61 (*aL)->processEvent(theMessage);
66 void Events_Loop::send(const std::shared_ptr<Events_Message>& theMessage, bool isGroup)
68 if (myImmediateListeners.find(theMessage->eventID().eventText()) != myImmediateListeners.end()) {
69 myImmediateListeners[theMessage->eventID().eventText()]->processEvent(theMessage);
71 // if it is grouped message, just accumulate it
72 bool isFlushedNow = myFlushed.find(theMessage->eventID().myID) != myFlushed.end();
73 if (isGroup && !isFlushedNow) {
74 std::shared_ptr<Events_MessageGroup> aGroup =
75 std::dynamic_pointer_cast<Events_MessageGroup>(theMessage);
77 std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup = myGroups.find(
78 aGroup->eventID().eventText());
79 if (aMyGroup == myGroups.end()) { // create a new group of messages for accumulation
80 myGroups[aGroup->eventID().eventText()] = aGroup->newEmpty();
81 aMyGroup = myGroups.find(aGroup->eventID().eventText());
83 std::shared_ptr<Events_MessageGroup> aStored =
84 std::dynamic_pointer_cast<Events_MessageGroup>(aMyGroup->second);
85 aStored->Join(aGroup);
90 std::map<char*, std::map<void*, std::list<Events_Listener*> > >::iterator aFindID =
91 myListeners.find(theMessage->eventID().eventText());
92 if (aFindID != myListeners.end()) {
93 std::map<void*, std::list<Events_Listener*> >::iterator aFindSender = aFindID->second.find(
94 theMessage->sender());
95 if (aFindSender != aFindID->second.end()) {
96 sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup);
98 if (theMessage->sender()) { // also call for NULL senders registered
99 aFindSender = aFindID->second.find(NULL);
100 if (aFindSender != aFindID->second.end()) {
101 sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup);
107 void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID theID,
108 void* theSender, bool theImmediate)
110 if (theImmediate) { // just register as an immediate
111 myImmediateListeners[theID.eventText()] = theListener;
114 std::map<char*, std::map<void*, std::list<Events_Listener*> > >::iterator aFindID =
115 myListeners.find(theID.eventText());
116 if (aFindID == myListeners.end()) { // create container associated with ID
117 myListeners[theID.eventText()] = std::map<void*, std::list<Events_Listener*> >();
118 aFindID = myListeners.find(theID.eventText());
121 std::map<void*, std::list<Events_Listener*> >::iterator aFindSender =
122 aFindID->second.find(theSender);
123 if (aFindSender == aFindID->second.end()) { // create container associated with sender
124 aFindID->second[theSender] = std::list<Events_Listener*>();
125 aFindSender = aFindID->second.find(theSender);
127 // check that listener was not registered with such parameters before
128 std::list<Events_Listener*>& aListeners = aFindSender->second;
129 for (std::list<Events_Listener*>::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++)
130 if (*aL == theListener)
131 return; // avoid duplicates
133 aListeners.push_back(theListener);
136 void Events_Loop::removeListener(Events_Listener* theListener)
138 // remove the listener in myListeners map
139 std::map<char*, std::map<void*, std::list<Events_Listener*> > >::const_reverse_iterator
140 anIt = myListeners.rbegin();
141 while(anIt != myListeners.rend()) {
142 std::map<void*, std::list<Events_Listener*> > aLMap = anIt->second;
143 std::map<void*, std::list<Events_Listener*> >::const_reverse_iterator aLIt = aLMap.rbegin();
144 while (aLIt != aLMap.rend()) {
145 std::list<Events_Listener*> aListeners = aLIt->second;
146 std::list<Events_Listener*>::const_reverse_iterator aLsIt = aListeners.rbegin();
147 for (; aLsIt != aListeners.rend(); aLsIt++) {
148 if (*aLsIt == theListener) {
149 aListeners.remove(theListener);
150 aLMap[aLIt->first] = aListeners;
151 myListeners[anIt->first] = aLMap;
155 if (aListeners.empty()) {
156 aLMap.erase(aLIt->first);
157 myListeners[anIt->first] = aLMap;
159 break; // avoid incrementation of the iterator if the container is empty
163 if (anIt->second.empty()) {
164 myListeners.erase(anIt->first);
165 if (myListeners.empty())
166 break; // avoid incrementation of the iterator if the container is empty
171 // remove the listener in myImmediateListeners map
172 std::map<char*, Events_Listener*>::const_reverse_iterator anImIt = myImmediateListeners.rbegin();
173 while(anImIt != myImmediateListeners.rend()) {
174 if (anImIt->second == theListener) {
175 myImmediateListeners.erase(anImIt->first);
176 if (myImmediateListeners.empty())
177 break; // avoid incrementation of the iterator if the container is empty
183 void Events_Loop::flush(const Events_ID& theID)
187 bool hasEventsToFlush = !myGroups.empty();
188 std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup;
189 for(aMyGroup = myGroups.find(theID.eventText());
190 aMyGroup != myGroups.end(); aMyGroup = myGroups.find(theID.eventText()))
192 bool aWasFlushed = myFlushed.find(theID.myID) != myFlushed.end();
194 myFlushed.insert(theID.myID);
195 std::shared_ptr<Events_Message> aGroup = aMyGroup->second;
196 myGroups.erase(aMyGroup);
200 // TODO: Stabilization fix. Check later.
201 if(myFlushed.find(theID.myID) != myFlushed.end()) {
202 myFlushed.erase(myFlushed.find(theID.myID));
204 bool aProblem = true;
207 // send accumulated messages to "groupListeners"
208 std::map<char*, std::map<void*, std::list<Events_Listener*> > >::iterator aFindID =
209 myListeners.find(theID.eventText());
210 if (aFindID != myListeners.end()) {
211 std::map<void*, std::list<Events_Listener*> >::iterator aFindSender =
212 aFindID->second.begin();
213 for(; aFindSender != aFindID->second.end(); aFindSender++) {
214 std::list<Events_Listener*>::iterator aListener = aFindSender->second.begin();
215 for(; aListener != aFindSender->second.end(); aListener++) {
216 if ((*aListener)->groupMessages()) {
217 (*aListener)->flushGrouped(theID);
223 if (hasEventsToFlush && myGroups.empty() && myFlushed.empty()) {
224 // no more messages left in the queue, so, finalize the sketch processing
225 static Events_ID anID = Events_Loop::eventByName("SketchPrepared");
226 std::shared_ptr<Events_Message> aMsg(new Events_Message(anID, this));
227 Events_Loop::loop()->send(aMsg, false);
231 void Events_Loop::eraseMessages(const Events_ID& theID)
233 std::map<char*, std::shared_ptr<Events_Message> >::iterator aMyGroup =
234 myGroups.find(theID.eventText());
235 if (aMyGroup != myGroups.end()) {
236 myGroups.erase(aMyGroup);
241 bool Events_Loop::activateFlushes(const bool theActivate)
243 bool isActive = myFlushActive;
244 myFlushActive = theActivate;
248 void Events_Loop::clear(const Events_ID& theID)
250 std::map<char*, std::shared_ptr<Events_Message>>::iterator aMyGroup =
251 myGroups.find(theID.eventText());
252 if (aMyGroup != myGroups.end()) { // really sends
253 myGroups.erase(aMyGroup);
257 bool Events_Loop::isFlushed(const Events_ID& theID)
259 return myFlushed.find(theID.myID) != myFlushed.end();
262 void Events_Loop::setFlushed(const Events_ID& theID, const bool theValue)
265 myFlushed.insert(theID.myID);
267 myFlushed.erase(myFlushed.find(theID.myID));
270 bool Events_Loop::hasGrouppedEvent(const Events_ID& theID)
272 return myGroups.find(theID.myID) != myGroups.end();