Merge branch 'master' of newgeom:newgeom.git into BR_PYTHON_PLUGIN

[modules/shaper.git] / src / Model / Model_Session.cpp

diff --git a/src/Model/Model_Session.cpp b/src/Model/Model_Session.cpp
index 3bc3dee03835ddcda2adbe36cc71b32d77e9b1d1..a42eb204696b7283251aae226a13b145bf6cc8e0 100644 (file)
--- a/src/Model/Model_Session.cpp
+++ b/src/Model/Model_Session.cpp
@@ -21,6 +21,9 @@
 #include <TDF_RelocationTable.hxx>
 #include <TDF_ClosureTool.hxx>
 
+// TEST
+#include <Python.h>
+
 using namespace std;
 
 static Model_Session* myImpl = new Model_Session();
@@ -46,11 +49,17 @@ void Model_Session::startOperation()
 void Model_Session::finishOperation()
 {
   ROOT_DOC->finishOperation();
+  static boost::shared_ptr<Events_Message> aFinishMsg
+    (new Events_Message(Events_Loop::eventByName("FinishOperation")));
+  Events_Loop::loop()->send(aFinishMsg);
 }
 
 void Model_Session::abortOperation()
 {
   ROOT_DOC->abortOperation();
+  static boost::shared_ptr<Events_Message> anAbortMsg
+    (new Events_Message(Events_Loop::eventByName("AbortOperation")));
+  Events_Loop::loop()->send(anAbortMsg);
 }
 
 bool Model_Session::isOperation()
@@ -85,15 +94,30 @@ void Model_Session::redo()
 
 FeaturePtr Model_Session::createFeature(string theFeatureID)
 {
-  if (this != myImpl)
+  if (this != myImpl) {
     return myImpl->createFeature(theFeatureID);
+  }
 
   LoadPluginsInfo();
   if (myPlugins.find(theFeatureID) != myPlugins.end()) {
-    myCurrentPluginName = myPlugins[theFeatureID];
+    std::pair<std::string, std::string>& 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);
+      //TODO: Get info from Config about python libraries
+      if (myCurrentPluginName.compare(string("PythonFeaturesPlugin")) == 0) {
+        Py_Initialize();
+        PyObject* module = PyImport_ImportModule(myCurrentPluginName.c_str());
+        assert(module != NULL);
+      } else {
+        Config_ModuleReader::loadLibrary(myCurrentPluginName);
+      }
     }
     if (myPluginObjs.find(myCurrentPluginName) != myPluginObjs.end()) {
       FeaturePtr aCreated = myPluginObjs[myCurrentPluginName]->createFeature(theFeatureID);
@@ -135,11 +159,32 @@ void Model_Session::setActiveDocument(boost::shared_ptr<ModelAPI_Document> theDo
 {
   if (myCurrentDoc != theDoc) {
     myCurrentDoc = theDoc;
-    static Events_Message aMsg(Events_Loop::eventByName("CurrentDocumentChanged"));
+    static boost::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()
+{
+  list<boost::shared_ptr<ModelAPI_Document> > aResult;
+  aResult.push_back(moduleDocument());
+  // add subs recursively
+  list<boost::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);
+    if (aDoc) {
+      std::set<std::string>::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;
+}
+
 boost::shared_ptr<ModelAPI_Document> Model_Session::copy(
     boost::shared_ptr<ModelAPI_Document> theSource, std::string theID)
 {
@@ -157,7 +202,7 @@ boost::shared_ptr<ModelAPI_Document> Model_Session::copy(
   aRT->SetRelocation(aSourceRoot, aTargetRoot);
   TDF_CopyTool::Copy(aDS, aRT);
 
-  aNew->synchronizeFeatures();
+  aNew->synchronizeFeatures(false, true);
   return aNew;
 }
 
@@ -170,28 +215,31 @@ Model_Session::Model_Session()
   Events_Loop* aLoop = Events_Loop::loop();
   static const Events_ID kFeatureEvent = Events_Loop::eventByName("FeatureRegisterEvent");
   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 boost::shared_ptr<Events_Message>& theMessage)
 {
   static const Events_ID kFeatureEvent = Events_Loop::eventByName("FeatureRegisterEvent");
   static const Events_ID kValidatorEvent = Events_Loop::eventByName(EVENT_VALIDATOR_LOADED);
   if (theMessage->eventID() == kFeatureEvent) {
-    const Config_FeatureMessage* aMsg = dynamic_cast<const Config_FeatureMessage*>(theMessage);
+    const boost::shared_ptr<Config_FeatureMessage> aMsg = 
+      boost::dynamic_pointer_cast<Config_FeatureMessage>(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<std::string, std::string>(
+          aMsg->pluginLibrary(), aMsg->documentKind());
       }
     }
     // plugins information was started to load, so, it will be loaded
     myPluginsInfoLoaded = true;
   } else if (theMessage->eventID() == kValidatorEvent) {
-    const Config_ValidatorMessage* aMsg = dynamic_cast<const Config_ValidatorMessage*>(theMessage);
+    boost::shared_ptr<Config_ValidatorMessage> aMsg = 
+      boost::dynamic_pointer_cast<Config_ValidatorMessage>(theMessage);
     if (aMsg) {
       if (aMsg->attributeId().empty()) {  // feature validator
         validators()->assignValidator(aMsg->validatorId(), aMsg->featureId(), aMsg->parameters());