src/Model/Model_Document.cpp

   1 // File:        Model_Document.cxx
   2 // Created:     28 Feb 2014
   3 // Author:      Mikhail PONIKAROV
   4
   5 #include <Model_Document.h>
   6 #include <ModelAPI_Feature.h>
   7 #include <Model_Data.h>
   8 #include <Model_Object.h>
   9 #include <Model_Application.h>
  10 #include <Model_PluginManager.h>
  11 #include <Model_Events.h>
  12 #include <Events_Loop.h>
  13 #include <Events_Error.h>
  14
  15 #include <TDataStd_Integer.hxx>
  16 #include <TDataStd_Comment.hxx>
  17 #include <TDF_ChildIDIterator.hxx>
  18 #include <TDataStd_ReferenceArray.hxx>
  19 #include <TDataStd_HLabelArray1.hxx>
  20 #include <TDataStd_Name.hxx>
  21
  22 #include <climits>
  23 #ifndef WIN32
  24 #include <sys/stat.h>
  25 #endif
  26
  27 #ifdef WIN32
  28 # define _separator_ '\\'
  29 #else
  30 # define _separator_ '/'
  31 #endif
  32
  33 static const int UNDO_LIMIT = 10; // number of possible undo operations
  34
  35 static const int TAG_GENERAL = 1; // general properties tag
  36 static const int TAG_OBJECTS = 2; // tag of the objects sub-tree (features)
  37 static const int TAG_HISTORY = 3; // tag of the history sub-tree (python dump)
  38
  39 using namespace std;
  40
  41 /// Returns the file name of this document by the nameof directory and identifuer of a document
  42 static TCollection_ExtendedString DocFileName(const char* theFileName, const string& theID)
  43 {
  44   TCollection_ExtendedString aPath ((const Standard_CString)theFileName);
  45   aPath += _separator_;
  46   aPath += theID.c_str();
  47   aPath += ".cbf"; // standard binary file extension
  48   return aPath;
  49 }
  50
  51 bool Model_Document::load(const char* theFileName)
  52 {
  53   Handle(Model_Application) anApp = Model_Application::getApplication();
  54   if (this == Model_PluginManager::get()->rootDocument().get()) {
  55     anApp->setLoadPath(theFileName);
  56   }
  57   TCollection_ExtendedString aPath (DocFileName(theFileName, myID));
  58   PCDM_ReaderStatus aStatus = (PCDM_ReaderStatus) -1;
  59   try
  60   {
  61     aStatus = anApp->Open(aPath, myDoc);
  62   }
  63   catch (Standard_Failure)
  64   {
  65     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
  66     Events_Error::send(string("Exception in opening of document: ") + aFail->GetMessageString());
  67     return false;
  68   }
  69   bool isError = aStatus != PCDM_RS_OK;
  70   if (isError)
  71   {
  72     switch (aStatus)
  73     {
  74     case PCDM_RS_UnknownDocument:
  75       Events_Error::send(string("Can not open document: PCDM_RS_UnknownDocument")); break;
  76     case PCDM_RS_AlreadyRetrieved:
  77       Events_Error::send(string("Can not open document: PCDM_RS_AlreadyRetrieved")); break;
  78     case PCDM_RS_AlreadyRetrievedAndModified:
  79       Events_Error::send(string("Can not open document: PCDM_RS_AlreadyRetrievedAndModified")); break;
  80     case PCDM_RS_NoDriver:
  81       Events_Error::send(string("Can not open document: PCDM_RS_NoDriver")); break;
  82     case PCDM_RS_UnknownFileDriver:
  83       Events_Error::send(string("Can not open document: PCDM_RS_UnknownFileDriver")); break;
  84     case PCDM_RS_OpenError:
  85       Events_Error::send(string("Can not open document: PCDM_RS_OpenError")); break;
  86     case PCDM_RS_NoVersion:
  87       Events_Error::send(string("Can not open document: PCDM_RS_NoVersion")); break;
  88     case PCDM_RS_NoModel:
  89       Events_Error::send(string("Can not open document: PCDM_RS_NoModel")); break;
  90     case PCDM_RS_NoDocument:
  91       Events_Error::send(string("Can not open document: PCDM_RS_NoDocument")); break;
  92     case PCDM_RS_FormatFailure:
  93       Events_Error::send(string("Can not open document: PCDM_RS_FormatFailure")); break;
  94     case PCDM_RS_TypeNotFoundInSchema:
  95       Events_Error::send(string("Can not open document: PCDM_RS_TypeNotFoundInSchema")); break;
  96     case PCDM_RS_UnrecognizedFileFormat:
  97       Events_Error::send(string("Can not open document: PCDM_RS_UnrecognizedFileFormat")); break;
  98     case PCDM_RS_MakeFailure:
  99       Events_Error::send(string("Can not open document: PCDM_RS_MakeFailure")); break;
 100     case PCDM_RS_PermissionDenied:
 101       Events_Error::send(string("Can not open document: PCDM_RS_PermissionDenied")); break;
 102     case PCDM_RS_DriverFailure:
 103       Events_Error::send(string("Can not open document: PCDM_RS_DriverFailure")); break;
 104     default:
 105       Events_Error::send(string("Can not open document: unknown error")); break;
 106     }
 107   }
 108   if (!isError) {
 109     myDoc->SetUndoLimit(UNDO_LIMIT);
 110     synchronizeFeatures();
 111   }
 112   return !isError;
 113 }
 114
 115 bool Model_Document::save(const char* theFileName)
 116 {
 117   // create a directory in the root document if it is not yet exist
 118   if (this == Model_PluginManager::get()->rootDocument().get()) {
 119 #ifdef WIN32
 120     CreateDirectory(theFileName, NULL);
 121 #else
 122     mkdir(theFileName, 0x1ff);
 123 #endif
 124   }
 125   // filename in the dir is id of document inside of the given directory
 126   TCollection_ExtendedString aPath(DocFileName(theFileName, myID));
 127   PCDM_StoreStatus aStatus;
 128   try {
 129     aStatus = Model_Application::getApplication()->SaveAs(myDoc, aPath);
 130   }
 131   catch (Standard_Failure) {
 132     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 133     Events_Error::send(string("Exception in saving of document: ") + aFail->GetMessageString());
 134     return false;
 135   }
 136   bool isDone = aStatus == PCDM_SS_OK || aStatus == PCDM_SS_No_Obj;
 137   if (!isDone)
 138   {
 139     switch (aStatus)
 140     {
 141     case PCDM_SS_DriverFailure:
 142       Events_Error::send(string("Can not save document: PCDM_SS_DriverFailure"));
 143       break;
 144     case PCDM_SS_WriteFailure:
 145       Events_Error::send(string("Can not save document: PCDM_SS_WriteFailure"));
 146       break;
 147     case PCDM_SS_Failure:
 148     default:
 149       Events_Error::send(string("Can not save document: PCDM_SS_Failure"));
 150       break;
 151     }
 152   }
 153   myTransactionsAfterSave = 0;
 154   if (isDone) { // save also sub-documents if any
 155     set<string>::iterator aSubIter = mySubs.begin();
 156     for(; aSubIter != mySubs.end() && isDone; aSubIter++)
 157       isDone = subDocument(*aSubIter)->save(theFileName);
 158   }
 159   return isDone;
 160 }
 161
 162 void Model_Document::close()
 163 {
 164   // close all subs
 165   set<string>::iterator aSubIter = mySubs.begin();
 166   for(; aSubIter != mySubs.end(); aSubIter++)
 167     subDocument(*aSubIter)->close();
 168   mySubs.clear();
 169   // close this
 170   myDoc->Close();
 171   Model_Application::getApplication()->deleteDocument(myID);
 172 }
 173
 174 void Model_Document::startOperation()
 175 {
 176   // check is it nested or not
 177   if (myDoc->HasOpenCommand()) {
 178     myNestedStart = myTransactionsAfterSave;
 179   }
 180   // new command for this
 181   myDoc->NewCommand();
 182   // new command for all subs
 183   set<string>::iterator aSubIter = mySubs.begin();
 184   for(; aSubIter != mySubs.end(); aSubIter++)
 185     subDocument(*aSubIter)->startOperation();
 186 }
 187
 188 void Model_Document::finishOperation()
 189 {
 190   if (myNestedStart > myTransactionsAfterSave) // this nested transaction is owervritten
 191     myNestedStart = 0;
 192   // returns false if delta is empty and no transaction was made
 193   myIsEmptyTr[myTransactionsAfterSave] = !myDoc->CommitCommand();
 194   myTransactionsAfterSave++;
 195   // finish for all subs
 196   set<string>::iterator aSubIter = mySubs.begin();
 197   for(; aSubIter != mySubs.end(); aSubIter++)
 198     subDocument(*aSubIter)->finishOperation();
 199 }
 200
 201 void Model_Document::abortOperation()
 202 {
 203   myDoc->AbortCommand();
 204   synchronizeFeatures();
 205   // abort for all subs
 206   set<string>::iterator aSubIter = mySubs.begin();
 207   for(; aSubIter != mySubs.end(); aSubIter++)
 208     subDocument(*aSubIter)->abortOperation();
 209 }
 210
 211 bool Model_Document::isOperation()
 212 {
 213   // operation is opened for all documents: no need to check subs
 214   return myDoc->HasOpenCommand() == Standard_True ;
 215 }
 216
 217 bool Model_Document::isModified()
 218 {
 219   // is modified if at least one operation was commited and not undoed
 220   return myTransactionsAfterSave > 0;
 221 }
 222
 223 bool Model_Document::canUndo()
 224 {
 225   if (myDoc->GetAvailableUndos() > 0 && myNestedStart != myTransactionsAfterSave)
 226     return true;
 227   // check other subs contains operation that can be undoed
 228   set<string>::iterator aSubIter = mySubs.begin();
 229   for(; aSubIter != mySubs.end(); aSubIter++)
 230     if (subDocument(*aSubIter)->canUndo())
 231       return true;
 232   return false;
 233 }
 234
 235 void Model_Document::undo()
 236 {
 237   myTransactionsAfterSave--;
 238   if (!myIsEmptyTr[myTransactionsAfterSave])
 239     myDoc->Undo();
 240   synchronizeFeatures();
 241   // undo for all subs
 242   set<string>::iterator aSubIter = mySubs.begin();
 243   for(; aSubIter != mySubs.end(); aSubIter++)
 244     subDocument(*aSubIter)->undo();
 245 }
 246
 247 bool Model_Document::canRedo()
 248 {
 249   if (myDoc->GetAvailableRedos() > 0)
 250     return true;
 251   // check other subs contains operation that can be redoed
 252   set<string>::iterator aSubIter = mySubs.begin();
 253   for(; aSubIter != mySubs.end(); aSubIter++)
 254     if (subDocument(*aSubIter)->canRedo())
 255       return true;
 256   return false;
 257 }
 258
 259 void Model_Document::redo()
 260 {
 261   if (!myIsEmptyTr[myTransactionsAfterSave])
 262     myDoc->Redo();
 263   myTransactionsAfterSave++;
 264   synchronizeFeatures();
 265   // redo for all subs
 266   set<string>::iterator aSubIter = mySubs.begin();
 267   for(; aSubIter != mySubs.end(); aSubIter++)
 268     subDocument(*aSubIter)->redo();
 269 }
 270
 271 boost::shared_ptr<ModelAPI_Feature> Model_Document::addFeature(string theID)
 272 {
 273   boost::shared_ptr<ModelAPI_Feature> aFeature =
 274     ModelAPI_PluginManager::get()->createFeature(theID);
 275   if (aFeature) {
 276     boost::dynamic_pointer_cast<Model_Document>(aFeature->documentToAdd())->addFeature(aFeature);
 277   } else {
 278     // TODO: generate error that feature is not created
 279   }
 280   return aFeature;
 281 }
 282
 283 /// Appenad to the array of references a new referenced label
 284 static void AddToRefArray(TDF_Label& theArrayLab, TDF_Label& theReferenced) {
 285   Handle(TDataStd_ReferenceArray) aRefs;
 286   if (!theArrayLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
 287     aRefs = TDataStd_ReferenceArray::Set(theArrayLab, 0, 0);
 288     aRefs->SetValue(0, theReferenced);
 289   } else { // extend array by one more element
 290     Handle(TDataStd_HLabelArray1) aNewArray =
 291       new TDataStd_HLabelArray1(aRefs->Lower(), aRefs->Upper() + 1);
 292     for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) {
 293       aNewArray->SetValue(a, aRefs->Value(a));
 294     }
 295     aNewArray->SetValue(aRefs->Upper() + 1, theReferenced);
 296     aRefs->SetInternalArray(aNewArray);
 297   }
 298 }
 299
 300 void Model_Document::addFeature(const boost::shared_ptr<ModelAPI_Feature> theFeature)
 301 {
 302   boost::shared_ptr<ModelAPI_Document> aThis =
 303     Model_Application::getApplication()->getDocument(myID);
 304   TDF_Label aFeaturesLab = groupLabel(FEATURES_GROUP);
 305   TDF_Label aFeatureLab = aFeaturesLab.NewChild();
 306
 307   // organize feature and data objects
 308   boost::shared_ptr<Model_Data> aData(new Model_Data);
 309   aData->setFeature(theFeature);
 310   aData->setLabel(aFeatureLab);
 311   theFeature->setDoc(aThis);
 312   theFeature->setData(aData);
 313   setUniqueName(theFeature);
 314   theFeature->initAttributes();
 315
 316   // keep the feature ID to restore document later correctly
 317   TDataStd_Comment::Set(aFeatureLab, theFeature->getKind().c_str());
 318   myFeatures.push_back(theFeature);
 319   // store feature in the history of features array
 320   if (theFeature->isInHistory()) {
 321     AddToRefArray(aFeaturesLab, aFeatureLab);
 322   }
 323   // add featue to the group
 324   const std::string& aGroup = theFeature->getGroup();
 325   TDF_Label aGroupLab = groupLabel(aGroup);
 326   AddToRefArray(aGroupLab, aFeatureLab);
 327   // new name of this feature object by default equal to name of feature
 328   TDF_Label anObjLab = aGroupLab.NewChild();
 329   TCollection_ExtendedString aName(theFeature->data()->getName().c_str());
 330   TDataStd_Name::Set(anObjLab, aName);
 331   TDF_Label aGrLabChild = aGroupLab.FindChild(1);
 332   AddToRefArray(aGrLabChild, anObjLab); // reference to names is on the first sub
 333
 334   // event: feature is added
 335   static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_CREATED);
 336   Model_FeatureUpdatedMessage aMsg(theFeature, anEvent);
 337   Events_Loop::loop()->send(aMsg);
 338 }
 339
 340 boost::shared_ptr<ModelAPI_Feature> Model_Document::feature(TDF_Label& theLabel)
 341 {
 342   // iterate all features, may be optimized later by keeping labels-map
 343   vector<boost::shared_ptr<ModelAPI_Feature> >::iterator aFIter = myFeatures.begin();
 344   for(; aFIter != myFeatures.end(); aFIter++) {
 345     boost::shared_ptr<Model_Data> aData =
 346       boost::dynamic_pointer_cast<Model_Data>((*aFIter)->data());
 347     if (aData->label().IsEqual(theLabel))
 348       return *aFIter;
 349   }
 350   return boost::shared_ptr<ModelAPI_Feature>(); // not found
 351 }
 352
 353 boost::shared_ptr<ModelAPI_Document> Model_Document::subDocument(string theDocID)
 354 {
 355   // just store sub-document identifier here to manage it later
 356   if (mySubs.find(theDocID) == mySubs.end())
 357     mySubs.insert(theDocID);
 358   return Model_Application::getApplication()->getDocument(theDocID);
 359 }
 360
 361 boost::shared_ptr<ModelAPI_Feature> Model_Document::feature(
 362   const string& theGroupID, const int theIndex)
 363 {
 364   TDF_Label aGroupLab = groupLabel(theGroupID);
 365   Handle(TDataStd_ReferenceArray) aRefs;
 366   if (aGroupLab.FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
 367     if (aRefs->Lower() <= theIndex && aRefs->Upper() >= theIndex) {
 368       TDF_Label aFeatureLab = aRefs->Value(theIndex);
 369       boost::shared_ptr<ModelAPI_Feature> aFeature = feature(aFeatureLab);
 370
 371       if (theGroupID == FEATURES_GROUP) { // just returns the feature from the history
 372         return aFeature;
 373       } else { // create a new object from the group to return it
 374         Handle(TDataStd_Name) aName; // name of the object
 375         if (aGroupLab.FindChild(1).FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs))
 376           aRefs->Value(theIndex).FindAttribute(TDataStd_Name::GetID(), aName);
 377         boost::shared_ptr<Model_Object> anObj(new Model_Object(aFeature, aName));
 378         return anObj;
 379       }
 380     }
 381   }
 382
 383   // not found
 384   return boost::shared_ptr<ModelAPI_Feature>();
 385 }
 386
 387 int Model_Document::size(const string& theGroupID)
 388 {
 389   Handle(TDataStd_ReferenceArray) aRefs;
 390   if (groupLabel(theGroupID).FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs))
 391     return aRefs->Length();
 392   // group is not found
 393   return 0;
 394 }
 395
 396 Model_Document::Model_Document(const std::string theID)
 397     : myID(theID), myDoc(new TDocStd_Document("BinOcaf")) // binary OCAF format
 398 {
 399   myDoc->SetUndoLimit(UNDO_LIMIT);
 400   myTransactionsAfterSave = 0;
 401   myNestedStart = 0;
 402   myDoc->SetNestedTransactionMode();
 403   // to have something in the document and avoid empty doc open/save problem
 404   TDataStd_Integer::Set(myDoc->Main().Father(), 0);
 405 }
 406
 407 TDF_Label Model_Document::groupLabel(const string theGroup)
 408 {
 409   // searching for existing
 410   TCollection_ExtendedString aGroup(theGroup.c_str());
 411   TDF_ChildIDIterator aGroupIter(myDoc->Main().FindChild(TAG_OBJECTS), TDataStd_Comment::GetID());
 412   for(; aGroupIter.More(); aGroupIter.Next()) {
 413     Handle(TDataStd_Comment) aName = Handle(TDataStd_Comment)::DownCast(aGroupIter.Value());
 414     if (aName->Get() == aGroup)
 415       return aGroupIter.Value()->Label();
 416   }
 417   // create a new
 418   TDF_Label aNew = myDoc->Main().FindChild(TAG_OBJECTS).NewChild();
 419   TDataStd_Comment::Set(aNew, aGroup);
 420   return aNew;
 421 }
 422
 423 void Model_Document::setUniqueName(boost::shared_ptr<ModelAPI_Feature> theFeature)
 424 {
 425   // first count all objects of such kind to start with index = count + 1
 426   int a, aNumObjects = 0;
 427   int aSize = size(FEATURES_GROUP);
 428   for(a = 0; a < aSize; a++) {
 429     if (feature(FEATURES_GROUP, a)->getKind() == theFeature->getKind())
 430       aNumObjects++;
 431   }
 432   // generate candidate name
 433   stringstream aNameStream;
 434   aNameStream<<theFeature->getKind()<<"_"<<aNumObjects + 1;
 435   string aName = aNameStream.str();
 436   // check this is unique, if not, increase index by 1
 437   for(a = 0; a < aSize;) {
 438     if (feature(FEATURES_GROUP, a)->data()->getName() == aName) {
 439       aNumObjects++;
 440       stringstream aNameStream;
 441       aNameStream<<theFeature->getKind()<<"_"<<aNumObjects + 1;
 442       // reinitialize iterator to make sure a new name is unique
 443       a = 0;
 444     } else a++;
 445   }
 446
 447   theFeature->data()->setName(aName);
 448 }
 449
 450 //! Returns the object by the feature
 451 boost::shared_ptr<ModelAPI_Feature> Model_Document::objectByFeature(
 452   const boost::shared_ptr<ModelAPI_Feature> theFeature)
 453 {
 454   for(int a = 0; a < size(theFeature->getGroup()); a++) {
 455     boost::shared_ptr<Model_Object> anObj =
 456       boost::dynamic_pointer_cast<Model_Object>(feature(theFeature->getGroup(), a));
 457     if (anObj) {
 458       return anObj;
 459     }
 460   }
 461   return boost::shared_ptr<ModelAPI_Feature>(); // not found
 462 }
 463
 464 void Model_Document::synchronizeFeatures()
 465 {
 466   boost::shared_ptr<ModelAPI_Document> aThis = Model_Application::getApplication()->getDocument(myID);
 467   // update features
 468   vector<boost::shared_ptr<ModelAPI_Feature> >::iterator aFIter = myFeatures.begin();
 469   // and in parallel iterate labels of features
 470   TDF_ChildIDIterator aFLabIter(groupLabel(FEATURES_GROUP), TDataStd_Comment::GetID());
 471   while(aFIter != myFeatures.end() || aFLabIter.More()) {
 472     static const int INFINITE_TAG = INT_MAX; // no label means that it exists somwhere in infinite
 473     int aFeatureTag = INFINITE_TAG;
 474     if (aFIter != myFeatures.end()) { // existing tag for feature
 475       boost::shared_ptr<Model_Data> aData = boost::dynamic_pointer_cast<Model_Data>((*aFIter)->data());
 476       aFeatureTag = aData->label().Tag();
 477     }
 478     int aDSTag = INFINITE_TAG;
 479     if (aFLabIter.More()) { // next label in DS is existing
 480       aDSTag = aFLabIter.Value()->Label().Tag();
 481     }
 482     if (aDSTag > aFeatureTag) { // feature is removed
 483       Model_FeatureDeletedMessage aMsg1(aThis, FEATURES_GROUP);
 484       Model_FeatureDeletedMessage aMsg2(aThis, (*aFIter)->getGroup());
 485       aFIter = myFeatures.erase(aFIter);
 486       // event: model is updated
 487       Events_Loop::loop()->send(aMsg1);
 488       Events_Loop::loop()->send(aMsg2);
 489     } else if (aDSTag < aFeatureTag) { // a new feature is inserted
 490       // create a feature
 491       boost::shared_ptr<ModelAPI_Feature> aFeature = ModelAPI_PluginManager::get()->createFeature(
 492         TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(
 493         aFLabIter.Value())->Get()).ToCString());
 494
 495       if (aFIter == myFeatures.end()) { // must be before "setData" to redo the sketch line correctly
 496         myFeatures.push_back(aFeature);
 497         aFIter = myFeatures.end();
 498       } else {
 499         aFIter++;
 500         myFeatures.insert(aFIter, aFeature);
 501       }
 502       boost::shared_ptr<Model_Data> aData(new Model_Data);
 503       TDF_Label aLab = aFLabIter.Value()->Label();
 504       aData->setLabel(aLab);
 505       aData->setFeature(aFeature);
 506       aFeature->setDoc(aThis);
 507       aFeature->setData(aData);
 508       aFeature->initAttributes();
 509
 510       // event: model is updated
 511       static Events_ID anEvent = Events_Loop::eventByName(EVENT_FEATURE_CREATED);
 512       Model_FeatureUpdatedMessage aMsg1(aFeature, anEvent);
 513       Events_Loop::loop()->send(aMsg1);
 514       boost::shared_ptr<ModelAPI_Feature> anObj = objectByFeature(aFeature);
 515       if (anObj) {
 516         Model_FeatureUpdatedMessage aMsg2(anObj, anEvent);
 517         Events_Loop::loop()->send(aMsg2);
 518       }
 519
 520       // feature for this label is added, so go to the next label
 521       aFLabIter.Next();
 522     } else { // nothing is changed, both iterators are incremented
 523       aFIter++;
 524       aFLabIter.Next();
 525     }
 526   }
 527 }