-// 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_AttributeSelection.h"
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultConstruction.h>
+#include <ModelAPI_ResultGroup.h>
#include <ModelAPI_ResultPart.h>
#include <ModelAPI_CompositeFeature.h>
#include <ModelAPI_Tools.h>
bool Model_AttributeSelection::setValue(const ObjectPtr& theContext,
const std::shared_ptr<GeomAPI_Shape>& theSubShape, const bool theTemporarily)
{
- if (theTemporarily &&
- (!theContext.get() || theContext->groupName() != ModelAPI_Feature::group())) {
+ if (theTemporarily) {
// just keep the stored without DF update
- myTmpContext = std::dynamic_pointer_cast<ModelAPI_Result>(theContext);
+ myTmpContext = theContext;
myTmpSubShape = theSubShape;
owner()->data()->sendAttributeUpdated(this);
return true;
aSelLab.ForgetAllAttributes(true);
TDataStd_UAttribute::Set(aSelLab, kPART_REF_ID);
selectPart(std::dynamic_pointer_cast<ModelAPI_Result>(theContext), theSubShape);
+ } else if (theContext->groupName() == ModelAPI_ResultGroup::group()) {
+ aSelLab.ForgetAllAttributes(true);
+ TDataStd_UAttribute::Set(aSelLab, kSIMPLE_REF_ID);
} else { // check the feature context: parent-Part of this feature should not be used
FeaturePtr aFeatureContext = std::dynamic_pointer_cast<ModelAPI_Feature>(theContext);
if (aFeatureContext.get()) {
// it is just reference to construction.
return myTmpSubShape;
}
- return myTmpSubShape.get() ? myTmpSubShape : myTmpContext->shape();
+ FeaturePtr aFeature =
+ std::dynamic_pointer_cast<ModelAPI_Feature>(myTmpContext);
+ if (aFeature.get()) {
+ // it is just reference to construction.
+ return myTmpSubShape;
+ }
+ return myTmpSubShape.get() ? myTmpSubShape :
+ std::dynamic_pointer_cast<ModelAPI_Result>(myTmpContext)->shape();
}
TDF_Label aSelLab = selectionLabel();
std::shared_ptr<GeomAPI_Shape> aResult;
if (myRef.isInitialized()) {
TDF_Label aSelLab = selectionLabel();
- if (aSelLab.IsAttribute(kSIMPLE_REF_ID)) { // it is just reference to shape, not sub-shape
+ // it is just reference to shape, not sub-shape
+ if (aSelLab.IsAttribute(kSIMPLE_REF_ID) || aSelLab.IsAttribute(kPART_REF_ID)) {
ResultPtr aContext = context();
return aContext.get() != NULL;
}
return ResultPtr();
if (myTmpContext.get() || myTmpSubShape.get()) {
- return myTmpContext;
+ return std::dynamic_pointer_cast<ModelAPI_Result>(myTmpContext);
}
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(myRef.value());
}
FeaturePtr Model_AttributeSelection::contextFeature() {
- if (myTmpContext.get() || myTmpSubShape.get()) {
- return FeaturePtr(); // feature can not be selected temporarily
+ if (myTmpContext.get()) {
+ return std::dynamic_pointer_cast<ModelAPI_Feature>(myTmpContext);
}
return std::dynamic_pointer_cast<ModelAPI_Feature>(myRef.value());
}
if(!this->isInitialized())
return !theDefaultName.empty() ? theDefaultName : aName;
+ // not argument has not parametric name (filters)
+ if (!this->isArgument() || (myParent && !myParent->isArgument())) {
+ GeomShapePtr aShape = value();
+ if (!aShape.get() && context().get())
+ aShape = context()->shape();
+ std::string aName;
+ if (aShape.get()) {
+ aName = aShape->shapeTypeStr();
+ if (myParent) {
+ aName += std::string("_") +
+ TCollection_AsciiString(selectionLabel().Father().Tag()).ToCString();
+ }
+ }
+ return aName;
+ }
+
CenterType aCenterType = NOT_CENTER;
std::shared_ptr<GeomAPI_Shape> aSubSh = internalValue(aCenterType);
ResultPtr aCont = context();
if (aWasWholeContext) {
theValShape = theOldContext->shape()->impl<TopoDS_Shape>();
}
+ TopAbs_ShapeEnum aValType = theValShape.ShapeType();
TopoDS_Shape aNewContShape = theNewContext->shape()->impl<TopoDS_Shape>();
// if a new value is unchanged in the new context, do nothing: value is correct
- TopExp_Explorer aSubExp(aNewContShape, theValShape.ShapeType());
+ TopExp_Explorer aSubExp(aNewContShape, aValType);
for(; aSubExp.More(); aSubExp.Next()) {
if (aSubExp.Current().IsSame(theValShape)) {
theShapes.Append(theValShape);
return;
}
// don't add edges generated from faces
- if (aPairIter.NewShape().ShapeType() <= theValShape.ShapeType())
+ if (aPairIter.NewShape().ShapeType() <= aValType)
theShapes.Append(aPairIter.NewShape());
}
} else if (!aPairIter.OldShape().IsNull()) { // search shape that contains this sub
- TopExp_Explorer anExp(aPairIter.OldShape(), theValShape.ShapeType());
+ TopExp_Explorer anExp(aPairIter.OldShape(), aValType);
for(; anExp.More(); anExp.Next()) {
if (anExp.Current().IsSame(theValShape)) { // found a new container
- if (aPairIter.NewShape().IsNull()) {// value was removed
- theShapes.Clear();
- return;
- }
+ if (aPairIter.NewShape().IsNull()) // skip removed high-level shape
+ continue;
aNewToOld.Bind(aPairIter.NewShape(), aPairIter.OldShape());
anOlds.Add(aPairIter.OldShape());
break;
}
}
if (aToFindPart == 2 && !aNewToOld.IsEmpty()) {
+ // also iterate the whole old shape to find not-modified shapes that contain this old
+ TopoDS_Shape anOldContShape = theOldContext->shape()->impl<TopoDS_Shape>();
+ NCollection_Map<TopAbs_ShapeEnum> aNewTypes; // types of shapes to iterate
+ TopTools_DataMapOfShapeShape::Iterator aNewTypeIter(aNewToOld);
+ for(; aNewTypeIter.More(); aNewTypeIter.Next()) {
+ if (aNewTypeIter.Key().ShapeType() != aValType)
+ aNewTypes.Add(aNewTypeIter.Key().ShapeType());
+ }
+ NCollection_Map<TopAbs_ShapeEnum>::Iterator aTypeIter(aNewTypes);
+ for(; aTypeIter.More(); aTypeIter.Next()) {
+ for(TopExp_Explorer anExp(anOldContShape, aTypeIter.Value()); anExp.More(); anExp.Next()) {
+ TopoDS_Shape anOld = anExp.Current();
+ if (aNewToOld.IsBound(anOld) || anOlds.Contains(anOld)) // this was modified
+ continue;
+ TopExp_Explorer aValExp(anOld, aValType);
+ for(; aValExp.More(); aValExp.Next()) {
+ const TopoDS_Shape& anUnchanged = aValExp.Current();
+ if (anUnchanged.IsSame(theValShape)) {
+ aNewToOld.Bind(anOld, anOld);
+ anOlds.Add(anOld);
+ break;
+ }
+ }
+ }
+ }
+
// map of sub-shapes -> number of occurrences 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());
+ TopExp_Explorer aSubExp(aContIter.Key(), aValType);
for(; aSubExp.More(); aSubExp.Next()) {
if (!aSubs.IsBound(aSubExp.Current())) {
aSubs.Bind(aSubExp.Current(), TopTools_MapOfShape());
aSubsIter(aSubs);
for(; aSubsIter.More(); aSubsIter.Next()) {
if (aSubsIter.Value().Size() == aCountInOld) {
- theShapes.Append(aSubsIter.Key());
+ TopoDS_Shape anOld = aSubsIter.Key();
+ // check this exists in the new shape
+ TopExp_Explorer aNew(aNewContShape, anOld.ShapeType());
+ for (; aNew.More(); aNew.Next()) {
+ if (aNew.Current().IsSame(anOld))
+ break;
+ }
+ if (aNew.More())
+ theShapes.Append(anOld);
}
}
}
if (theShapes.IsEmpty()) { // nothing was changed
- theShapes.Append(aWasWholeContext ? TopoDS_Shape() : theValShape);
+ if (aWasWholeContext)
+ theShapes.Append(TopoDS_Shape());
+ else { // if theValShape exists in new context, add it without changes, otherwise - nothing
+ for (TopExp_Explorer aNew(aNewContShape, aValType); aNew.More(); aNew.Next()){
+ if (aNew.Current().IsSame(theValShape)) {
+ theShapes.Append(theValShape);
+ break;
+ }
+ }
+ }
+ } else if (theShapes.Size() > 1) {
+ // check it is possible to remove extra sub-shapes:
+ // keep only shapes with the same number of containers if possible
+ TopAbs_ShapeEnum anAncType = TopAbs_FACE;
+ if (aValType == TopAbs_VERTEX)
+ anAncType = TopAbs_EDGE;
+ TopoDS_Shape anOldContext = theOldContext->shape()->impl<TopoDS_Shape>();
+ TopTools_IndexedDataMapOfShapeListOfShape anOldMap;
+ TopExp::MapShapesAndUniqueAncestors(anOldContext, aValType, anAncType, anOldMap);
+ if (anOldMap.Contains(theValShape)) {
+ int aNumInOld = anOldMap.FindFromKey(theValShape).Extent();
+ TopTools_IndexedDataMapOfShapeListOfShape aNewMap;
+ TopExp::MapShapesAndUniqueAncestors(aNewContShape, aValType, anAncType, aNewMap);
+ TopTools_ListOfShape aNewResults;
+ for(TopTools_ListOfShape::Iterator aNewSubs(theShapes); aNewSubs.More(); aNewSubs.Next()) {
+ TopoDS_Shape aCand = aNewSubs.Value();
+ if (aNewMap.Contains(aCand) && aNewMap.FindFromKey(aCand).Extent() == aNumInOld)
+ aNewResults.Append(aCand);
+ }
+ if (!aNewResults.IsEmpty() && aNewResults.Size() < theShapes.Size())
+ theShapes = aNewResults;
+ }
}
}
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);
aModifIter.Label().FindAttribute(TNaming_NamedShape::GetID(), aNewNS);
if (aNewNS->Evolution() == TNaming_MODIFY || aNewNS->Evolution() == TNaming_GENERATED) {
aResults.insert(aModifierObj);
- 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-processed modification => don't support it
}
}
}
- if (aResults.empty())
- return false; // no modifications found, must stay the same
+ // if there exist context composite and sub-result(s), leave only sub(s)
+ for(std::set<ResultPtr>::iterator aResIter = aResults.begin(); aResIter != aResults.end();) {
+ ResultPtr aParent = ModelAPI_Tools::bodyOwner(*aResIter);
+ for(; aParent.get(); aParent = ModelAPI_Tools::bodyOwner(aParent))
+ if (aResults.count(aParent))
+ break;
+ if (aParent.get()) { // erase from set, so, restart iteration
+ aResults.erase(aParent);
+ aResIter = aResults.begin();
+ } else aResIter++;
+ }
+
+ if (aResults.empty()) {
+ // check the context become concealed by operation which is earlier than this selection
+ std::list<ResultPtr> allRes;
+ ResultPtr aRoot = ModelAPI_Tools::bodyOwner(theContext, true);
+ if (!aRoot.get())
+ aRoot = theContext;
+ ResultBodyPtr aRootBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aRoot);
+ if (aRootBody.get()) {
+ ModelAPI_Tools::allSubs(aRootBody, allRes);
+ allRes.push_back(aRootBody);
+ } else
+ allRes.push_back(aRoot);
+
+ FeaturePtr aThisFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
+ for (std::list<ResultPtr>::iterator aSub = allRes.begin(); aSub != allRes.end(); aSub++) {
+ ResultPtr aResCont = *aSub;
+ const std::set<AttributePtr>& aRefs = aResCont->data()->refsToMe();
+ std::set<AttributePtr>::const_iterator aRef = aRefs.begin();
+ for (; aRef != aRefs.end(); aRef++) {
+ if (!aRef->get() || !(*aRef)->owner().get())
+ continue;
+ // concealed attribute only
+ FeaturePtr aRefFeat = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRef)->owner());
+ if (aRefFeat == aThisFeature)
+ continue;
+ if (!ModelAPI_Session::get()->validators()->isConcealed(
+ aRefFeat->getKind(), (*aRef)->id()))
+ continue;
+ if (theDoc->isLaterByDep(aThisFeature, aRefFeat)) {
+ // for extrusion cut in python script the nested sketch reference may be concealed before
+ // it is nested, so, check this composite feature is valid
+ static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators();
+ // need to be validated to update the "Apply" state if not previewed
+ if (aFactory->validate(aRefFeat)) {
+ // there could be a reference to unmodified object, check result contain same shape
+ std::list<ResultPtr> aRefResults;
+ ModelAPI_Tools::allResults(aRefFeat, aRefResults);
+ std::list<ResultPtr>::iterator aRefIter = aRefResults.begin();
+ for(; aRefIter != aRefResults.end(); aRefIter++) {
+ ResultBodyPtr aRefBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(*aRefIter);
+ if (!aRefBody.get() || aRefBody->numberOfSubs() != 0) // iterate only leafs
+ continue;
+ GeomShapePtr aRefShape = aRefBody->shape();
+ if (!aRefShape.get() || aRefShape->isNull())
+ continue;
+ if (aRefShape->impl<TopoDS_Shape>().IsSame(theContShape)) {
+ // add the new context result with the same shape
+ aResults.insert(aRefBody);
+ }
+ }
+ if (aResults.empty())
+ return true; // feature conceals result, return true, so the context will be removed
+ }
+ }
+ }
+ }
+ if (aResults.empty())
+ return false; // no modifications found, must stay the same
+ }
// iterate all results to find further modifications
std::set<ResultPtr>::iterator aResIter = aResults.begin();
for(; aResIter != aResults.end(); aResIter++) {
return true; // theResults must be empty: everything is deleted
}
-void Model_AttributeSelection::updateInHistory()
+void Model_AttributeSelection::updateInHistory(bool& theRemove)
{
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 (!aContData.get() || !aContData->isValid())
return;
TDF_Label aContLab = aContData->shapeLab(); // named shape where the selected context is located
+
+ // checking this may be just a reference to another context (same shape), so use that label
Handle(TNaming_NamedShape) aContNS;
+ Handle(TDF_Reference) aRefAttr;
+ while(!aContLab.FindAttribute(TNaming_NamedShape::GetID(), aContNS) &&
+ aContLab.FindAttribute(TDF_Reference::GetID(), aRefAttr))
+ aContLab = aRefAttr->Get();
+
if (!aContLab.FindAttribute(TNaming_NamedShape::GetID(), aContNS)) {
bool aFoundNewContext = true;
ResultPtr aNewContext = aContext;
continue;
FeaturePtr aRefFeat = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRef)->owner());
- if (aRefFeat.get() && aRefFeat != owner()) {
+
+ if (aRefFeat.get() && aRefFeat != owner() && aRefFeat->firstResult().get()) {
+ // check the reference is concealed: #2900
+ ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators();
+ if (!aValidators->isConcealed(aRefFeat->getKind(), (*aRef)->id()))
+ continue;
FeaturePtr aThisFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
if (!aDoc->isLaterByDep(aRefFeat, aThisFeature)) { // found better feature
aFoundNewContext = true;
TopTools_ListOfShape aValShapes;
if (searchNewContext(aDoc, aNewCShape, aContext, aValShape, aContLab, aNewContexts, aValShapes))
{
+ std::set<ResultPtr> allContexts, aSkippedContext;
+ std::list<ResultPtr>::iterator aNewContext = aNewContexts.begin();
+ for(; aNewContext != aNewContexts.end(); aNewContext++)
+ allContexts.insert(*aNewContext);
+
+ // if there exist context composite and sub-result(s), leave only sub(s)
+ std::set<ResultPtr>::iterator aResIter = allContexts.begin();
+ for(; aResIter != allContexts.end(); aResIter++) {
+ ResultPtr aParent = ModelAPI_Tools::bodyOwner(*aResIter);
+ for(; aParent.get(); aParent = ModelAPI_Tools::bodyOwner(aParent))
+ if (allContexts.count(aParent))
+ aSkippedContext.insert(aParent);
+ }
+
GeomAPI_Shape::ShapeType aListShapeType = GeomAPI_Shape::SHAPE;
if (myParent) {
- if (myParent->selectionType() == "VERTEX") aListShapeType = GeomAPI_Shape::VERTEX;
- else if (myParent->selectionType() == "EDGE") aListShapeType = GeomAPI_Shape::EDGE;
- else if (myParent->selectionType() == "FACE") aListShapeType = GeomAPI_Shape::FACE;
+ if (myParent->selectionType() == "VERTEX" || myParent->selectionType() == "Vertices")
+ aListShapeType = GeomAPI_Shape::VERTEX;
+ else if (myParent->selectionType() == "EDGE" || myParent->selectionType() == "Edges")
+ aListShapeType = GeomAPI_Shape::EDGE;
+ else if (myParent->selectionType() == "FACE" || myParent->selectionType() == "Faces")
+ aListShapeType = GeomAPI_Shape::FACE;
}
std::list<ResultPtr>::iterator aNewCont = aNewContexts.begin();
TopTools_ListIteratorOfListOfShape aNewValues(aValShapes);
bool aFirst = true; // first is set to this, next are appended to parent
for(; aNewCont != aNewContexts.end(); aNewCont++, aNewValues.Next()) {
+ if (aSkippedContext.count(*aNewCont))
+ continue;
GeomShapePtr aValueShape;
if (!aNewValues.Value().IsNull()) {
if (aListShapeType != GeomAPI_Shape::SHAPE && aListShapeType != aShapeShapeType) {
continue;
}
+
+ ResultPtr aNewContext = *aNewCont;
+ if (aValueShape.get()) { // #2892 if context is higher level result, search this sub in lower
+ ResultBodyPtr aBodyContext = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aNewContext);
+ if (aBodyContext.get() && aBodyContext->numberOfSubs() != 0) {
+ std::list<ResultPtr> aLower;
+ ModelAPI_Tools::allSubs(aBodyContext, aLower, true);
+ for(std::list<ResultPtr>::iterator aL = aLower.begin(); aL != aLower.end(); aL++) {
+ GeomShapePtr aLShape = (*aL)->shape();
+ if (aLShape.get() && !aLShape->isNull()) {
+ if (aLShape->isSubShape(aValueShape, false)) {
+ aNewContext = *aL;
+ break;
+ }
+ }
+ }
+ }
+ }
+
if (aFirst) {
- setValue(*aNewCont, aValueShape);
- aFirst = false;
+ if (!myParent || !myParent->isInList(aNewContext, aValueShape)) { // avoid duplicates
+ setValue(aNewContext, aValueShape);
+ aFirst = false;
+ }
} else if (myParent) {
- myParent->append(*aNewCont, aValueShape);
+ if (!myParent->isInList(aNewContext, aValueShape)) // avoid addition of duplicates
+ myParent->append(aNewContext, aValueShape);
}
}
if (aFirst) { // nothing was added, all results were deleted
- ResultPtr anEmptyContext;
- std::shared_ptr<GeomAPI_Shape> anEmptyShape;
- setValue(anEmptyContext, anEmptyShape); // nullify the selection
- return;
+ if (myParent) {
+ theRemove = true;
+ } else {
+ ResultPtr anEmptyContext;
+ std::shared_ptr<GeomAPI_Shape> anEmptyShape;
+ setValue(anEmptyContext, anEmptyShape); // nullify the selection
+ return;
+ }
}
}
}