X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Document.cpp;h=be2877848b1a34b891a39b3dae19561fb94e780a;hb=ad2e59f946f2fb5092b1e3de09bae96d6f9a3a10;hp=e8e9a588752204858e1880dde91e7180780f11b7;hpb=7ab55ab9035e1f5c3249ec8d76993bb6aff006df;p=modules%2Fshaper.git diff --git a/src/Model/Model_Document.cpp b/src/Model/Model_Document.cpp old mode 100755 new mode 100644 index e8e9a5887..be2877848 --- a/src/Model/Model_Document.cpp +++ b/src/Model/Model_Document.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// Copyright (C) 2014-2019 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -12,10 +12,9 @@ // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.salome-platform.org/ or -// email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // #include @@ -30,9 +29,9 @@ #include #include #include -#include #include #include +#include #include #include @@ -45,19 +44,24 @@ #include #include #include -#include #include #include #include #include #include #include +#include #include +#include +#include #include #include #include #include #include +#include +#include +#include #include #include @@ -85,14 +89,18 @@ static const int TAG_GENERAL = 1; // general properties tag // general sub-labels /// where the reference to the current feature label is located (or no attribute if null feature) static const int TAG_CURRENT_FEATURE = 1; ///< reference to the current feature -static const int TAG_CURRENT_TRANSACTION = 2; ///< integer, index of the transaction +/// integer, index of the transaction + GUID for auto recomputation blocking +static const int TAG_CURRENT_TRANSACTION = 2; static const int TAG_SELECTION_FEATURE = 3; ///< integer, tag of the selection feature label static const int TAG_NODES_STATE = 4; ///< array, tag of the Object Browser nodes states ///< naming structures constructions selected from other document static const int TAG_EXTERNAL_CONSTRUCTIONS = 5; +/// reference to the shape in external document: sting list attribute identifier +static const Standard_GUID kEXTERNAL_SHAPE_REF("9aa5dd14-6d34-4a8d-8786-05842fd7bbbd"); + Model_Document::Model_Document(const int theID, const std::string theKind) - : myID(theID), myKind(theKind), myIsActive(false), + : myID(theID), myKind(theKind), myIsActive(false), myIsSetCurrentFeature(false), myDoc(new TDocStd_Document("BinOcaf")) // binary OCAF format { #ifdef TINSPECTOR @@ -135,6 +143,84 @@ bool Model_Document::isRoot() const return this == Model_Session::get()->moduleDocument().get(); } +// LCOV_EXCL_START +/// Makes all modification and generation naming shapes that have old shapes corresponding to +/// shapes in a root document be equal to this root document +static void updateShapesFromRoot(const TDF_Label theThisAccess, const TDF_Label theRootAccess) +{ + TopTools_DataMapOfShapeShape aCurrentToRoot; // shapes that must be updated: from this to root + TDF_ChildIDIterator aThisIter(theThisAccess.Root(), kEXTERNAL_SHAPE_REF, true); + for(; aThisIter.More(); aThisIter.Next()) { + aCurrentToRoot.Clear(); + Handle(TNaming_NamedShape) aNS; + if (!aThisIter.Value()->Label().FindAttribute(TNaming_NamedShape::GetID(), aNS)) + continue; + if (aNS->Evolution() != TNaming_GENERATED && aNS->Evolution() != TNaming_MODIFY) + continue; + for (TNaming_Iterator aNSIter(aNS); aNSIter.More(); aNSIter.Next()) { + const TopoDS_Shape& anOld = aNSIter.OldShape(); + if (anOld.IsNull()) + continue; + TNaming_OldShapeIterator aNewIter(anOld, theThisAccess); + for (; aNewIter.More(); aNewIter.Next()) { + TNaming_Evolution anEvolution = aNewIter.NamedShape()->Evolution(); + if (anEvolution != TNaming_SELECTED && anEvolution != TNaming_DELETE) + break; + } + if (aNewIter.More()) + continue; + GeomShapePtr anOldShape(new GeomAPI_Shape), aRootShape(new GeomAPI_Shape); + anOldShape->setImpl(new TopoDS_Shape(anOld)); + anOldShape = GeomAPI_Tools::getTypedShape(anOldShape); + + // search the same shape in the root document + Handle(TDataStd_ExtStringList) anEntries = + Handle(TDataStd_ExtStringList)::DownCast(aThisIter.Value()); + TDataStd_ListOfExtendedString::Iterator anIter(anEntries->List()); + for (; anIter.More(); anIter.Next()) { + TDF_Label aRootLab; + TDF_Tool::Label(theRootAccess.Data(), anIter.Value(), aRootLab); + if (aRootLab.IsNull()) + continue; + Handle(TNaming_NamedShape) aRootNS; + if (!aRootLab.FindAttribute(TNaming_NamedShape::GetID(), aRootNS)) + continue; + TNaming_Iterator aRootShapes(aRootNS); + for (; aRootShapes.More(); aRootShapes.Next()) { + if (aRootShapes.NewShape().IsNull()) + continue; + aRootShape->setImpl(new TopoDS_Shape(aRootShapes.NewShape())); + aRootShape = GeomAPI_Tools::getTypedShape(aRootShape); + if (!anOldShape->isEqual(aRootShape)) // special checking by geometry + continue; + // found a good corresponded shape + if (!anOld.IsEqual(aRootShapes.NewShape())) + aCurrentToRoot.Bind(anOld, aRootShapes.NewShape()); + } + } + } + if (!aCurrentToRoot.IsEmpty()) { // update the whole named shape content + TopTools_ListOfShape anOld, aNew; + TNaming_Evolution anEvol = aNS->Evolution(); + for(TNaming_Iterator aNSIter(aNS); aNSIter.More(); aNSIter.Next()) { + anOld.Prepend(aCurrentToRoot.IsBound(aNSIter.OldShape()) ? + aCurrentToRoot.Find(aNSIter.OldShape()) : aNSIter.OldShape()); + aNew.Prepend(aNSIter.NewShape()); + } + TNaming_Builder aBuilder(aNS->Label()); + TopTools_ListOfShape::Iterator anOldIter(anOld), aNewIter(aNew); + for(; anOldIter.More(); anOldIter.Next(), aNewIter.Next()) { + if (anEvol == TNaming_GENERATED) { + aBuilder.Generated(anOldIter.Value(), aNewIter.Value()); + } else if (anEvol == TNaming_MODIFY) { + aBuilder.Modify(anOldIter.Value(), aNewIter.Value()); + } + } + } + } +} +// LCOV_EXCL_STOP + bool Model_Document::load(const char* theDirName, const char* theFileName, DocumentPtr theThis) { Handle(Model_Application) anApp = Model_Application::getApplication(); @@ -146,14 +232,14 @@ bool Model_Document::load(const char* theDirName, const char* theFileName, Docum Handle(TDocStd_Document) aLoaded; try { aStatus = anApp->Open(aPath, aLoaded); - } catch (Standard_Failure) { - Handle(Standard_Failure) aFail = Standard_Failure::Caught(); + } catch (Standard_Failure const& anException) { Events_InfoMessage("Model_Document", - "Exception in opening of document: %1").arg(aFail->GetMessageString()).send(); + "Exception in opening of document: %1").arg(anException.GetMessageString()).send(); return false; } bool isError = aStatus != PCDM_RS_OK; if (isError) { + // LCOV_EXCL_START switch (aStatus) { case PCDM_RS_UnknownDocument: Events_InfoMessage("Model_Document", "Can not open document").send(); @@ -208,6 +294,7 @@ bool Model_Document::load(const char* theDirName, const char* theFileName, Docum Events_InfoMessage("Model_Document", "Can not open document: unknown error").send(); break; } + // LCOV_EXCL_STOP } std::shared_ptr aSession = std::dynamic_pointer_cast(Model_Session::get()); @@ -220,12 +307,12 @@ bool Model_Document::load(const char* theDirName, const char* theFileName, Docum aSession->setCheckTransactions(false); if (myObjs) delete myObjs; - myObjs = new Model_Objects(myDoc->Main()); // synchronisation is inside + myObjs = new Model_Objects(myDoc->Main()); // synchronization is inside myObjs->setOwner(theThis); // update the current features status setCurrentFeature(currentFeature(false), false); aSession->setCheckTransactions(true); - aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false); + aSession->setActiveDocument(aSession->moduleDocument(), false); // this is done in Part result "activate", so no needed here. Causes not-blue active part. // aSession->setActiveDocument(anApp->getDocument(myID), true); @@ -239,8 +326,11 @@ bool Model_Document::load(const char* theDirName, const char* theFileName, Docum anApp->setLoadByDemand(aPart->data()->name(), aPart->data()->document(ModelAPI_ResultPart::DOC_REF())->docId()); } - - } else { // open failed, but new documnet was created to work with it: inform the model + if (!isRoot()) { + updateShapesFromRoot(myDoc->Main(), + std::dynamic_pointer_cast(aSession->moduleDocument())->generalLabel()); + } + } else { // open failed, but new document was created to work with it: inform the model aSession->setActiveDocument(Model_Session::get()->moduleDocument(), false); } return !isError; @@ -274,7 +364,10 @@ bool Model_Document::save( Handle(Model_Application) anApp = Model_Application::getApplication(); if (isRoot()) { #ifdef WIN32 - CreateDirectory(theDirName, NULL); + size_t aDirLen = strlen(theDirName); + std::wstring aWStr(aDirLen, L'#'); + mbstowcs(&aWStr[0], theDirName, aDirLen); + CreateDirectory(aWStr.c_str(), NULL); #else mkdir(theDirName, 0x1ff); #endif @@ -284,10 +377,9 @@ bool Model_Document::save( PCDM_StoreStatus aStatus; try { aStatus = anApp->SaveAs(myDoc, aPath); - } catch (Standard_Failure) { - Handle(Standard_Failure) aFail = Standard_Failure::Caught(); + } catch (Standard_Failure const& anException) { Events_InfoMessage("Model_Document", - "Exception in saving of document: %1").arg(aFail->GetMessageString()).send(); + "Exception in saving of document: %1").arg(anException.GetMessageString()).send(); if (aWasCurrent.get()) { // return the current feature to the initial position setCurrentFeature(aWasCurrent, false); aSession->setCheckTransactions(true); @@ -370,10 +462,10 @@ void Model_Document::close(const bool theForever) aSub->close(theForever); } - // close for thid document needs no transaction in this document + // close for this document needs no transaction in this document std::static_pointer_cast(Model_Session::get())->setCheckTransactions(false); - // close all only if it is really asked, otherwise it can be undoed/redoed + // close all only if it is really asked, otherwise it can be undone/redone if (theForever) { // flush everything to avoid messages with bad objects delete myObjs; @@ -426,7 +518,7 @@ void Model_Document::compactNested() aSumOfTransaction += myTransactions.rbegin()->myOCAFNum; myTransactions.pop_back(); } - // the latest transaction is the start of lower-level operation which startes the nested + // the latest transaction is the start of lower-level operation which starts the nested myTransactions.rbegin()->myOCAFNum += aSumOfTransaction; myNestedNum.pop_back(); } @@ -522,7 +614,7 @@ static bool isEqualContent(Handle(TDF_Attribute) theAttr1, Handle(TDF_Attribute) return false; } -/// Returns true if the last transaction is actually empty: modification to te same values +/// Returns true if the last transaction is actually empty: modification to the same values /// were performed only static bool isEmptyTransaction(const Handle(TDocStd_Document)& theDoc) { Handle(TDF_Delta) aDelta; @@ -569,7 +661,7 @@ bool Model_Document::finishOperation() // 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 + // it in the python scripts correctly): sketch become current after creation of sub-elements FeaturePtr aCurrent = currentFeature(false); CompositeFeaturePtr aMain, aNext = ModelAPI_Tools::compositeOwner(aCurrent); while(aNext.get()) { @@ -581,10 +673,10 @@ bool Model_Document::finishOperation() } myObjs->synchronizeBackRefs(); Events_Loop* aLoop = Events_Loop::loop(); - static const Events_ID kCreatedEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED); - static const Events_ID kUpdatedEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED); - static const Events_ID kRedispEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY); - static const Events_ID kDeletedEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED); + static const Events_ID kCreatedEvent = aLoop->eventByName(EVENT_OBJECT_CREATED); + static const Events_ID kUpdatedEvent = aLoop->eventByName(EVENT_OBJECT_UPDATED); + static const Events_ID kRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + static const Events_ID kDeletedEvent = aLoop->eventByName(EVENT_OBJECT_DELETED); aLoop->flush(kCreatedEvent); aLoop->flush(kUpdatedEvent); aLoop->flush(kRedispEvent); @@ -628,7 +720,7 @@ bool Model_Document::finishOperation() // 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 + // if commit is successful, just increment counters if (isEmptyTransaction(myDoc)) { // erase this transaction myDoc->Undo(); myDoc->ClearRedos(); @@ -648,7 +740,7 @@ bool Model_Document::finishOperation() // nothing inside in all documents, so remove this transaction from the transactions list undoInternal(true, false); } - // on finish clear redos in any case (issue 446) and for all subs (issue 408) + // on finish clear redo in any case (issue 446) and for all subs (issue 408) myDoc->ClearRedos(); myRedos.clear(); for (aSubIter = aSubs.begin(); aSubIter != aSubs.end(); aSubIter++) { @@ -684,7 +776,7 @@ static void modifiedLabels(const Handle(TDocStd_Document)& theDoc, TDF_LabelList if (anAttr.Value()->Attribute()->ID() == TNaming_NamedShape::GetID()) { anExcludedInt.Add(anAttr.Value()->Label()); // named shape evolution is changed in history update => skip them, - // they are not the features arguents + // they are not the features arguments continue; } if (anAttr.Value()->Attribute()->ID() == TDataStd_Integer::GetID()) { @@ -756,7 +848,7 @@ bool Model_Document::isOperation() const bool Model_Document::isModified() { - // is modified if at least one operation was commited and not undoed + // is modified if at least one operation was committed and not undone return myTransactions.size() != myTransactionSave || isOperation(); } @@ -769,7 +861,7 @@ bool Model_Document::canUndo() (myNestedNum.empty() || *myNestedNum.rbegin() - aCurrentNum > 0) && myTransactions.size() - aCurrentNum > 0 /* for omitting the first useless transaction */) return true; - // check other subs contains operation that can be undoed + // check other subs contains operation that can be undone const std::set aSubs = subDocuments(); std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) { @@ -800,9 +892,10 @@ void Model_Document::undoInternal(const bool theWithSubs, const bool theSynchron myDoc->Undo(); } + std::set aSubs; if (theWithSubs) { // undo for all subs - const std::set aSubs = subDocuments(); + aSubs = subDocuments(); std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) { if (!subDoc(*aSubIter)->myObjs) @@ -815,6 +908,19 @@ void Model_Document::undoInternal(const bool theWithSubs, const bool theSynchron myObjs->synchronizeFeatures(aDeltaLabels, true, false, false, isRoot()); // update the current features status setCurrentFeature(currentFeature(false), false); + + if (theWithSubs) { + // undo for all subs + const std::set aNewSubs = subDocuments(); + std::set::iterator aNewSubIter = aNewSubs.begin(); + for (; aNewSubIter != aNewSubs.end(); aNewSubIter++) { + // synchronize only newly appeared documents + if (!subDoc(*aNewSubIter)->myObjs || aSubs.find(*aNewSubIter) != aSubs.end()) + continue; + TDF_LabelList anEmptyDeltas; + subDoc(*aNewSubIter)->myObjs->synchronizeFeatures(anEmptyDeltas, true, false, true, true); + } + } } } @@ -827,7 +933,7 @@ bool Model_Document::canRedo() { if (!myRedos.empty()) return true; - // check other subs contains operation that can be redoed + // check other subs contains operation that can be redone const std::set aSubs = subDocuments(); std::set::iterator aSubIter = aSubs.begin(); for (; aSubIter != aSubs.end(); aSubIter++) { @@ -863,7 +969,8 @@ void Model_Document::redo() // update the current features status setCurrentFeature(currentFeature(false), false); } - +// this is used for creation of undo/redo1-list by GUI +// LCOV_EXCL_START std::list Model_Document::undoList() const { std::list aResult; @@ -889,6 +996,7 @@ std::list Model_Document::redoList() const } return aResult; } +// LCOV_EXCL_STOP void Model_Document::operationId(const std::string& theId) { @@ -931,6 +1039,15 @@ FeaturePtr Model_Document::addFeature(std::string theID, const bool theMakeCurre } } } + // #2861,3029: if the parameter is added, add it after parameters existing in the list + if (aCurrent.get() && + (aFeature->getKind() == "Parameter" || aFeature->getKind() == "ParametersMgr")) { + int anIndex = kUNDEFINED_FEATURE_INDEX; + for(FeaturePtr aNextFeat = myObjs->nextFeature(aCurrent, anIndex); + aNextFeat.get() && aNextFeat->getKind() == "Parameter"; + aNextFeat = myObjs->nextFeature(aCurrent, anIndex)) + aCurrent = aNextFeat; + } aDocToAdd->myObjs->addFeature(aFeature, aCurrent); if (!aFeature->isAction()) { // do not add action to the data model if (theMakeCurrent) // after all this feature stays in the document, so make it current @@ -943,7 +1060,6 @@ FeaturePtr Model_Document::addFeature(std::string theID, const bool theMakeCurre return aFeature; } - void Model_Document::refsToFeature(FeaturePtr theFeature, std::set >& theRefs, const bool isSendError) { @@ -953,6 +1069,22 @@ void Model_Document::refsToFeature(FeaturePtr theFeature, void Model_Document::removeFeature(FeaturePtr theFeature) { myObjs->removeFeature(theFeature); + // fix for #2723: send signal that part is updated + if (!isRoot() && isOperation()) { + std::shared_ptr aRoot = + std::dynamic_pointer_cast(ModelAPI_Session::get()->moduleDocument()); + std::list allParts; + aRoot->objects()->allResults(ModelAPI_ResultPart::group(), allParts); + std::list::iterator aParts = allParts.begin(); + for(; aParts != allParts.end(); aParts++) { + ResultPartPtr aPart = std::dynamic_pointer_cast(*aParts); + if (aPart->partDoc().get() == this) { + static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); + ModelAPI_EventCreator::get()->sendUpdated(aRoot->feature(aPart), anEvent); + break; + } + } + } } // recursive function to check if theSub is a child of theMain composite feature @@ -966,7 +1098,6 @@ static bool isSub(const CompositeFeaturePtr theMain, const FeaturePtr theSub) { return isSub(theMain, aParent); } - void Model_Document::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis) { bool aCurrentUp = theMoved == currentFeature(false); @@ -980,8 +1111,9 @@ void Model_Document::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis) FeaturePtr anAfterThisSub = theAfterThis; if (aCompositeAfter.get()) { FeaturePtr aSub = aCompositeAfter; + int anIndex = kUNDEFINED_FEATURE_INDEX; do { - FeaturePtr aNext = myObjs->nextFeature(aSub); + FeaturePtr aNext = myObjs->nextFeature(aSub, anIndex); if (!isSub(aCompositeAfter, aNext)) { anAfterThisSub = aSub; break; @@ -1001,12 +1133,14 @@ void Model_Document::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis) void Model_Document::updateHistory(const std::shared_ptr theObject) { - myObjs->updateHistory(theObject); + if (myObjs) + myObjs->updateHistory(theObject); } void Model_Document::updateHistory(const std::string theGroup) { - myObjs->updateHistory(theGroup); + if (myObjs) + myObjs->updateHistory(theGroup); } const std::set Model_Document::subDocuments() const @@ -1044,9 +1178,10 @@ std::shared_ptr Model_Document::objectByName( return myObjs->objectByName(theGroupID, theName); } -const int Model_Document::index(std::shared_ptr theObject) +const int Model_Document::index(std::shared_ptr theObject, + const bool theAllowFolder) { - return myObjs->index(theObject); + return myObjs->index(theObject, theAllowFolder); } int Model_Document::size(const std::string& theGroupID, const bool theAllowFolder) @@ -1056,6 +1191,14 @@ int Model_Document::size(const std::string& theGroupID, const bool theAllowFolde return myObjs->size(theGroupID, theAllowFolder); } +std::shared_ptr Model_Document::parent( + const std::shared_ptr theChild) +{ + if(myObjs == 0) // may be on close + return ObjectPtr(); + return myObjs->parent(theChild); +} + std::shared_ptr Model_Document::currentFeature(const bool theVisible) { if (!myObjs) // on close document feature destruction it may call this method @@ -1066,8 +1209,9 @@ 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 + int anIndex = kUNDEFINED_FEATURE_INDEX; while(aResult.get() && !aResult->isInHistory()) { - aResult = myObjs->nextFeature(aResult, true); + aResult = myObjs->nextFeature(aResult, anIndex, true); } } return aResult; @@ -1078,6 +1222,9 @@ std::shared_ptr Model_Document::currentFeature(const bool theV void Model_Document::setCurrentFeature( std::shared_ptr theCurrent, const bool theVisible) { + if (myIsSetCurrentFeature) + return; + myIsSetCurrentFeature = true; // blocks the flush signals to avoid each objects visualization in the viewer // they should not be shown once after all modifications are performed Events_Loop* aLoop = Events_Loop::loop(); @@ -1100,9 +1247,10 @@ void Model_Document::setCurrentFeature( if (theVisible && !theCurrent.get()) { // needed to avoid disabling of PartSet initial constructions + int anIndex = kUNDEFINED_FEATURE_INDEX; FeaturePtr aNext = - theCurrent.get() ? myObjs->nextFeature(theCurrent) : myObjs->firstFeature(); - for (; aNext.get(); aNext = myObjs->nextFeature(theCurrent)) { + theCurrent.get() ? myObjs->nextFeature(theCurrent, anIndex, false) : myObjs->firstFeature(); + for (; aNext.get(); aNext = myObjs->nextFeature(theCurrent, anIndex, false)) { if (aNext->isInHistory()) { break; // next in history is not needed } else { // next not in history is good for making current @@ -1110,10 +1258,23 @@ void Model_Document::setCurrentFeature( } } } + if (theVisible) { // make RemoveResults feature be active even it is performed after the current + int anIndex = kUNDEFINED_FEATURE_INDEX; + FeaturePtr aNext = + theCurrent.get() ? myObjs->nextFeature(theCurrent, anIndex, false) : myObjs->firstFeature(); + for (; aNext.get(); aNext = myObjs->nextFeature(theCurrent, anIndex, false)) { + if (aNext->isInHistory()) { + break; // next in history is not needed + } else if (aNext->getKind() == "RemoveResults"){ + theCurrent = aNext; + } + } + } if (theCurrent.get()) { std::shared_ptr aData = std::static_pointer_cast(theCurrent->data()); if (!aData.get() || !aData->isValid()) { aLoop->activateFlushes(isActive); + myIsSetCurrentFeature = false; return; } TDF_Label aFeatureLabel = aData->label().Father(); @@ -1128,14 +1289,15 @@ void Model_Document::setCurrentFeature( aRefLab.ForgetAttribute(TDF_Reference::GetID()); } // make all features after this feature disabled in reversed order - // (to remove results without deps) + // (to remove results without dependencies) static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); 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)) { + int anIndex = kUNDEFINED_FEATURE_INDEX; + for(; anIter.get(); anIter = myObjs->nextFeature(anIter, anIndex, true)) { // check this before passed become enabled: the current feature is enabled! if (anIter == theCurrent) aPassed = true; @@ -1145,7 +1307,8 @@ void Model_Document::setCurrentFeature( aDisabledFlag = false; else if (anOwners.find(anIter) != anOwners.end()) // disable the higher-level feature if the nested is the current - aDisabledFlag = true; + if (aMain->getKind() != "Import") // exception for the import XAO feature with Group (2430) + aDisabledFlag = true; } if (anIter->getKind() == "Parameter") { @@ -1154,7 +1317,7 @@ void Model_Document::setCurrentFeature( //if (!isCurrentParameter) aDisabledFlag = false; } else if (isCurrentParameter) { - // if paramater is active, all other features become enabled (issue 1307) + // if parameter is active, all other features become enabled (issue 1307) aDisabledFlag = false; } @@ -1169,7 +1332,7 @@ void Model_Document::setCurrentFeature( ModelAPI_EventCreator::get()->sendUpdated(anIter, aRedispEvent /*, false*/); aWasChanged = true; } - // update for everyone the concealment flag immideately: on edit feature in the midle of history + // update for everyone concealment flag immediately: on edit feature in the middle of history if (aWasChanged) { std::list aResults; ModelAPI_Tools::allResults(anIter, aResults); @@ -1178,13 +1341,14 @@ void Model_Document::setCurrentFeature( 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 + // update the concealment status for display in isConcealed of ResultBody for(aRes = aResults.begin(); aRes != aResults.end(); aRes++) { if ((*aRes).get() && (*aRes)->data()->isValid() && !(*aRes)->isDisabled()) (*aRes)->isConcealed(); } } } + myIsSetCurrentFeature = false; // unblock the flush signals and up them after this aLoop->activateFlushes(isActive); } @@ -1195,12 +1359,13 @@ void Model_Document::setCurrentFeatureUp() // problems if it is true: here and in "setCurrentFeature" FeaturePtr aCurrent = currentFeature(false); if (aCurrent.get()) { // if not, do nothing because null is the upper - FeaturePtr aPrev = myObjs->nextFeature(aCurrent, true); + int anIndex = kUNDEFINED_FEATURE_INDEX; + FeaturePtr aPrev = myObjs->nextFeature(aCurrent, anIndex, true); // make the higher level composite as current (sketch becomes disabled if line is enabled) if (aPrev.get()) { FeaturePtr aComp = ModelAPI_Tools::compositeOwner(aPrev); // without cycle (issue 1555): otherwise extrusion fuse - // will be enabled and displayed whaen inside sketch + // will be enabled and displayed when inside sketch if (aComp.get()) aPrev = aComp; } @@ -1265,25 +1430,51 @@ std::shared_ptr Model_Document::addFolder( void Model_Document::removeFolder(std::shared_ptr theFolder) { + if (theFolder) + myObjs->removeFolder(theFolder); } -std::shared_ptr Model_Document::feature( - const std::shared_ptr& theResult) +std::shared_ptr Model_Document::findFolderAbove( + const std::list >& theFeatures) { - return myObjs->feature(theResult); + return myObjs->findFolder(theFeatures, false); } -Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper) +std::shared_ptr Model_Document::findFolderBelow( + const std::list >& theFeatures) { - return TDF_LabelMapHasher::HashCode(theLab, theUpper); + return myObjs->findFolder(theFeatures, true); +} +std::shared_ptr Model_Document::findContainingFolder( + const std::shared_ptr& theFeature, + int& theIndexInFolder) +{ + return myObjs->findContainingFolder(theFeature, theIndexInFolder); } -Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2) + +bool Model_Document::moveToFolder( + const std::list >& theFeatures, + const std::shared_ptr& theFolder) +{ + return myObjs->moveToFolder(theFeatures, theFolder); +} + +bool Model_Document::removeFromFolder( + const std::list >& theFeatures, + const bool theBefore) { - return TDF_LabelMapHasher::IsEqual(theLab1, theLab2); + return myObjs->removeFromFolder(theFeatures, theBefore); +} + +std::shared_ptr Model_Document::feature( + const std::shared_ptr& theResult) +{ + if (myObjs == 0) // may be on close + return std::shared_ptr(); + return myObjs->feature(theResult); } -// searches in this document feature that contains this label FeaturePtr Model_Document::featureByLab(const TDF_Label& theLab) { TDF_Label aCurrentLab = theLab; while(aCurrentLab.Depth() > 3) @@ -1291,12 +1482,25 @@ FeaturePtr Model_Document::featureByLab(const TDF_Label& theLab) { return myObjs->feature(aCurrentLab); } +ResultPtr Model_Document::resultByLab(const TDF_Label& theLab) +{ + TDF_Label aCurrentLab = theLab; + while(aCurrentLab.Depth() > 3) { + ObjectPtr aResultObj = myObjs->object(aCurrentLab); + if (aResultObj.get()) { + return std::dynamic_pointer_cast(aResultObj); // this may be null if feature + } + aCurrentLab = aCurrentLab.Father(); + } + return ResultPtr(); // not found +} + void Model_Document::addNamingName(const TDF_Label theLabel, std::string theName) { std::map >::iterator aFind = myNamingNames.find(theName); if (aFind != myNamingNames.end()) { // to avoid duplicate-labels - // to keep correct order inspite of history line management + // to keep correct order in spite of history line management std::list::iterator anAddAfterThis = aFind->second.end(); FeaturePtr anAddedFeature = featureByLab(theLabel); std::list::iterator aLabIter = aFind->second.begin(); @@ -1340,6 +1544,17 @@ void Model_Document::changeNamingName(const std::string theOldName, } else { // remove from the list aFind->second.erase(aLabIter); } + // check the sketch vertex name located under renamed sketch line + TDF_ChildIDIterator aChild(theLabel, TDataStd_Name::GetID()); + for(; aChild.More(); aChild.Next()) { + Handle(TDataStd_Name) aSubName = Handle(TDataStd_Name)::DownCast(aChild.Value()); + std::string aName = TCollection_AsciiString(aSubName->Get()).ToCString(); + if (aName.find(theOldName) == 0) { // started from parent name + std::string aNewSubName = theNewName + aName.substr(theOldName.size()); + changeNamingName(aName, aNewSubName, aSubName->Label()); + aSubName->Set(aNewSubName.c_str()); + } + } return; } } @@ -1358,7 +1573,7 @@ TDF_Label Model_Document::findNamingName(std::string theName, ResultPtr theConte return *aLabIter; } } - return *(aFind->second.rbegin()); // no more variannts, so, return the last + return *(aFind->second.rbegin()); // no more variants, so, return the last } // not found exact name, try to find by sub-components std::string::size_type aSlash = theName.rfind('/'); @@ -1375,28 +1590,40 @@ TDF_Label Model_Document::findNamingName(std::string theName, ResultPtr theConte if (theContext != myObjs->object(aLabIter->Father())) continue; } + // copy aSubName to avoid incorrect further processing after its suffix cutting + TCollection_ExtendedString aSubNameCopy(aSubName); // searching sub-labels with this name TDF_ChildIDIterator aNamesIter(*aLabIter, TDataStd_Name::GetID(), Standard_True); for(; aNamesIter.More(); aNamesIter.Next()) { Handle(TDataStd_Name) aName = Handle(TDataStd_Name)::DownCast(aNamesIter.Value()); - if (aName->Get() == aSubName) + if (aName->Get() == aSubNameCopy) return aName->Label(); } // If not found child label with the exact sub-name, then try to find compound with // such sub-name without suffix. - Standard_Integer aSuffixPos = aSubName.SearchFromEnd('_'); - if (aSuffixPos != -1 && aSuffixPos != aSubName.Length()) { - TCollection_ExtendedString anIndexStr = aSubName.Split(aSuffixPos); - aSubName.Remove(aSuffixPos); + Standard_Integer aSuffixPos = aSubNameCopy.SearchFromEnd('_'); + if (aSuffixPos != -1 && aSuffixPos != aSubNameCopy.Length()) { + TCollection_ExtendedString anIndexStr = aSubNameCopy.Split(aSuffixPos); + aSubNameCopy.Remove(aSuffixPos); aNamesIter.Initialize(*aLabIter, TDataStd_Name::GetID(), Standard_True); for(; aNamesIter.More(); aNamesIter.Next()) { Handle(TDataStd_Name) aName = Handle(TDataStd_Name)::DownCast(aNamesIter.Value()); - if (aName->Get() == aSubName) { + if (aName->Get() == aSubNameCopy) { + return aName->Label(); + } + } + // check also "this" label + Handle(TDataStd_Name) aName; + if (aLabIter->FindAttribute(TDataStd_Name::GetID(), aName)) { + if (aName->Get() == aSubNameCopy) { return aName->Label(); } } } } + // verify context's name is same as sub-component's and use context's label + if (aSubName.IsEqual(anObjName.c_str())) + return *(aFind->second.rbegin()); } } return TDF_Label(); // not found @@ -1417,12 +1644,24 @@ bool Model_Document::isLaterByDep(FeaturePtr theThis, FeaturePtr theOther) { if (!aRefFeat.get()) { // take feature of the result aRefFeat = feature(std::dynamic_pointer_cast(aRefObj)); } - if (aRefFeat.get() && aRefFeat == theThis) { - return false; // other references to this, so this later than other + if (aRefFeat.get()) { + if (aRefFeat == theThis) + return false; // other references to this, so other later than this + //if (std::dynamic_pointer_cast(aRefFeat)) { + // if (!isLaterByDep(theThis, aRefFeat)) // nested composites: recursion + // return false; + //} } } } } + FeaturePtr aThisOwner = ModelAPI_Tools::compositeOwner(theThis); + if (aThisOwner.get()) { + if (aThisOwner == theOther) + return true; // composite owner is later that its sub + if (!isLaterByDep(aThisOwner, theOther)) + return false; + } return myObjs->isLater(theThis, theOther); } @@ -1473,7 +1712,7 @@ ResultPtr Model_Document::findByName( std::string aName = theName; ResultPtr aRes = myObjs->findByName(aName); theUniqueContext = !(aRes.get() && myNamingNames.find(aName) != myNamingNames.end()); - while(!aRes.get() && aName[0] == '_') { // this may be thecontext with the history index + while(!aRes.get() && aName[0] == '_') { // this may be theContext with the history index aNumInHistory++; aName = aName.substr(1); aRes = myObjs->findByName(aName); @@ -1518,21 +1757,11 @@ void Model_Document::setActive(const bool theFlag) FeaturePtr aFeature = std::dynamic_pointer_cast( object(ModelAPI_Feature::group(), a)); if (aFeature.get() && aFeature->data()->isValid()) { - const std::list >& aResList = aFeature->results(); - std::list >::const_iterator aRes = aResList.begin(); - for(; aRes != aResList.end(); aRes++) { + std::list aResults; + ModelAPI_Tools::allResults(aFeature, aResults); + for (std::list::iterator aRes = aResults.begin(); + aRes != aResults.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); - } - } - } } } } @@ -1559,11 +1788,6 @@ void Model_Document::incrementTransactionID() int aNewVal = transactionID() + 1; TDataStd_Integer::Set(generalLabel().FindChild(TAG_CURRENT_TRANSACTION), aNewVal); } -void Model_Document::decrementTransactionID() -{ - int aNewVal = transactionID() - 1; - TDataStd_Integer::Set(generalLabel().FindChild(TAG_CURRENT_TRANSACTION), aNewVal); -} TDF_Label Model_Document::extConstructionsLabel() const { @@ -1585,27 +1809,22 @@ 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 = std::dynamic_pointer_cast(ModelAPI_Session::get()->moduleDocument()).get(); if (aRoot == this) - return; // don't need to synchronise root with root + return; // don't need to synchronize root with root std::shared_ptr aSession = std::dynamic_pointer_cast(Model_Session::get()); - while(myRedos.size() > aRoot->myRedos.size()) { // remove redos in this + while(myRedos.size() > aRoot->myRedos.size()) { // remove redo in this aSession->setCheckTransactions(false); redo(); aSession->setCheckTransactions(true); } /* this case can not be reproduced in any known case for the current moment, so, just comment - while(myRedos.size() < aRoot->myRedos.size()) { // add more redos in this + while(myRedos.size() < aRoot->myRedos.size()) { // add more redo in this undoInternal(false, true); }*/ } @@ -1706,9 +1925,15 @@ std::shared_ptr Model_Document::producedByFeature( if (aShape.IsNull()) return FeaturePtr(); - // for comsolids and compounds all the naming is located in the main object, so, try to use + // for compsolids and compounds all the naming is located in the main object, so, try to use // it first - ResultCompSolidPtr aMain = ModelAPI_Tools::compSolidOwner(theResult); + ResultBodyPtr aMain = ModelAPI_Tools::bodyOwner(theResult); + while (aMain.get()) { // get the top-most main + ResultBodyPtr aNextMain = ModelAPI_Tools::bodyOwner(aMain); + if (aNextMain.get()) + aMain = aNextMain; + else break; + } if (aMain.get()) { FeaturePtr aMainRes = producedByFeature(aMain, theShape); if (aMainRes) @@ -1719,11 +1944,11 @@ std::shared_ptr Model_Document::producedByFeature( if (!aBodyData.get() || !aBodyData->isValid()) return FeaturePtr(); - TopoDS_Shape anOldShape; // old shape in the pair oldshape->theShape in the named shape + TopoDS_Shape anOldShape; // old shape in the pair old shape->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_Label aBodyLab = aBodyData->shapeLab(); + // use child 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)) { @@ -1803,6 +2028,8 @@ bool Model_Document::isLater(FeaturePtr theLater, FeaturePtr theCurrent) const return myObjs->isLater(theLater, theCurrent); } +// Object Browser nodes states +// LCOV_EXCL_START void Model_Document::storeNodesState(const std::list& theStates) { TDF_Label aLab = generalLabel().FindChild(TAG_NODES_STATE); @@ -1828,9 +2055,63 @@ void Model_Document::restoreNodesState(std::list& theStates) const } } } +// LCOV_EXCL_STOP void Model_Document::eraseAllFeatures() { if (myObjs) myObjs->eraseAllFeatures(); } + +std::shared_ptr Model_Document::nextFeature( + std::shared_ptr theCurrent, const bool theReverse) const +{ + if (theCurrent.get() && myObjs) { + int anIndex = kUNDEFINED_FEATURE_INDEX; + return myObjs->nextFeature(theCurrent, anIndex, theReverse); + } + return FeaturePtr(); // nothing by default +} + +void Model_Document::setExecuteFeatures(const bool theFlag) +{ + myExecuteFeatures = theFlag; + const std::set aSubs = subDocuments(); + std::set::iterator aSubIter = aSubs.begin(); + for (; aSubIter != aSubs.end(); aSubIter++) { + if (!subDoc(*aSubIter)->myObjs) + continue; + subDoc(*aSubIter)->setExecuteFeatures(theFlag); + } +} + +void Model_Document::appendTransactionToPrevious() +{ + Transaction anAppended = myTransactions.back(); + myTransactions.pop_back(); + if (!myTransactions.empty()) { // if it is empty, just forget the appended + myTransactions.back().myOCAFNum += anAppended.myOCAFNum; + } + // propagate the same action to sub-documents + const std::set aSubs = subDocuments(); + for (std::set::iterator aSubIter = aSubs.begin(); aSubIter != aSubs.end(); aSubIter++) { + subDoc(*aSubIter)->appendTransactionToPrevious(); + } +} + +/// GUID for keeping information about the auto-recomputation state +static const Standard_GUID kAutoRecomputationID("8493fb74-0674-4912-a100-1cf46c7cfab3"); + +void Model_Document::setAutoRecomutationState(const bool theState) +{ + if (theState) + generalLabel().FindChild(TAG_CURRENT_TRANSACTION).ForgetAttribute(kAutoRecomputationID); + else + TDataStd_UAttribute::Set( + generalLabel().FindChild(TAG_CURRENT_TRANSACTION), kAutoRecomputationID); +} + +bool Model_Document::autoRecomutationState() const +{ + return !generalLabel().FindChild(TAG_CURRENT_TRANSACTION).IsAttribute(kAutoRecomputationID); +}