+
+void Model_AttributeSelection::setId(int theID)
+{
+ const ResultPtr& aContext = context();
+ std::shared_ptr<GeomAPI_Shape> aSelection;
+
+ std::shared_ptr<GeomAPI_Shape> aContextShape = aContext->shape();
+ // support for compsolids:
+ if (aContext.get() && ModelAPI_Tools::compSolidOwner(aContext).get())
+ aContextShape = ModelAPI_Tools::compSolidOwner(aContext)->shape();
+
+ TopoDS_Shape aMainShape = aContextShape->impl<TopoDS_Shape>();
+ // searching for the latest main shape
+ if (theID > 0 &&
+ aContextShape && !aContextShape->isNull())
+ {
+ std::shared_ptr<Model_Document> aDoc =
+ std::dynamic_pointer_cast<Model_Document>(aContext->document());
+ if (aDoc.get()) {
+ Handle(TNaming_NamedShape) aNS = TNaming_Tool::NamedShape(aMainShape, aDoc->generalLabel());
+ if (!aNS.IsNull()) {
+ aMainShape = TNaming_Tool::CurrentShape(aNS);
+ }
+ }
+
+ TopTools_IndexedMapOfShape aSubShapesMap;
+ TopExp::MapShapes(aMainShape, aSubShapesMap);
+ const TopoDS_Shape& aSelShape = aSubShapesMap.FindKey(theID);
+
+ std::shared_ptr<GeomAPI_Shape> aResult(new GeomAPI_Shape);
+ aResult->setImpl(new TopoDS_Shape(aSelShape));
+
+ aSelection = aResult;
+ }
+
+ setValue(aContext, aSelection);
+}
+
+std::string Model_AttributeSelection::contextName(const ResultPtr& theContext) const
+{
+ std::string aResult;
+ if (owner()->document() != theContext->document()) {
+ if (theContext->document() == ModelAPI_Session::get()->moduleDocument()) {
+ aResult = theContext->document()->kind() + "/";
+ } else {
+ ResultPtr aDocRes = ModelAPI_Tools::findPartResult(
+ ModelAPI_Session::get()->moduleDocument(), theContext->document());
+ if (aDocRes.get()) {
+ aResult = aDocRes->data()->name() + "/";
+ }
+ }
+ }
+ aResult += theContext->data()->name();
+ return aResult;
+}
+
+void Model_AttributeSelection::computeValues(
+ ResultPtr theOldContext, ResultPtr theNewContext, TopoDS_Shape theValShape,
+ TopTools_ListOfShape& theShapes)
+{
+ bool aWasWholeContext = theValShape.IsNull();
+ if (aWasWholeContext) {
+ //theShapes.Append(theValShape);
+ //return;
+ theValShape = theOldContext->shape()->impl<TopoDS_Shape>();
+ }
+ //TopoDS_Shape anOldContShape = theOldContext->shape()->impl<TopoDS_Shape>();
+ TopoDS_Shape aNewContShape = theNewContext->shape()->impl<TopoDS_Shape>();
+ //if (anOldContShape.IsSame(theValShape)) { // full context shape substituted by new full context
+ //theShapes.Append(aNewContShape);
+ //return;
+ //}
+ // if a new value is unchanged in the new context, do nothing: value is correct
+ TopExp_Explorer aSubExp(aNewContShape, theValShape.ShapeType());
+ for(; aSubExp.More(); aSubExp.Next()) {
+ if (aSubExp.Current().IsSame(theValShape)) {
+ theShapes.Append(theValShape);
+ return;
+ }
+ }
+ // if new context becomes compsolid, the resulting sub may be in sub-solids
+ std::list<ResultPtr> aNewToIterate;
+ aNewToIterate.push_back(theNewContext);
+ ResultCompSolidPtr aComp = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theNewContext);
+ if (aComp.get()) {
+ for(int a = 0; a < aComp->numberOfSubs(); a++)
+ aNewToIterate.push_back(aComp->subResult(a, false));
+ }
+
+ // first iteration: searching for the whole shape appearance (like face of the box)
+ // second iteration: searching for sub-shapes that contain the sub (like vertex on faces)
+ int aToFindPart = 0;
+ TopTools_DataMapOfShapeShape aNewToOld; // map from new containers to old containers (with val)
+ TopTools_MapOfShape anOlds; // to know how many olds produced new containers
+ for(; aToFindPart != 2 && theShapes.IsEmpty(); aToFindPart++) {
+ std::list<ResultPtr>::iterator aNewContIter = aNewToIterate.begin();
+ for(; aNewContIter != aNewToIterate.end(); aNewContIter++) {
+ std::shared_ptr<Model_Data> aNewData =
+ std::dynamic_pointer_cast<Model_Data>((*aNewContIter)->data());
+ TDF_Label aNewLab = aNewData->label();
+ // searching for produced sub-shape fully on some label
+ TDF_ChildIDIterator aNSIter(aNewLab, TNaming_NamedShape::GetID(), Standard_True);
+ for(; aNSIter.More(); aNSIter.Next()) {
+ Handle(TNaming_NamedShape) aNS = Handle(TNaming_NamedShape)::DownCast(aNSIter.Value());
+ for(TNaming_Iterator aPairIter(aNS); aPairIter.More(); aPairIter.Next()) {
+ if (aToFindPart == 0) { // search shape is fully inside
+ if (aPairIter.OldShape().IsSame(theValShape)) {
+ if (aPairIter.NewShape().IsNull()) {// value was removed
+ theShapes.Clear();
+ return;
+ }
+ theShapes.Append(aPairIter.NewShape());
+ }
+ } else if (!aPairIter.OldShape().IsNull()) { // search shape that contains this sub
+ TopExp_Explorer anExp(aPairIter.OldShape(), theValShape.ShapeType());
+ for(; anExp.More(); anExp.Next()) {
+ if (anExp.Current().IsSame(theValShape)) { // found a new container
+ if (aPairIter.NewShape().IsNull()) {// value was removed
+ theShapes.Clear();
+ return;
+ }
+ aNewToOld.Bind(aPairIter.NewShape(), aPairIter.OldShape());
+ anOlds.Add(aPairIter.OldShape());
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (aToFindPart == 2 && !aNewToOld.IsEmpty()) {
+ // map of sub-shapes -> number of occurences of these shapes in containers
+ NCollection_DataMap<TopoDS_Shape, TopTools_MapOfShape, TopTools_ShapeMapHasher> aSubs;
+ TopTools_DataMapOfShapeShape::Iterator aContIter(aNewToOld);
+ for(; aContIter.More(); aContIter.Next()) {
+ TopExp_Explorer aSubExp(aContIter.Key(), theValShape.ShapeType());
+ for(; aSubExp.More(); aSubExp.Next()) {
+ if (!aSubs.IsBound(aSubExp.Current())) {
+ aSubs.Bind(aSubExp.Current(), TopTools_MapOfShape());
+ }
+ // store old to know how many olds produced this shape
+ aSubs.ChangeFind(aSubExp.Current()).Add(aContIter.Value());
+ }
+ }
+ // if sub is appeared same times in containers as the number of old shapes that contain it
+ int aCountInOld = anOlds.Size();
+ NCollection_DataMap<TopoDS_Shape, TopTools_MapOfShape, TopTools_ShapeMapHasher>::Iterator
+ aSubsIter(aSubs);
+ for(; aSubsIter.More(); aSubsIter.Next()) {
+ if (aSubsIter.Value().Size() == aCountInOld) {
+ theShapes.Append(aSubsIter.Key());
+ }
+ }
+ }
+ if (theShapes.IsEmpty()) { // nothing was changed
+ theShapes.Append(aWasWholeContext ? TopoDS_Shape() : theValShape);
+ }
+}
+
+bool Model_AttributeSelection::searchNewContext(std::shared_ptr<Model_Document> theDoc,
+ const TopoDS_Shape theContShape, ResultPtr theContext, TopoDS_Shape theValShape,
+ TDF_Label theAccessLabel,
+ std::list<ResultPtr>& theResults, TopTools_ListOfShape& theValShapes)
+{
+ std::set<ResultPtr> aResults; // to avoid duplicates, new context, null if deleted
+ TopTools_ListOfShape aResContShapes;
+ // iterate context and shape, but also if it is sub-shape of main shape, check also it
+ TopTools_ListOfShape aContextList;
+ aContextList.Append(theContShape);
+ if (theContext.get()) {
+ ResultPtr aComposite = ModelAPI_Tools::compSolidOwner(theContext);
+ if (aComposite.get() && aComposite->shape().get() && !aComposite->shape()->isNull())
+ aContextList.Append(aComposite->shape()->impl<TopoDS_Shape>());
+ }
+ for(TopTools_ListOfShape::Iterator aContIter(aContextList); aContIter.More(); aContIter.Next()) {
+ TNaming_SameShapeIterator aModifIter(aContIter.ChangeValue(), theAccessLabel);
+ for(; aModifIter.More(); aModifIter.Next()) {
+ TDF_Label anObjLab = aModifIter.Label().Father();
+ ResultPtr aModifierObj = std::dynamic_pointer_cast<ModelAPI_Result>
+ (theDoc->objects()->object(anObjLab));
+ if (!aModifierObj.get()) {
+ // #2241: shape may be sub-element of new object, not main (shell created from faces)
+ if (!anObjLab.IsRoot())
+ aModifierObj = std::dynamic_pointer_cast<ModelAPI_Result>
+ (theDoc->objects()->object(anObjLab.Father()));
+ if (!aModifierObj.get())
+ continue;
+ }
+ FeaturePtr aModifierFeat = theDoc->feature(aModifierObj);
+ if (!aModifierFeat.get())
+ continue;
+ FeaturePtr aThisFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
+ if (aModifierFeat == aThisFeature || theDoc->objects()->isLater(aModifierFeat, aThisFeature))
+ continue; // the modifier feature is later than this, so, should not be used
+ FeaturePtr aCurrentModifierFeat = theDoc->feature(theContext);
+ if (aCurrentModifierFeat == aModifierFeat ||
+ theDoc->objects()->isLater(aCurrentModifierFeat, aModifierFeat))
+ continue; // the current modifier is later than the found, so, useless
+ Handle(TNaming_NamedShape) aNewNS;
+ aModifIter.Label().FindAttribute(TNaming_NamedShape::GetID(), aNewNS);
+ if (aNewNS->Evolution() == TNaming_MODIFY || aNewNS->Evolution() == TNaming_GENERATED) {
+ aResults.insert(aModifierObj);
+ //TNaming_Iterator aPairIter(aNewNS);
+ //aResContShapes.Append(aPairIter.NewShape());
+ aResContShapes.Append(aModifierObj->shape()->impl<TopoDS_Shape>());
+ } else if (aNewNS->Evolution() == TNaming_DELETE) { // a shape was deleted => result is empty
+ aResults.insert(ResultPtr());
+ } else { // not-precessed modification => don't support it
+ continue;
+ }
+ }
+ }
+ if (aResults.empty())
+ return false; // no modifications found, must stay the same
+ // iterate all results to find futher modifications
+ std::set<ResultPtr>::iterator aResIter = aResults.begin();
+ for(; aResIter != aResults.end(); aResIter++) {
+ if (aResIter->get() != NULL) {
+ // compute new values by two contextes: the old and the new
+ TopTools_ListOfShape aValShapes;
+ computeValues(theContext, *aResIter, theValShape, aValShapes);
+
+ TopTools_ListIteratorOfListOfShape aNewVal(aValShapes);
+ for(; aNewVal.More(); aNewVal.Next()) {
+ std::list<ResultPtr> aNewRes;
+ TopTools_ListOfShape aNewUpdatedVal;
+ TopoDS_Shape aNewValSh = aNewVal.Value();
+ TopoDS_Shape aNewContShape = (*aResIter)->shape()->impl<TopoDS_Shape>();
+ if (theValShape.IsNull() && aNewContShape.IsSame(aNewValSh))
+ aNewValSh.Nullify();
+ if (searchNewContext(theDoc, aNewContShape, *aResIter, aNewValSh,
+ theAccessLabel, aNewRes, aNewUpdatedVal))
+ {
+ // appeand new results instead of the current ones
+ std::list<ResultPtr>::iterator aNewIter = aNewRes.begin();
+ TopTools_ListIteratorOfListOfShape aNewUpdVal(aNewUpdatedVal);
+ for(; aNewIter != aNewRes.end(); aNewIter++, aNewUpdVal.Next()) {
+ theResults.push_back(*aNewIter);
+ theValShapes.Append(aNewUpdVal.Value());
+ }
+ } else { // the current result is good
+ theResults.push_back(*aResIter);
+ theValShapes.Append(aNewValSh);
+ }
+ }
+ }
+ }
+ return true; // theResults must be empty: everything is deleted
+}
+
+void Model_AttributeSelection::updateInHistory()
+{
+ ResultPtr aContext = std::dynamic_pointer_cast<ModelAPI_Result>(myRef.value());
+ // only bodies and parts may be modified later in the history, don't do anything otherwise
+ if (!aContext.get() || (aContext->groupName() != ModelAPI_ResultBody::group() &&
+ aContext->groupName() != ModelAPI_ResultPart::group()))
+ return;
+ std::shared_ptr<Model_Document> aDoc =
+ std::dynamic_pointer_cast<Model_Document>(aContext->document());
+ std::shared_ptr<Model_Data> aContData = std::dynamic_pointer_cast<Model_Data>(aContext->data());
+ if (!aContData.get() || !aContData->isValid())
+ return;
+ TDF_Label aContLab = aContData->label(); // named shape where the selected context is located
+ Handle(TNaming_NamedShape) aContNS;
+ if (!aContLab.FindAttribute(TNaming_NamedShape::GetID(), aContNS)) {
+ bool aFoundNewContext = true;
+ ResultPtr aNewContext = aContext;
+ while(aFoundNewContext) {
+ aFoundNewContext = false;
+ // parts have no shape in result, so, trace references using the Part info
+ if (aNewContext->groupName() == ModelAPI_ResultPart::group()) {
+ ResultPartPtr aPartContext = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aNewContext);
+ if (aPartContext.get()) { // searching for the up to date references to the referenced cont
+ const std::set<AttributePtr>& aRefs = aPartContext->data()->refsToMe();
+ std::set<AttributePtr>::const_iterator aRef = aRefs.begin();
+ for(; aRef != aRefs.end(); aRef++) {
+ // to avoid detection of part changes by local selection only
+ AttributeSelectionPtr aSel =
+ std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(*aRef);
+ if (aSel.get() && !aSel->value()->isSame(aSel->context()->shape()))
+ continue;
+
+ FeaturePtr aRefFeat = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRef)->owner());
+ if (aRefFeat.get() && aRefFeat != owner()) {
+ FeaturePtr aThisFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
+ if (aDoc->objects()->isLater(aThisFeature, aRefFeat)) { // found better feature
+ aFoundNewContext = true;
+ aNewContext = aRefFeat->firstResult();
+ }
+ }
+ }
+ }
+ }
+ }
+ if (aNewContext != aContext) {
+ setValue(aNewContext, value());
+ }
+ return;
+ }
+ FeaturePtr aThisFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
+ FeaturePtr aCurrentModifierFeat = aDoc->feature(aContext);
+ // iterate the context shape modifications in order to find a feature that is upper in history
+ // that this one and is really modifies the referenced result to refer to it
+ ResultPtr aModifierResFound;
+ TNaming_Iterator aPairIter(aContNS);
+ if (!aPairIter.More())
+ return;
+ TopoDS_Shape aNewCShape = aPairIter.NewShape();
+ bool anIterate = true;
+ // trying to update also the sub-shape selected
+ GeomShapePtr aSubShape = value();
+ if (aSubShape.get() && aSubShape->isEqual(aContext->shape()))
+ aSubShape.reset();
+ TopoDS_Shape aValShape;
+ if (aSubShape.get()) {
+ aValShape = aSubShape->impl<TopoDS_Shape>();
+ }
+
+ std::list<ResultPtr> aNewContexts;
+ TopTools_ListOfShape aValShapes;
+ if (searchNewContext(aDoc, aNewCShape, aContext, aValShape, aContLab, aNewContexts, aValShapes))
+ {
+ // update scope to reset to a new one
+ myScope.Clear();
+
+ std::list<ResultPtr>::iterator aNewCont = aNewContexts.begin();
+ TopTools_ListIteratorOfListOfShape aNewValues(aValShapes);
+ if (aNewCont == aNewContexts.end()) { // all results were deleted
+ ResultPtr anEmptyContext;
+ std::shared_ptr<GeomAPI_Shape> anEmptyShape;
+ setValue(anEmptyContext, anEmptyShape); // nullify the selection
+ return;
+ }
+
+ GeomShapePtr aValueShape;
+ if (!aNewValues.Value().IsNull()) {
+ aValueShape = std::make_shared<GeomAPI_Shape>();
+ aValueShape->setImpl<TopoDS_Shape>(new TopoDS_Shape(aNewValues.Value()));
+ }
+ setValue(*aNewCont, aValueShape);
+ // if there are more than one result, put them by "append" into "parent" list
+ if (myParent) {
+ for(aNewCont++, aNewValues.Next(); aNewCont != aNewContexts.end();
+ aNewCont++, aNewValues.Next()) {
+ GeomShapePtr aValueShape;
+ if (!aNewValues.Value().IsNull()) {
+ aValueShape = std::make_shared<GeomAPI_Shape>();
+ aValueShape->setImpl<TopoDS_Shape>(new TopoDS_Shape(aNewValues.Value()));
+ }
+ myParent->append(*aNewCont, aValueShape);
+ }
+ }
+ }
+}
+
+void Model_AttributeSelection::setParent(Model_AttributeSelectionList* theParent)
+{
+ myParent = theParent;
+}