+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
+
// File: Model_Session.cxx
// Created: 20 Mar 2014
// Author: Mikhail PONIKAROV
static Model_Session* myImpl = new Model_Session();
// t oredirect all calls to the root document
-#define ROOT_DOC boost::dynamic_pointer_cast<Model_Document>(moduleDocument())
+#define ROOT_DOC std::dynamic_pointer_cast<Model_Document>(moduleDocument())
bool Model_Session::load(const char* theFileName)
{
void Model_Session::startOperation()
{
ROOT_DOC->startOperation();
- static boost::shared_ptr<Events_Message> aStartedMsg
+ static std::shared_ptr<Events_Message> aStartedMsg
(new Events_Message(Events_Loop::eventByName("StartOperation")));
Events_Loop::loop()->send(aStartedMsg);
+ // remove all useless documents that has been closed: on start of operation undo/redo is cleared
+ std::list<std::shared_ptr<ModelAPI_Document> > aUsedDocs = allOpenedDocuments();
+ Model_Application::getApplication()->removeUselessDocuments(aUsedDocs);
}
void Model_Session::finishOperation()
void Model_Session::abortOperation()
{
ROOT_DOC->abortOperation();
- static boost::shared_ptr<Events_Message> anAbortMsg
+ // 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<Events_Message> anAbortMsg
(new Events_Message(Events_Loop::eventByName("AbortOperation")));
Events_Loop::loop()->send(anAbortMsg);
+ myCheckTransactions = true;
+ myCheckTransactions = aWasCheck;
}
bool Model_Session::isOperation()
FeaturePtr Model_Session::createFeature(string theFeatureID)
{
- if (this != myImpl)
+ if (this != myImpl) {
return myImpl->createFeature(theFeatureID);
+ }
+
+ // load all information about plugins, features and attributes
+ LoadPluginsInfo();
if (myPlugins.find(theFeatureID) != myPlugins.end()) {
std::pair<std::string, std::string>& aPlugin = myPlugins[theFeatureID]; // plugin and doc kind
myCurrentPluginName = aPlugin.first;
if (myPluginObjs.find(myCurrentPluginName) == myPluginObjs.end()) {
// load plugin library if not yet done
- Config_ModuleReader::loadLibrary(myCurrentPluginName);
+ Config_ModuleReader::loadPlugin(myCurrentPluginName);
}
if (myPluginObjs.find(myCurrentPluginName) != myPluginObjs.end()) {
FeaturePtr aCreated = myPluginObjs[myCurrentPluginName]->createFeature(theFeatureID);
return FeaturePtr(); // return nothing
}
-boost::shared_ptr<ModelAPI_Document> Model_Session::moduleDocument()
+std::shared_ptr<ModelAPI_Document> Model_Session::moduleDocument()
{
- return boost::shared_ptr<ModelAPI_Document>(
+ return std::shared_ptr<ModelAPI_Document>(
Model_Application::getApplication()->getDocument("root"));
}
+std::shared_ptr<ModelAPI_Document> Model_Session::document(std::string theDocID)
+{
+ return std::shared_ptr<ModelAPI_Document>(
+ Model_Application::getApplication()->getDocument(theDocID));
+}
+
bool Model_Session::hasModuleDocument()
{
return Model_Application::getApplication()->hasDocument("root");
}
-boost::shared_ptr<ModelAPI_Document> Model_Session::activeDocument()
+std::shared_ptr<ModelAPI_Document> Model_Session::activeDocument()
{
if (!myCurrentDoc || !Model_Application::getApplication()->hasDocument(myCurrentDoc->id()))
myCurrentDoc = moduleDocument();
}
void Model_Session::setActiveDocument(
- boost::shared_ptr<ModelAPI_Document> theDoc, bool theSendSignal)
+ std::shared_ptr<ModelAPI_Document> theDoc, bool theSendSignal)
{
if (myCurrentDoc != theDoc) {
myCurrentDoc = theDoc;
if (theSendSignal) {
- static boost::shared_ptr<Events_Message> aMsg(new Events_Message(Events_Loop::eventByName("CurrentDocumentChanged")));
+ static std::shared_ptr<Events_Message> aMsg(new Events_Message(Events_Loop::eventByName("CurrentDocumentChanged")));
Events_Loop::loop()->send(aMsg);
}
}
}
-std::list<boost::shared_ptr<ModelAPI_Document> > Model_Session::allOpenedDocuments()
+std::list<std::shared_ptr<ModelAPI_Document> > Model_Session::allOpenedDocuments()
{
- list<boost::shared_ptr<ModelAPI_Document> > aResult;
+ list<std::shared_ptr<ModelAPI_Document> > aResult;
aResult.push_back(moduleDocument());
// add subs recursively
- list<boost::shared_ptr<ModelAPI_Document> >::iterator aDoc = aResult.begin();
+ list<std::shared_ptr<ModelAPI_Document> >::iterator aDoc = aResult.begin();
for(; aDoc != aResult.end(); aDoc++) {
DocumentPtr anAPIDoc = *aDoc;
- boost::shared_ptr<Model_Document> aDoc = boost::dynamic_pointer_cast<Model_Document>(anAPIDoc);
+ std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(anAPIDoc);
if (aDoc) {
- std::set<std::string>::const_iterator aSubIter = aDoc->subDocuments().cbegin();
- for(; aSubIter != aDoc->subDocuments().cend(); aSubIter++) {
+ const std::set<std::string> aSubs = aDoc->subDocuments(true);
+ std::set<std::string>::const_iterator aSubIter = aSubs.cbegin();
+ for(; aSubIter != aSubs.cend(); aSubIter++) {
if (!Model_Application::getApplication()->isLoadByDemand(*aSubIter)) {
aResult.push_back(Model_Application::getApplication()->getDocument(*aSubIter));
}
return aResult;
}
-boost::shared_ptr<ModelAPI_Document> Model_Session::copy(
- boost::shared_ptr<ModelAPI_Document> theSource, std::string theID)
+std::shared_ptr<ModelAPI_Document> Model_Session::copy(
+ std::shared_ptr<ModelAPI_Document> theSource, std::string theID)
{
// create a new document
- boost::shared_ptr<Model_Document> aNew = boost::dynamic_pointer_cast<Model_Document>(
+ std::shared_ptr<Model_Document> aNew = std::dynamic_pointer_cast<Model_Document>(
Model_Application::getApplication()->getDocument(theID));
// make a copy of all labels
- TDF_Label aSourceRoot = boost::dynamic_pointer_cast<Model_Document>(theSource)->document()->Main()
+ TDF_Label aSourceRoot = std::dynamic_pointer_cast<Model_Document>(theSource)->document()->Main()
.Father();
TDF_Label aTargetRoot = aNew->document()->Main().Father();
Handle(TDF_DataSet) aDS = new TDF_DataSet;
{
myPluginsInfoLoaded = false;
myCheckTransactions = true;
- ModelAPI_Session::setSession(boost::shared_ptr<ModelAPI_Session>(this));
+ ModelAPI_Session::setSession(std::shared_ptr<ModelAPI_Session>(this));
// register the configuration reading listener
Events_Loop* aLoop = Events_Loop::loop();
static const Events_ID kFeatureEvent = Events_Loop::eventByName(Config_FeatureMessage::MODEL_EVENT());
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));
-
- // load all information about plugins, features and attributes
- LoadPluginsInfo();
}
-void Model_Session::processEvent(const boost::shared_ptr<Events_Message>& theMessage)
+void Model_Session::processEvent(const std::shared_ptr<Events_Message>& theMessage)
{
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 boost::shared_ptr<Config_FeatureMessage> aMsg =
- boost::dynamic_pointer_cast<Config_FeatureMessage>(theMessage);
+ const std::shared_ptr<Config_FeatureMessage> aMsg =
+ std::dynamic_pointer_cast<Config_FeatureMessage>(theMessage);
if (aMsg) {
// proccess the plugin info, load plugin
if (myPlugins.find(aMsg->id()) == myPlugins.end()) {
aMsg->pluginLibrary(), aMsg->documentKind());
}
} else {
- const boost::shared_ptr<Config_AttributeMessage> aMsgAttr =
- boost::dynamic_pointer_cast<Config_AttributeMessage>(theMessage);
+ const std::shared_ptr<Config_AttributeMessage> aMsgAttr =
+ std::dynamic_pointer_cast<Config_AttributeMessage>(theMessage);
if (aMsgAttr) {
if (!aMsgAttr->isObligatory()) {
validators()->registerNotObligatory(aMsgAttr->featureId(), aMsgAttr->attributeId());
// plugins information was started to load, so, it will be loaded
myPluginsInfoLoaded = true;
} else if (theMessage->eventID() == kValidatorEvent) {
- boost::shared_ptr<Config_ValidatorMessage> aMsg =
- boost::dynamic_pointer_cast<Config_ValidatorMessage>(theMessage);
+ std::shared_ptr<Config_ValidatorMessage> aMsg =
+ std::dynamic_pointer_cast<Config_ValidatorMessage>(theMessage);
if (aMsg) {
if (aMsg->attributeId().empty()) { // feature validator
validators()->assignValidator(aMsg->validatorId(), aMsg->featureId(), aMsg->parameters());
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<Events_Listener*>(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()
