#include <ModelAPI_Tools.h>
#include <Events_Loop.h>
-#include <Events_Error.h>
+#include <Events_InfoMessage.h>
#include <TDataStd_Integer.hxx>
#include <TDataStd_Comment.hxx>
myDoc = theDoc;
// update all fields and recreate features and result objects if needed
TDF_LabelList aNoUpdated;
- synchronizeFeatures(aNoUpdated, true, true);
+ synchronizeFeatures(aNoUpdated, true, true, true);
myHistory.clear();
}
aFeature->erase();
myFeatures.UnBind(aFeaturesIter.Key());
}
+ myHistory.clear();
aLoop->activateFlushes(isActive);
// erase update, because features are destroyed and update should not performed for them anywhere
aLoop->eraseMessages(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
// keep the feature ID to restore document later correctly
TDataStd_Comment::Set(aFeatureLab, theFeature->getKind().c_str());
myFeatures.Bind(aFeatureLab, theFeature);
- // must be after binding to the map because of "Box" macro feature that
+ // must be before the event sending: for OB the feature is already added
+ updateHistory(ModelAPI_Feature::group());
+ // do not change the order:
+ // initData()
+ // sendUpdated()
+ // during python script with fillet constraint feature data should be
+ // initialized before using it in GUI
+
+ // must be after binding to the map because of "Box" macro feature that
// creates other features in "initData"
initData(theFeature, aFeatureLab, TAG_FEATURE_ARGUMENTS);
- // event: feature is added
+ // 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);
ModelAPI_EventCreator::get()->sendUpdated(theFeature, anEvent);
- updateHistory(ModelAPI_Feature::group());
} else { // make feature has not-null data anyway
theFeature->setData(Model_Data::invalidData());
theFeature->setDoc(myDoc);
{
// check the feature: it must have no depended objects on it
// the dependencies can be in the feature results
- std::list<ResultPtr>::const_iterator aResIter = theFeature->results().cbegin();
- for (; aResIter != theFeature->results().cend(); aResIter++) {
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(theFeature, aResults);
+ std::list<ResultPtr>::const_iterator aResIter = aResults.cbegin();
+ for (; aResIter != aResults.cend(); aResIter++) {
ResultPtr aResult = (*aResIter);
std::shared_ptr<Model_Data> aData =
std::dynamic_pointer_cast<Model_Data>(aResult->data());
}
if (!theRefs.empty() && isSendError) {
- Events_Error::send(
- "Feature '" + theFeature->data()->name() + "' is used and can not be deleted");
+ Events_InfoMessage("Model_Objects",
+ "Feature '%1' is used and can not be deleted").arg(theFeature->data()->name()).send();
}
}
for(; aRefIter != aRefs.end(); aRefIter++) {
std::shared_ptr<ModelAPI_CompositeFeature> aComposite =
std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aRefIter);
- if (aComposite.get()) {
+ if (aComposite.get() && aComposite->isSub(theFeature)) {
aComposite->removeFeature(theFeature);
}
}
RemoveFromRefArray(featuresLabel(), aFeatureLabel);
// event: feature is deleted
ModelAPI_EventCreator::get()->sendDeleted(theFeature->document(), ModelAPI_Feature::group());
- // the redisplay signal should be flushed in order to erase the feature presentation in the viewer
- Events_Loop::loop()->flush(EVENT_DISP);
updateHistory(ModelAPI_Feature::group());
}
}
if (!aPassedMovedFrom || !aPassedMovedTo) {// not found: unknown situation
if (!aPassedMovedFrom) {
static std::string aMovedFromError("The moved feature is not found");
- Events_Error::send(aMovedFromError);
+ Events_InfoMessage("Model_Objects", aMovedFromError).send();
} else {
static std::string aMovedToError("The 'after' feature for movement is not found");
- Events_Error::send(aMovedToError);
+ Events_InfoMessage("Model_Objects", aMovedToError).send();
}
return;
}
// update the feature and the history
clearHistory(theMoved);
// make sure all (selection) attributes of moved feature will be updated
- theMoved->data()->setUpdateID(0);
- static Events_ID EVENT_UPD = Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED);
- ModelAPI_EventCreator::get()->sendUpdated(theMoved, EVENT_UPD);
- ModelAPI_EventCreator::get()->sendReordered(theMoved->document(), theMoved->groupName());
+ static Events_ID kUpdateSelection = Events_Loop::loop()->eventByName(EVENT_UPDATE_SELECTION);
+ ModelAPI_EventCreator::get()->sendUpdated(theMoved, kUpdateSelection, false);
+ ModelAPI_EventCreator::get()->sendReordered(theMoved);
}
void Model_Objects::clearHistory(ObjectPtr theObj)
{
std::map<std::string, std::vector<ObjectPtr> >::iterator aHIter = myHistory.find(theGroupID);
if (aHIter == myHistory.end()) {
- myHistory[theGroupID] = std::vector<ObjectPtr>();
- std::vector<ObjectPtr>& aResult = myHistory[theGroupID];
+ std::vector<ObjectPtr> aResult = std::vector<ObjectPtr>();
// iterate the array of references and get feature by feature from the array
bool isFeature = theGroupID == ModelAPI_Feature::group();
Handle(TDataStd_ReferenceArray) aRefs;
FeaturePtr aFeature = feature(aRefs->Value(a));
if (aFeature.get()) {
// if feature is in sub-component, remove it from history: it is in sub-tree of sub-component
- if (!ModelAPI_Tools::compositeOwner(aFeature).get()) {
- if (isFeature) { // here may be also disabled features
- if (aFeature->isInHistory()) {
- aResult.push_back(aFeature);
- }
- } else if (!aFeature->isDisabled()) { // iterate all results of not-disabled feature
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
+ bool isSub = ModelAPI_Tools::compositeOwner(aFeature).get() != NULL;
+ if (isFeature) { // here may be also disabled features
+ if (!isSub && aFeature->isInHistory()) {
+ aResult.push_back(aFeature);
+ }
+ } else if (!aFeature->isDisabled()) { // iterate all results of not-disabled feature
+ // construction results of sub-features should not be in the tree
+ if (!isSub || theGroupID != ModelAPI_ResultConstruction::group()) {
+ // do not use reference to the list here since results can be changed by "isConcealed"
+ const std::list<std::shared_ptr<ModelAPI_Result> > aResults = aFeature->results();
std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
for (; aRIter != aResults.cend(); aRIter++) {
ResultPtr aRes = *aRIter;
}
}
}
+ // to be sure that isConcealed did not update the history (issue 1089) during the iteration
+ if (myHistory.find(theGroupID) == myHistory.end())
+ myHistory[theGroupID] = aResult;
}
}
const std::string& theGroupID, const std::string& theName)
{
createHistory(theGroupID);
- std::vector<ObjectPtr>& allObjs = myHistory[theGroupID];
- std::vector<ObjectPtr>::iterator anObjIter = allObjs.begin();
- for(; anObjIter != allObjs.end(); anObjIter++) {
- if ((*anObjIter)->data()->name() == theName)
- return *anObjIter;
+ 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++) {
+ 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;
+ }
+ }
+ }
+ }
+ }
+ }
}
// not found
return ObjectPtr();
int Model_Objects::size(const std::string& theGroupID)
{
createHistory(theGroupID);
- return myHistory[theGroupID].size();
+ return int(myHistory[theGroupID].size());
}
void Model_Objects::allResults(const std::string& theGroupID, std::list<ResultPtr>& theResults)
isSameName = (*aRIter)->data()->name() == aName;
}
}
+
if (isSameName) {
aNumObjects++;
std::stringstream aNameStream;
theObj->initAttributes();
}
+std::shared_ptr<ModelAPI_Feature> Model_Objects::featureById(const int theId)
+{
+ if (theId > 0) {
+ TDF_Label aLab = featuresLabel().FindChild(theId, Standard_False);
+ return feature(aLab);
+ }
+ return std::shared_ptr<ModelAPI_Feature>(); // not found
+}
+
void Model_Objects::synchronizeFeatures(
- const TDF_LabelList& theUpdated, const bool theUpdateReferences, const bool theFlush)
+ const TDF_LabelList& theUpdated, const bool theUpdateReferences,
+ const bool theOpen, const bool theFlush)
{
Model_Document* anOwner = std::dynamic_pointer_cast<Model_Document>(myDoc).get();
if (!anOwner) // this may happen on creation of document: nothing there, so nothing to synchronize
TCollection_AsciiString(Handle(TDataStd_Comment)::DownCast(aLabIter.Value())->Get())
.ToCString(), anOwner);
if (!aFeature.get()) { // somethig is wrong, most probably, the opened document has invalid structure
- Events_Error::send("Invalid type of object in the document");
+ Events_InfoMessage("Model_Objects", "Invalid type of object in the document").send();
aLabIter.Value()->Label().ForgetAllAttributes();
continue;
}
aFeature = myFeatures.Find(aFeatureLabel);
aKeptFeatures.insert(aFeature);
if (anUpdatedMap.Contains(aFeatureLabel)) {
+ if (!theOpen) { // on abort/undo/redo reinitialize attributes is something is changed
+ std::list<std::shared_ptr<ModelAPI_Attribute> > anAttrs = aFeature->data()->attributes("");
+ std::list<std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = anAttrs.begin();
+ for(; anAttr != anAttrs.end(); anAttr++)
+ (*anAttr)->reinit();
+ }
ModelAPI_EventCreator::get()->sendUpdated(aFeature, anUpdateEvent);
if (aFeature->getKind() == "Parameter") { // if parameters are changed, update the results (issue 937)
const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
ModelAPI_EventCreator::get()->sendUpdated(aFeature, aRedispEvent);
updateHistory(aFeature);
aFeature->erase();
+
// unbind after the "erase" call: on abort sketch is removes sub-objects that corrupts aFIter
myFeatures.UnBind(aFIter.Key());
// reinitialize iterator because unbind may corrupt the previous order in the map
FeaturePtr aFeature = myFeatures.Find(aFeatureLabel);
if (std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeature).get())
aComposites.push_back(aFeature);
- updateResults(aFeature);
+ else
+ updateResults(aFeature);
}
}
std::list<FeaturePtr>::iterator aComposite = aComposites.begin();
myHistory.clear();
}
- anOwner->executeFeatures() = false;
+ if (theOpen)
+ anOwner->executeFeatures() = false;
aLoop->activateFlushes(isActive);
if (theFlush) {
- aLoop->flush(aCreateEvent);
aLoop->flush(aDeleteEvent);
+ aLoop->flush(aCreateEvent); // delete should be emitted before create to reacts to aborted feature
aLoop->flush(anUpdateEvent);
aLoop->flush(aCreateEvent); // after update of features, there could be results created
aLoop->flush(aDeleteEvent); // or deleted
aLoop->flush(aRedispEvent);
aLoop->flush(aToHideEvent);
}
- anOwner->executeFeatures() = true;
+ if (theOpen)
+ anOwner->executeFeatures() = true;
}
-void Model_Objects::synchronizeBackRefs()
+/// synchronises back references for the given object basing on the collected data
+void Model_Objects::synchronizeBackRefsForObject(const std::set<AttributePtr>& theNewRefs,
+ ObjectPtr theObject)
{
- // keeps the concealed flags of result to catch the change and create created/deleted events
- std::list<std::pair<ResultPtr, bool> > aConcealed;
- // first cycle: erase all data about back-references
- NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFeatures(myFeatures);
- for(; aFeatures.More(); aFeatures.Next()) {
- FeaturePtr aFeature = aFeatures.Value();
- std::shared_ptr<Model_Data> aFData =
- std::dynamic_pointer_cast<Model_Data>(aFeature->data());
- if (aFData.get()) {
- aFData->eraseBackReferences();
+ if (!theObject.get() || !theObject->data()->isValid())
+ return; // invalid
+ std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theObject->data());
+ // iterate new list to compare with curent
+ std::set<AttributePtr>::iterator aNewIter = theNewRefs.begin();
+ for(; aNewIter != theNewRefs.end(); aNewIter++) {
+ if (aData->refsToMe().find(*aNewIter) == aData->refsToMe().end()) {
+ FeaturePtr aRefFeat = std::dynamic_pointer_cast<ModelAPI_Feature>((*aNewIter)->owner());
+ aData->addBackReference(aRefFeat, (*aNewIter)->id());
}
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
- std::shared_ptr<Model_Data> aResData =
- std::dynamic_pointer_cast<Model_Data>((*aRIter)->data());
- if (aResData.get()) {
- aConcealed.push_back(std::pair<ResultPtr, bool>(*aRIter, (*aRIter)->isConcealed()));
- aResData->eraseBackReferences();
- }
- // iterate sub-bodies of compsolid
- ResultCompSolidPtr aComp = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aRIter);
- if (aComp.get()) {
- int aNumSub = aComp->numberOfSubs();
- for(int a = 0; a < aNumSub; a++) {
- ResultPtr aSub = aComp->subResult(a);
- std::shared_ptr<Model_Data> aResData =
- std::dynamic_pointer_cast<Model_Data>(aSub->data());
- if (aResData.get()) {
- aConcealed.push_back(std::pair<ResultPtr, bool>(aSub, aSub->isConcealed()));
- aResData->eraseBackReferences();
+ }
+ if (theNewRefs.size() != aData->refsToMe().size()) { // some back ref must be removed
+ std::set<AttributePtr>::iterator aCurrentIter = aData->refsToMe().begin();
+ while(aCurrentIter != aData->refsToMe().end()) {
+ if (theNewRefs.find(*aCurrentIter) == theNewRefs.end()) {
+ // for external references from other documents this system is not working: refs are collected from
+ // different Model_Objects, so before remove check this external object exists and still referenced
+ bool aLeaveIt = false;
+ if ((*aCurrentIter)->owner().get() && (*aCurrentIter)->owner()->document() != myDoc &&
+ (*aCurrentIter)->owner()->data().get() && (*aCurrentIter)->owner()->data()->isValid()) {
+ std::list<std::pair<std::string, std::list<std::shared_ptr<ModelAPI_Object> > > > aRefs;
+ (*aCurrentIter)->owner()->data()->referencesToObjects(aRefs);
+ std::list<std::pair<std::string, std::list<std::shared_ptr<ModelAPI_Object> > > >::iterator
+ aRefIter = aRefs.begin();
+ for(; aRefIter != aRefs.end(); aRefIter++) {
+ if ((*aCurrentIter)->id() == aRefIter->first) {
+ std::list<std::shared_ptr<ModelAPI_Object> >::iterator anOIt;
+ for(anOIt = aRefIter->second.begin(); anOIt != aRefIter->second.end(); anOIt++) {
+ if (*anOIt == theObject) {
+ aLeaveIt = true;
+ }
+ }
+ }
}
}
- }
+ if (!aLeaveIt) {
+ aData->removeBackReference(*aCurrentIter);
+ aCurrentIter = aData->refsToMe().begin(); // reinitialize iteration after delete
+ } else aCurrentIter++;
+ } else aCurrentIter++;
}
}
+ aData->updateConcealmentFlag();
+}
- // second cycle: set new back-references: only features may have reference, iterate only them
- ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators();
- for(aFeatures.Initialize(myFeatures); aFeatures.More(); aFeatures.Next()) {
+void Model_Objects::synchronizeBackRefs()
+{
+ // collect all back references in the separated container: to update everything at once,
+ // without additional Concealment switchin on and off: only the final modification
+
+ // referenced (slave) objects to referencing attirbutes
+ std::map<ObjectPtr, std::set<AttributePtr> > allRefs;
+ NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFeatures(myFeatures);
+ for(; aFeatures.More(); aFeatures.Next()) {
FeaturePtr aFeature = aFeatures.Value();
- std::shared_ptr<Model_Data> aFData =
- std::dynamic_pointer_cast<Model_Data>(aFeature->data());
+ std::shared_ptr<Model_Data> aFData = std::dynamic_pointer_cast<Model_Data>(aFeature->data());
if (aFData.get()) {
std::list<std::pair<std::string, std::list<ObjectPtr> > > aRefs;
aFData->referencesToObjects(aRefs);
- std::list<std::pair<std::string, std::list<ObjectPtr> > >::iterator
- aRefsIter = aRefs.begin();
- for(; aRefsIter != aRefs.end(); aRefsIter++) {
- std::list<ObjectPtr>::iterator aRefTo = aRefsIter->second.begin();
- for(; aRefTo != aRefsIter->second.end(); aRefTo++) {
+ std::list<std::pair<std::string, std::list<ObjectPtr> > >::iterator aRefsIt = aRefs.begin();
+ for(; aRefsIt != aRefs.end(); aRefsIt++) {
+ std::list<ObjectPtr>::iterator aRefTo = aRefsIt->second.begin();
+ for(; aRefTo != aRefsIt->second.end(); aRefTo++) {
if (*aRefTo) {
- std::shared_ptr<Model_Data> aRefData =
- std::dynamic_pointer_cast<Model_Data>((*aRefTo)->data());
- aRefData->addBackReference(aFeature, aRefsIter->first); // here the Concealed flag is updated
- // update enable/disable status: the nested status must be equal to the composite
- CompositeFeaturePtr aComp =
- std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeature);
- if (aComp.get()) {
- FeaturePtr aReferenced = std::dynamic_pointer_cast<ModelAPI_Feature>(*aRefTo);
- if (aReferenced.get()) {
- aReferenced->setDisabled(aComp->isDisabled());
- }
+ std::map<ObjectPtr, std::set<AttributePtr> >::iterator aFound = allRefs.find(*aRefTo);
+ if (aFound == allRefs.end()) {
+ allRefs[*aRefTo] = std::set<AttributePtr>();
+ aFound = allRefs.find(*aRefTo);
}
+ aFound->second.insert(aFeature->data()->attribute(aRefsIt->first));
}
}
}
}
}
- std::list<std::pair<ResultPtr, bool> >::iterator aCIter = aConcealed.begin();
- for(; aCIter != aConcealed.end(); aCIter++) {
- if (aCIter->first->isConcealed() != aCIter->second) { // something is changed => produce event
- if (aCIter->second) { // was concealed become not => creation event
- static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED);
- ModelAPI_EventCreator::get()->sendUpdated(aCIter->first, anEvent);
- } else { // was not concealed become concealed => delete event
- ModelAPI_EventCreator::get()->sendDeleted(myDoc, aCIter->first->groupName());
- // redisplay for the viewer (it must be disappeared also)
- static Events_ID EVENT_DISP =
- Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
- ModelAPI_EventCreator::get()->sendUpdated(aCIter->first, EVENT_DISP);
+ // second iteration: just compare back-references with existing in features and results
+ for(aFeatures.Initialize(myFeatures); aFeatures.More(); aFeatures.Next()) {
+ FeaturePtr aFeature = aFeatures.Value();
+ static std::set<AttributePtr> anEmpty;
+ std::map<ObjectPtr, std::set<AttributePtr> >::iterator aFound = allRefs.find(aFeature);
+ if (aFound == allRefs.end()) { // not found => erase all back references
+ synchronizeBackRefsForObject(anEmpty, aFeature);
+ } else {
+ synchronizeBackRefsForObject(aFound->second, aFeature);
+ allRefs.erase(aFound); // to check that all refs are counted
+ }
+ // also for results
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ std::list<ResultPtr>::iterator aRIter = aResults.begin();
+ for(; aRIter != aResults.cend(); aRIter++) {
+ aFound = allRefs.find(*aRIter);
+ if (aFound == allRefs.end()) { // not found => erase all back references
+ synchronizeBackRefsForObject(anEmpty, *aRIter);
+ } else {
+ synchronizeBackRefsForObject(aFound->second, *aRIter);
+ allRefs.erase(aFound); // to check that all refs are counted
}
}
}
+ for(aFeatures.Initialize(myFeatures); aFeatures.More(); aFeatures.Next()) {
+ FeaturePtr aFeature = aFeatures.Value();
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ // update the concealment status for disply in isConcealed of ResultBody
+ std::list<ResultPtr>::iterator aRIter = aResults.begin();
+ for(; aRIter != aResults.cend(); aRIter++) {
+ (*aRIter)->isConcealed();
+ }
+ }
+ // the rest all refs means that feature references to the external document feature: process also them
+ std::map<ObjectPtr, std::set<AttributePtr> >::iterator anExtIter = allRefs.begin();
+ for(; anExtIter != allRefs.end(); anExtIter++) {
+ synchronizeBackRefsForObject(anExtIter->second, anExtIter->first);
+ }
}
TDF_Label Model_Objects::resultLabel(
if (!theFeature->data() || !theFeature->data()->isValid() || theFeature->isDisabled())
return;
// check that results are presented on all labels
- int aResSize = theFeature->results().size();
+ int aResSize = int(theFeature->results().size());
TDF_ChildIterator aLabIter(resultLabel(theFeature->data(), 0).Father());
for(; aLabIter.More(); aLabIter.Next()) {
// here must be GUID of the feature
theFeature->attributeChanged("expression"); // just produce a value
break;
} else {
- Events_Error::send(std::string("Unknown type of result is found in the document:") +
- TCollection_AsciiString(aGroup->Get()).ToCString());
+ Events_InfoMessage("Model_Objects", "Unknown type of result is found in the document:")
+ .arg(TCollection_AsciiString(aGroup->Get()).ToCString()).send();
}
}
if (aNewBody && !aNewBody->data()->isDeleted()) {
FeaturePtr& aFeature = anObjIter.ChangeValue();
if (!aFeature.get() || aFeature->isDisabled()) // may be on close
continue;
- const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
- std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
- for (; aRIter != aResults.cend(); aRIter++) {
+ std::list<ResultPtr> allResults;
+ ModelAPI_Tools::allResults(aFeature, allResults);
+ std::list<ResultPtr>::iterator aRIter = allResults.begin();
+ for (; aRIter != allResults.cend(); aRIter++) {
ResultPtr aRes = *aRIter;
if (aRes.get() && aRes->data() && aRes->data()->isValid() && !aRes->isDisabled() &&
aRes->data()->name() == theName) {