X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Session.cpp;h=d264be4d34519940d9dd5cda5dbc55886f388248;hb=4cc670477fa518dd1e90c709d28711ffdbc90085;hp=730b6eca2b1d87aef743d0cab7c7e4b1784f3fb0;hpb=daeab27f92af64bc3d0fd5328ce61d1d525c4802;p=modules%2Fshaper.git diff --git a/src/Model/Model_Session.cpp b/src/Model/Model_Session.cpp index 730b6eca2..d264be4d3 100644 --- a/src/Model/Model_Session.cpp +++ b/src/Model/Model_Session.cpp @@ -1,3 +1,5 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D + // File: Model_Session.cxx // Created: 20 Mar 2014 // Author: Mikhail PONIKAROV @@ -13,6 +15,7 @@ #include #include #include +#include #include #include @@ -25,14 +28,99 @@ using namespace std; static Model_Session* myImpl = new Model_Session(); +// t oredirect all calls to the root document +#define ROOT_DOC std::dynamic_pointer_cast(moduleDocument()) + +bool Model_Session::load(const char* theFileName) +{ + return ROOT_DOC->load(theFileName); +} + +bool Model_Session::save(const char* theFileName, std::list& theResults) +{ + return ROOT_DOC->save(theFileName, theResults); +} + +void Model_Session::closeAll() +{ + ROOT_DOC->close(true); + Model_Application::getApplication()->deleteAllDocuments(); +} + +void Model_Session::startOperation() +{ + ROOT_DOC->startOperation(); + static std::shared_ptr aStartedMsg + (new Events_Message(Events_Loop::eventByName("StartOperation"))); + Events_Loop::loop()->send(aStartedMsg); +} + +void Model_Session::finishOperation() +{ + ROOT_DOC->finishOperation(); +} + +void Model_Session::abortOperation() +{ + ROOT_DOC->abortOperation(); + // here the update mechanism may work after abort, so, supress the warnings about + // modifications outside of the transactions + bool aWasCheck = myCheckTransactions; + myCheckTransactions = false; + static std::shared_ptr anAbortMsg + (new Events_Message(Events_Loop::eventByName("AbortOperation"))); + Events_Loop::loop()->send(anAbortMsg); + myCheckTransactions = true; + myCheckTransactions = aWasCheck; +} + +bool Model_Session::isOperation() +{ + return ROOT_DOC->isOperation(); +} + +bool Model_Session::isModified() +{ + return ROOT_DOC->isModified(); +} + +bool Model_Session::canUndo() +{ + return ROOT_DOC->canUndo(); +} + +void Model_Session::undo() +{ + ROOT_DOC->undo(); +} + +bool Model_Session::canRedo() +{ + return ROOT_DOC->canRedo(); +} + +void Model_Session::redo() +{ + ROOT_DOC->redo(); +} + FeaturePtr Model_Session::createFeature(string theFeatureID) { if (this != myImpl) return myImpl->createFeature(theFeatureID); + // load all information about plugins, features and attributes LoadPluginsInfo(); + if (myPlugins.find(theFeatureID) != myPlugins.end()) { - myCurrentPluginName = myPlugins[theFeatureID]; + std::pair& aPlugin = myPlugins[theFeatureID]; // plugin and doc kind + if (!aPlugin.second.empty() && aPlugin.second != activeDocument()->kind()) { + Events_Error::send( + string("Feature '") + theFeatureID + "' can be created only in document '" + + aPlugin.second + "' by the XML definition"); + return FeaturePtr(); + } + myCurrentPluginName = aPlugin.first; if (myPluginObjs.find(myCurrentPluginName) == myPluginObjs.end()) { // load plugin library if not yet done Config_ModuleReader::loadLibrary(myCurrentPluginName); @@ -55,39 +143,71 @@ FeaturePtr Model_Session::createFeature(string theFeatureID) return FeaturePtr(); // return nothing } -boost::shared_ptr Model_Session::rootDocument() +std::shared_ptr Model_Session::moduleDocument() { - return boost::shared_ptr( + return std::shared_ptr( Model_Application::getApplication()->getDocument("root")); } -bool Model_Session::hasRootDocument() +std::shared_ptr Model_Session::document(std::string theDocID) +{ + return std::shared_ptr( + Model_Application::getApplication()->getDocument(theDocID)); +} + +bool Model_Session::hasModuleDocument() { return Model_Application::getApplication()->hasDocument("root"); } -boost::shared_ptr Model_Session::currentDocument() +std::shared_ptr Model_Session::activeDocument() { if (!myCurrentDoc || !Model_Application::getApplication()->hasDocument(myCurrentDoc->id())) - myCurrentDoc = rootDocument(); + myCurrentDoc = moduleDocument(); return myCurrentDoc; } -void Model_Session::setCurrentDocument(boost::shared_ptr theDoc) +void Model_Session::setActiveDocument( + std::shared_ptr theDoc, bool theSendSignal) { - myCurrentDoc = theDoc; - static Events_Message aMsg(Events_Loop::eventByName("CurrentDocumentChanged")); - Events_Loop::loop()->send(aMsg); + if (myCurrentDoc != theDoc) { + myCurrentDoc = theDoc; + if (theSendSignal) { + static std::shared_ptr aMsg(new Events_Message(Events_Loop::eventByName("CurrentDocumentChanged"))); + Events_Loop::loop()->send(aMsg); + } + } } -boost::shared_ptr Model_Session::copy( - boost::shared_ptr theSource, std::string theID) +std::list > Model_Session::allOpenedDocuments() +{ + list > aResult; + aResult.push_back(moduleDocument()); + // add subs recursively + list >::iterator aDoc = aResult.begin(); + for(; aDoc != aResult.end(); aDoc++) { + DocumentPtr anAPIDoc = *aDoc; + std::shared_ptr aDoc = std::dynamic_pointer_cast(anAPIDoc); + if (aDoc) { + std::set::const_iterator aSubIter = aDoc->subDocuments().cbegin(); + for(; aSubIter != aDoc->subDocuments().cend(); aSubIter++) { + if (!Model_Application::getApplication()->isLoadByDemand(*aSubIter)) { + aResult.push_back(Model_Application::getApplication()->getDocument(*aSubIter)); + } + } + } + } + return aResult; +} + +std::shared_ptr Model_Session::copy( + std::shared_ptr theSource, std::string theID) { // create a new document - boost::shared_ptr aNew = boost::dynamic_pointer_cast( + std::shared_ptr aNew = std::dynamic_pointer_cast( Model_Application::getApplication()->getDocument(theID)); // make a copy of all labels - TDF_Label aSourceRoot = boost::dynamic_pointer_cast(theSource)->document()->Main() + TDF_Label aSourceRoot = std::dynamic_pointer_cast(theSource)->document()->Main() .Father(); TDF_Label aTargetRoot = aNew->document()->Main().Father(); Handle(TDF_DataSet) aDS = new TDF_DataSet; @@ -97,7 +217,7 @@ boost::shared_ptr Model_Session::copy( aRT->SetRelocation(aSourceRoot, aTargetRoot); TDF_CopyTool::Copy(aDS, aRT); - aNew->synchronizeFeatures(); + aNew->synchronizeFeatures(false, true); return aNew; } @@ -105,33 +225,48 @@ Model_Session::Model_Session() { myPluginsInfoLoaded = false; myCheckTransactions = true; - ModelAPI_Session::setSession(boost::shared_ptr(this)); + ModelAPI_Session::setSession(std::shared_ptr(this)); // register the configuration reading listener Events_Loop* aLoop = Events_Loop::loop(); - static const Events_ID kFeatureEvent = Events_Loop::eventByName("FeatureRegisterEvent"); + static const Events_ID kFeatureEvent = Events_Loop::eventByName(Config_FeatureMessage::MODEL_EVENT()); aLoop->registerListener(this, kFeatureEvent); - aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_CREATED)); - aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_UPDATED)); - aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_DELETED)); + aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_CREATED), 0, true); + aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_UPDATED), 0, true); + aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_DELETED), 0, true); aLoop->registerListener(this, Events_Loop::eventByName(EVENT_VALIDATOR_LOADED)); } -void Model_Session::processEvent(const Events_Message* theMessage) +void Model_Session::processEvent(const std::shared_ptr& theMessage) { - static const Events_ID kFeatureEvent = Events_Loop::eventByName("FeatureRegisterEvent"); + static const Events_ID kFeatureEvent = Events_Loop::eventByName(Config_FeatureMessage::MODEL_EVENT()); static const Events_ID kValidatorEvent = Events_Loop::eventByName(EVENT_VALIDATOR_LOADED); if (theMessage->eventID() == kFeatureEvent) { - const Config_FeatureMessage* aMsg = dynamic_cast(theMessage); + const std::shared_ptr aMsg = + std::dynamic_pointer_cast(theMessage); if (aMsg) { // proccess the plugin info, load plugin if (myPlugins.find(aMsg->id()) == myPlugins.end()) { - myPlugins[aMsg->id()] = aMsg->pluginLibrary(); + myPlugins[aMsg->id()] = std::pair( + aMsg->pluginLibrary(), aMsg->documentKind()); + } + } else { + const std::shared_ptr aMsgAttr = + std::dynamic_pointer_cast(theMessage); + if (aMsgAttr) { + if (!aMsgAttr->isObligatory()) { + validators()->registerNotObligatory(aMsgAttr->featureId(), aMsgAttr->attributeId()); + } + if(aMsgAttr->isConcealment()) { + validators()->registerConcealment(aMsgAttr->featureId(), aMsgAttr->attributeId()); + } + } } // plugins information was started to load, so, it will be loaded myPluginsInfoLoaded = true; } else if (theMessage->eventID() == kValidatorEvent) { - const Config_ValidatorMessage* aMsg = dynamic_cast(theMessage); + std::shared_ptr aMsg = + std::dynamic_pointer_cast(theMessage); if (aMsg) { if (aMsg->attributeId().empty()) { // feature validator validators()->assignValidator(aMsg->validatorId(), aMsg->featureId(), aMsg->parameters()); @@ -141,7 +276,7 @@ void Model_Session::processEvent(const Events_Message* theMessage) } } } else { // create/update/delete - if (myCheckTransactions && !rootDocument()->isOperation()) + if (myCheckTransactions && !isOperation()) Events_Error::send("Modification of data structure outside of the transaction"); } } @@ -152,7 +287,7 @@ void Model_Session::LoadPluginsInfo() return; // Read plugins information from XML files - Config_ModuleReader aXMLReader("FeatureRegisterEvent"); + Config_ModuleReader aXMLReader(Config_FeatureMessage::MODEL_EVENT()); aXMLReader.readAll(); } @@ -162,6 +297,14 @@ void Model_Session::registerPlugin(ModelAPI_Plugin* thePlugin) static Events_ID EVENT_LOAD = Events_Loop::loop()->eventByName(EVENT_PLUGIN_LOADED); ModelAPI_EventCreator::get()->sendUpdated(ObjectPtr(), EVENT_LOAD); Events_Loop::loop()->flush(EVENT_LOAD); + // If the plugin has an ability to process GUI events, register it + Events_Listener* aListener = dynamic_cast(thePlugin); + if (aListener) { + Events_Loop* aLoop = Events_Loop::loop(); + static Events_ID aStateRequestEventId = + Events_Loop::loop()->eventByName(EVENT_FEATURE_STATE_REQUEST); + aLoop->registerListener(aListener, aStateRequestEventId); + } } ModelAPI_ValidatorsFactory* Model_Session::validators()