#include <Model_ResultPart.h>
#include <Model_ResultConstruction.h>
#include <Model_ResultBody.h>
-#include <Model_ResultCompSolid.h>
#include <Model_ResultGroup.h>
#include <Model_ResultField.h>
#include <Model_ResultParameter.h>
#include <TDF_ChildIDIterator.hxx>
#include <TDataStd_ReferenceArray.hxx>
#include <TDataStd_HLabelArray1.hxx>
-#include <TDataStd_Name.hxx>
#include <TDF_Reference.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TDF_LabelMapHasher.hxx>
return theGroupID;
}
+// Check theFeature is a first or last feature in folder and return this folder
+static FolderPtr inFolder(const FeaturePtr& theFeature, const std::string& theFolderAttr)
+{
+ const std::set<AttributePtr>& aRefs = theFeature->data()->refsToMe();
+ for (std::set<AttributePtr>::iterator anIt = aRefs.begin(); anIt != aRefs.end(); ++anIt) {
+ if ((*anIt)->id() != theFolderAttr)
+ continue;
+
+ ObjectPtr anOwner = (*anIt)->owner();
+ FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(anOwner);
+ if (aFolder.get())
+ return aFolder;
+ }
+ return FolderPtr();
+}
+
static const int TAG_OBJECTS = 2; // tag of the objects sub-tree (features, results)
// store feature in the features array: before "initData" because in macro features
// in initData it creates new features, appeared later than this
TDF_Label aPrevFeateureLab;
+ FolderPtr aParentFolder;
if (theAfterThis.get()) { // searching for the previous feature label
std::shared_ptr<Model_Data> aPrevData =
std::dynamic_pointer_cast<Model_Data>(theAfterThis->data());
if (aPrevData.get()) {
aPrevFeateureLab = aPrevData->label().Father();
}
+ // Check if the previous feature is the last feature in a folder,
+ // then the folder should be updated to contain additional feature.
+ // Macro features are not stored in folder.
+ if (!theFeature->isMacro()) {
+ // If the last feature is a sub-feature of composite, use parent feature
+ // to check belonging to a folder.
+ FeaturePtr afterThis = ModelAPI_Tools::compositeOwner(theAfterThis);
+ if (!afterThis)
+ afterThis = theAfterThis;
+ aParentFolder = inFolder(afterThis, ModelAPI_Folder::LAST_FEATURE_ID());
+ }
}
AddToRefArray(aFeaturesLab, aFeatureLab, aPrevFeateureLab);
// must be after binding to the map because of "Box" macro feature that
// creates other features in "initData"
initData(theFeature, aFeatureLab, TAG_FEATURE_ARGUMENTS);
+ // put feature to the end of folder if it is added while
+ // the history line is set to the last feature from the folder
+ if (aParentFolder) {
+ aParentFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID())->setValue(theFeature);
+ updateHistory(ModelAPI_Folder::group());
+ }
// event: feature is added, mist be before "initData" to update OB correctly on Duplicate:
// first new part, then the content
static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
for(; aRefIter != aRefs.end(); aRefIter++) {
std::shared_ptr<ModelAPI_CompositeFeature> aComposite =
std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aRefIter);
- if (aComposite.get() && aComposite->isSub(theFeature)) {
+ if (aComposite.get() && aComposite->data()->isValid() && aComposite->isSub(theFeature)) {
aComposite->removeFeature(theFeature);
}
}
+ // remove feature from folder
+ removeFromFolder(std::list<FeaturePtr>(1, theFeature));
// this must be before erase since theFeature erasing removes all information about
// the feature results and groups of results
// To reproduce: create sketch, extrusion, remove sketch => constructions tree is not updated
}
kCreator->sendDeleted(myDoc, ModelAPI_Feature::group());
myFeatures.Clear(); // just remove features without modification of DS
- updateHistory(ModelAPI_Feature::group());
+ myHistory.clear();
}
void Model_Objects::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis)
if (theAfterThis.get())
anAfterLab = std::dynamic_pointer_cast<Model_Data>(theAfterThis->data())->label().Father();
+ // check whether some folder refers to the moved feature by start or end: if yes, remove from it
+ removeFromFolder(std::list<FeaturePtr>(1, theMoved));
+
Handle(TDataStd_HLabelArray1) aNewArray =
new TDataStd_HLabelArray1(aRefs->Lower(), aRefs->Upper());
int aPassedMovedFrom = 0; // the prev feature location is found and passed
} else {
// it may be a folder
- ObjectPtr aFolder = folder(aRefs->Value(a));
+ const ObjectPtr& aFolder = folder(aRefs->Value(a));
if (aFolder.get()) {
// store folder information for the Features group only
if (isFeature || isFolder) {
}
}
-ObjectPtr Model_Objects::folder(TDF_Label theLabel) const
+const ObjectPtr& Model_Objects::folder(TDF_Label theLabel) const
{
if (myFolders.IsBound(theLabel))
return myFolders.Find(theLabel);
- return ObjectPtr();
+ static ObjectPtr anEmptyResult;
+ return anEmptyResult;
}
FeaturePtr Model_Objects::feature(TDF_Label theLabel) const
FeaturePtr aFeature = feature(theLabel);
if (aFeature.get())
return feature(theLabel);
- TDF_Label aFeatureLabel = theLabel.Father().Father(); // let's suppose it is result
- aFeature = feature(aFeatureLabel);
- bool isSubResult = false;
- if (!aFeature.get() && aFeatureLabel.Depth() > 1) { // let's suppose this is sub-result of result
+ TDF_Label aFeatureLabel = theLabel; // let's suppose it is result of this feature
+ TDF_LabelList aSubLabs; // sub - labels from higher level to lower level of result
+ while(!aFeature.get() && aFeatureLabel.Depth() > 1) {
+ aSubLabs.Prepend(aFeatureLabel);
aFeatureLabel = aFeatureLabel.Father().Father();
aFeature = feature(aFeatureLabel);
- isSubResult = true;
}
if (aFeature.get()) {
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.cbegin();
- for (; aRIter != aResults.cend(); aRIter++) {
- if (isSubResult) {
- ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aRIter);
- if (aCompRes.get()) {
- int aNumSubs = aCompRes->numberOfSubs();
- for(int a = 0; a < aNumSubs; a++) {
- ResultPtr aSub = aCompRes->subResult(a);
- if (aSub.get()) {
- std::shared_ptr<Model_Data> aSubData = std::dynamic_pointer_cast<Model_Data>(
- aSub->data());
- if (aSubData->label().Father().IsEqual(theLabel))
- return aSub;
+ ResultPtr aCurrentResult;
+ // searching for results then sub-results label by label
+ for(TDF_ListIteratorOfLabelList aSubLab(aSubLabs); aSubLab.More(); aSubLab.Next()) {
+ if (aCurrentResult.get()) { // iterate sub-results of result
+ ResultBodyPtr anOwner = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aCurrentResult);
+ if (!anOwner)
+ return ObjectPtr(); // only Body can have sub-results
+ int a, aNumSubs = anOwner->numberOfSubs();
+ for(a = 0; a < aNumSubs; a++) {
+ ResultPtr aSub = anOwner->subResult(a);
+ if (aSub.get()) {
+ std::shared_ptr<Model_Data> aSubData = std::dynamic_pointer_cast<Model_Data>(
+ aSub->data());
+ const TDF_Label& aSubLabVal = aSubLab.ChangeValue();
+ if (aSubData->label().Father().IsEqual(aSubLabVal)) {
+ aCurrentResult = aSub;
+ break;
}
}
}
- } else {
- std::shared_ptr<Model_Data> aResData = std::dynamic_pointer_cast<Model_Data>(
- (*aRIter)->data());
- if (aResData->label().Father().IsEqual(theLabel))
- return *aRIter;
+ if (a == aNumSubs) // not found an appropriate sub-result of result
+ return ObjectPtr();
+ } else { // iterate results of feature
+ const std::list<ResultPtr>& aResults = aFeature->results();
+ std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.cbegin();
+ for(; aRIter != aResults.cend(); aRIter++) {
+ std::shared_ptr<Model_Data> aResData =
+ std::dynamic_pointer_cast<Model_Data>((*aRIter)->data());
+ if (aResData->label().Father().IsEqual(aSubLab.ChangeValue())) {
+ aCurrentResult = *aRIter;
+ break;
+ }
+ }
+ if (aRIter == aResults.cend()) // not found an appropriate result of feature
+ return ObjectPtr();
}
}
+ return aCurrentResult;
}
- return FeaturePtr(); // not found
+ return ObjectPtr(); // not found
}
ObjectPtr Model_Objects::object(const std::string& theGroupID,
return ObjectPtr();
createHistory(theGroupID);
const std::string& aGroupID = groupNameFoldering(theGroupID, theAllowFolder);
+ const std::vector<ObjectPtr>& aVec = myHistory[theGroupID];
+ //if (aVec.size() <= theIndex)
+ // return aVec[aVec.size() - 1]; // too high index requested (to avoid crash in #2360)
return aGroupID.empty() ? myHistory[theGroupID][theIndex] : myHistory[aGroupID][theIndex];
}
createHistory(theGroupID);
if (theGroupID == ModelAPI_Feature::group()) { // searching among features (in history or not)
std::list<std::shared_ptr<ModelAPI_Feature> > allObjs = allFeatures();
- std::list<std::shared_ptr<ModelAPI_Feature> >::iterator anObjIter = allObjs.begin();
- for(; anObjIter != allObjs.end(); anObjIter++) {
+ // from the end to find the latest result with such name
+ std::list<std::shared_ptr<ModelAPI_Feature> >::reverse_iterator anObjIter = allObjs.rbegin();
+ for(; anObjIter != allObjs.rend(); anObjIter++) {
if ((*anObjIter)->data()->name() == theName)
return *anObjIter;
}
} else { // searching among results (concealed or not)
std::list<std::shared_ptr<ModelAPI_Feature> > allObjs = allFeatures();
- std::list<std::shared_ptr<ModelAPI_Feature> >::iterator anObjIter = allObjs.begin();
- for(; anObjIter != allObjs.end(); anObjIter++) {
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = (*anObjIter)->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.cbegin();
- for (; aRIter != aResults.cend(); aRIter++) {
- if (aRIter->get() && (*aRIter)->groupName() == theGroupID) {
- if ((*aRIter)->data()->name() == theName)
- return *aRIter;
- ResultCompSolidPtr aCompRes =
- std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aRIter);
- if (aCompRes.get()) {
- int aNumSubs = aCompRes->numberOfSubs();
- for(int a = 0; a < aNumSubs; a++) {
- ResultPtr aSub = aCompRes->subResult(a);
- if (aSub.get() && aSub->groupName() == theGroupID) {
- if (aSub->data()->name() == theName)
- return aSub;
- }
- }
- }
+ // from the end to find the latest result with such name
+ std::list<std::shared_ptr<ModelAPI_Feature> >::reverse_iterator anObjIter = allObjs.rbegin();
+ for(; anObjIter != allObjs.rend(); anObjIter++) {
+ std::list<ResultPtr> allRes;
+ ModelAPI_Tools::allResults(*anObjIter, allRes);
+ for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
+ if (aRes->get() && (*aRes)->groupName() == theGroupID) {
+ if ((*aRes)->data()->name() == theName)
+ return *aRes;
}
}
}
return aGroupID.empty() ? int(myHistory[theGroupID].size()) : int(myHistory[aGroupID].size());
}
+std::shared_ptr<ModelAPI_Object> Model_Objects::parent(
+ const std::shared_ptr<ModelAPI_Object> theChild)
+{
+ if (theChild.get()) {
+ std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theChild->data());
+ TDF_Label aLab = aData->label();
+ if (!aLab.IsNull() && aLab.Depth() > 2) {
+ ObjectPtr anObj = object(aLab.Father().Father().Father());
+ return anObj;
+ }
+ }
+ return ObjectPtr();
+}
+
+
void Model_Objects::allResults(const std::string& theGroupID, std::list<ResultPtr>& theResults)
{
// iterate the array of references and get feature by feature from the array
TDF_Label& aFeatureLab = anUpdatedIter.Value();
while(aFeatureLab.Depth() > 3)
aFeatureLab = aFeatureLab.Father();
- if (myFeatures.IsBound(aFeatureLab))
+ if (myFeatures.IsBound(aFeatureLab) || myFolders.IsBound(aFeatureLab))
anUpdatedMap.Add(aFeatureLab);
}
} else aCurrentIter++;
}
}
+ // for the last feature in the folder, check if it is a sub-feature,
+ // then refer the folder to a top-level parent composite feature
+ const std::set<AttributePtr>& aRefs = aData->refsToMe();
+ std::set<AttributePtr>::iterator anIt = aRefs.begin();
+ for (; anIt != aRefs.end(); ++anIt)
+ if ((*anIt)->id() == ModelAPI_Folder::LAST_FEATURE_ID())
+ break;
+ if (anIt != aRefs.end()) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
+ if (aFeature) {
+ CompositeFeaturePtr aParent;
+ CompositeFeaturePtr aGrandParent = ModelAPI_Tools::compositeOwner(aFeature);
+ do {
+ aParent = aGrandParent;
+ if (aGrandParent)
+ aGrandParent = ModelAPI_Tools::compositeOwner(aParent);
+ } while (aGrandParent.get());
+ if (aParent) {
+ ObjectPtr aFolder = (*anIt)->owner();
+ // remove reference from the current feature
+ aData->removeBackReference(aFolder, ModelAPI_Folder::LAST_FEATURE_ID());
+ // set reference to a top-level parent
+ aFolder->data()->reference(ModelAPI_Folder::LAST_FEATURE_ID())->setValue(aParent);
+ std::shared_ptr<Model_Data> aParentData =
+ std::dynamic_pointer_cast<Model_Data>(aParent->data());
+ aParentData->addBackReference(aFolder, ModelAPI_Folder::LAST_FEATURE_ID());
+ }
+ }
+ }
aData->updateConcealmentFlag();
}
int theResultIndex,
std::string& theParentName) const
{
- ResultCompSolidPtr aCompSolidRes =
- std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theFeatureData->owner());
- if (aCompSolidRes) {
- FeaturePtr anOwner = ModelAPI_Feature::feature(theResult->data()->owner());
+ ResultBodyPtr aBodyRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theFeatureData->owner());
+ if (aBodyRes) {
+ // only for top-results (works for the cases when results are not yet added to the feature)
+ FeaturePtr anOwner = ModelAPI_Feature::feature(theResult);
// names of sub-solids in CompSolid should be default (for example,
// result of boolean operation 'Boolean_1' is a CompSolid which is renamed to 'MyBOOL',
// however, sub-elements of 'MyBOOL' should be named 'Boolean_1_1', 'Boolean_1_2' etc.)
- std::ostringstream aDefaultName;
- aDefaultName << anOwner->name();
- // compute default name of CompSolid (name of feature + index of CompSolid's result)
- int aCompSolidResultIndex = 0;
- const std::list<ResultPtr>& aResults = anOwner->results();
- for (std::list<ResultPtr>::const_iterator anIt = aResults.begin();
- anIt != aResults.end(); ++anIt, ++aCompSolidResultIndex)
- if (aCompSolidRes == *anIt)
- break;
- aDefaultName << "_" << (aCompSolidResultIndex + 1);
- theParentName = aDefaultName.str();
+ if (std::dynamic_pointer_cast<Model_Data>(aBodyRes->data())->label().Depth() == 6) {
+ std::ostringstream aDefaultName;
+ // compute default name of CompSolid (name of feature + index of CompSolid's result)
+ int aBodyResultIndex = 0;
+ const std::list<ResultPtr>& aResults = anOwner->results();
+ std::list<ResultPtr>::const_iterator anIt = aResults.begin();
+ for (; anIt != aResults.end(); ++anIt, ++aBodyResultIndex)
+ if (aBodyRes == *anIt)
+ break;
+ aDefaultName << anOwner->name();
+ aDefaultName << "_" << (aBodyResultIndex + 1);
+ theParentName = aDefaultName.str();
+ } else { // just name of the parent result if it is deeper than just a sub-result
+ theParentName = aBodyRes->data()->name();
+ }
return false;
}
- std::pair<std::string, bool> aName = ModelAPI_Tools::getDefaultName(theResult, theResultIndex);
+ std::pair<std::string, bool> aName = ModelAPI_Tools::getDefaultName(theResult);
if (aName.second)
theParentName = aName.first;
return aName.second;
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex)
{
TDF_Label aLab = resultLabel(theFeatureData, theIndex);
- // for feature create compsolid, but for result sub create body:
- // only one level of recursion is supported now
- ResultPtr aResultOwner = std::dynamic_pointer_cast<ModelAPI_Result>(theFeatureData->owner());
- ObjectPtr anOldObject;
- if (aResultOwner.get()) {
- TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str());
- } else { // in compsolid (higher level result) old object probably may be found
- TDataStd_Comment::Set(aLab, ModelAPI_ResultCompSolid::group().c_str());
- anOldObject = object(aLab);
- }
+ TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str());
+ ObjectPtr anOldObject = object(aLab);
std::shared_ptr<ModelAPI_ResultBody> aResult;
if (anOldObject.get()) {
aResult = std::dynamic_pointer_cast<ModelAPI_ResultBody>(anOldObject);
}
if (!aResult.get()) {
- // create compsolid anyway; if it is compsolid, it will create sub-bodies internally
- if (aResultOwner.get()) {
- aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultBody);
- } else {
- aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultCompSolid);
- }
+ aResult = std::shared_ptr<ModelAPI_ResultBody>(new Model_ResultBody);
storeResult(theFeatureData, aResult, theIndex);
}
return aResult;
continue;
}
- aFoundFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(folder(aCurLabel));
- if (aFoundFolder) {
+ const ObjectPtr& aFolderObj = folder(aCurLabel);
+ if (aFolderObj.get()) {
+ aFoundFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(aFolderObj);
AttributeReferencePtr aLastFeatAttr =
aFoundFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID());
if (aLastFeatAttr) {
return true;
}
-static FolderPtr inFolder(const FeaturePtr& theFeature, const std::string& theFolderAttr)
-{
- const std::set<AttributePtr>& aRefs = theFeature->data()->refsToMe();
- for (std::set<AttributePtr>::iterator anIt = aRefs.begin(); anIt != aRefs.end(); ++anIt) {
- if ((*anIt)->id() != theFolderAttr)
- continue;
-
- ObjectPtr anOwner = (*anIt)->owner();
- FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(anOwner);
- if (aFolder.get())
- return aFolder;
- }
- return FolderPtr();
-}
-
static FolderPtr isExtractionCorrect(const FolderPtr& theFirstFeatureFolder,
const FolderPtr& theLastFeatureFolder,
bool& isExtractBefore)
for (int aRefIndex = aRefs->Lower(); aRefIndex <= aRefs->Upper(); ++aRefIndex) {
TDF_Label aCurLabel = aRefs->Value(aRefIndex);
- if (isSkippedFeature(feature(aCurLabel)))
- continue;
if (aFoundFolder)
++theIndexInFolder;
- if (aCurLabel == aLabelToFind) // the feature is reached
+ if (aCurLabel == aLabelToFind) { // the feature is reached
+ if (aFoundFolder) {
+ if (isSkippedFeature(theFeature)) {
+ theIndexInFolder = -1;
+ return FolderPtr();
+ }
+ // decrease the index of the feature in the folder by the number of skipped features
+ for (int anIndex = theIndexInFolder - 1; anIndex > 0; anIndex--) {
+ aCurLabel = aRefs->Value(aRefIndex - anIndex);
+ if (isSkippedFeature(feature(aCurLabel)))
+ theIndexInFolder--;
+ }
+ }
return aFoundFolder;
+ }
if (!aFoundFolder) {
// if the current label refers to a folder, feel all necessary data
- aFoundFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(folder(aCurLabel));
- if (aFoundFolder) {
+ const ObjectPtr& aFolderObj = folder(aCurLabel);
+ if (aFolderObj.get()) {
+ aFoundFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(aFolderObj);
theIndexInFolder = -1;
AttributeReferencePtr aLastRef =
const std::shared_ptr<ModelAPI_Result>& theResult)
{
std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theResult->data());
- if (aData.get()) {
+ if (aData.get() && aData->isValid()) {
TDF_Label aFeatureLab = aData->label().Father().Father().Father();
FeaturePtr aFeature = feature(aFeatureLab);
- if (!aFeature.get() && aFeatureLab.Depth() > 1) { // this may be sub-result of result
+ while(!aFeature.get() && aFeatureLab.Depth() > 1) { // this may be sub-result of result
aFeatureLab = aFeatureLab.Father().Father();
aFeature = feature(aFeatureLab);
}
}
}
- // for not persistent is will be done by parametric updater automatically
- //if (!theFeature->isPersistentResult()) return;
// check the existing results and remove them if there is nothing on the label
std::list<ResultPtr>::const_iterator aResIter = theFeature->results().cbegin();
while(aResIter != theFeature->results().cend()) {
TDF_Label anArgLab = aLabIter.Value();
Handle(TDataStd_Comment) aGroup;
if (anArgLab.FindAttribute(TDataStd_Comment::GetID(), aGroup)) {
- if (aGroup->Get() == ModelAPI_ResultBody::group().c_str() ||
- aGroup->Get() == ModelAPI_ResultCompSolid::group().c_str()) {
+ if (aGroup->Get() == ModelAPI_ResultBody::group().c_str()) {
aNewBody = createBody(theFeature->data(), aResIndex);
} else if (aGroup->Get() == ModelAPI_ResultPart::group().c_str()) {
- std::shared_ptr<ModelAPI_ResultPart> aNewP = createPart(theFeature->data(), aResIndex);
- theFeature->setResult(aNewP, aResIndex);
- if (!aNewP->partDoc().get())
- // create the part result: it is better to restore the previous result if it is possible
- theFeature->execute();
+ if (aResIndex <= theFeature->results().size()) { // to avoid crash if previous execute
+ // for index = 0 erases result
+ std::shared_ptr<ModelAPI_ResultPart> aNewP = createPart(theFeature->data(), aResIndex);
+ theFeature->setResult(aNewP, aResIndex);
+ if (!aNewP->partDoc().get())
+ // create the part result: it is better to restore the previous result if possible
+ theFeature->execute();
+ }
} else if (aGroup->Get() == ModelAPI_ResultConstruction::group().c_str()) {
- theFeature->execute(); // construction shapes are needed for sketch solver
+ ResultConstructionPtr aConstr = createConstruction(theFeature->data(), aResIndex);
+ if (!aConstr->updateShape())
+ theFeature->execute(); // not stored shape in the data structure, execute to have it
+ else
+ theFeature->setResult(aConstr, aResIndex); // result is ready without execution
} else if (aGroup->Get() == ModelAPI_ResultGroup::group().c_str()) {
aNewBody = createGroup(theFeature->data(), aResIndex);
} else if (aGroup->Get() == ModelAPI_ResultField::group().c_str()) {
}
}
}
+ if (aResSize > 0) { // check there exist a body that must be updated
+ std::list<ResultPtr>::const_iterator aRes = theFeature->results().cbegin();
+ for (; aResSize && aRes != theFeature->results().cend(); aRes++, aResSize++) {
+ if ((*aRes)->data()->isValid()) {
+ if ((*aRes)->groupName() == ModelAPI_ResultBody::group()) {
+ ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(*aRes);
+ aBody->updateSubs(aBody->shape(), false);
+ } else if ((*aRes)->groupName() == ModelAPI_ResultConstruction::group()) {
+ // update the cashed myShape presented in construction
+ ResultConstructionPtr aConstr =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aRes);
+ aConstr->updateShape();
+ }
+ }
+ }
+ }
}
ResultPtr Model_Objects::findByName(const std::string theName)
std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theCurrent->data());
if (aData.get() && aData->isValid()) {
TDF_Label aFeatureLabel = aData->label().Father();
- TDF_Label aNextLabel = nextLabel(aFeatureLabel, theReverse);
- if (!aNextLabel.IsNull())
- return feature(aNextLabel);
+ do {
+ TDF_Label aNextLabel = nextLabel(aFeatureLabel, theReverse);
+ if (aNextLabel.IsNull())
+ break; // last or something is wrong
+ FeaturePtr aFound = feature(aNextLabel);
+ if (aFound)
+ return aFound; // the feature is found
+ // if the next label is a folder, skip it
+ aFeatureLabel = folder(aNextLabel).get() ? aNextLabel : TDF_Label();
+ } while (!aFeatureLabel.IsNull());
}
return FeaturePtr(); // not found, last, or something is wrong
}
{
Handle(TDataStd_ReferenceArray) aRefs;
if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
+ // comment this because of #2674 - features are removed from array on deactivation of Part
+ /*FeaturePtr aLast = feature(aRefs->Value(aRefs->Upper()));
+ if (!aLast.get() && aRefs->Length() != 0) { // erase the invalid feature from the array
+ RemoveFromRefArray(featuresLabel(), aRefs->Value(aRefs->Upper()));
+ return lastFeature(); // try once again, after the last was removed
+ }*/
return feature(aRefs->Value(aRefs->Upper()));
}
return FeaturePtr(); // no features at all