X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FEvents%2FEvents_Loop.cpp;h=ca8fb331cfb59a58606d39ce50321bdadf2fd050;hb=77ce6d35ac8d2f0fdaecb4f23e0870bf74e36103;hp=3ab9a1cafe5e1e7450e89be8ebbb278ef40eec9e;hpb=f1cd93fd02a54259f72e3191d037323a496b2bef;p=modules%2Fshaper.git diff --git a/src/Events/Events_Loop.cpp b/src/Events/Events_Loop.cpp index 3ab9a1caf..ca8fb331c 100644 --- a/src/Events/Events_Loop.cpp +++ b/src/Events/Events_Loop.cpp @@ -1,8 +1,21 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: Events_Loop.hxx -// Created: Thu Mar 13 2014 -// Author: Mikhail PONIKAROV +// Copyright (C) 2014-2024 CEA, EDF +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include #include @@ -10,8 +23,6 @@ #include #include -using namespace std; - Events_Loop* Events_Loop::loop() { // initialized on initialization of the application @@ -22,10 +33,10 @@ Events_Loop* Events_Loop::loop() Events_ID Events_Loop::eventByName(const char* theName) { ///! All events created in this session, uniquely identified by the text and char pointer - static map CREATED_EVENTS; + static std::map CREATED_EVENTS; char* aResult; - string aName(theName); - map::iterator aFound = CREATED_EVENTS.find(aName); + std::string aName(theName); + std::map::iterator aFound = CREATED_EVENTS.find(aName); if (aFound == CREATED_EVENTS.end()) { //not created yet #ifdef WIN32 aResult = _strdup(theName); // copy to make unique internal pointer @@ -39,14 +50,28 @@ Events_ID Events_Loop::eventByName(const char* theName) return Events_ID(aResult); } +void Events_Loop::sendProcessEvent(const std::shared_ptr& theMessage, + std::list& theListeners, const bool theFlushedNow) +{ + std::list::iterator aL = theListeners.begin(); + for (; aL != theListeners.end(); aL++) { + if (theFlushedNow && (*aL)->groupMessages()) { + (*aL)->groupWhileFlush(theMessage); + } else { + (*aL)->processEvent(theMessage); + } + } +} + void Events_Loop::send(const std::shared_ptr& theMessage, bool isGroup) { if (myImmediateListeners.find(theMessage->eventID().eventText()) != myImmediateListeners.end()) { myImmediateListeners[theMessage->eventID().eventText()]->processEvent(theMessage); } // if it is grouped message, just accumulate it - if (isGroup && myFlushed.find(theMessage->eventID().myID) == myFlushed.end()) { - std::shared_ptr aGroup = + bool isFlushedNow = myFlushed.find(theMessage->eventID().myID) != myFlushed.end(); + if (isGroup && !isFlushedNow) { + std::shared_ptr aGroup = std::dynamic_pointer_cast(theMessage); if (aGroup) { std::map >::iterator aMyGroup = myGroups.find( @@ -61,25 +86,19 @@ void Events_Loop::send(const std::shared_ptr& theMessage, bool i return; } } - - // TODO: make it in thread and with usage of semaphores - - map > >::iterator aFindID = myListeners.find( - theMessage->eventID().eventText()); + // send + std::map > >::iterator aFindID = + myListeners.find(theMessage->eventID().eventText()); if (aFindID != myListeners.end()) { - map >::iterator aFindSender = aFindID->second.find( + std::map >::iterator aFindSender = aFindID->second.find( theMessage->sender()); if (aFindSender != aFindID->second.end()) { - list& aListeners = aFindSender->second; - for (list::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++) - (*aL)->processEvent(theMessage); + sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup); } if (theMessage->sender()) { // also call for NULL senders registered aFindSender = aFindID->second.find(NULL); if (aFindSender != aFindID->second.end()) { - list& aListeners = aFindSender->second; - for (list::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++) - (*aL)->processEvent(theMessage); + sendProcessEvent(theMessage, aFindSender->second, isFlushedNow && isGroup); } } } @@ -92,31 +111,80 @@ void Events_Loop::registerListener(Events_Listener* theListener, const Events_ID myImmediateListeners[theID.eventText()] = theListener; return; } - map > >::iterator aFindID = myListeners.find( - theID.eventText()); + std::map > >::iterator aFindID = + myListeners.find(theID.eventText()); if (aFindID == myListeners.end()) { // create container associated with ID - myListeners[theID.eventText()] = map >(); + myListeners[theID.eventText()] = std::map >(); aFindID = myListeners.find(theID.eventText()); } - map >::iterator aFindSender = aFindID->second.find(theSender); + std::map >::iterator aFindSender = + aFindID->second.find(theSender); if (aFindSender == aFindID->second.end()) { // create container associated with sender - aFindID->second[theSender] = list(); + aFindID->second[theSender] = std::list(); aFindSender = aFindID->second.find(theSender); } - // check that listener was not registered wit hsuch parameters before - list& aListeners = aFindSender->second; - for (list::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++) + // check that listener was not registered with such parameters before + std::list& aListeners = aFindSender->second; + for (std::list::iterator aL = aListeners.begin(); aL != aListeners.end(); aL++) if (*aL == theListener) return; // avoid duplicates aListeners.push_back(theListener); } +void Events_Loop::removeListener(Events_Listener* theListener) +{ + // remove the listener in myListeners map + std::map > >::const_reverse_iterator + anIt = myListeners.rbegin(); + while(anIt != myListeners.rend()) { + std::map > aLMap = anIt->second; + std::map >::const_reverse_iterator aLIt = aLMap.rbegin(); + while (aLIt != aLMap.rend()) { + std::list aListeners = aLIt->second; + std::list::const_reverse_iterator aLsIt = aListeners.rbegin(); + for (; aLsIt != aListeners.rend(); aLsIt++) { + if (*aLsIt == theListener) { + aListeners.remove(theListener); + aLMap[aLIt->first] = aListeners; + myListeners[anIt->first] = aLMap; + break; + } + } + if (aListeners.empty()) { + aLMap.erase(aLIt->first); + myListeners[anIt->first] = aLMap; + if (aLMap.empty()) + break; // avoid incrementation of the iterator if the container is empty + } + aLIt++; + } + if (anIt->second.empty()) { + myListeners.erase(anIt->first); + if (myListeners.empty()) + break; // avoid incrementation of the iterator if the container is empty + } + anIt++; + } + + // remove the listener in myImmediateListeners map + std::map::const_reverse_iterator anImIt = myImmediateListeners.rbegin(); + while(anImIt != myImmediateListeners.rend()) { + if (anImIt->second == theListener) { + myImmediateListeners.erase(anImIt->first); + if (myImmediateListeners.empty()) + break; // avoid incrementation of the iterator if the container is empty + } + anImIt++; + } +} + void Events_Loop::flush(const Events_ID& theID) { if (!myFlushActive) return; + bool hasEventsToFlush = !myGroups.empty(); std::map >::iterator aMyGroup; for(aMyGroup = myGroups.find(theID.eventText()); aMyGroup != myGroups.end(); aMyGroup = myGroups.find(theID.eventText())) @@ -127,14 +195,57 @@ void Events_Loop::flush(const Events_ID& theID) std::shared_ptr aGroup = aMyGroup->second; myGroups.erase(aMyGroup); send(aGroup, false); - if (!aWasFlushed) - myFlushed.erase(myFlushed.find(theID.myID)); + + if (!aWasFlushed) { + // TODO: Stabilization fix. Check later. + if(myFlushed.find(theID.myID) != myFlushed.end()) { + myFlushed.erase(myFlushed.find(theID.myID)); + } +#ifdef _DEBUG + else { + bool aProblem = true; + } +#endif + } + // send accumulated messages to "groupListeners" + std::map > >::iterator aFindID = + myListeners.find(theID.eventText()); + if (aFindID != myListeners.end()) { + std::map >::iterator aFindSender = + aFindID->second.begin(); + for(; aFindSender != aFindID->second.end(); aFindSender++) { + std::list::iterator aListener = aFindSender->second.begin(); + for(; aListener != aFindSender->second.end(); aListener++) { + if ((*aListener)->groupMessages()) { + (*aListener)->flushGrouped(theID); + } + } + } + } + } + if (hasEventsToFlush && myGroups.empty() && myFlushed.empty()) { + // no more messages left in the queue, so, finalize the sketch processing + static Events_ID anID = Events_Loop::eventByName("SketchPrepared"); + std::shared_ptr aMsg(new Events_Message(anID, this)); + Events_Loop::loop()->send(aMsg, false); + } +} + +void Events_Loop::eraseMessages(const Events_ID& theID) +{ + std::map >::iterator aMyGroup = + myGroups.find(theID.eventText()); + if (aMyGroup != myGroups.end()) { + myGroups.erase(aMyGroup); } } -void Events_Loop::activateFlushes(const bool theActivate) + +bool Events_Loop::activateFlushes(const bool theActivate) { + bool isActive = myFlushActive; myFlushActive = theActivate; + return isActive; } void Events_Loop::clear(const Events_ID& theID) @@ -146,14 +257,6 @@ void Events_Loop::clear(const Events_ID& theID) } } -void Events_Loop::autoFlush(const Events_ID& theID, const bool theAuto) -{ - if (theAuto) - myFlushed.insert(theID.myID); - else - myFlushed.erase(myFlushed.find(theID.myID)); -} - bool Events_Loop::isFlushed(const Events_ID& theID) { return myFlushed.find(theID.myID) != myFlushed.end(); @@ -166,3 +269,8 @@ void Events_Loop::setFlushed(const Events_ID& theID, const bool theValue) else myFlushed.erase(myFlushed.find(theID.myID)); } + +bool Events_Loop::hasGrouppedEvent(const Events_ID& theID) +{ + return myGroups.find(theID.myID) != myGroups.end(); +} \ No newline at end of file