X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Document.cpp;h=ec10e79632777634a6ca203b35b9d2f7edced0b1;hb=4b07d0ae015bc7ed510f8795d9d57d408e0367eb;hp=59cb68ddbcc6a96864852f215a529f244260e688;hpb=b5ed624c7308fceecfb3237d1e099729a1cd3c76;p=modules%2Fshaper.git diff --git a/src/Model/Model_Document.cpp b/src/Model/Model_Document.cpp index 59cb68ddb..ec10e7963 100644 --- a/src/Model/Model_Document.cpp +++ b/src/Model/Model_Document.cpp @@ -1,3 +1,5 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D + // File: Model_Document.cxx // Created: 28 Feb 2014 // Author: Mikhail PONIKAROV @@ -12,6 +14,7 @@ #include #include #include +#include #include #include @@ -24,6 +27,8 @@ #include #include #include +#include +#include #include #ifndef WIN32 @@ -36,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) @@ -46,13 +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); - myTransactionsAfterSave = 0; - myNestedNum = -1; + myTransactionSave = 0; myExecuteFeatures = true; // to have something in the document and avoid empty doc open/save problem // in transaction for nesting correct working @@ -94,7 +103,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")); @@ -147,8 +156,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)); + std::shared_ptr aSession = + std::dynamic_pointer_cast(Model_Session::get()); + aSession->setActiveDocument(anApp->getDocument(myID), false); + aSession->setCheckTransactions(false); synchronizeFeatures(false, true); + aSession->setCheckTransactions(true); + aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false); + aSession->setActiveDocument(anApp->getDocument(myID), true); } return !isError; } @@ -156,6 +171,7 @@ bool Model_Document::load(const char* theFileName) bool Model_Document::save(const char* theFileName, std::list& theResults) { // 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()) { #ifdef WIN32 CreateDirectory(theFileName, NULL); @@ -167,7 +183,7 @@ bool Model_Document::save(const char* theFileName, std::list& theRe TCollection_ExtendedString aPath(DocFileName(theFileName, myID)); PCDM_StoreStatus aStatus; try { - aStatus = Model_Application::getApplication()->SaveAs(myDoc, aPath); + aStatus = anApp->SaveAs(myDoc, aPath); } catch (Standard_Failure) { Handle(Standard_Failure) aFail = Standard_Failure::Caught(); Events_Error::send( @@ -189,83 +205,131 @@ bool Model_Document::save(const char* theFileName, std::list& theRe break; } } - myTransactionsAfterSave = 0; + 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); + 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); + } } } return isDone; } -void Model_Document::close() +void Model_Document::close(const bool theForever) { - boost::shared_ptr aPM = Model_Session::get(); + std::shared_ptr aPM = Model_Session::get(); if (this != aPM->moduleDocument().get() && this == aPM->activeDocument().get()) { aPM->setActiveDocument(aPM->moduleDocument()); + } else if (this == aPM->moduleDocument().get()) { + // 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++) - subDoc(*aSubIter)->close(); - mySubs.clear(); - // close this only if it is module document, otherwise it can be undoed - if (this == aPM->moduleDocument().get()) { + const std::set aSubs = subDocuments(true); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) + subDoc(*aSubIter)->close(theForever); + + // close for thid document needs no transaction in this document + std::static_pointer_cast(Model_Session::get())->setCheckTransactions(false); + + // delete all features of this document + std::shared_ptr aThis = + Model_Application::getApplication()->getDocument(myID); + Events_Loop* aLoop = Events_Loop::loop(); + NCollection_DataMap::Iterator aFeaturesIter(myObjs); + for(; aFeaturesIter.More(); aFeaturesIter.Next()) { + FeaturePtr aFeature = aFeaturesIter.Value(); + static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendDeleted(aThis, ModelAPI_Feature::group()); + ModelAPI_EventCreator::get()->sendUpdated(aFeature, EVENT_DISP); + aFeature->eraseResults(); + 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(); + } + aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED)); + aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY)); + + // close all only if it is really asked, otherwise it can be undoed/redoed + if (theForever) { if (myDoc->CanClose() == CDM_CCS_OK) myDoc->Close(); - Model_Application::getApplication()->deleteDocument(myID); } + + std::static_pointer_cast(Model_Session::get())->setCheckTransactions(true); } 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())++; // if has open command, the list is not empty } - myIsEmptyTr[myTransactionsAfterSave] = !myDoc->CommitCommand(); - myTransactionsAfterSave++; + 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(0); + 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) { - myTransactionsAfterSave--; - if (!myIsEmptyTr[myTransactionsAfterSave]) { - allWasEmpty = false; + if (!myNestedNum.empty()) { + int aNumToCompact = *(myNestedNum.rbegin()); + int aSumOfTransaction = 0; + for(int a = 0; a < aNumToCompact; a++) { + aSumOfTransaction += *(myTransactions.rbegin()); + myTransactions.pop_back(); } - myIsEmptyTr.erase(myTransactionsAfterSave); - myNestedNum--; + // the latest transaction is the start of lower-level operation which startes the nested + *(myTransactions.rbegin()) += aSumOfTransaction; + myNestedNum.pop_back(); } - myIsEmptyTr[myTransactionsAfterSave] = allWasEmpty; - myTransactionsAfterSave++; - myDoc->PerformDeltaCompaction(); - return !allWasEmpty; } -void Model_Document::finishOperation() +bool Model_Document::finishOperation() { - // 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(); - - // just to be sure that everybody knows that changes were performed - if (!myDoc->HasOpenCommand() && myNestedNum != -1) - boost::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)); @@ -273,44 +337,71 @@ void Model_Document::finishOperation() aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY)); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_TOHIDE)); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED)); - if (!myDoc->HasOpenCommand() && myNestedNum != -1) - boost::static_pointer_cast(Model_Session::get()) - ->setCheckTransactions(true); // for nested transaction commit - - 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[myTransactionsAfterSave] = !myDoc->CommitCommand(); // && (myNestedNum == -1); - myTransactionsAfterSave++; + // 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 + Events_Loop::loop()->autoFlush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED)); + static std::shared_ptr aFinishMsg + (new Events_Message(Events_Loop::eventByName("FinishOperation"))); + Events_Loop::loop()->send(aFinishMsg); + Events_Loop::loop()->autoFlush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED), false); } + // to avoid "updated" message appearance by updater + //aLoop->clear(Events_Loop::eventByName(EVENT_OBJECT_UPDATED)); + + // finish for all subs first: to avoid nested finishing and "isOperation" calls problems inside + 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())++; + aResult = true; + } + + if (isNestedClosed) { + compactNested(); + } + if (!aResult && !myTransactions.empty() /* it can be for just created part document */) + aResult = *(myTransactions.rbegin()) != 0; + + if (!aResult && Model_Session::get()->moduleDocument().get() == this) { + // 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()) { - // for nested it is undo and clear redos - myDoc->Undo(); - } + if (!myNestedNum.empty() && !myDoc->HasOpenCommand()) { // abort all what was done in nested + compactNested(); + undoInternal(false, false); myDoc->ClearRedos(); - myTransactionsAfterSave--; - myIsEmptyTr.erase(myTransactionsAfterSave); - } else { - if (myNestedNum == 0) // abort only high-level - myNestedNum = -1; + myRedos.clear(); + } else { // abort the current + int aNumTransactions = *myTransactions.rbegin(); + 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 // 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(); } @@ -323,34 +414,48 @@ bool Model_Document::isOperation() bool Model_Document::isModified() { // is modified if at least one operation was commited and not undoed - return myTransactionsAfterSave > 0 || isOperation(); + return myTransactions.size() != myTransactionSave || isOperation(); } bool Model_Document::canUndo() { - if (myDoc->GetAvailableUndos() > 0 && myNestedNum != 0 - && myTransactionsAfterSave != 0 /* for omitting the first useless transaction */) + if (myDoc->GetAvailableUndos() > 0 && (myNestedNum.empty() || *myNestedNum.rbegin() != 0) && + !myTransactions.empty() /* 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) { - myTransactionsAfterSave--; - if (myNestedNum > 0) - myNestedNum--; - if (!myIsEmptyTr[myTransactionsAfterSave]) + int aNumTransactions = *myTransactions.rbegin(); + myTransactions.pop_back(); + myRedos.push_back(aNumTransactions); + 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 (theSynchronize) + synchronizeFeatures(true, true); + 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); + } +} + +void Model_Document::undo() +{ + undoInternal(true, true); } bool Model_Document::canRedo() @@ -358,8 +463,9 @@ bool Model_Document::canRedo() if (myDoc->GetAvailableRedos() > 0) 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; @@ -367,19 +473,23 @@ bool Model_Document::canRedo() void Model_Document::redo() { - if (myNestedNum != -1) - myNestedNum++; - if (!myIsEmptyTr[myTransactionsAfterSave]) + if (!myNestedNum.empty()) + (*myNestedNum.rbegin())++; + int aNumRedos = *myRedos.rbegin(); + myRedos.pop_back(); + myTransactions.push_back(aNumRedos); + for(int a = 0; a < aNumRedos; a++) myDoc->Redo(); - myTransactionsAfterSave++; + 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(); } -/// Appenad to the array of references a new referenced label +/// Append to the array of references a new referenced label static void AddToRefArray(TDF_Label& theArrayLab, TDF_Label& theReferenced) { Handle(TDataStd_ReferenceArray) aRefs; @@ -404,7 +514,7 @@ FeaturePtr Model_Document::addFeature(std::string theID) FeaturePtr aFeature = ModelAPI_Session::get()->createFeature(theID); if (!aFeature) return aFeature; - boost::shared_ptr aDocToAdd = boost::dynamic_pointer_cast( + std::shared_ptr aDocToAdd = std::dynamic_pointer_cast( aFeature->documentToAdd()); if (aFeature) { TDF_Label aFeatureLab; @@ -470,8 +580,8 @@ void Model_Document::removeFeature(FeaturePtr theFeature, const bool 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++) { - boost::shared_ptr aData = - boost::dynamic_pointer_cast((*aResIter)->data()); + 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"); @@ -480,25 +590,27 @@ void Model_Document::removeFeature(FeaturePtr theFeature, const bool theCheck) } } - boost::shared_ptr aData = boost::static_pointer_cast(theFeature->data()); - TDF_Label aFeatureLabel = aData->label().Father(); - if (myObjs.IsBound(aFeatureLabel)) - myObjs.UnBind(aFeatureLabel); - else - return; // not found feature => do not remove - // erase fields - theFeature->erase(); - // erase all attributes under the label of feature - aFeatureLabel.ForgetAllAttributes(); - // remove it from the references array - if (theFeature->isInHistory()) { - RemoveFromRefArray(featuresLabel(), aFeatureLabel); + std::shared_ptr aData = std::static_pointer_cast(theFeature->data()); + if (aData) { + TDF_Label aFeatureLabel = aData->label().Father(); + if (myObjs.IsBound(aFeatureLabel)) + myObjs.UnBind(aFeatureLabel); + else + return; // not found feature => do not remove + // erase fields + theFeature->erase(); + // 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()); } -FeaturePtr Model_Document::feature(TDF_Label& theLabel) +FeaturePtr Model_Document::feature(TDF_Label& theLabel) const { if (myObjs.IsBound(theLabel)) return myObjs.Find(theLabel); @@ -514,10 +626,10 @@ ObjectPtr Model_Document::object(TDF_Label theLabel) TDF_Label aFeatureLabel = theLabel.Father().Father(); // let's suppose it is result aFeature = feature(aFeatureLabel); if (aFeature) { - const std::list >& aResults = aFeature->results(); - std::list >::const_iterator aRIter = aResults.cbegin(); + const std::list >& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.cbegin(); for (; aRIter != aResults.cend(); aRIter++) { - boost::shared_ptr aResData = boost::dynamic_pointer_cast( + std::shared_ptr aResData = std::dynamic_pointer_cast( (*aRIter)->data()); if (aResData->label().Father().IsEqual(theLabel)) return *aRIter; @@ -526,20 +638,40 @@ ObjectPtr Model_Document::object(TDF_Label theLabel) return FeaturePtr(); // not found } -boost::shared_ptr Model_Document::subDocument(std::string theDocID) +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); } -boost::shared_ptr Model_Document::subDoc(std::string 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 boost::dynamic_pointer_cast( + return std::dynamic_pointer_cast( Model_Application::getApplication()->getDocument(theDocID)); } @@ -573,8 +705,8 @@ ObjectPtr Model_Document::object(const std::string& theGroupID, const int theInd 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(); + const std::list >& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.begin(); for (; aRIter != aResults.cend(); aRIter++) { if ((*aRIter)->groupName() != theGroupID) continue; bool isIn = theHidden && (*aRIter)->isInHistory(); @@ -610,8 +742,10 @@ int Model_Document::size(const std::string& theGroupID, const bool theHidden) 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(); + 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)->groupName() != theGroupID) continue; bool isIn = theHidden; @@ -627,7 +761,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); } @@ -653,8 +787,8 @@ void Model_Document::setUniqueName(FeaturePtr theFeature) FeaturePtr aFeature = aFIter.Value(); bool isSameName = aFeature->data()->name() == aName; if (!isSameName) { // check also results to avoid same results names (actual for Parts) - const std::list >& aResults = aFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); + const std::list >& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.begin(); for (; aRIter != aResults.cend(); aRIter++) { isSameName = (*aRIter)->data()->name() == aName; } @@ -674,14 +808,14 @@ void Model_Document::setUniqueName(FeaturePtr theFeature) void Model_Document::initData(ObjectPtr theObj, TDF_Label theLab, const int theTag) { - boost::shared_ptr aThis = Model_Application::getApplication()->getDocument( + std::shared_ptr aThis = Model_Application::getApplication()->getDocument( myID); - boost::shared_ptr aData(new Model_Data); + std::shared_ptr aData(new Model_Data); aData->setLabel(theLab.FindChild(theTag)); aData->setObject(theObj); theObj->setDoc(aThis); theObj->setData(aData); - FeaturePtr aFeature = boost::dynamic_pointer_cast(theObj); + FeaturePtr aFeature = std::dynamic_pointer_cast(theObj); if (aFeature) { setUniqueName(aFeature); // must be before "initAttributes" because duplicate part uses name aFeature->initAttributes(); @@ -690,11 +824,9 @@ void Model_Document::initData(ObjectPtr theObj, TDF_Label theLab, const int theT void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool theUpdateReferences) { - boost::shared_ptr aThis = + std::shared_ptr aThis = Model_Application::getApplication()->getDocument(myID); // after all updates, sends a message that groups of features were created or updated - boost::static_pointer_cast(Model_Session::get()) - ->setCheckTransactions(false); Events_Loop* aLoop = Events_Loop::loop(); aLoop->activateFlushes(false); @@ -722,9 +854,6 @@ void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool t // event: model is updated static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); ModelAPI_EventCreator::get()->sendUpdated(aFeature, anEvent); - - // update results of the appeared feature - updateResults(aFeature); } else { // nothing is changed, both iterators are incremented aFeature = myObjs.Find(aFeatureLabel); aKeptFeatures.insert(aFeature); @@ -732,9 +861,25 @@ void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool t static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); ModelAPI_EventCreator::get()->sendUpdated(aFeature, anEvent); } + } + } + // update results of thefeatures (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()) { @@ -747,15 +892,15 @@ void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool t //} // 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(); + 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); + myObjs.UnBind(aFIter.Key()); + // reinitialize iterator because unbind may corrupt the previous order in the map + aFIter.Initialize(myObjs); } else aFIter.Next(); } @@ -772,14 +917,12 @@ void Model_Document::synchronizeFeatures(const bool theMarkUpdated, const bool t 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)); - boost::static_pointer_cast(Model_Session::get()) - ->setCheckTransactions(true); myExecuteFeatures = true; } void Model_Document::synchronizeBackRefs() { - boost::shared_ptr aThis = + std::shared_ptr aThis = Model_Application::getApplication()->getDocument(myID); // keeps the concealed flags of result to catch the change and create created/deleted events std::list > aConcealed; @@ -787,16 +930,16 @@ void Model_Document::synchronizeBackRefs() NCollection_DataMap::Iterator aFeatures(myObjs); for(; aFeatures.More(); aFeatures.Next()) { FeaturePtr aFeature = aFeatures.Value(); - boost::shared_ptr aFData = - boost::dynamic_pointer_cast(aFeature->data()); + std::shared_ptr aFData = + std::dynamic_pointer_cast(aFeature->data()); if (aFData) { aFData->eraseBackReferences(); } - const std::list >& aResults = aFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); + const std::list >& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.begin(); for (; aRIter != aResults.cend(); aRIter++) { - boost::shared_ptr aResData = - boost::dynamic_pointer_cast((*aRIter)->data()); + std::shared_ptr aResData = + std::dynamic_pointer_cast((*aRIter)->data()); if (aResData) { aConcealed.push_back(std::pair(*aRIter, (*aRIter)->isConcealed())); aResData->eraseBackReferences(); @@ -808,8 +951,8 @@ void Model_Document::synchronizeBackRefs() ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators(); for(aFeatures.Initialize(myObjs); aFeatures.More(); aFeatures.Next()) { FeaturePtr aFeature = aFeatures.Value(); - boost::shared_ptr aFData = - boost::dynamic_pointer_cast(aFeature->data()); + std::shared_ptr aFData = + std::dynamic_pointer_cast(aFeature->data()); if (aFData) { std::list > > aRefs; aFData->referencesToObjects(aRefs); @@ -818,8 +961,8 @@ void Model_Document::synchronizeBackRefs() std::list::iterator aRefTo = aRefsIter->second.begin(); for(; aRefTo != aRefsIter->second.end(); aRefTo++) { if (*aRefTo) { - boost::shared_ptr aRefData = - boost::dynamic_pointer_cast((*aRefTo)->data()); + std::shared_ptr aRefData = + std::dynamic_pointer_cast((*aRefTo)->data()); aRefData->addBackReference(aFeature, aRefsIter->first); // here the Concealed flag is updated } } @@ -834,24 +977,28 @@ void Model_Document::synchronizeBackRefs() ModelAPI_EventCreator::get()->sendUpdated(aCIter->first, anEvent); } else { // was not concealed become concealed => delete event ModelAPI_EventCreator::get()->sendDeleted(aThis, aCIter->first->groupName()); + // redisplay for the viewer (it must be disappeared also) + static Events_ID EVENT_DISP = + Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendUpdated(aCIter->first, EVENT_DISP); } } } } TDF_Label Model_Document::resultLabel( - const boost::shared_ptr& theFeatureData, const int theResultIndex) + const std::shared_ptr& theFeatureData, const int theResultIndex) { - const boost::shared_ptr& aData = - boost::dynamic_pointer_cast(theFeatureData); + const std::shared_ptr& aData = + std::dynamic_pointer_cast(theFeatureData); return aData->label().Father().FindChild(TAG_FEATURE_RESULTS).FindChild(theResultIndex + 1); } -void Model_Document::storeResult(boost::shared_ptr theFeatureData, - boost::shared_ptr theResult, +void Model_Document::storeResult(std::shared_ptr theFeatureData, + std::shared_ptr theResult, const int theResultIndex) { - boost::shared_ptr aThis = + std::shared_ptr aThis = Model_Application::getApplication()->getDocument(myID); theResult->setDoc(aThis); initData(theResult, resultLabel(theFeatureData, theResultIndex), TAG_FEATURE_ARGUMENTS); @@ -860,78 +1007,78 @@ void Model_Document::storeResult(boost::shared_ptr theFeatureData } } -boost::shared_ptr Model_Document::createConstruction( - const boost::shared_ptr& theFeatureData, const int theIndex) +std::shared_ptr Model_Document::createConstruction( + const std::shared_ptr& theFeatureData, const int theIndex) { TDF_Label aLab = resultLabel(theFeatureData, theIndex); TDataStd_Comment::Set(aLab, ModelAPI_ResultConstruction::group().c_str()); ObjectPtr anOldObject = object(aLab); - boost::shared_ptr aResult; + std::shared_ptr aResult; if (anOldObject) { - aResult = boost::dynamic_pointer_cast(anOldObject); + aResult = std::dynamic_pointer_cast(anOldObject); } if (!aResult) { - aResult = boost::shared_ptr(new Model_ResultConstruction); + aResult = std::shared_ptr(new Model_ResultConstruction); storeResult(theFeatureData, aResult, theIndex); } return aResult; } -boost::shared_ptr Model_Document::createBody( - const boost::shared_ptr& theFeatureData, const int theIndex) +std::shared_ptr Model_Document::createBody( + const std::shared_ptr& theFeatureData, const int theIndex) { TDF_Label aLab = resultLabel(theFeatureData, theIndex); TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str()); ObjectPtr anOldObject = object(aLab); - boost::shared_ptr aResult; + std::shared_ptr aResult; if (anOldObject) { - aResult = boost::dynamic_pointer_cast(anOldObject); + aResult = std::dynamic_pointer_cast(anOldObject); } if (!aResult) { - aResult = boost::shared_ptr(new Model_ResultBody); + aResult = std::shared_ptr(new Model_ResultBody); storeResult(theFeatureData, aResult, theIndex); } return aResult; } -boost::shared_ptr Model_Document::createPart( - const boost::shared_ptr& theFeatureData, const int theIndex) +std::shared_ptr Model_Document::createPart( + const std::shared_ptr& theFeatureData, const int theIndex) { TDF_Label aLab = resultLabel(theFeatureData, theIndex); TDataStd_Comment::Set(aLab, ModelAPI_ResultPart::group().c_str()); ObjectPtr anOldObject = object(aLab); - boost::shared_ptr aResult; + std::shared_ptr aResult; if (anOldObject) { - aResult = boost::dynamic_pointer_cast(anOldObject); + aResult = std::dynamic_pointer_cast(anOldObject); } if (!aResult) { - aResult = boost::shared_ptr(new Model_ResultPart); + aResult = std::shared_ptr(new Model_ResultPart); storeResult(theFeatureData, aResult, theIndex); } return aResult; } -boost::shared_ptr Model_Document::createGroup( - const boost::shared_ptr& theFeatureData, const int theIndex) +std::shared_ptr Model_Document::createGroup( + const std::shared_ptr& theFeatureData, const int theIndex) { TDF_Label aLab = resultLabel(theFeatureData, theIndex); TDataStd_Comment::Set(aLab, ModelAPI_ResultGroup::group().c_str()); ObjectPtr anOldObject = object(aLab); - boost::shared_ptr aResult; + std::shared_ptr aResult; if (anOldObject) { - aResult = boost::dynamic_pointer_cast(anOldObject); + aResult = std::dynamic_pointer_cast(anOldObject); } if (!aResult) { - aResult = boost::shared_ptr(new Model_ResultGroup(theFeatureData)); + aResult = std::shared_ptr(new Model_ResultGroup(theFeatureData)); storeResult(theFeatureData, aResult, theIndex); } return aResult; } -boost::shared_ptr Model_Document::feature( - const boost::shared_ptr& theResult) +std::shared_ptr Model_Document::feature( + const std::shared_ptr& theResult) { - boost::shared_ptr aData = boost::dynamic_pointer_cast(theResult->data()); + std::shared_ptr aData = std::dynamic_pointer_cast(theResult->data()); if (aData) { TDF_Label aFeatureLab = aData->label().Father().Father().Father(); return feature(aFeatureLab); @@ -942,11 +1089,11 @@ boost::shared_ptr Model_Document::feature( void Model_Document::updateResults(FeaturePtr theFeature) { // for not persistent is will be done by parametric updater automatically - if (!theFeature->isPersistentResult()) return; + //if (!theFeature->isPersistentResult()) return; // check the existing results and remove them if there is nothing on the label std::list::const_iterator aResIter = theFeature->results().cbegin(); while(aResIter != theFeature->results().cend()) { - ResultBodyPtr aBody = boost::dynamic_pointer_cast(*aResIter); + ResultPtr aBody = std::dynamic_pointer_cast(*aResIter); if (aBody) { if (!aBody->data()->isValid()) { // found a disappeared result => remove it @@ -958,6 +1105,9 @@ void Model_Document::updateResults(FeaturePtr theFeature) } aResIter++; } + // it may be on undo + if (!theFeature->data() || !theFeature->data()->isValid()) + return; // check that results are presented on all labels int aResSize = theFeature->results().size(); TDF_ChildIterator aLabIter(resultLabel(theFeature->data(), 0).Father()); @@ -973,8 +1123,12 @@ void Model_Document::updateResults(FeaturePtr theFeature) aNewBody = createBody(theFeature->data(), aResIndex); } else if (aGroup->Get() == ModelAPI_ResultPart::group().c_str()) { aNewBody = createPart(theFeature->data(), aResIndex); - } else if (aGroup->Get() != ModelAPI_ResultConstruction::group().c_str() && - aGroup->Get() != ModelAPI_ResultGroup::group().c_str()) { + } else if (aGroup->Get() == ModelAPI_ResultConstruction::group().c_str()) { + theFeature->execute(); // construction shapes are needed for sketch solver + break; + } else if (aGroup->Get() == ModelAPI_ResultGroup::group().c_str()) { + aNewBody = createGroup(theFeature->data(), aResIndex); + } else { Events_Error::send(std::string("Unknown type of result is found in the document:") + TCollection_AsciiString(aGroup->Get()).ToCString()); } @@ -995,3 +1149,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(); +}