-// 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
//
// 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<mailto:webmaster.salome@opencascade.com>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include <Model_Document.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
#include <ModelAPI_ResultBody.h>
-#include <ModelAPI_ResultCompSolid.h>
#include <Events_Loop.h>
#include <Events_InfoMessage.h>
+#include <GeomAPI_Tools.h>
#include <TDataStd_Integer.hxx>
#include <TDataStd_Comment.hxx>
#include <TDataStd_AsciiString.hxx>
#include <TDF_Reference.hxx>
#include <TDF_ChildIDIterator.hxx>
-#include <TDF_LabelMapHasher.hxx>
#include <TDF_Delta.hxx>
#include <TDF_AttributeDelta.hxx>
#include <TDF_AttributeDeltaList.hxx>
#include <TDF_ListIteratorOfAttributeDeltaList.hxx>
#include <TDF_ListIteratorOfLabelList.hxx>
#include <TDF_LabelMap.hxx>
+#include <TDF_Tool.hxx>
#include <TDF_DeltaOnAddition.hxx>
+#include <TDataStd_ExtStringList.hxx>
+#include <TDataStd_UAttribute.hxx>
#include <TNaming_Builder.hxx>
#include <TNaming_SameShapeIterator.hxx>
#include <TNaming_Iterator.hxx>
#include <TNaming_NamedShape.hxx>
#include <TNaming_Tool.hxx>
+#include<TNaming_OldShapeIterator.hxx>
+#include <TopTools_DataMapOfShapeShape.hxx>
+#include <TopTools_ListOfShape.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS_Shape.hxx>
// 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
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<TopoDS_Shape>(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();
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();
Events_InfoMessage("Model_Document", "Can not open document: unknown error").send();
break;
}
+ // LCOV_EXCL_STOP
}
std::shared_ptr<Model_Session> aSession =
std::dynamic_pointer_cast<Model_Session>(Model_Session::get());
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);
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<Model_Document>(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;
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
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);
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>(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;
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();
}
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;
// 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()) {
}
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);
// 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();
// 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++) {
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()) {
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();
}
(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<int> aSubs = subDocuments();
std::set<int>::iterator aSubIter = aSubs.begin();
for (; aSubIter != aSubs.end(); aSubIter++) {
{
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<int> aSubs = subDocuments();
std::set<int>::iterator aSubIter = aSubs.begin();
for (; aSubIter != aSubs.end(); aSubIter++) {
// 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<std::string> Model_Document::undoList() const
{
std::list<std::string> aResult;
}
return aResult;
}
+// LCOV_EXCL_STOP
void Model_Document::operationId(const std::string& theId)
{
aCurrent = aSub;
}
}
+ // #2861: 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
return aFeature;
}
-
void Model_Document::refsToFeature(FeaturePtr theFeature,
std::set<std::shared_ptr<ModelAPI_Feature> >& theRefs, const bool isSendError)
{
void Model_Document::removeFeature(FeaturePtr theFeature)
{
myObjs->removeFeature(theFeature);
+ // fix for #2723: send signal that part is updated
+ if (!isRoot() && isOperation()) {
+ std::shared_ptr<Model_Document> aRoot =
+ std::dynamic_pointer_cast<Model_Document>(ModelAPI_Session::get()->moduleDocument());
+ std::list<ResultPtr> allParts;
+ aRoot->objects()->allResults(ModelAPI_ResultPart::group(), allParts);
+ std::list<ResultPtr>::iterator aParts = allParts.begin();
+ for(; aParts != allParts.end(); aParts++) {
+ ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*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
return isSub(theMain, aParent);
}
-
void Model_Document::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis)
{
bool aCurrentUp = theMoved == currentFeature(false);
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;
void Model_Document::updateHistory(const std::shared_ptr<ModelAPI_Object> 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<int> Model_Document::subDocuments() const
return myObjs->size(theGroupID, theAllowFolder);
}
+std::shared_ptr<ModelAPI_Object> Model_Document::parent(
+ const std::shared_ptr<ModelAPI_Object> theChild)
+{
+ if(myObjs == 0) // may be on close
+ return ObjectPtr();
+ return myObjs->parent(theChild);
+}
+
std::shared_ptr<ModelAPI_Feature> Model_Document::currentFeature(const bool theVisible)
{
if (!myObjs) // on close document feature destruction it may call this method
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;
void Model_Document::setCurrentFeature(
std::shared_ptr<ModelAPI_Feature> 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();
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
}
}
}
+ 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<Model_Data> aData = std::static_pointer_cast<Model_Data>(theCurrent->data());
if (!aData.get() || !aData->isValid()) {
aLoop->activateFlushes(isActive);
+ myIsSetCurrentFeature = false;
return;
}
TDF_Label aFeatureLabel = aData->label().Father();
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;
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") {
//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;
}
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<ResultPtr> aResults;
ModelAPI_Tools::allResults(anIter, aResults);
if ((*aRes).get() && (*aRes)->data()->isValid() && !(*aRes)->isDisabled())
std::dynamic_pointer_cast<Model_Data>((*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);
}
// 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;
}
return myObjs->feature(theResult);
}
-Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper)
-{
- return TDF_LabelMapHasher::HashCode(theLab, theUpper);
-
-}
-Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2)
-{
- return TDF_LabelMapHasher::IsEqual(theLab1, theLab2);
-}
-
-// 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)
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<ModelAPI_Result>(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<std::string, std::list<TDF_Label> >::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<TDF_Label>::iterator anAddAfterThis = aFind->second.end();
FeaturePtr anAddedFeature = featureByLab(theLabel);
std::list<TDF_Label>::iterator aLabIter = aFind->second.begin();
} 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;
}
}
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('/');
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() == aSubName) {
+ 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
if (!aRefFeat.get()) { // take feature of the result
aRefFeat = feature(std::dynamic_pointer_cast<ModelAPI_Result>(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<ModelAPI_CompositeFeature>(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);
}
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);
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(
object(ModelAPI_Feature::group(), a));
if (aFeature.get() && aFeature->data()->isValid()) {
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResList = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResList.begin();
- for(; aRes != aResList.end(); aRes++) {
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ for (std::list<ResultPtr>::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<ModelAPI_ResultCompSolid>(*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);
- }
- }
- }
}
}
}
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
{
return myObjs->internalFeature(theIndex);
}
-std::shared_ptr<ModelAPI_Feature> Model_Document::featureById(const int theId)
-{
- return myObjs->featureById(theId);
-}
-
void Model_Document::synchronizeTransactions()
{
Model_Document* aRoot =
std::dynamic_pointer_cast<Model_Document>(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<Model_Session> aSession =
std::dynamic_pointer_cast<Model_Session>(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);
}*/
}
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)
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)) {
return myObjs->isLater(theLater, theCurrent);
}
+// Object Browser nodes states
+// LCOV_EXCL_START
void Model_Document::storeNodesState(const std::list<bool>& theStates)
{
TDF_Label aLab = generalLabel().FindChild(TAG_NODES_STATE);
}
}
}
+// LCOV_EXCL_STOP
void Model_Document::eraseAllFeatures()
{
myObjs->eraseAllFeatures();
}
+std::shared_ptr<ModelAPI_Feature> Model_Document::nextFeature(
+ std::shared_ptr<ModelAPI_Feature> 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;
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<int> aSubs = subDocuments();
+ for (std::set<int>::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);
+}
