X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Document.cpp;h=ee8cebc14c9d0274a1dd486a1638fca540450c17;hb=f367061802012d6909c2619ef6b6c4cba86fc503;hp=557ee00e59e6fc53e2e96ee73eccc9793c3df541;hpb=2f89053146098946372bae4d1a3fe2e5272ab9e2;p=modules%2Fshaper.git diff --git a/src/Model/Model_Document.cpp b/src/Model/Model_Document.cpp index 557ee00e5..ee8cebc14 100644 --- a/src/Model/Model_Document.cpp +++ b/src/Model/Model_Document.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include @@ -40,7 +41,7 @@ # define _separator_ '/' #endif -static const int UNDO_LIMIT = 10; // number of possible undo operations +static const int UNDO_LIMIT = 1000; // number of possible undo operations (big for sketcher) static const int TAG_GENERAL = 1; // general properties tag static const int TAG_OBJECTS = 2; // tag of the objects sub-tree (features, results) @@ -50,14 +51,17 @@ static const int TAG_HISTORY = 3; // tag of the history sub-tree (python dump) static const int TAG_FEATURE_ARGUMENTS = 1; ///< where the arguments are located static const int TAG_FEATURE_RESULTS = 2; ///< where the results are located +/// +/// 0:1:2 - where features are located +/// 0:1:2:N:1 - data of the feature N +/// 0:1:2:N:2:K:1 - data of the K result of the feature N + Model_Document::Model_Document(const std::string theID, const std::string theKind) : myID(theID), myKind(theKind), myDoc(new TDocStd_Document("BinOcaf")) // binary OCAF format { myDoc->SetUndoLimit(UNDO_LIMIT); - myTransactionsCounter = 0; myTransactionSave = 0; - myNestedNum = -1; myExecuteFeatures = true; // to have something in the document and avoid empty doc open/save problem // in transaction for nesting correct working @@ -71,7 +75,8 @@ static TCollection_ExtendedString DocFileName(const char* theFileName, const std { TCollection_ExtendedString aPath((const Standard_CString) theFileName); // remove end-separators - while(aPath.Length() && (aPath.Value(aPath.Length()) == '\\' || aPath.Value(aPath.Length()) == '/')) + while(aPath.Length() && + (aPath.Value(aPath.Length()) == '\\' || aPath.Value(aPath.Length()) == '/')) aPath.Remove(aPath.Length()); aPath += _separator_; aPath += theID.c_str(); @@ -79,10 +84,15 @@ static TCollection_ExtendedString DocFileName(const char* theFileName, const std return aPath; } +bool Model_Document::isRoot() const +{ + return this == Model_Session::get()->moduleDocument().get(); +} + bool Model_Document::load(const char* theFileName) { Handle(Model_Application) anApp = Model_Application::getApplication(); - if (this == Model_Session::get()->moduleDocument().get()) { + if (isRoot()) { anApp->setLoadPath(theFileName); } TCollection_ExtendedString aPath(DocFileName(theFileName, myID)); @@ -99,7 +109,7 @@ bool Model_Document::load(const char* theFileName) if (isError) { switch (aStatus) { case PCDM_RS_UnknownDocument: - Events_Error::send(std::string("Can not open document: unknown format")); + Events_Error::send(std::string("Can not open document")); break; case PCDM_RS_AlreadyRetrieved: Events_Error::send(std::string("Can not open document: already opened")); @@ -152,10 +162,14 @@ bool Model_Document::load(const char* theFileName) if (!isError) { myDoc->SetUndoLimit(UNDO_LIMIT); // to avoid the problem that feature is created in the current, not this, document - Model_Session::get()->setActiveDocument(anApp->getDocument(myID), false); - synchronizeFeatures(false, true); - Model_Session::get()->setActiveDocument(Model_Session::get()->moduleDocument(), false); - Model_Session::get()->setActiveDocument(anApp->getDocument(myID), true); + std::shared_ptr aSession = + std::dynamic_pointer_cast(Model_Session::get()); + aSession->setActiveDocument(anApp->getDocument(myID), false); + aSession->setCheckTransactions(false); + synchronizeFeatures(false, true, true); + aSession->setCheckTransactions(true); + aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false); + aSession->setActiveDocument(anApp->getDocument(myID), true); } return !isError; } @@ -164,7 +178,7 @@ bool Model_Document::save(const char* theFileName, std::list& theRe { // create a directory in the root document if it is not yet exist Handle(Model_Application) anApp = Model_Application::getApplication(); - if (this == Model_Session::get()->moduleDocument().get()) { + if (isRoot()) { #ifdef WIN32 CreateDirectory(theFileName, NULL); #else @@ -197,36 +211,32 @@ bool Model_Document::save(const char* theFileName, std::list& theRe break; } } - myTransactionSave = myTransactionsCounter; + myTransactionSave = myTransactions.size(); if (isDone) { // save also sub-documents if any theResults.push_back(TCollection_AsciiString(aPath).ToCString()); - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end() && isDone; aSubIter++) { - isDone = subDoc(*aSubIter)->save(theFileName, theResults); - } - if (isDone) { // also try to copy the not-activated sub-documents - // they are not in mySubs but as ResultParts - int aPartsNum = size(ModelAPI_ResultPart::group()); - for(int aPart = 0; aPart < aPartsNum; aPart++) { - ResultPartPtr aPartRes = std::dynamic_pointer_cast - (object(ModelAPI_ResultPart::group(), aPart)); - if (aPartRes) { - std::string aDocName = aPartRes->data()->name(); - if (!aDocName.empty() && mySubs.find(aDocName) == mySubs.end()) { - // just copy file - TCollection_AsciiString aSubPath(DocFileName(anApp->loadPath().c_str(), aDocName)); - OSD_Path aPath(aSubPath); - OSD_File aFile(aPath); - if (aFile.Exists()) { - TCollection_AsciiString aDestinationDir(DocFileName(theFileName, aDocName)); - OSD_Path aDestination(aDestinationDir); - aFile.Copy(aDestination); - } else { - Events_Error::send( - std::string("Can not open file ") + aSubPath.ToCString() + " for saving"); - } + const std::set aSubs = subDocuments(false); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end() && isDone; aSubIter++) { + if (anApp->isLoadByDemand(*aSubIter)) { + // copy not-activated document that is not in the memory + std::string aDocName = *aSubIter; + if (!aDocName.empty()) { + // just copy file + TCollection_AsciiString aSubPath(DocFileName(anApp->loadPath().c_str(), aDocName)); + OSD_Path aPath(aSubPath); + OSD_File aFile(aPath); + if (aFile.Exists()) { + TCollection_AsciiString aDestinationDir(DocFileName(theFileName, aDocName)); + OSD_Path aDestination(aDestinationDir); + aFile.Copy(aDestination); + theResults.push_back(aDestinationDir.ToCString()); + } else { + Events_Error::send( + std::string("Can not open file ") + aSubPath.ToCString() + " for saving"); } } + } else { // simply save opened document + isDone = subDoc(*aSubIter)->save(theFileName, theResults); } } } @@ -236,14 +246,17 @@ bool Model_Document::save(const char* theFileName, std::list& theRe void Model_Document::close(const bool theForever) { std::shared_ptr aPM = Model_Session::get(); - if (this != aPM->moduleDocument().get() && this == aPM->activeDocument().get()) { + if (!isRoot() && this == aPM->activeDocument().get()) { aPM->setActiveDocument(aPM->moduleDocument()); + } else if (isRoot()) { + // erase the active document if root is closed + aPM->setActiveDocument(DocumentPtr()); } // close all subs - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end(); aSubIter++) + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) subDoc(*aSubIter)->close(theForever); - mySubs.clear(); // close for thid document needs no transaction in this document std::static_pointer_cast(Model_Session::get())->setCheckTransactions(false); @@ -259,9 +272,15 @@ void Model_Document::close(const bool theForever) ModelAPI_EventCreator::get()->sendDeleted(aThis, ModelAPI_Feature::group()); ModelAPI_EventCreator::get()->sendUpdated(aFeature, EVENT_DISP); aFeature->eraseResults(); - aFeature->erase(); + if (theForever) { // issue #294: do not delete content of the document until it can be redone + aFeature->erase(); + } else { + aFeature->data()->execState(ModelAPI_StateMustBeUpdated); + } + } + if (theForever) { + myObjs.Clear(); } - myObjs.Clear(); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED)); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY)); @@ -277,51 +296,46 @@ void Model_Document::close(const bool theForever) void Model_Document::startOperation() { if (myDoc->HasOpenCommand()) { // start of nested command - if (myNestedNum == -1) { - myNestedNum = 0; - myDoc->InitDeltaCompaction(); + if (myDoc->CommitCommand()) { // commit the current: it will contain all nested after compactification + myTransactions.rbegin()->myOCAFNum++; // if has open command, the list is not empty } - myIsEmptyTr[myTransactionsCounter] = !myDoc->CommitCommand(); - myTransactionsCounter++; + myNestedNum.push_back(0); // start of nested operation with zero transactions inside yet myDoc->OpenCommand(); } else { // start the simple command myDoc->NewCommand(); } + // starts a new operation + myTransactions.push_back(Transaction()); + if (!myNestedNum.empty()) + (*myNestedNum.rbegin())++; + myRedos.clear(); // new command for all subs - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end(); aSubIter++) + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) subDoc(*aSubIter)->startOperation(); } -bool Model_Document::compactNested() +void Model_Document::compactNested() { - bool allWasEmpty = true; - while (myNestedNum != -1) { - myTransactionsCounter--; - if (!myIsEmptyTr[myTransactionsCounter]) { - allWasEmpty = false; + if (!myNestedNum.empty()) { + int aNumToCompact = *(myNestedNum.rbegin()); + int aSumOfTransaction = 0; + for(int a = 0; a < aNumToCompact; a++) { + aSumOfTransaction += myTransactions.rbegin()->myOCAFNum; + myTransactions.pop_back(); } - myIsEmptyTr.erase(myTransactionsCounter); - myNestedNum--; - } - myIsEmptyTr[myTransactionsCounter] = allWasEmpty; - myTransactionsCounter++; - if (allWasEmpty) { - // Issue 151: if everything is empty, it is a problem for OCCT to work with it, - // just commit the empty that returns nothing - myDoc->CommitCommand(); - } else { - myDoc->PerformDeltaCompaction(); + // the latest transaction is the start of lower-level operation which startes the nested + myTransactions.rbegin()->myOCAFNum += aSumOfTransaction; + myNestedNum.pop_back(); } - return !allWasEmpty; } -void Model_Document::finishOperation() +bool Model_Document::finishOperation() { - // just to be sure that everybody knows that changes were performed - if (!myDoc->HasOpenCommand() && myNestedNum != -1) - std::static_pointer_cast(Model_Session::get()) - ->setCheckTransactions(false); // for nested transaction commit + bool isNestedClosed = !myDoc->HasOpenCommand() && !myNestedNum.empty(); + static std::shared_ptr aSession = + std::static_pointer_cast(Model_Session::get()); synchronizeBackRefs(); Events_Loop* aLoop = Events_Loop::loop(); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED)); @@ -332,7 +346,7 @@ void Model_Document::finishOperation() // this must be here just after everything is finished but before real transaction stop // to avoid messages about modifications outside of the transaction // and to rebuild everything after all updates and creates - if (Model_Session::get()->moduleDocument().get() == this) { // once for root document + if (isRoot()) { // once for root document Events_Loop::loop()->autoFlush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED)); static std::shared_ptr aFinishMsg (new Events_Message(Events_Loop::eventByName("FinishOperation"))); @@ -342,52 +356,63 @@ void Model_Document::finishOperation() // to avoid "updated" message appearance by updater //aLoop->clear(Events_Loop::eventByName(EVENT_OBJECT_UPDATED)); - if (!myDoc->HasOpenCommand() && myNestedNum != -1) - std::static_pointer_cast(Model_Session::get()) - ->setCheckTransactions(true); // for nested transaction commit - // finish for all subs first: to avoid nested finishing and "isOperation" calls problems inside - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end(); aSubIter++) - subDoc(*aSubIter)->finishOperation(); - - if (myNestedNum != -1) // this nested transaction is owervritten - myNestedNum++; - if (!myDoc->HasOpenCommand()) { - if (myNestedNum != -1) { - myNestedNum--; - compactNested(); - } - } else { - // returns false if delta is empty and no transaction was made - myIsEmptyTr[myTransactionsCounter] = !myDoc->CommitCommand(); // && (myNestedNum == -1); - myTransactionsCounter++; + bool aResult = false; + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) + if (subDoc(*aSubIter)->finishOperation()) + aResult = true; + + // transaction may be empty if this document was created during this transaction (create part) + if (!myTransactions.empty() && myDoc->CommitCommand()) { // if commit is successfull, just increment counters + myTransactions.rbegin()->myOCAFNum++; + aResult = true; + } + + if (isNestedClosed) { + compactNested(); } + if (!aResult && !myTransactions.empty() /* it can be for just created part document */) + aResult = myTransactions.rbegin()->myOCAFNum != 0; + + if (!aResult && isRoot()) { + // nothing inside in all documents, so remove this transaction from the transactions list + undoInternal(true, false); + myDoc->ClearRedos(); + myRedos.clear(); + } + return aResult; } void Model_Document::abortOperation() { - if (myNestedNum > 0 && !myDoc->HasOpenCommand()) { // abort all what was done in nested - // first compact all nested - if (compactNested()) { - myDoc->Undo(); // undo only compacted, if not: do not undo the empty transaction - } + if (!myNestedNum.empty() && !myDoc->HasOpenCommand()) { // abort all what was done in nested + compactNested(); + undoInternal(false, false); myDoc->ClearRedos(); - myTransactionsCounter--; - myIsEmptyTr.erase(myTransactionsCounter); - } else { - if (myNestedNum == 0) // abort only high-level - myNestedNum = -1; + myRedos.clear(); + } else { // abort the current + int aNumTransactions = myTransactions.rbegin()->myOCAFNum; + myTransactions.pop_back(); + if (!myNestedNum.empty()) + (*myNestedNum.rbegin())--; + // roll back the needed number of transactions myDoc->AbortCommand(); + for(int a = 0; a < aNumTransactions; a++) + myDoc->Undo(); + myDoc->ClearRedos(); } - synchronizeFeatures(true, false); // references were not changed since transaction start + // references were not changed since transaction start + synchronizeFeatures(true, false, isRoot()); // abort for all subs - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end(); aSubIter++) + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) subDoc(*aSubIter)->abortOperation(); } -bool Model_Document::isOperation() +bool Model_Document::isOperation() const { // operation is opened for all documents: no need to check subs return myDoc->HasOpenCommand() == Standard_True ; @@ -396,43 +421,62 @@ bool Model_Document::isOperation() bool Model_Document::isModified() { // is modified if at least one operation was commited and not undoed - return myTransactionsCounter != myTransactionSave || isOperation(); + return myTransactions.size() != myTransactionSave || isOperation(); } bool Model_Document::canUndo() { - if (myDoc->GetAvailableUndos() > 0 && myNestedNum != 0 - && myTransactionsCounter != 0 /* for omitting the first useless transaction */) + // issue 406 : if transaction is opened, but nothing to undo behind, can not undo + int aCurrentNum = isOperation() ? 1 : 0; + if (myDoc->GetAvailableUndos() > 0 && + (myNestedNum.empty() || *myNestedNum.rbegin() - aCurrentNum > 0) && // there is something to undo in nested + myTransactions.size() - aCurrentNum > 0 /* for omitting the first useless transaction */) return true; // check other subs contains operation that can be undoed - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end(); aSubIter++) + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) if (subDoc(*aSubIter)->canUndo()) return true; return false; } -void Model_Document::undo() +void Model_Document::undoInternal(const bool theWithSubs, const bool theSynchronize) { - myTransactionsCounter--; - if (myNestedNum > 0) - myNestedNum--; - if (!myIsEmptyTr[myTransactionsCounter]) + int aNumTransactions = myTransactions.rbegin()->myOCAFNum; + myRedos.push_back(*myTransactions.rbegin()); + myTransactions.pop_back(); + if (!myNestedNum.empty()) + (*myNestedNum.rbegin())--; + // roll back the needed number of transactions + for(int a = 0; a < aNumTransactions; a++) myDoc->Undo(); - synchronizeFeatures(true, true); - // undo for all subs - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end(); aSubIter++) - subDoc(*aSubIter)->undo(); + + if (theWithSubs) { + // undo for all subs + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) + subDoc(*aSubIter)->undoInternal(theWithSubs, theSynchronize); + } + // after redo of all sub-documents to avoid updates on not-modified data (issue 370) + if (theSynchronize) + synchronizeFeatures(true, true, isRoot()); +} + +void Model_Document::undo() +{ + undoInternal(true, true); } bool Model_Document::canRedo() { - if (myDoc->GetAvailableRedos() > 0) + if (!myRedos.empty()) return true; // check other subs contains operation that can be redoed - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end(); aSubIter++) + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) if (subDoc(*aSubIter)->canRedo()) return true; return false; @@ -440,19 +484,56 @@ bool Model_Document::canRedo() void Model_Document::redo() { - if (myNestedNum != -1) - myNestedNum++; - if (!myIsEmptyTr[myTransactionsCounter]) + if (!myNestedNum.empty()) + (*myNestedNum.rbegin())++; + int aNumRedos = myRedos.rbegin()->myOCAFNum; + myTransactions.push_back(*myRedos.rbegin()); + myRedos.pop_back(); + for(int a = 0; a < aNumRedos; a++) myDoc->Redo(); - myTransactionsCounter++; - synchronizeFeatures(true, true); + // redo for all subs - std::set::iterator aSubIter = mySubs.begin(); - for (; aSubIter != mySubs.end(); aSubIter++) + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) subDoc(*aSubIter)->redo(); + + // after redo of all sub-documents to avoid updates on not-modified data (issue 370) + synchronizeFeatures(true, true, isRoot()); } -/// Appenad to the array of references a new referenced label +std::list Model_Document::undoList() const +{ + std::list aResult; + // the number of skipped current operations (on undo they will be aborted) + int aSkipCurrent = isOperation() ? 1 : 0; + std::list::const_reverse_iterator aTrIter = myTransactions.crbegin(); + int aNumUndo = myTransactions.size(); + if (!myNestedNum.empty()) + aNumUndo = *myNestedNum.rbegin(); + for( ; aNumUndo > 0; aTrIter++, aNumUndo--) { + if (aSkipCurrent == 0) aResult.push_back(aTrIter->myId); + else aSkipCurrent--; + } + return aResult; +} + +std::list Model_Document::redoList() const +{ + std::list aResult; + std::list::const_reverse_iterator aTrIter = myRedos.crbegin(); + for( ; aTrIter != myRedos.crend(); aTrIter++) { + aResult.push_back(aTrIter->myId); + } + return aResult; +} + +void Model_Document::operationId(const std::string& theId) +{ + myTransactions.rbegin()->myId = theId; +} + +/// Append to the array of references a new referenced label static void AddToRefArray(TDF_Label& theArrayLab, TDF_Label& theReferenced) { Handle(TDataStd_ReferenceArray) aRefs; @@ -477,8 +558,12 @@ FeaturePtr Model_Document::addFeature(std::string theID) FeaturePtr aFeature = ModelAPI_Session::get()->createFeature(theID); if (!aFeature) return aFeature; - std::shared_ptr aDocToAdd = std::dynamic_pointer_cast( - aFeature->documentToAdd()); + Model_Document* aDocToAdd; + if (aFeature->documentToAdd().get()) { // use the customized document to add + aDocToAdd = std::dynamic_pointer_cast(aFeature->documentToAdd()).get(); + } else { // if customized is not presented, add to "this" document + aDocToAdd = this; + } if (aFeature) { TDF_Label aFeatureLab; if (!aFeature->isAction()) { // do not add action to the data model @@ -506,10 +591,10 @@ FeaturePtr Model_Document::addFeature(std::string theID) } /// Appenad to the array of references a new referenced label. -/// If theIndex is not -1, removes element at thisindex, not theReferenced. +/// If theIndex is not -1, removes element at this index, not theReferenced. /// \returns the index of removed element -static int RemoveFromRefArray(TDF_Label theArrayLab, TDF_Label theReferenced, const int theIndex = - -1) +static int RemoveFromRefArray(TDF_Label theArrayLab, TDF_Label theReferenced, + const int theIndex = -1) { int aResult = -1; // no returned Handle(TDataStd_ReferenceArray) aRefs; @@ -537,22 +622,48 @@ static int RemoveFromRefArray(TDF_Label theArrayLab, TDF_Label theReferenced, co return aResult; } -void Model_Document::removeFeature(FeaturePtr theFeature, const bool theCheck) +void Model_Document::refsToFeature(FeaturePtr theFeature, + std::set >& theRefs, + const bool isSendError) { - if (theCheck) { - // check the feature: it must have no depended objects on it - std::list::const_iterator aResIter = theFeature->results().cbegin(); - for(; aResIter != theFeature->results().cend(); aResIter++) { - std::shared_ptr aData = - std::dynamic_pointer_cast((*aResIter)->data()); - if (aData && !aData->refsToMe().empty()) { - Events_Error::send( - "Feature '" + theFeature->data()->name() + "' is used and can not be deleted"); - return; + // check the feature: it must have no depended objects on it + // the dependencies can be in the feature results + std::list::const_iterator aResIter = theFeature->results().cbegin(); + for(; aResIter != theFeature->results().cend(); aResIter++) { + ResultPtr aResult = (*aResIter); + std::shared_ptr aData = + std::dynamic_pointer_cast(aResult->data()); + if (aData.get() != NULL) { + const std::set& aRefs = aData->refsToMe(); + std::set::const_iterator aRefIt = aRefs.begin(), aRefLast = aRefs.end(); + for(; aRefIt != aRefLast; aRefIt++) { + FeaturePtr aFeature = std::dynamic_pointer_cast((*aRefIt)->owner()); + if (aFeature.get() != NULL) + theRefs.insert(aFeature); } } } + // the dependencies can be in the feature itself + std::shared_ptr aData = + std::dynamic_pointer_cast(theFeature->data()); + if (aData && !aData->refsToMe().empty()) { + const std::set& aRefs = aData->refsToMe(); + std::set::const_iterator aRefIt = aRefs.begin(), aRefLast = aRefs.end(); + for(; aRefIt != aRefLast; aRefIt++) { + FeaturePtr aFeature = std::dynamic_pointer_cast((*aRefIt)->owner()); + if (aFeature.get() != NULL) + theRefs.insert(aFeature); + } + } + if (!theRefs.empty() && isSendError) { + Events_Error::send( + "Feature '" + theFeature->data()->name() + "' is used and can not be deleted"); + } +} + +void Model_Document::removeFeature(FeaturePtr theFeature/*, const bool theCheck*/) +{ std::shared_ptr aData = std::static_pointer_cast(theFeature->data()); if (aData) { TDF_Label aFeatureLabel = aData->label().Father(); @@ -560,20 +671,51 @@ void Model_Document::removeFeature(FeaturePtr theFeature, const bool theCheck) myObjs.UnBind(aFeatureLabel); else return; // not found feature => do not remove + + // checking that the sub-element of composite feature is removed: if yes, inform the owner + std::set > aRefs; + refsToFeature(theFeature, aRefs, false); + std::set >::iterator aRefIter = aRefs.begin(); + for(; aRefIter != aRefs.end(); aRefIter++) { + std::shared_ptr aComposite = + std::dynamic_pointer_cast(*aRefIter); + if (aComposite.get()) { + aComposite->removeFeature(theFeature); + } + } + // erase fields theFeature->erase(); + static Events_ID EVENT_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendUpdated(theFeature, EVENT_DISP); // erase all attributes under the label of feature aFeatureLabel.ForgetAllAttributes(); // remove it from the references array if (theFeature->isInHistory()) { RemoveFromRefArray(featuresLabel(), aFeatureLabel); } + // event: feature is deleted + ModelAPI_EventCreator::get()->sendDeleted(theFeature->document(), ModelAPI_Feature::group()); } - // event: feature is deleted - ModelAPI_EventCreator::get()->sendDeleted(theFeature->document(), ModelAPI_Feature::group()); } -FeaturePtr Model_Document::feature(TDF_Label& theLabel) +void Model_Document::addToHistory(const std::shared_ptr theObject) +{ + TDF_Label aFeaturesLab = featuresLabel(); + std::shared_ptr aData = std::static_pointer_cast(theObject->data()); + if (!aData) { + return; // not found feature => do not remove + } + TDF_Label aFeatureLabel = aData->label().Father(); + // store feature in the history of features array + if (theObject->isInHistory()) { + AddToRefArray(aFeaturesLab, aFeatureLabel); + } else { + RemoveFromRefArray(aFeaturesLab, aFeatureLabel); + } +} + +FeaturePtr Model_Document::feature(TDF_Label& theLabel) const { if (myObjs.IsBound(theLabel)) return myObjs.Find(theLabel); @@ -603,17 +745,37 @@ ObjectPtr Model_Document::object(TDF_Label theLabel) std::shared_ptr Model_Document::subDocument(std::string theDocID) { - // just store sub-document identifier here to manage it later - if (mySubs.find(theDocID) == mySubs.end()) - mySubs.insert(theDocID); return Model_Application::getApplication()->getDocument(theDocID); } +const std::set Model_Document::subDocuments(const bool theActivatedOnly) const +{ + std::set aResult; + // comment must be in any feature: it is kind + int anIndex = 0; + TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID()); + for (; aLabIter.More(); aLabIter.Next()) { + TDF_Label aFLabel = aLabIter.Value()->Label(); + FeaturePtr aFeature = feature(aFLabel); + if (aFeature.get()) { // if document is closed the feature may be not in myObjs map + const std::list >& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.begin(); + for (; aRIter != aResults.cend(); aRIter++) { + if ((*aRIter)->groupName() != ModelAPI_ResultPart::group()) continue; + if ((*aRIter)->isInHistory()) { + ResultPartPtr aPart = std::dynamic_pointer_cast(*aRIter); + if (aPart && (!theActivatedOnly || aPart->isActivated())) + aResult.insert(aPart->data()->name()); + } + } + } + } + return aResult; +} + std::shared_ptr Model_Document::subDoc(std::string theDocID) { // just store sub-document identifier here to manage it later - if (mySubs.find(theDocID) == mySubs.end()) - mySubs.insert(theDocID); return std::dynamic_pointer_cast( Model_Application::getApplication()->getDocument(theDocID)); } @@ -668,6 +830,37 @@ ObjectPtr Model_Document::object(const std::string& theGroupID, const int theInd return ObjectPtr(); } +std::shared_ptr Model_Document::objectByName( + const std::string& theGroupID, const std::string& theName) +{ + if (theGroupID == ModelAPI_Feature::group()) { + int anIndex = 0; + TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID()); + for (; aLabIter.More(); aLabIter.Next()) { + TDF_Label aFLabel = aLabIter.Value()->Label(); + FeaturePtr aFeature = feature(aFLabel); + if (aFeature && aFeature->name() == theName) + return aFeature; + } + } else { + // comment must be in any feature: it is kind + int anIndex = 0; + TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID()); + for (; aLabIter.More(); aLabIter.Next()) { + TDF_Label aFLabel = aLabIter.Value()->Label(); + FeaturePtr aFeature = feature(aFLabel); + const std::list >& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.begin(); + for (; aRIter != aResults.cend(); aRIter++) { + if ((*aRIter)->groupName() == theGroupID && (*aRIter)->data()->name() == theName) + return *aRIter; + } + } + } + // not found + return ObjectPtr(); +} + int Model_Document::size(const std::string& theGroupID, const bool theHidden) { int aResult = 0; @@ -704,7 +897,7 @@ int Model_Document::size(const std::string& theGroupID, const bool theHidden) return aResult; } -TDF_Label Model_Document::featuresLabel() +TDF_Label Model_Document::featuresLabel() const { return myDoc->Main().FindChild(TAG_OBJECTS); } @@ -761,21 +954,26 @@ void Model_Document::initData(ObjectPtr theObj, TDF_Label theLab, const int theT FeaturePtr aFeature = std::dynamic_pointer_cast(theObj); if (aFeature) { setUniqueName(aFeature); // must be before "initAttributes" because duplicate part uses name - aFeature->initAttributes(); } + theObj->initAttributes(); } -void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool theUpdateReferences) +void Model_Document::synchronizeFeatures( + const bool theMarkUpdated, const bool theUpdateReferences, const bool theFlush) { std::shared_ptr aThis = Model_Application::getApplication()->getDocument(myID); // after all updates, sends a message that groups of features were created or updated - std::static_pointer_cast(Model_Session::get()) - ->setCheckTransactions(false); Events_Loop* aLoop = Events_Loop::loop(); + static Events_ID aDispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + static Events_ID aCreateEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); + static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); + static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + static Events_ID aDeleteEvent = Events_Loop::eventByName(EVENT_OBJECT_DELETED); + static Events_ID aToHideEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); aLoop->activateFlushes(false); - // update all objects by checking are they of labels or not + // update all objects by checking are they on labels or not std::set aNewFeatures, aKeptFeatures; TDF_ChildIDIterator aLabIter(featuresLabel(), TDataStd_Comment::GetID()); for (; aLabIter.More(); aLabIter.Next()) { @@ -784,8 +982,8 @@ void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool t if (!myObjs.IsBound(aFeatureLabel)) { // a new feature is inserted // create a feature aFeature = ModelAPI_Session::get()->createFeature( - TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(aLabIter.Value())->Get()) - .ToCString()); + TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(aLabIter.Value())->Get()) + .ToCString()); if (!aFeature) { // somethig is wrong, most probably, the opened document has invalid structure Events_Error::send("Invalid type of object in the document"); aLabIter.Value()->Label().ForgetAllAttributes(); @@ -797,48 +995,50 @@ void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool t initData(aFeature, aFeatureLabel, TAG_FEATURE_ARGUMENTS); // event: model is updated - static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); - ModelAPI_EventCreator::get()->sendUpdated(aFeature, anEvent); + ModelAPI_EventCreator::get()->sendUpdated(aFeature, aCreateEvent); } else { // nothing is changed, both iterators are incremented aFeature = myObjs.Find(aFeatureLabel); aKeptFeatures.insert(aFeature); if (theMarkUpdated) { - static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); - ModelAPI_EventCreator::get()->sendUpdated(aFeature, anEvent); + ModelAPI_EventCreator::get()->sendUpdated(aFeature, anUpdateEvent); } } } - // update results of thefeatures (after features created because they may be connected, like sketch and sub elements) + // update results of the features (after features created because they may be connected, like sketch and sub elements) + std::list aComposites; // composites must be updated after their subs (issue 360) TDF_ChildIDIterator aLabIter2(featuresLabel(), TDataStd_Comment::GetID()); for (; aLabIter2.More(); aLabIter2.Next()) { TDF_Label aFeatureLabel = aLabIter2.Value()->Label(); if (myObjs.IsBound(aFeatureLabel)) { // a new feature is inserted FeaturePtr aFeature = myObjs.Find(aFeatureLabel); + if (std::dynamic_pointer_cast(aFeature).get()) + aComposites.push_back(aFeature); updateResults(aFeature); } } + std::list::iterator aComposite = aComposites.begin(); + for(; aComposite != aComposites.end(); aComposite++) { + updateResults(*aComposite); + } // check all features are checked: if not => it was removed NCollection_DataMap::Iterator aFIter(myObjs); while (aFIter.More()) { if (aKeptFeatures.find(aFIter.Value()) == aKeptFeatures.end() - && aNewFeatures.find(aFIter.Value()) == aNewFeatures.end()) { - FeaturePtr aFeature = aFIter.Value(); - // event: model is updated - //if (aFeature->isInHistory()) { + && aNewFeatures.find(aFIter.Value()) == aNewFeatures.end()) { + FeaturePtr aFeature = aFIter.Value(); + // event: model is updated + //if (aFeature->isInHistory()) { ModelAPI_EventCreator::get()->sendDeleted(aThis, ModelAPI_Feature::group()); - //} - // results of this feature must be redisplayed (hided) - static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); - const std::list >& aResults = aFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); - // redisplay also removed feature (used for sketch and AISObject) - ModelAPI_EventCreator::get()->sendUpdated(aFeature, EVENT_DISP); - aFeature->erase(); - // unbind after the "erase" call: on abort sketch is removes sub-objects that corrupts aFIter - TDF_Label aLab = aFIter.Key(); - aFIter.Next(); - myObjs.UnBind(aLab); + //} + // results of this feature must be redisplayed (hided) + // redisplay also removed feature (used for sketch and AISObject) + ModelAPI_EventCreator::get()->sendUpdated(aFeature, aRedispEvent); + aFeature->erase(); + // unbind after the "erase" call: on abort sketch is removes sub-objects that corrupts aFIter + myObjs.UnBind(aFIter.Key()); + // reinitialize iterator because unbind may corrupt the previous order in the map + aFIter.Initialize(myObjs); } else aFIter.Next(); } @@ -850,13 +1050,13 @@ void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool t myExecuteFeatures = false; aLoop->activateFlushes(true); - aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED)); - aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED)); - aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED)); - aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY)); - aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TOHIDE)); - std::static_pointer_cast(Model_Session::get()) - ->setCheckTransactions(true); + if (theFlush) { + aLoop->flush(aCreateEvent); + aLoop->flush(aDeleteEvent); + aLoop->flush(anUpdateEvent); + aLoop->flush(aRedispEvent); + aLoop->flush(aToHideEvent); + } myExecuteFeatures = true; } @@ -896,7 +1096,8 @@ void Model_Document::synchronizeBackRefs() if (aFData) { std::list > > aRefs; aFData->referencesToObjects(aRefs); - std::list > >::iterator aRefsIter = aRefs.begin(); + std::list > >::iterator + aRefsIter = aRefs.begin(); for(; aRefsIter != aRefs.end(); aRefsIter++) { std::list::iterator aRefTo = aRefsIter->second.begin(); for(; aRefTo != aRefsIter->second.end(); aRefTo++) { @@ -943,7 +1144,11 @@ void Model_Document::storeResult(std::shared_ptr theFeatureData, theResult->setDoc(aThis); initData(theResult, resultLabel(theFeatureData, theResultIndex), TAG_FEATURE_ARGUMENTS); if (theResult->data()->name().empty()) { // if was not initialized, generate event and set a name - theResult->data()->setName(theFeatureData->name()); + std::stringstream aNewName; + aNewName<name(); + if (theResultIndex > 0) // if there are several results, add unique prefix starting from second + aNewName<<"_"<data()->setName(aNewName.str()); } } @@ -1089,3 +1294,36 @@ Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2) { return TDF_LabelMapHasher::IsEqual(theLab1, theLab2); } + +void Model_Document::addNamingName(const TDF_Label theLabel, std::string theName) +{ + myNamingNames[theName] = theLabel; +} + +TDF_Label Model_Document::findNamingName(std::string theName) +{ + std::map::iterator aFind = myNamingNames.find(theName); + if (aFind == myNamingNames.end()) + return TDF_Label(); // not found + return aFind->second; +} + +ResultPtr Model_Document::findByName(const std::string theName) +{ + NCollection_DataMap::Iterator anObjIter(myObjs); + for(; anObjIter.More(); anObjIter.Next()) { + FeaturePtr& aFeature = anObjIter.ChangeValue(); + if (!aFeature) // may be on close + continue; + const std::list >& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.begin(); + for (; aRIter != aResults.cend(); aRIter++) { + if (aRIter->get() && (*aRIter)->data() && (*aRIter)->data()->isValid() && + (*aRIter)->data()->name() == theName) { + return *aRIter; + } + } + } + // not found + return ResultPtr(); +}