1 // File: Model_Document.cxx
2 // Created: 28 Feb 2014
3 // Author: Mikhail PONIKAROV
5 #include <Model_Document.h>
6 #include <ModelAPI_Feature.h>
7 #include <Model_Data.h>
8 #include <Model_Application.h>
9 #include <Model_PluginManager.h>
10 #include <Model_Events.h>
11 #include <Events_Loop.h>
12 #include <Events_Error.h>
14 #include <TDataStd_Integer.hxx>
15 #include <TDataStd_Comment.hxx>
16 #include <TDF_ChildIDIterator.hxx>
17 #include <TDataStd_ReferenceArray.hxx>
18 #include <TDataStd_HLabelArray1.hxx>
23 # define _separator_ '\\'
25 # define _separator_ '/'
28 static const int UNDO_LIMIT = 10; // number of possible undo operations
30 static const int TAG_GENERAL = 1; // general properties tag
31 static const int TAG_OBJECTS = 2; // tag of the objects sub-tree (features)
32 static const int TAG_HISTORY = 3; // tag of the history sub-tree (python dump)
36 /// Returns the file name of this document by the nameof directory and identifuer of a document
37 static TCollection_ExtendedString DocFileName(const char* theFileName, const string& theID)
39 TCollection_ExtendedString aPath ((const Standard_CString)theFileName);
41 aPath += theID.c_str();
42 aPath += ".cbf"; // standard binary file extension
46 bool Model_Document::load(const char* theFileName)
48 Handle(Model_Application) anApp = Model_Application::getApplication();
49 if (this == Model_PluginManager::get()->rootDocument().get()) {
50 anApp->setLoadPath(theFileName);
52 TCollection_ExtendedString aPath (DocFileName(theFileName, myID));
53 PCDM_ReaderStatus aStatus = (PCDM_ReaderStatus) -1;
56 aStatus = anApp->Open(aPath, myDoc);
58 catch (Standard_Failure)
60 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
61 Events_Error::send(string("Exception in opening of document: ") + aFail->GetMessageString());
64 bool isError = aStatus != PCDM_RS_OK;
69 case PCDM_RS_UnknownDocument:
70 Events_Error::send(string("Can not open document: PCDM_RS_UnknownDocument")); break;
71 case PCDM_RS_AlreadyRetrieved:
72 Events_Error::send(string("Can not open document: PCDM_RS_AlreadyRetrieved")); break;
73 case PCDM_RS_AlreadyRetrievedAndModified:
74 Events_Error::send(string("Can not open document: PCDM_RS_AlreadyRetrievedAndModified")); break;
75 case PCDM_RS_NoDriver:
76 Events_Error::send(string("Can not open document: PCDM_RS_NoDriver")); break;
77 case PCDM_RS_UnknownFileDriver:
78 Events_Error::send(string("Can not open document: PCDM_RS_UnknownFileDriver")); break;
79 case PCDM_RS_OpenError:
80 Events_Error::send(string("Can not open document: PCDM_RS_OpenError")); break;
81 case PCDM_RS_NoVersion:
82 Events_Error::send(string("Can not open document: PCDM_RS_NoVersion")); break;
84 Events_Error::send(string("Can not open document: PCDM_RS_NoModel")); break;
85 case PCDM_RS_NoDocument:
86 Events_Error::send(string("Can not open document: PCDM_RS_NoDocument")); break;
87 case PCDM_RS_FormatFailure:
88 Events_Error::send(string("Can not open document: PCDM_RS_FormatFailure")); break;
89 case PCDM_RS_TypeNotFoundInSchema:
90 Events_Error::send(string("Can not open document: PCDM_RS_TypeNotFoundInSchema")); break;
91 case PCDM_RS_UnrecognizedFileFormat:
92 Events_Error::send(string("Can not open document: PCDM_RS_UnrecognizedFileFormat")); break;
93 case PCDM_RS_MakeFailure:
94 Events_Error::send(string("Can not open document: PCDM_RS_MakeFailure")); break;
95 case PCDM_RS_PermissionDenied:
96 Events_Error::send(string("Can not open document: PCDM_RS_PermissionDenied")); break;
97 case PCDM_RS_DriverFailure:
98 Events_Error::send(string("Can not open document: PCDM_RS_DriverFailure")); break;
100 Events_Error::send(string("Can not open document: unknown error")); break;
104 myDoc->SetUndoLimit(UNDO_LIMIT);
105 synchronizeFeatures();
110 bool Model_Document::save(const char* theFileName)
112 // create a directory in the root document if it is not yet exist
113 if (this == Model_PluginManager::get()->rootDocument().get()) {
115 CreateDirectory(theFileName, NULL);
117 mkdir(theFileName, 0x1ff);
120 // filename in the dir is id of document inside of the given directory
121 TCollection_ExtendedString aPath(DocFileName(theFileName, myID));
122 PCDM_StoreStatus aStatus;
124 aStatus = Model_Application::getApplication()->SaveAs(myDoc, aPath);
126 catch (Standard_Failure) {
127 Handle(Standard_Failure) aFail = Standard_Failure::Caught();
128 Events_Error::send(string("Exception in saving of document: ") + aFail->GetMessageString());
131 bool isDone = aStatus == PCDM_SS_OK || aStatus == PCDM_SS_No_Obj;
136 case PCDM_SS_DriverFailure:
137 Events_Error::send(string("Can not save document: PCDM_SS_DriverFailure"));
139 case PCDM_SS_WriteFailure:
140 Events_Error::send(string("Can not save document: PCDM_SS_WriteFailure"));
142 case PCDM_SS_Failure:
144 Events_Error::send(string("Can not save document: PCDM_SS_Failure"));
148 myTransactionsAfterSave = 0;
149 if (isDone) { // save also sub-documents if any
150 set<string>::iterator aSubIter = mySubs.begin();
151 for(; aSubIter != mySubs.end() && isDone; aSubIter++)
152 isDone = subDocument(*aSubIter)->save(theFileName);
157 void Model_Document::close()
160 set<string>::iterator aSubIter = mySubs.begin();
161 for(; aSubIter != mySubs.end(); aSubIter++)
162 subDocument(*aSubIter)->close();
166 Model_Application::getApplication()->deleteDocument(myID);
169 void Model_Document::startOperation()
171 // check is it nested or not
172 if (myDoc->HasOpenCommand()) {
173 myNestedStart = myTransactionsAfterSave;
175 // new command for this
177 // new command for all subs
178 set<string>::iterator aSubIter = mySubs.begin();
179 for(; aSubIter != mySubs.end(); aSubIter++)
180 subDocument(*aSubIter)->startOperation();
183 void Model_Document::finishOperation()
185 if (myNestedStart > myTransactionsAfterSave) // this nested transaction is owervritten
187 // returns false if delta is empty and no transaction was made
188 myIsEmptyTr[myTransactionsAfterSave] = !myDoc->CommitCommand();
189 myTransactionsAfterSave++;
190 // finish for all subs
191 set<string>::iterator aSubIter = mySubs.begin();
192 for(; aSubIter != mySubs.end(); aSubIter++)
193 subDocument(*aSubIter)->finishOperation();
196 void Model_Document::abortOperation()
198 myDoc->AbortCommand();
199 synchronizeFeatures();
200 // abort for all subs
201 set<string>::iterator aSubIter = mySubs.begin();
202 for(; aSubIter != mySubs.end(); aSubIter++)
203 subDocument(*aSubIter)->abortOperation();
206 bool Model_Document::isOperation()
208 // operation is opened for all documents: no need to check subs
209 return myDoc->HasOpenCommand() == Standard_True ;
212 bool Model_Document::isModified()
214 // is modified if at least one operation was commited and not undoed
215 return myTransactionsAfterSave > 0;
218 bool Model_Document::canUndo()
220 if (myDoc->GetAvailableUndos() > 0 && myNestedStart != myTransactionsAfterSave)
222 // check other subs contains operation that can be undoed
223 set<string>::iterator aSubIter = mySubs.begin();
224 for(; aSubIter != mySubs.end(); aSubIter++)
225 if (subDocument(*aSubIter)->canUndo())
230 void Model_Document::undo()
232 myTransactionsAfterSave--;
233 if (!myIsEmptyTr[myTransactionsAfterSave])
235 synchronizeFeatures();
237 set<string>::iterator aSubIter = mySubs.begin();
238 for(; aSubIter != mySubs.end(); aSubIter++)
239 subDocument(*aSubIter)->undo();
242 bool Model_Document::canRedo()
244 if (myDoc->GetAvailableRedos() > 0)
246 // check other subs contains operation that can be redoed
247 set<string>::iterator aSubIter = mySubs.begin();
248 for(; aSubIter != mySubs.end(); aSubIter++)
249 if (subDocument(*aSubIter)->canRedo())
254 void Model_Document::redo()
256 if (!myIsEmptyTr[myTransactionsAfterSave])
258 myTransactionsAfterSave++;
259 synchronizeFeatures();
261 set<string>::iterator aSubIter = mySubs.begin();
262 for(; aSubIter != mySubs.end(); aSubIter++)
263 subDocument(*aSubIter)->redo();
266 boost::shared_ptr<ModelAPI_Feature> Model_Document::addFeature(string theID)
268 boost::shared_ptr<ModelAPI_Feature> aFeature =
269 ModelAPI_PluginManager::get()->createFeature(theID);
271 boost::dynamic_pointer_cast<Model_Document>(aFeature->documentToAdd())->addFeature(aFeature);
273 // TODO: generate error that feature is not created
278 void Model_Document::addFeature(const boost::shared_ptr<ModelAPI_Feature> theFeature)
280 const std::string& aGroup = theFeature->getGroup();
281 TDF_Label aGroupLab = groupLabel(aGroup);
282 TDF_Label anObjLab = aGroupLab.NewChild();
283 boost::shared_ptr<Model_Data> aData(new Model_Data);
284 aData->setFeature(theFeature);
285 aData->setLabel(anObjLab);
286 boost::shared_ptr<ModelAPI_Document> aThis =
287 Model_Application::getApplication()->getDocument(myID);
288 theFeature->setDoc(aThis);
289 theFeature->setData(aData);
290 setUniqueName(theFeature);
291 theFeature->initAttributes();
292 // keep the feature ID to restore document later correctly
293 TDataStd_Comment::Set(anObjLab, theFeature->getKind().c_str());
294 // put index of the feature in the group in the tree
295 TDataStd_Integer::Set(anObjLab, myFeatures[aGroup].size());
296 myFeatures[aGroup].push_back(theFeature);
297 // store feature in the history of features array
298 if (theFeature->isInHistory()) {
299 Handle(TDataStd_ReferenceArray) aRefs;
300 if (!groupLabel(FEATURES_GROUP).FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
301 aRefs = TDataStd_ReferenceArray::Set(groupLabel(FEATURES_GROUP), 0, 0);
302 aRefs->SetValue(0, anObjLab);
303 } else { // extend array by one more element
304 Handle(TDataStd_HLabelArray1) aNewArray =
305 new TDataStd_HLabelArray1(aRefs->Lower(), aRefs->Upper() + 1);
306 for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) {
307 aNewArray->SetValue(a, aRefs->Value(a));
309 aNewArray->SetValue(aRefs->Upper() + 1, anObjLab);
310 aRefs->SetInternalArray(aNewArray);
314 // event: feature is added
315 static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_CREATED);
316 Model_FeatureUpdatedMessage aMsg(theFeature, anEvent);
317 Events_Loop::loop()->send(aMsg);
320 boost::shared_ptr<ModelAPI_Feature> Model_Document::feature(TDF_Label& theLabel)
322 Handle(TDataStd_Integer) aFeatureIndex;
323 if (theLabel.FindAttribute(TDataStd_Integer::GetID(), aFeatureIndex)) {
324 Handle(TDataStd_Comment) aGroupID;
325 if (theLabel.Father().FindAttribute(TDataStd_Comment::GetID(), aGroupID)) {
326 string aGroup = TCollection_AsciiString(aGroupID->Get()).ToCString();
327 return myFeatures[aGroup][aFeatureIndex->Get()];
330 return boost::shared_ptr<ModelAPI_Feature>(); // not found
333 int Model_Document::featureIndex(boost::shared_ptr<ModelAPI_Feature> theFeature)
335 if (theFeature->document().get() != this) {
336 return theFeature->document()->featureIndex(theFeature);
338 boost::shared_ptr<Model_Data> aData =
339 boost::dynamic_pointer_cast<Model_Data>(theFeature->data());
340 Handle(TDataStd_Integer) aFeatureIndex;
341 if (aData->label().FindAttribute(TDataStd_Integer::GetID(), aFeatureIndex)) {
342 return aFeatureIndex->Get();
344 return -1; // not found
347 boost::shared_ptr<ModelAPI_Document> Model_Document::subDocument(string theDocID)
349 // just store sub-document identifier here to manage it later
350 if (mySubs.find(theDocID) == mySubs.end())
351 mySubs.insert(theDocID);
352 return Model_Application::getApplication()->getDocument(theDocID);
355 boost::shared_ptr<ModelAPI_Feature> Model_Document::feature(
356 const string& theGroupID, const int theIndex)
358 if (theGroupID == FEATURES_GROUP) { // history is just a references array
359 Handle(TDataStd_ReferenceArray) aRefs;
360 if (groupLabel(FEATURES_GROUP).FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
361 if (aRefs->Lower() <= theIndex && aRefs->Upper() >= theIndex) {
362 TDF_Label aFeatureLab = aRefs->Value(theIndex);
363 return feature(aFeatureLab);
366 } else { // one of the group
367 map<string, vector<boost::shared_ptr<ModelAPI_Feature> > >::iterator aGroup =
368 myFeatures.find(theGroupID);
369 if (aGroup != myFeatures.end() && (int)(aGroup->second.size()) > theIndex) {
370 return aGroup->second[theIndex];
374 return boost::shared_ptr<ModelAPI_Feature>();
377 int Model_Document::size(const string& theGroupID)
379 if (theGroupID == FEATURES_GROUP) { // history is just a references array
380 Handle(TDataStd_ReferenceArray) aRefs;
381 if (groupLabel(FEATURES_GROUP).FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs))
382 return aRefs->Length();
383 } else { // one of the group
384 map<string, vector<boost::shared_ptr<ModelAPI_Feature> > >::iterator aGroup =
385 myFeatures.find(theGroupID);
386 if (aGroup != myFeatures.end())
387 return aGroup->second.size();
389 // group is not found
393 const vector<string>& Model_Document::getGroups() const
395 return myGroupsNames;
398 Model_Document::Model_Document(const std::string theID)
399 : myID(theID), myDoc(new TDocStd_Document("BinOcaf")) // binary OCAF format
401 myDoc->SetUndoLimit(UNDO_LIMIT);
402 myTransactionsAfterSave = 0;
404 myDoc->SetNestedTransactionMode();
405 // to have something in the document and avoid empty doc open/save problem
406 TDataStd_Integer::Set(myDoc->Main().Father(), 0);
409 TDF_Label Model_Document::groupLabel(const string theGroup)
411 if (myGroups.find(theGroup) == myGroups.end()) {
412 myGroups[theGroup] = myDoc->Main().FindChild(TAG_OBJECTS).NewChild();
413 myGroupsNames.push_back(theGroup);
414 // set to the group label the group idntifier to restore on "open"
415 TDataStd_Comment::Set(myGroups[theGroup], theGroup.c_str());
416 myFeatures[theGroup] = vector<boost::shared_ptr<ModelAPI_Feature> >();
418 return myGroups[theGroup];
421 void Model_Document::setUniqueName(boost::shared_ptr<ModelAPI_Feature> theFeature)
423 // first count all objects of such kind to start with index = count + 1
424 int a, aNumObjects = 0;
425 int aSize = size(theFeature->getGroup());
426 for(a = 0; a < aSize; a++) {
427 if (feature(theFeature->getGroup(), a)->getKind() == theFeature->getKind())
430 // generate candidate name
431 stringstream aNameStream;
432 aNameStream<<theFeature->getKind()<<"_"<<aNumObjects + 1;
433 string aName = aNameStream.str();
434 // check this is unique, if not, increase index by 1
435 for(a = 0; a < aSize;) {
436 if (feature(theFeature->getGroup(), a)->data()->getName() == aName) {
438 stringstream aNameStream;
439 aNameStream<<theFeature->getKind()<<"_"<<aNumObjects + 1;
440 // reinitialize iterator to make sure a new name is unique
445 theFeature->data()->setName(aName);
448 void Model_Document::synchronizeFeatures()
450 boost::shared_ptr<ModelAPI_Document> aThis = Model_Application::getApplication()->getDocument(myID);
451 // iterate groups labels
452 TDF_ChildIDIterator aGroupsIter(myDoc->Main().FindChild(TAG_OBJECTS),
453 TDataStd_Comment::GetID(), Standard_False);
454 vector<string>::iterator aGroupNamesIter = myGroupsNames.begin();
455 for(; aGroupsIter.More() && aGroupNamesIter != myGroupsNames.end();
456 aGroupsIter.Next(), aGroupNamesIter++) {
457 string aGroupName = TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(
458 aGroupsIter.Value())->Get()).ToCString();
459 if (*aGroupNamesIter != aGroupName)
460 break; // all since there is a change this must be recreated from scratch
462 // delete all groups left after the data model groups iteration
463 while(aGroupNamesIter != myGroupsNames.end()) {
464 string aGroupName = *aGroupNamesIter;
465 myFeatures.erase(aGroupName);
466 myGroups.erase(aGroupName);
467 aGroupNamesIter = myGroupsNames.erase(aGroupNamesIter);
468 // say that features were deleted from group
469 Model_FeatureDeletedMessage aMsg(aThis, aGroupName);
470 Events_Loop::loop()->send(aMsg);
472 // create new groups basing on the following data model update
473 for(; aGroupsIter.More(); aGroupsIter.Next()) {
474 string aGroupName = TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(
475 aGroupsIter.Value())->Get()).ToCString();
476 myGroupsNames.push_back(aGroupName);
477 myGroups[aGroupName] = aGroupsIter.Value()->Label();
478 myFeatures[aGroupName] = vector<boost::shared_ptr<ModelAPI_Feature> >();
480 // update features group by group
481 aGroupsIter.Initialize(myDoc->Main().FindChild(TAG_OBJECTS),
482 TDataStd_Comment::GetID(), Standard_False);
483 for(; aGroupsIter.More(); aGroupsIter.Next()) {
484 string aGroupName = TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(
485 aGroupsIter.Value())->Get()).ToCString();
486 // iterate features in internal container
487 vector<boost::shared_ptr<ModelAPI_Feature> >& aFeatures = myFeatures[aGroupName];
488 vector<boost::shared_ptr<ModelAPI_Feature> >::iterator aFIter = aFeatures.begin();
489 // and in parallel iterate labels of features
490 TDF_ChildIDIterator aFLabIter(
491 aGroupsIter.Value()->Label(), TDataStd_Comment::GetID(), Standard_False);
492 while(aFIter != aFeatures.end() || aFLabIter.More()) {
493 static const int INFINITE_TAG = INT_MAX; // no label means that it exists somwhere in infinite
494 int aFeatureTag = INFINITE_TAG;
495 if (aFIter != aFeatures.end()) { // existing tag for feature
496 boost::shared_ptr<Model_Data> aData = boost::dynamic_pointer_cast<Model_Data>((*aFIter)->data());
497 aFeatureTag = aData->label().Tag();
499 int aDSTag = INFINITE_TAG;
500 if (aFLabIter.More()) { // next label in DS is existing
501 aDSTag = aFLabIter.Value()->Label().Tag();
503 if (aDSTag > aFeatureTag) { // feature is removed
504 aFIter = aFeatures.erase(aFIter);
505 // event: model is updated
506 Model_FeatureDeletedMessage aMsg(aThis, aGroupName);
507 Events_Loop::loop()->send(aMsg);
508 } else if (aDSTag < aFeatureTag) { // a new feature is inserted
510 boost::shared_ptr<ModelAPI_Feature> aFeature = ModelAPI_PluginManager::get()->createFeature(
511 TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(
512 aFLabIter.Value())->Get()).ToCString());
514 if (aFIter == aFeatures.end()) { // must be before "setData" to redo the sketch line correctly
515 aFeatures.push_back(aFeature);
516 aFIter = aFeatures.end();
519 aFeatures.insert(aFIter, aFeature);
521 boost::shared_ptr<Model_Data> aData(new Model_Data);
522 TDF_Label aLab = aFLabIter.Value()->Label();
523 aData->setLabel(aLab);
524 aData->setFeature(aFeature);
525 aFeature->setDoc(aThis);
526 aFeature->setData(aData);
527 aFeature->initAttributes();
529 // event: model is updated
530 static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_CREATED);
531 Model_FeatureUpdatedMessage aMsg(aFeature, anEvent);
532 Events_Loop::loop()->send(aMsg);
534 // feature for this label is added, so go to the next label
536 } else { // nothing is changed, both iterators are incremented