X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Document.cpp;h=54840e4bc65d1cedfe0165601732964bc28b12e9;hb=323ddeaed96f1be1a1071a7facc924085cd65d39;hp=e0ae73e76109b438637f051a4f49870317863581;hpb=7cb6ac084270943d926ec7ef35bf9e63d6a3eaf5;p=modules%2Fshaper.git diff --git a/src/Model/Model_Document.cpp b/src/Model/Model_Document.cpp old mode 100644 new mode 100755 index e0ae73e76..54840e4bc --- a/src/Model/Model_Document.cpp +++ b/src/Model/Model_Document.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include #include @@ -23,8 +24,11 @@ #include #include #include +#include +#include #include #include +#include #include #include #include @@ -35,6 +39,11 @@ #include #include #include +#include +#include +#include +#include +#include #include #ifndef WIN32 @@ -53,10 +62,10 @@ static const int TAG_GENERAL = 1; // general properties tag // general sub-labels static const int TAG_CURRENT_FEATURE = 1; ///< where the reference to the current feature label is located (or no attribute if null feature) -static const int TAG_CURRENT_TRANSACTION = 2; ///< integer, index of the cransaction +static const int TAG_CURRENT_TRANSACTION = 2; ///< integer, index of the transaction static const int TAG_SELECTION_FEATURE = 3; ///< integer, tag of the selection feature label -Model_Document::Model_Document(const std::string theID, const std::string theKind) +Model_Document::Model_Document(const int theID, const std::string theKind) : myID(theID), myKind(theKind), myIsActive(false), myDoc(new TDocStd_Document("BinOcaf")) // binary OCAF format { @@ -78,10 +87,10 @@ void Model_Document::setThis(DocumentPtr theDoc) myObjs->setOwner(theDoc); } -/// Returns the file name of this document by the nameof directory and identifuer of a document -static TCollection_ExtendedString DocFileName(const char* theFileName, const std::string& theID) +/// Returns the file name of this document by the name of directory and identifier of a document +static TCollection_ExtendedString DocFileName(const char* theDirName, const std::string& theID) { - TCollection_ExtendedString aPath((const Standard_CString) theFileName); + TCollection_ExtendedString aPath((const Standard_CString) theDirName); // remove end-separators while(aPath.Length() && (aPath.Value(aPath.Length()) == '\\' || aPath.Value(aPath.Length()) == '/')) @@ -97,13 +106,13 @@ bool Model_Document::isRoot() const return this == Model_Session::get()->moduleDocument().get(); } -bool Model_Document::load(const char* theFileName, DocumentPtr theThis) +bool Model_Document::load(const char* theDirName, const char* theFileName, DocumentPtr theThis) { Handle(Model_Application) anApp = Model_Application::getApplication(); if (isRoot()) { - anApp->setLoadPath(theFileName); + anApp->setLoadPath(theDirName); } - TCollection_ExtendedString aPath(DocFileName(theFileName, myID)); + TCollection_ExtendedString aPath(DocFileName(theDirName, theFileName)); PCDM_ReaderStatus aStatus = (PCDM_ReaderStatus) -1; Handle(TDocStd_Document) aLoaded; try { @@ -174,7 +183,7 @@ bool Model_Document::load(const char* theFileName, DocumentPtr theThis) myDoc = aLoaded; myDoc->SetUndoLimit(UNDO_LIMIT); // to avoid the problem that feature is created in the current, not this, document - aSession->setActiveDocument(anApp->getDocument(myID), false); + aSession->setActiveDocument(anApp->document(myID), false); aSession->setCheckTransactions(false); if (myObjs) delete myObjs; @@ -186,13 +195,25 @@ bool Model_Document::load(const char* theFileName, DocumentPtr theThis) aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false); // this is done in Part result "activate", so no needed here. Causes not-blue active part. // aSession->setActiveDocument(anApp->getDocument(myID), true); + + // make sub-parts as loaded by demand + std::list aPartResults; + myObjs->allResults(ModelAPI_ResultPart::group(), aPartResults); + std::list::iterator aPartRes = aPartResults.begin(); + for(; aPartRes != aPartResults.end(); aPartRes++) { + ResultPartPtr aPart = std::dynamic_pointer_cast(*aPartRes); + if (aPart.get()) + anApp->setLoadByDemand(aPart->data()->name()); + } + } else { // open failed, but new documnet was created to work with it: inform the model aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false); } return !isError; } -bool Model_Document::save(const char* theFileName, std::list& theResults) +bool Model_Document::save( + const char* theDirName, 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(); @@ -204,7 +225,7 @@ bool Model_Document::save(const char* theFileName, std::list& theRe #endif } // filename in the dir is id of document inside of the given directory - TCollection_ExtendedString aPath(DocFileName(theFileName, myID)); + TCollection_ExtendedString aPath(DocFileName(theDirName, theFileName)); PCDM_StoreStatus aStatus; try { aStatus = anApp->SaveAs(myDoc, aPath); @@ -229,22 +250,25 @@ bool Model_Document::save(const char* theFileName, std::list& theRe break; } } - myTransactionSave = myTransactions.size(); + myTransactionSave = int(myTransactions.size()); if (isDone) { // save also sub-documents if any theResults.push_back(TCollection_AsciiString(aPath).ToCString()); - const std::set aSubs = subDocuments(false); - std::set::iterator aSubIter = aSubs.begin(); - for (; aSubIter != aSubs.end() && isDone; aSubIter++) { - if (anApp->isLoadByDemand(*aSubIter)) { + // iterate all result parts to find all loaded or not yet loaded documents + std::list aPartResults; + myObjs->allResults(ModelAPI_ResultPart::group(), aPartResults); + std::list::iterator aPartRes = aPartResults.begin(); + for(; aPartRes != aPartResults.end(); aPartRes++) { + ResultPartPtr aPart = std::dynamic_pointer_cast(*aPartRes); + if (!aPart->isActivated()) { // copy not-activated document that is not in the memory - std::string aDocName = *aSubIter; + std::string aDocName = aPart->data()->name(); 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)); + TCollection_AsciiString aDestinationDir(DocFileName(theDirName, aDocName)); OSD_Path aDestination(aDestinationDir); aFile.Copy(aDestination); theResults.push_back(aDestinationDir.ToCString()); @@ -254,7 +278,8 @@ bool Model_Document::save(const char* theFileName, std::list& theRe } } } else { // simply save opened document - isDone = subDoc(*aSubIter)->save(theFileName, theResults); + isDone = std::dynamic_pointer_cast(aPart->partDoc())-> + save(theDirName, aPart->data()->name().c_str(), theResults); } } } @@ -271,8 +296,8 @@ void Model_Document::close(const bool theForever) aPM->setActiveDocument(DocumentPtr()); } // close all subs - const std::set aSubs = subDocuments(true); - std::set::iterator aSubIter = aSubs.begin(); + const std::set aSubs = subDocuments(); + std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) { std::shared_ptr aSub = subDoc(*aSubIter); if (aSub->myObjs) // if it was not closed before @@ -292,6 +317,10 @@ void Model_Document::close(const bool theForever) mySelectionFeature.reset(); } else { setCurrentFeature(FeaturePtr(), false); // disables all features + // update the OB: features are disabled (on remove of Part) + Events_Loop* aLoop = Events_Loop::loop(); + static Events_ID aDeleteEvent = Events_Loop::eventByName(EVENT_OBJECT_DELETED); + aLoop->flush(aDeleteEvent); } std::static_pointer_cast(Model_Session::get())->setCheckTransactions(true); @@ -299,6 +328,7 @@ void Model_Document::close(const bool theForever) void Model_Document::startOperation() { + incrementTransactionID(); // outside of transaction in order to avoid empty transactions keeping if (myDoc->HasOpenCommand()) { // start of nested command 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 @@ -309,14 +339,13 @@ void Model_Document::startOperation() myDoc->NewCommand(); } // starts a new operation - incrementTransactionID(); myTransactions.push_back(Transaction()); if (!myNestedNum.empty()) (*myNestedNum.rbegin())++; myRedos.clear(); // new command for all subs - const std::set aSubs = subDocuments(true); - std::set::iterator aSubIter = aSubs.begin(); + const std::set aSubs = subDocuments(); + std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) subDoc(*aSubIter)->startOperation(); } @@ -336,11 +365,141 @@ void Model_Document::compactNested() } } +/// Compares the content ofthe given attributes, returns true if equal. +/// This method is used to avoid empty transactions when only "current" is changed +/// to some value and then comes back in this transaction, so, it compares only +/// references and Boolean and Integer Arrays for the current moment. +static bool isEqualContent(Handle(TDF_Attribute) theAttr1, Handle(TDF_Attribute) theAttr2) +{ + if (Standard_GUID::IsEqual(theAttr1->ID(), TDF_Reference::GetID())) { // reference + Handle(TDF_Reference) aRef1 = Handle(TDF_Reference)::DownCast(theAttr1); + Handle(TDF_Reference) aRef2 = Handle(TDF_Reference)::DownCast(theAttr2); + if (aRef1.IsNull() && aRef2.IsNull()) + return true; + if (aRef1.IsNull() || aRef2.IsNull()) + return false; + return aRef1->Get().IsEqual(aRef2->Get()) == Standard_True; + } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDataStd_BooleanArray::GetID())) { + Handle(TDataStd_BooleanArray) anArr1 = Handle(TDataStd_BooleanArray)::DownCast(theAttr1); + Handle(TDataStd_BooleanArray) anArr2 = Handle(TDataStd_BooleanArray)::DownCast(theAttr2); + if (anArr1.IsNull() && anArr2.IsNull()) + return true; + if (anArr1.IsNull() || anArr2.IsNull()) + return false; + if (anArr1->Lower() == anArr2->Lower() && anArr1->Upper() == anArr2->Upper()) { + for(int a = anArr1->Lower(); a <= anArr1->Upper(); a++) + if (a != 1 && anArr1->Value(a) != anArr2->Value(a)) // second is for display + return false; + return true; + } + } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDataStd_IntegerArray::GetID())) { + Handle(TDataStd_IntegerArray) anArr1 = Handle(TDataStd_IntegerArray)::DownCast(theAttr1); + Handle(TDataStd_IntegerArray) anArr2 = Handle(TDataStd_IntegerArray)::DownCast(theAttr2); + if (anArr1.IsNull() && anArr2.IsNull()) + return true; + if (anArr1.IsNull() || anArr2.IsNull()) + return false; + if (anArr1->Lower() == anArr2->Lower() && anArr1->Upper() == anArr2->Upper()) { + for(int a = anArr1->Lower(); a <= anArr1->Upper(); a++) + if (anArr1->Value(a) != anArr2->Value(a)) { + // avoid the transaction ID checking + if (a == 2 && anArr1->Upper() == 2 && anArr2->Label().Tag() == 1 && + (anArr2->Label().Depth() == 4 || anArr2->Label().Depth() == 6)) + continue; + return false; + } + return true; + } + } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDataStd_ReferenceArray::GetID())) { + Handle(TDataStd_ReferenceArray) anArr1 = Handle(TDataStd_ReferenceArray)::DownCast(theAttr1); + Handle(TDataStd_ReferenceArray) anArr2 = Handle(TDataStd_ReferenceArray)::DownCast(theAttr2); + if (anArr1.IsNull() && anArr2.IsNull()) + return true; + if (anArr1.IsNull() || anArr2.IsNull()) + return false; + if (anArr1->Lower() == anArr2->Lower() && anArr1->Upper() == anArr2->Upper()) { + for(int a = anArr1->Lower(); a <= anArr1->Upper(); a++) + if (anArr1->Value(a) != anArr2->Value(a)) { + // avoid the transaction ID checking + if (a == 2 && anArr1->Upper() == 2 && anArr2->Label().Tag() == 1 && + (anArr2->Label().Depth() == 4 || anArr2->Label().Depth() == 6)) + continue; + return false; + } + return true; + } + } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDataStd_ReferenceList::GetID())) { + Handle(TDataStd_ReferenceList) aList1 = Handle(TDataStd_ReferenceList)::DownCast(theAttr1); + Handle(TDataStd_ReferenceList) aList2= Handle(TDataStd_ReferenceList)::DownCast(theAttr2); + if (aList1.IsNull() && aList2.IsNull()) + return true; + if (aList1.IsNull() || aList2.IsNull()) + return false; + const TDF_LabelList& aLList1 = aList1->List(); + const TDF_LabelList& aLList2 = aList2->List(); + TDF_ListIteratorOfLabelList aLIter1(aLList1); + TDF_ListIteratorOfLabelList aLIter2(aLList2); + for(; aLIter1.More() && aLIter2.More(); aLIter1.Next(), aLIter2.Next()) { + if (aLIter1.Value() != aLIter2.Value()) + return false; + } + return !aLIter1.More() && !aLIter2.More(); // both lists are with the same size + } else if (Standard_GUID::IsEqual(theAttr1->ID(), TDF_TagSource::GetID())) { + return true; // it just for created and removed feature: nothing is changed + } + return false; +} + +/// Returns true if the last transaction is actually empty: modification to te same values +/// were performed only +static bool isEmptyTransaction(const Handle(TDocStd_Document)& theDoc) { + Handle(TDF_Delta) aDelta; + aDelta = theDoc->GetUndos().Last(); + TDF_LabelList aDeltaList; + aDelta->Labels(aDeltaList); // it clears list, so, use new one and then append to the result + for(TDF_ListIteratorOfLabelList aListIter(aDeltaList); aListIter.More(); aListIter.Next()) { + return false; + } + // add also label of the modified attributes + const TDF_AttributeDeltaList& anAttrs = aDelta->AttributeDeltas(); + for (TDF_ListIteratorOfAttributeDeltaList anAttr(anAttrs); anAttr.More(); anAttr.Next()) { + Handle(TDF_AttributeDelta)& anADelta = anAttr.Value(); + Handle(TDF_DeltaOnAddition) anAddition = Handle(TDF_DeltaOnAddition)::DownCast(anADelta); + if (anAddition.IsNull()) { // if the attribute was added, transaction is not empty + if (!anADelta->Label().IsNull() && !anADelta->Attribute().IsNull()) { + Handle(TDF_Attribute) aCurrentAttr; + if (anADelta->Label().FindAttribute(anADelta->Attribute()->ID(), aCurrentAttr)) { + if (isEqualContent(anADelta->Attribute(), aCurrentAttr)) { + continue; // attribute is not changed actually + } + } else if (Standard_GUID::IsEqual(anADelta->Attribute()->ID(), TDataStd_AsciiString::GetID())) { + continue; // error message is disappeared + } + } + } + return false; + } + return true; +} + bool Model_Document::finishOperation() { bool isNestedClosed = !myDoc->HasOpenCommand() && !myNestedNum.empty(); static std::shared_ptr aSession = std::static_pointer_cast(Model_Session::get()); + // do it before flashes to enable and recompute nesting features correctly + if (myNestedNum.empty() || (isNestedClosed && myNestedNum.size() == 1)) { + // if all nested operations are closed, make current the higher level objects (to perform + // it in the python scripts correctly): sketch become current after creation ofsub-elements + FeaturePtr aCurrent = currentFeature(false); + CompositeFeaturePtr aMain, aNext = ModelAPI_Tools::compositeOwner(aCurrent); + while(aNext.get()) { + aMain = aNext; + aNext = ModelAPI_Tools::compositeOwner(aMain); + } + if (aMain.get() && aMain != aCurrent) + setCurrentFeature(aMain, false); + } myObjs->synchronizeBackRefs(); Events_Loop* aLoop = Events_Loop::loop(); aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED)); @@ -362,16 +521,21 @@ bool Model_Document::finishOperation() // 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(); + const std::set aSubs = subDocuments(); + 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 (isEmptyTransaction(myDoc)) { // erase this transaction + myDoc->Undo(); + myDoc->ClearRedos(); + } else { + myTransactions.rbegin()->myOCAFNum++; + aResult = true; + } } if (isNestedClosed) { @@ -439,9 +603,9 @@ void Model_Document::abortOperation() if (!myNestedNum.empty()) (*myNestedNum.rbegin())--; // roll back the needed number of transactions - // make commit/undo to get the modification delta //myDoc->AbortCommand(); - if (myDoc->CommitCommand()) { + // instead of abort, do commit and undo: to get the delta of modifications + if (myDoc->CommitCommand()) { modifiedLabels(myDoc, aDeltaLabels); myDoc->Undo(); } @@ -452,12 +616,12 @@ void Model_Document::abortOperation() myDoc->ClearRedos(); } // abort for all subs, flushes will be later, in the end of root abort - const std::set aSubs = subDocuments(true); - std::set::iterator aSubIter = aSubs.begin(); + const std::set aSubs = subDocuments(); + std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) subDoc(*aSubIter)->abortOperation(); // references may be changed because they are set in attributes on the fly - myObjs->synchronizeFeatures(aDeltaLabels, true, isRoot()); + myObjs->synchronizeFeatures(aDeltaLabels, true, false, isRoot()); } bool Model_Document::isOperation() const @@ -481,8 +645,8 @@ bool Model_Document::canUndo() myTransactions.size() - aCurrentNum > 0 /* for omitting the first useless transaction */) return true; // check other subs contains operation that can be undoed - const std::set aSubs = subDocuments(true); - std::set::iterator aSubIter = aSubs.begin(); + const std::set aSubs = subDocuments(); + std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) { std::shared_ptr aSub = subDoc(*aSubIter); if (aSub->myObjs) {// if it was not closed before @@ -496,6 +660,8 @@ bool Model_Document::canUndo() void Model_Document::undoInternal(const bool theWithSubs, const bool theSynchronize) { + if (myTransactions.empty()) + return; int aNumTransactions = myTransactions.rbegin()->myOCAFNum; myRedos.push_back(*myTransactions.rbegin()); myTransactions.pop_back(); @@ -511,8 +677,8 @@ void Model_Document::undoInternal(const bool theWithSubs, const bool theSynchron if (theWithSubs) { // undo for all subs - const std::set aSubs = subDocuments(true); - std::set::iterator aSubIter = aSubs.begin(); + const std::set aSubs = subDocuments(); + std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) { if (!subDoc(*aSubIter)->myObjs) continue; @@ -521,7 +687,7 @@ void Model_Document::undoInternal(const bool theWithSubs, const bool theSynchron } // after undo of all sub-documents to avoid updates on not-modified data (issue 370) if (theSynchronize) { - myObjs->synchronizeFeatures(aDeltaLabels, true, isRoot()); + myObjs->synchronizeFeatures(aDeltaLabels, true, false, isRoot()); // update the current features status setCurrentFeature(currentFeature(false), false); } @@ -537,8 +703,8 @@ bool Model_Document::canRedo() if (!myRedos.empty()) return true; // check other subs contains operation that can be redoed - const std::set aSubs = subDocuments(true); - std::set::iterator aSubIter = aSubs.begin(); + const std::set aSubs = subDocuments(); + std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) { if (!subDoc(*aSubIter)->myObjs) continue; @@ -562,13 +728,13 @@ void Model_Document::redo() } // redo for all subs - const std::set aSubs = subDocuments(true); - std::set::iterator aSubIter = aSubs.begin(); + const std::set aSubs = subDocuments(); + 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) - myObjs->synchronizeFeatures(aDeltaLabels, true, isRoot()); + myObjs->synchronizeFeatures(aDeltaLabels, true, false, isRoot()); // update the current features status setCurrentFeature(currentFeature(false), false); } @@ -579,7 +745,7 @@ std::list Model_Document::undoList() const // 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(); + int aNumUndo = int(myTransactions.size()); if (!myNestedNum.empty()) aNumUndo = *myNestedNum.rbegin(); for( ; aNumUndo > 0; aTrIter++, aNumUndo--) { @@ -666,9 +832,18 @@ void Model_Document::removeFeature(FeaturePtr theFeature) void Model_Document::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis) { + bool aCurrentUp = theMoved == currentFeature(false); + if (aCurrentUp) { + setCurrentFeatureUp(); + } + myObjs->moveFeature(theMoved, theAfterThis); - if (theAfterThis == currentFeature(true)) + if (aCurrentUp) { // make the moved feature enabled or disabled due to the real status + setCurrentFeature(currentFeature(false), false); + } else if (theAfterThis == currentFeature(false)) { + // must be after move to make enabled all features which are before theMoved setCurrentFeature(theMoved, true); + } } void Model_Document::updateHistory(const std::shared_ptr theObject) @@ -681,31 +856,26 @@ void Model_Document::updateHistory(const std::string theGroup) myObjs->updateHistory(theGroup); } -std::shared_ptr Model_Document::subDocument(std::string theDocID) -{ - return Model_Application::getApplication()->getDocument(theDocID); -} - -const std::set Model_Document::subDocuments(const bool theActivatedOnly) const +const std::set Model_Document::subDocuments() const { - std::set aResult; + std::set aResult; std::list aPartResults; myObjs->allResults(ModelAPI_ResultPart::group(), aPartResults); std::list::iterator aPartRes = aPartResults.begin(); for(; aPartRes != aPartResults.end(); aPartRes++) { ResultPartPtr aPart = std::dynamic_pointer_cast(*aPartRes); - if (aPart && (!theActivatedOnly || aPart->isActivated())) { - aResult.insert(aPart->original()->data()->name()); + if (aPart && aPart->isActivated()) { + aResult.insert(aPart->original()->partDoc()->id()); } } return aResult; } -std::shared_ptr Model_Document::subDoc(std::string theDocID) +std::shared_ptr Model_Document::subDoc(int theDocID) { // just store sub-document identifier here to manage it later return std::dynamic_pointer_cast( - Model_Application::getApplication()->getDocument(theDocID)); + Model_Application::getApplication()->document(theDocID)); } ObjectPtr Model_Document::object(const std::string& theGroupID, const int theIndex) @@ -726,6 +896,8 @@ const int Model_Document::index(std::shared_ptr theObject) int Model_Document::size(const std::string& theGroupID) { + if (myObjs == 0) // may be on close + return 0; return myObjs->size(theGroupID); } @@ -739,8 +911,7 @@ std::shared_ptr Model_Document::currentFeature(const bool theV TDF_Label aLab = aRef->Get(); FeaturePtr aResult = myObjs->feature(aLab); if (theVisible) { // get nearest visible (in history) going up - while(aResult.get() && // sub-composites are never in history - (!aResult->isInHistory() || ModelAPI_Tools::compositeOwner(aResult).get())) { + while(aResult.get() && !aResult->isInHistory()) { aResult = myObjs->nextFeature(aResult, true); } } @@ -749,6 +920,17 @@ std::shared_ptr Model_Document::currentFeature(const bool theV return std::shared_ptr(); // null feature means the higher than first } +// recursive function to check if theSub is a child of theMain composite feature +// through all the hierarchy of parents +static bool isSub(const CompositeFeaturePtr theMain, const FeaturePtr theSub) { + CompositeFeaturePtr aParent = ModelAPI_Tools::compositeOwner(theSub); + if (!aParent.get()) + return false; + if (aParent == theMain) + return true; + return isSub(theMain, aParent); +} + void Model_Document::setCurrentFeature( std::shared_ptr theCurrent, const bool theVisible) { @@ -759,24 +941,20 @@ void Model_Document::setCurrentFeature( TDF_Label aRefLab = generalLabel().FindChild(TAG_CURRENT_FEATURE); CompositeFeaturePtr aMain; // main feature that may nest the new current + std::set anOwners; // composites that contain theCurrent (with any level of nesting) if (theCurrent.get()) { aMain = std::dynamic_pointer_cast(theCurrent); - if (!aMain.get()) { - // if feature nests into compisite feature, make the composite feature as current - const std::set& aRefsToMe = theCurrent->data()->refsToMe(); - std::set::const_iterator aRefToMe = aRefsToMe.begin(); - for(; aRefToMe != aRefsToMe.end(); aRefToMe++) { - CompositeFeaturePtr aComposite = - std::dynamic_pointer_cast((*aRefToMe)->owner()); - if (aComposite.get() && aComposite->isSub(theCurrent)) { - aMain = aComposite; - break; - } + CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(theCurrent); + while(anOwner.get()) { + if (!aMain.get()) { + aMain = anOwner; } + anOwners.insert(anOwner); + anOwner = ModelAPI_Tools::compositeOwner(anOwner); } } - if (theVisible) { // make features below which are not in history also enabled: sketch subs + if (theVisible && !theCurrent.get()) { // needed to avoid disabling of PartSet initial constructions FeaturePtr aNext = theCurrent.get() ? myObjs->nextFeature(theCurrent) : myObjs->firstFeature(); for (; aNext.get(); aNext = myObjs->nextFeature(theCurrent)) { @@ -806,23 +984,31 @@ void Model_Document::setCurrentFeature( } // make all features after this feature disabled in reversed order (to remove results without deps) static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); - static Events_ID aCreateEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); - static Events_ID aDeleteEvent = aLoop->eventByName(EVENT_OBJECT_DELETED); bool aPassed = false; // flag that the current object is already passed in cycle FeaturePtr anIter = myObjs->lastFeature(); bool aWasChanged = false; + bool isCurrentParameter = theCurrent.get() && theCurrent->getKind() == "Parameter"; for(; anIter.get(); anIter = myObjs->nextFeature(anIter, true)) { // check this before passed become enabled: the current feature is enabled! if (anIter == theCurrent) aPassed = true; bool aDisabledFlag = !aPassed; - if (aMain.get() && aMain->isSub(anIter)) // sub-elements of not-disabled feature are not disabled - aDisabledFlag = false; + if (aMain.get()) { + if (isSub(aMain, anIter)) // sub-elements of not-disabled feature are not disabled + aDisabledFlag = false; + else if (anOwners.find(anIter) != anOwners.end()) // disable the higher-level feature is the nested is the current + aDisabledFlag = true; + } + if (anIter->getKind() == "Parameter") {// parameters are always out of the history of features, but not parameters - if (theCurrent.get() && theCurrent->getKind() != "Parameter") + // due to the issue 1491 all parameters are kept enabled any time + //if (!isCurrentParameter) aDisabledFlag = false; + } else if (isCurrentParameter) { // if paramater is active, all other features become enabled (issue 1307) + aDisabledFlag = false; } + if (anIter->setDisabled(aDisabledFlag)) { // state of feature is changed => so feature become updated static Events_ID anUpdateEvent = aLoop->eventByName(EVENT_OBJECT_UPDATED); @@ -833,13 +1019,18 @@ void Model_Document::setCurrentFeature( } // update for everyone the concealment flag immideately: on edit feature in the midle of history if (aWasChanged) { - const std::list >& aResList = anIter->results(); - std::list >::const_iterator aRes = aResList.begin(); - for(; aRes != aResList.end(); aRes++) { + std::list aResults; + ModelAPI_Tools::allResults(anIter, aResults); + std::list::const_iterator aRes = aResults.begin(); + for(; aRes != aResults.end(); aRes++) { if ((*aRes).get() && (*aRes)->data()->isValid() && !(*aRes)->isDisabled()) std::dynamic_pointer_cast((*aRes)->data())->updateConcealmentFlag(); } - + // update the concealment status for disply in isConcealed of ResultBody + for(aRes = aResults.begin(); aRes != aResults.end(); aRes++) { + if ((*aRes).get() && (*aRes)->data()->isValid() && !(*aRes)->isDisabled()) + (*aRes)->isConcealed(); + } } } // unblock the flush signals and up them after this @@ -853,6 +1044,12 @@ void Model_Document::setCurrentFeatureUp() FeaturePtr aCurrent = currentFeature(false); if (aCurrent.get()) { // if not, do nothing because null is the upper FeaturePtr aPrev = myObjs->nextFeature(aCurrent, true); + // make the higher level composite as current (sketch becomes disabled if line is enabled) + if (aPrev.get()) { + for(FeaturePtr aComp = ModelAPI_Tools::compositeOwner(aPrev); aComp.get(); + aComp = ModelAPI_Tools::compositeOwner(aPrev)) + aPrev = aComp; + } // do not flush: it is called only on remove, it will be flushed in the end of transaction setCurrentFeature(aPrev, false); } @@ -955,6 +1152,17 @@ void Model_Document::setActive(const bool theFlag) std::list >::const_iterator aRes = aResList.begin(); for(; aRes != aResList.end(); aRes++) { ModelAPI_EventCreator::get()->sendUpdated(*aRes, aRedispEvent); + // #issue 1048: sub-compsolids also + ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast(*aRes); + if (aCompRes.get()) { + int aNumSubs = aCompRes->numberOfSubs(); + for(int a = 0; a < aNumSubs; a++) { + ResultPtr aSub = aCompRes->subResult(a); + if (aSub.get()) { + ModelAPI_EventCreator::get()->sendUpdated(aSub, aRedispEvent); + } + } + } } } } @@ -1002,6 +1210,11 @@ std::shared_ptr Model_Document::internalFeature(const int theI return myObjs->internalFeature(theIndex); } +std::shared_ptr Model_Document::featureById(const int theId) +{ + return myObjs->featureById(theId); +} + void Model_Document::synchronizeTransactions() { Model_Document* aRoot = @@ -1060,6 +1273,9 @@ AttributeSelectionListPtr Model_Document::selectionInPartFeature() mySelectionFeature->data()->setName(aName); mySelectionFeature->setDoc(myObjs->owner()); mySelectionFeature->initAttributes(); + mySelectionFeature->init(); // to make it enabled and Update correctly + // this update may cause recomputation of the part after selection on it, that is not needed + mySelectionFeature->data()->blockSendAttributeUpdated(true); } return mySelectionFeature->selectionList("selection"); } @@ -1070,3 +1286,121 @@ FeaturePtr Model_Document::lastFeature() return myObjs->lastFeature(); return FeaturePtr(); } + +std::shared_ptr Model_Document::producedByFeature( + std::shared_ptr theResult, + const std::shared_ptr& theShape) +{ + ResultBodyPtr aBody = std::dynamic_pointer_cast(theResult); + if (!aBody.get()) { + return feature(theResult); // for not-body just returns the feature that produced this result + } + // otherwise get the shape and search the very initial label for it + TopoDS_Shape aShape = theShape->impl(); + if (aShape.IsNull()) + return FeaturePtr(); + + // for comsolids and compounds all the naming is located in the main object, so, try to use + // it first + ResultCompSolidPtr aMain = ModelAPI_Tools::compSolidOwner(theResult); + if (aMain.get()) { + FeaturePtr aMainRes = producedByFeature(aMain, theShape); + if (aMainRes) + return aMainRes; + } + + std::shared_ptr aBodyData = std::dynamic_pointer_cast(theResult->data()); + if (!aBodyData.get() || !aBodyData->isValid()) + return FeaturePtr(); + + TopoDS_Shape anOldShape; // old shape in the pair oldshape->theShape in the named shape + TopoDS_Shape aShapeContainer; // old shape of the shape that contains aShape as sub-element + Handle(TNaming_NamedShape) aCandidatInThis, aCandidatContainer; + TDF_Label aBodyLab = aBodyData->label(); + // use childs and this label (the lowest priority) + TDF_ChildIDIterator aNSIter(aBodyLab, TNaming_NamedShape::GetID(), Standard_True); + bool aUseThis = !aNSIter.More(); + while(anOldShape.IsNull() && (aNSIter.More() || aUseThis)) { + Handle(TNaming_NamedShape) aNS; + if (aUseThis) { + if (!aBodyLab.FindAttribute(TNaming_NamedShape::GetID(), aNS)) + break; + } else { + aNS = Handle(TNaming_NamedShape)::DownCast(aNSIter.Value()); + } + for(TNaming_Iterator aShapesIter(aNS); aShapesIter.More(); aShapesIter.Next()) { + if (aShapesIter.Evolution() == TNaming_SELECTED || aShapesIter.Evolution() == TNaming_DELETE) + continue; // don't use the selection evolution + if (aShapesIter.NewShape().IsSame(aShape)) { // found the original shape + aCandidatInThis = aNS; + if (aCandidatInThis->Evolution() == TNaming_MODIFY) + anOldShape = aShapesIter.OldShape(); + if (!anOldShape.IsNull()) // otherwise may me searching for another item of this shape with longer history + break; + } + // check that the shape contains aShape as sub-shape to fill container + if (aShapesIter.NewShape().ShapeType() < aShape.ShapeType() && aCandidatContainer.IsNull()) { + TopExp_Explorer anExp(aShapesIter.NewShape(), aShape.ShapeType()); + for(; anExp.More(); anExp.Next()) { + if (aShape.IsSame(anExp.Current())) { + aCandidatContainer = aNS; + aShapeContainer = aShapesIter.NewShape(); + } + } + } + } + // iterate to the next label or to the body label in the end + if (!aUseThis) + aNSIter.Next(); + if (!aNSIter.More()) { + if (aUseThis) + break; + aUseThis = true; + } + } + if (aCandidatInThis.IsNull()) { + if (aCandidatContainer.IsNull()) + return FeaturePtr(); + // with the lower priority use the higher level shape that contains aShape + aCandidatInThis = aCandidatContainer; + anOldShape = aShapeContainer; + } + + while(!anOldShape.IsNull()) { // searching for the very initial shape that produces this one + aShape = anOldShape; + anOldShape.Nullify(); + for(TNaming_SameShapeIterator anIter(aShape, myDoc->Main()); anIter.More(); anIter.Next()) { + TDF_Label aNSLab = anIter.Label(); + Handle(TNaming_NamedShape) aNS; + if (aNSLab.FindAttribute(TNaming_NamedShape::GetID(), aNS)) { + for(TNaming_Iterator aShapesIter(aNS); aShapesIter.More(); aShapesIter.Next()) { + if (aShapesIter.Evolution() == TNaming_SELECTED || aShapesIter.Evolution() == TNaming_DELETE) + continue; // don't use the selection evolution + if (aShapesIter.NewShape().IsSame(aShape)) { // found the original shape + aCandidatInThis = aNS; + if (aCandidatInThis->Evolution() == TNaming_MODIFY) + anOldShape = aShapesIter.OldShape(); + if (!anOldShape.IsNull()) // otherwise may me searching for another item of this shape with longer history + break; + } + } + } + } + } + FeaturePtr aResult; + TDF_Label aResultLab = aCandidatInThis->Label(); + while(aResultLab.Depth() > 3) + aResultLab = aResultLab.Father(); + FeaturePtr aFeature = myObjs->feature(aResultLab); + if (aFeature.get()) { + if (!aResult.get() || myObjs->isLater(aResult, aFeature)) { + aResult = aFeature; + } + } + return aResult; +} + +bool Model_Document::isLater(FeaturePtr theLater, FeaturePtr theCurrent) const +{ + return myObjs->isLater(theLater, theCurrent); +}