Salome HOME
75cb32ee044bc5eb327ba56372f7ce2dff19de79
[modules/shaper.git] / src / Model / Model_Session.cpp
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
2
3 // File:        Model_Session.cxx
4 // Created:     20 Mar 2014
5 // Author:      Mikhail PONIKAROV
6
7 #include <Model_Session.h>
8 #include <ModelAPI_Feature.h>
9 #include <ModelAPI_Plugin.h>
10 #include <Model_Data.h>
11 #include <Model_Document.h>
12 #include <Model_Objects.h>
13 #include <Model_Application.h>
14 #include <Model_Events.h>
15 #include <Model_Validator.h>
16 #include <ModelAPI_Events.h>
17 #include <Events_Loop.h>
18 #include <Events_InfoMessage.h>
19 #include <Config_FeatureMessage.h>
20 #include <Config_AttributeMessage.h>
21 #include <Config_ValidatorMessage.h>
22 #include <Config_ModuleReader.h>
23 #include <Config_ValidatorReader.h>
24 #include <ModelAPI_ResultPart.h>
25 #include <ModelAPI_Tools.h>
26
27 #include <TDF_CopyTool.hxx>
28 #include <TDF_DataSet.hxx>
29 #include <TDF_RelocationTable.hxx>
30 #include <TDF_ClosureTool.hxx>
31
32 using namespace std;
33
34 static Model_Session* myImpl = new Model_Session();
35
36 // t oredirect all calls to the root document
37 #define ROOT_DOC std::dynamic_pointer_cast<Model_Document>(moduleDocument())
38
39 bool Model_Session::load(const char* theFileName)
40 {
41   bool aRes = ROOT_DOC->load(theFileName, "root", ROOT_DOC);
42   return aRes;
43 }
44
45 bool Model_Session::save(const char* theFileName, std::list<std::string>& theResults)
46 {
47   return ROOT_DOC->save(theFileName, "root", theResults);
48 }
49
50 void Model_Session::closeAll()
51 {
52   Model_Application::getApplication()->deleteAllDocuments();
53 }
54
55 void Model_Session::startOperation(const std::string& theId, const bool theAttachedToNested)
56 {
57   myOperationAttachedToNext = theAttachedToNested;
58   ROOT_DOC->startOperation();
59   ROOT_DOC->operationId(theId);
60   static std::shared_ptr<Events_Message> aStartedMsg
61     (new Events_Message(Events_Loop::eventByName("StartOperation")));
62   Events_Loop::loop()->send(aStartedMsg);
63   // remove all useless documents that has been closed: on start of operation undo/redo is cleared
64   // MPV: this code is dangerous now because it may close the document that is activated right now
65   // but not in the list of the opened documents yet (create, delete, undo, activate Part)
66   // later this must be updated by correct usage of uniques IDs of documents, not names of results
67   //std::list<std::shared_ptr<ModelAPI_Document> > aUsedDocs = allOpenedDocuments();
68   //Model_Application::getApplication()->removeUselessDocuments(aUsedDocs);
69 }
70
71 void Model_Session::finishOperation()
72 {
73   setCheckTransactions(false);
74   ROOT_DOC->finishOperation();
75   if (myOperationAttachedToNext) { // twice, with nested
76     ROOT_DOC->finishOperation();
77     myOperationAttachedToNext = false;
78   }
79   setCheckTransactions(true);
80 }
81
82 void Model_Session::abortOperation()
83 {
84   setCheckTransactions(false);
85   ROOT_DOC->abortOperation();
86   if (myOperationAttachedToNext) { // twice, with nested
87     ROOT_DOC->abortOperation();
88     myOperationAttachedToNext = false;
89   }
90   setCheckTransactions(true);
91   // here the update mechanism may work after abort, so, supress the warnings about
92   // modifications outside of the transactions
93   bool aWasCheck = myCheckTransactions;
94   myCheckTransactions = false;
95   static std::shared_ptr<Events_Message> anAbortMsg
96     (new Events_Message(Events_Loop::eventByName("AbortOperation")));
97   Events_Loop::loop()->send(anAbortMsg);
98   myCheckTransactions = true;
99   myCheckTransactions = aWasCheck;
100 }
101
102 bool Model_Session::isOperation()
103 {
104   return ROOT_DOC->isOperation();
105 }
106
107 bool Model_Session::isModified()
108 {
109   return ROOT_DOC->isModified();
110 }
111
112 bool Model_Session::canUndo()
113 {
114   return ROOT_DOC->canUndo();
115 }
116
117 void Model_Session::undo()
118 {
119   setCheckTransactions(false);
120   ROOT_DOC->undo();
121   setCheckTransactions(true);
122 }
123
124 bool Model_Session::canRedo()
125 {
126   return ROOT_DOC->canRedo();
127 }
128
129 void Model_Session::redo()
130 {
131   setCheckTransactions(false);
132   ROOT_DOC->redo();
133   setCheckTransactions(true);
134 }
135
136 //! Returns stack of performed operations
137 std::list<std::string> Model_Session::undoList()
138 {
139   return ROOT_DOC->undoList();
140 }
141 //! Returns stack of rolled back operations
142 std::list<std::string> Model_Session::redoList()
143 {
144   return ROOT_DOC->redoList();
145 }
146
147 FeaturePtr Model_Session::createFeature(string theFeatureID, Model_Document* theDocOwner)
148 {
149   if (this != myImpl) {
150     return myImpl->createFeature(theFeatureID, theDocOwner);
151   }
152
153   // load all information about plugins, features and attributes
154   LoadPluginsInfo();
155
156   if (myPlugins.find(theFeatureID) != myPlugins.end()) {
157     std::pair<std::string, std::string>& aPlugin = myPlugins[theFeatureID]; // plugin and doc kind
158     if (!aPlugin.second.empty() && aPlugin.second != theDocOwner->kind()) {
159       Events_InfoMessage("Model_Session",
160           "Feature '%1' can be created only in document '%2' by the XML definition")
161           .arg(theFeatureID).arg(aPlugin.second).send();
162       return FeaturePtr();
163     }
164     myCurrentPluginName = aPlugin.first;
165     if (myPluginObjs.find(myCurrentPluginName) == myPluginObjs.end()) {
166       // load plugin library if not yet done
167       Config_ModuleReader::loadPlugin(myCurrentPluginName);
168     }
169     if (myPluginObjs.find(myCurrentPluginName) != myPluginObjs.end()) {
170       FeaturePtr aCreated = myPluginObjs[myCurrentPluginName]->createFeature(theFeatureID);
171       if (!aCreated) {
172         Events_InfoMessage("Model_Session",
173             "Can not initialize feature '%1' in plugin '%2'")
174             .arg(theFeatureID).arg(myCurrentPluginName).send();
175       }
176       return aCreated;
177     } else {
178       Events_InfoMessage("Model_Session",
179         "Can not load plugin '%1'").arg(myCurrentPluginName).send();
180     }
181   } else {
182     Events_InfoMessage("Model_Session",
183       "Feature '%1' not found in any plugin").arg(theFeatureID).send();
184   }
185
186   return FeaturePtr();  // return nothing
187 }
188
189 std::shared_ptr<ModelAPI_Document> Model_Session::moduleDocument()
190 {
191   Handle(Model_Application) anApp = Model_Application::getApplication();
192   bool aFirstCall = !anApp->hasRoot();
193   if (aFirstCall) {
194     // to be sure that plugins are loaded,
195     // even before the first "createFeature" call (in unit tests)
196     LoadPluginsInfo();
197     // creation of the root document is always outside of the transaction, so, avoid checking it
198     setCheckTransactions(false);
199     anApp->createDocument(0); // 0 is a root ID
200     // creation of the root document is always outside of the transaction, so, avoid checking it
201     setCheckTransactions(true);
202   }
203   return anApp->rootDocument();
204 }
205
206 std::shared_ptr<ModelAPI_Document> Model_Session::document(int theDocID)
207 {
208   return std::shared_ptr<ModelAPI_Document>(
209       Model_Application::getApplication()->document(theDocID));
210 }
211
212 bool Model_Session::hasModuleDocument()
213 {
214   return Model_Application::getApplication()->hasRoot();
215 }
216
217 std::shared_ptr<ModelAPI_Document> Model_Session::activeDocument()
218 {
219   if (!myCurrentDoc || !Model_Application::getApplication()->hasDocument(myCurrentDoc->id()))
220     myCurrentDoc = moduleDocument();
221   return myCurrentDoc;
222 }
223
224 /// makes the last feature in the document as the current
225 static void makeCurrentLast(std::shared_ptr<ModelAPI_Document> theDoc) {
226   if (theDoc.get()) {
227     FeaturePtr aLast = std::dynamic_pointer_cast<Model_Document>(theDoc)->lastFeature();
228     // if last is nested into something else, make this something else as last:
229     // otherwise it will look like edition of sub-element, so, the main will be disabled
230     if (aLast.get()) {
231       CompositeFeaturePtr aMain = ModelAPI_Tools::compositeOwner(aLast);
232       while(aMain.get()) {
233         aLast = aMain;
234         aMain = ModelAPI_Tools::compositeOwner(aLast);
235       }
236     }
237     theDoc->setCurrentFeature(aLast, false);
238   }
239 }
240
241 void Model_Session::setActiveDocument(
242   std::shared_ptr<ModelAPI_Document> theDoc, bool theSendSignal)
243 {
244   if (myCurrentDoc != theDoc) {
245     if (myCurrentDoc.get())
246       myCurrentDoc->setActive(false);
247     if (theDoc.get())
248       theDoc->setActive(true);
249
250     std::shared_ptr<ModelAPI_Document> aPrevious = myCurrentDoc;
251     myCurrentDoc = theDoc;
252     if (theDoc.get() && theSendSignal) {
253       // this must be before the synchronisation call because features in PartSet lower than this
254       // part feature must be disabled and don't recomputed anymore (issue 1156,
255       // translation feature is failed on activation of Part 2)
256       if (isOperation()) { // do it only in transaction, not on opening of document
257         DocumentPtr aRoot = moduleDocument();
258         if (myCurrentDoc != aRoot) {
259           FeaturePtr aPartFeat = ModelAPI_Tools::findPartFeature(aRoot, myCurrentDoc);
260           if (aPartFeat.get()) {
261             aRoot->setCurrentFeature(aPartFeat, false);
262           }
263         }
264       }
265       // syncronize the document: it may be just opened or opened but removed before
266       std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(theDoc);
267       if (aDoc.get()) {
268         bool aWasChecked = myCheckTransactions;
269         setCheckTransactions(false);
270         TDF_LabelList anEmptyUpdated;
271         aDoc->objects()->synchronizeFeatures(anEmptyUpdated, true, true, true);
272         if (aWasChecked)
273             setCheckTransactions(true);
274       }
275       static std::shared_ptr<Events_Message> aMsg(
276           new Events_Message(Events_Loop::eventByName(EVENT_DOCUMENT_CHANGED)));
277       Events_Loop::loop()->send(aMsg);
278     }
279     // make the current state correct and synchronised in the module and sub-documents
280     if (isOperation()) { // do it only in transaction, not on opening of document
281       if (myCurrentDoc == moduleDocument()) {
282         // make the current feature the latest in root, in previous root current become also last
283         makeCurrentLast(aPrevious);
284         makeCurrentLast(myCurrentDoc);
285       } else {
286         // make the current feature the latest in sub, root current feature becomes this sub
287         makeCurrentLast(myCurrentDoc);
288       }
289     }
290   }
291 }
292
293 std::list<std::shared_ptr<ModelAPI_Document> > Model_Session::allOpenedDocuments()
294 {
295   list<std::shared_ptr<ModelAPI_Document> > aResult;
296   aResult.push_back(moduleDocument());
297   // add subs recursively
298   list<std::shared_ptr<ModelAPI_Document> >::iterator aDoc = aResult.begin();
299   for(; aDoc != aResult.end(); aDoc++) {
300     DocumentPtr anAPIDoc = *aDoc;
301     std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(anAPIDoc);
302     if (aDoc) {
303       const std::set<int> aSubs = aDoc->subDocuments();
304       std::set<int>::const_iterator aSubIter = aSubs.cbegin();
305       for(; aSubIter != aSubs.cend(); aSubIter++) {
306         aResult.push_back(Model_Application::getApplication()->document(*aSubIter));
307       }
308     }
309   }
310   return aResult;
311 }
312
313 bool Model_Session::isLoadByDemand(const std::string theDocID)
314 {
315   return Model_Application::getApplication()->isLoadByDemand(theDocID);
316 }
317
318 std::shared_ptr<ModelAPI_Document> Model_Session::copy(
319     std::shared_ptr<ModelAPI_Document> theSource, const int theDestID)
320 {
321   std::shared_ptr<Model_Document> aNew = Model_Application::getApplication()->document(theDestID);
322   // make a copy of all labels
323   TDF_Label aSourceRoot = std::dynamic_pointer_cast<Model_Document>(theSource)->document()->Main()
324       .Father();
325   TDF_Label aTargetRoot = aNew->document()->Main().Father();
326   Handle(TDF_DataSet) aDS = new TDF_DataSet;
327   aDS->AddLabel(aSourceRoot);
328   TDF_ClosureTool::Closure(aDS);
329   Handle(TDF_RelocationTable) aRT = new TDF_RelocationTable;
330   aRT->SetRelocation(aSourceRoot, aTargetRoot);
331   TDF_CopyTool::Copy(aDS, aRT);
332
333   TDF_LabelList anEmptyUpdated;
334   aNew->objects()->synchronizeFeatures(anEmptyUpdated, true, true, true);
335   return aNew;
336 }
337
338 Model_Session::Model_Session()
339 {
340   myPluginsInfoLoaded = false;
341   myCheckTransactions = true;
342   myOperationAttachedToNext = false;
343   ModelAPI_Session::setSession(std::shared_ptr<ModelAPI_Session>(this));
344   // register the configuration reading listener
345   Events_Loop* aLoop = Events_Loop::loop();
346   static const Events_ID kFeatureEvent =
347     Events_Loop::eventByName(Config_FeatureMessage::MODEL_EVENT());
348   aLoop->registerListener(this, kFeatureEvent);
349   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_CREATED), 0, true);
350   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_UPDATED), 0, true);
351   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_DELETED), 0, true);
352   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_VALIDATOR_LOADED));
353 }
354
355 void Model_Session::processEvent(const std::shared_ptr<Events_Message>& theMessage)
356 {
357   static const Events_ID kFeatureEvent =
358     Events_Loop::eventByName(Config_FeatureMessage::MODEL_EVENT());
359   static const Events_ID kValidatorEvent = Events_Loop::eventByName(EVENT_VALIDATOR_LOADED);
360   if (theMessage->eventID() == kFeatureEvent) {
361     const std::shared_ptr<Config_FeatureMessage> aMsg =
362       std::dynamic_pointer_cast<Config_FeatureMessage>(theMessage);
363     if (aMsg) {
364
365       // process the plugin info, load plugin
366       if (myPlugins.find(aMsg->id()) == myPlugins.end()) {
367         myPlugins[aMsg->id()] = std::pair<std::string, std::string>(
368           aMsg->pluginLibrary(), aMsg->documentKind());
369       }
370     } else {
371       const std::shared_ptr<Config_AttributeMessage> aMsgAttr =
372         std::dynamic_pointer_cast<Config_AttributeMessage>(theMessage);
373       if (aMsgAttr) {
374
375         if (!aMsgAttr->isObligatory()) {
376           validators()->registerNotObligatory(aMsgAttr->featureId(), aMsgAttr->attributeId());
377         }
378         if(aMsgAttr->isConcealment()) {
379           validators()->registerConcealment(aMsgAttr->featureId(), aMsgAttr->attributeId());
380         }
381         const std::list<std::pair<std::string, std::string> >& aCases = aMsgAttr->getCases();
382         if (!aCases.empty()) {
383           validators()->registerCase(aMsgAttr->featureId(), aMsgAttr->attributeId(), aCases);
384         }
385       }
386     }
387     // plugins information was started to load, so, it will be loaded
388     myPluginsInfoLoaded = true;
389   } else if (theMessage->eventID() == kValidatorEvent) {
390     std::shared_ptr<Config_ValidatorMessage> aMsg =
391       std::dynamic_pointer_cast<Config_ValidatorMessage>(theMessage);
392     if (aMsg) {
393       if (aMsg->attributeId().empty()) {  // feature validator
394         validators()->assignValidator(aMsg->validatorId(), aMsg->featureId(), aMsg->parameters());
395       } else {  // attribute validator
396         validators()->assignValidator(aMsg->validatorId(), aMsg->featureId(), aMsg->attributeId(),
397                                       aMsg->parameters());
398       }
399     }
400   } else {  // create/update/delete
401     if (myCheckTransactions && !isOperation())
402       Events_InfoMessage("Model_Session",
403         "Modification of data structure outside of the transaction").send();
404     // if part is deleted, make the root as the current document (on undo of Parts creations)
405     static const Events_ID kDeletedEvent = Events_Loop::eventByName(EVENT_OBJECT_DELETED);
406     if (theMessage->eventID() == kDeletedEvent) {
407       std::shared_ptr<ModelAPI_ObjectDeletedMessage> aDeleted =
408         std::dynamic_pointer_cast<ModelAPI_ObjectDeletedMessage>(theMessage);
409       if (aDeleted &&
410           aDeleted->groups().find(ModelAPI_ResultPart::group()) != aDeleted->groups().end())
411       {
412          // check that the current feature of the session is still the active Part (even disabled)
413         bool aFound = false;
414         FeaturePtr aCurrentPart = moduleDocument()->currentFeature(true);
415         if (aCurrentPart.get()) {
416           const std::list<std::shared_ptr<ModelAPI_Result> >& aResList = aCurrentPart->results();
417           std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResList.begin();
418           for(; !aFound && aRes != aResList.end(); aRes++) {
419             ResultPartPtr aPRes = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aRes);
420             if (aPRes.get() && aPRes->isActivated() && aPRes->partDoc() == activeDocument()) {
421               aFound = true;
422
423             }
424           }
425         }
426         if (!aFound) { // if not, the part was removed, so activate the module document
427           setActiveDocument(moduleDocument());
428         }
429       }
430     }
431   }
432 }
433
434 void Model_Session::LoadPluginsInfo()
435 {
436   if (myPluginsInfoLoaded)  // nothing to do
437     return;
438
439   // Read plugins information from XML files
440   Config_ModuleReader aModuleReader(Config_FeatureMessage::MODEL_EVENT());
441   aModuleReader.readAll();
442   std::set<std::string> aFiles = aModuleReader.modulePluginFiles();
443   std::set<std::string>::iterator it = aFiles.begin();
444   for ( ; it != aFiles.end(); it++ ) {
445     Config_ValidatorReader aValidatorReader (*it);
446     aValidatorReader.readAll();
447   };
448
449 }
450
451 void Model_Session::registerPlugin(ModelAPI_Plugin* thePlugin)
452 {
453   myPluginObjs[myCurrentPluginName] = thePlugin;
454   static Events_ID EVENT_LOAD = Events_Loop::loop()->eventByName(EVENT_PLUGIN_LOADED);
455   ModelAPI_EventCreator::get()->sendUpdated(ObjectPtr(), EVENT_LOAD);
456   Events_Loop::loop()->flush(EVENT_LOAD);
457   // If the plugin has an ability to process GUI events, register it
458   Events_Listener* aListener = dynamic_cast<Events_Listener*>(thePlugin);
459   if (aListener) {
460     Events_Loop* aLoop = Events_Loop::loop();
461     static Events_ID aStateRequestEventId =
462         Events_Loop::loop()->eventByName(EVENT_FEATURE_STATE_REQUEST);
463     aLoop->registerListener(aListener, aStateRequestEventId);
464   }
465 }
466
467 ModelAPI_ValidatorsFactory* Model_Session::validators()
468 {
469   static Model_ValidatorsFactory* aFactory = new Model_ValidatorsFactory;
470   return aFactory;
471 }
472
473 int Model_Session::transactionID()
474 {
475   return ROOT_DOC->transactionID();
476 }