Salome HOME
Additional fix for the #2659 optimization
[modules/shaper.git] / src / Model / Model_AttributeSelection.cpp
index 1be7f53ee6a44491185f482f3923fc695adca38d..7b1259db39ecaa7c013a37deb329fdf113d7fa38 100644 (file)
 #include <ModelAPI_Tools.h>
 #include <ModelAPI_Session.h>
 #include <ModelAPI_Validator.h>
+#include <ModelGeomAlgo_Shape.h>
 #include <Events_InfoMessage.h>
 #include <GeomAPI_Edge.h>
+#include <GeomAPI_Pnt.h>
 #include <GeomAPI_Vertex.h>
 #include <GeomAlgoAPI_CompoundBuilder.h>
+#include <GeomAlgoAPI_NExplode.h>
 
 #include <TNaming_Selector.hxx>
 #include <TNaming_NamedShape.hxx>
@@ -85,6 +88,10 @@ Standard_GUID kCIRCLE_CENTER("d0d0e0f1-217a-4b95-8fbb-0c4132f23718");
 Standard_GUID kELLIPSE_CENTER1("f70df04c-3168-4dc9-87a4-f1f840c1275d");
 // identifier of the selection of the second focus point of ellipse on edge
 Standard_GUID kELLIPSE_CENTER2("1395ae73-8e02-4cf8-b204-06ff35873a32");
+// identifier of the weak naming index
+Standard_GUID kWEAK_NAMING("9dcdd9be-a3a9-46eb-9b16-1c957ab20142");
+// identifier of the weak naming sub-shape type
+Standard_GUID kWEAK_NAMING_SHAPETYPE("6b9cc709-e320-4a1f-9c42-df5622369ea7");
 
 // prefix for the whole feature context identification
 const static std::string kWHOLE_FEATURE = "all-in-";
@@ -131,6 +138,8 @@ bool Model_AttributeSelection::setValue(const ObjectPtr& theContext,
   aSelLab.ForgetAttribute(kCIRCLE_CENTER);
   aSelLab.ForgetAttribute(kELLIPSE_CENTER1);
   aSelLab.ForgetAttribute(kELLIPSE_CENTER2);
+  aSelLab.ForgetAttribute(kWEAK_NAMING);
+  aSelLab.ForgetAttribute(kWEAK_NAMING_SHAPETYPE);
 
   bool isDegeneratedEdge = false;
   // do not use the degenerated edge as a shape, a null context and shape is used in the case
@@ -180,6 +189,17 @@ bool Model_AttributeSelection::setValue(const ObjectPtr& theContext,
     aSelLab.ForgetAllAttributes(true);
     TDataStd_UAttribute::Set(aSelLab, kPART_REF_ID);
     selectPart(std::dynamic_pointer_cast<ModelAPI_Result>(theContext), theSubShape);
+  } 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()) {
+      if (owner()->document() != aFeatureContext->document()) {
+        aSelLab.ForgetAllAttributes(true);
+        myRef.setValue(ObjectPtr());
+        if (aToUnblock)
+          owner()->data()->blockSendAttributeUpdated(false);
+        return false;
+      }
+    }
   }
 
   owner()->data()->sendAttributeUpdated(this);
@@ -353,20 +373,46 @@ std::shared_ptr<GeomAPI_Shape> Model_AttributeSelection::internalValue(CenterTyp
       if (aConstr->isInfinite())
         return aResult; // empty result
     }
-    // whole feature
-    FeaturePtr aFeature = contextFeature();
-    if (aFeature.get()) {
-      std::list<GeomShapePtr> allShapes;
-      std::list<ResultPtr>::const_iterator aRes = aFeature->results().cbegin();
-      for (; aRes != aFeature->results().cend(); aRes++) {
-        if (aRes->get() && !(*aRes)->isDisabled()) {
-          GeomShapePtr aShape = (*aRes)->shape();
-          if (aShape.get() && !aShape->isNull()) {
-            allShapes.push_back(aShape);
+    if (!aConstr.get()) { // for construction context, return empty result as usual even
+      // the whole feature is selected
+      FeaturePtr aFeature = contextFeature();
+      if (aFeature.get()) {
+        std::list<GeomShapePtr> allShapes;
+        std::list<ResultPtr>::const_iterator aRes = aFeature->results().cbegin();
+        for (; aRes != aFeature->results().cend(); aRes++) {
+          if (aRes->get() && !(*aRes)->isDisabled()) {
+            GeomShapePtr aShape = (*aRes)->shape();
+            if (aShape.get() && !aShape->isNull()) {
+              allShapes.push_back(aShape);
+            }
           }
         }
+        return GeomAlgoAPI_CompoundBuilder::compound(allShapes);
       }
-      return GeomAlgoAPI_CompoundBuilder::compound(allShapes);
+    }
+
+    if (aSelLab.IsAttribute(kWEAK_NAMING)) { // a weak naming is used
+      Handle(TDataStd_Integer) aWeakId;
+      aSelLab.FindAttribute(kWEAK_NAMING, aWeakId);
+      // get the context shape
+      GeomShapePtr aContextShape;
+      ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(context());
+      if (aBody.get()) {
+        aContextShape = aBody->shape();
+      } else {
+        ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(myRef.value());
+        if (aResult) {
+          aContextShape = aResult->shape();
+        }
+      }
+      if (!aContextShape.get())
+        return GeomShapePtr();
+      Handle(TDataStd_Integer) aWeakShapeType;
+      aSelLab.FindAttribute(kWEAK_NAMING_SHAPETYPE, aWeakShapeType);
+      GeomAlgoAPI_NExplode aNExplode(
+        aContextShape, GeomAPI_Shape::ShapeType(aWeakShapeType->Get()));
+      GeomShapePtr aValue = aNExplode.shape(aWeakId->Get());
+      return aValue;
     }
 
     Handle(TNaming_NamedShape) aSelection;
@@ -448,19 +494,26 @@ ResultPtr Model_AttributeSelection::context()
 
   ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(myRef.value());
   // for parts there could be same-data result, so take the last enabled
-  if (aResult.get() && aResult->groupName() == ModelAPI_ResultPart::group()) {
-    int aSize = aResult->document()->size(ModelAPI_ResultPart::group());
-    for(int a = aSize - 1; a >= 0; a--) {
-      ObjectPtr aPart = aResult->document()->object(ModelAPI_ResultPart::group(), a);
-      if (aPart.get() && aPart->data() == aResult->data()) {
-        ResultPtr aPartResult = std::dynamic_pointer_cast<ModelAPI_Result>(aPart);
-        FeaturePtr anOwnerFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
-        // check that this result is not this-feature result (it is forbidden t oselect itself)
-        if (anOwnerFeature.get() && anOwnerFeature->firstResult() != aPartResult) {
-          return aPartResult;
+  if (aResult.get()) {
+    if(aResult->groupName() == ModelAPI_ResultPart::group()) {
+      int aSize = aResult->document()->size(ModelAPI_ResultPart::group());
+      for(int a = aSize - 1; a >= 0; a--) {
+        ObjectPtr aPart = aResult->document()->object(ModelAPI_ResultPart::group(), a);
+        if(aPart.get() && aPart->data() == aResult->data()) {
+          ResultPtr aPartResult = std::dynamic_pointer_cast<ModelAPI_Result>(aPart);
+          FeaturePtr anOwnerFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
+          // check that this result is not this-feature result (it is forbidden t oselect itself)
+          if(anOwnerFeature.get() && anOwnerFeature->firstResult() != aPartResult) {
+            return aPartResult;
+          }
         }
       }
     }
+  } else { // if feature - construction is selected, it has only one result, return this result
+    FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(myRef.value());
+    if (aFeature.get() && aFeature->results().size() == 1 &&
+        aFeature->firstResult()->groupName() == ModelAPI_ResultConstruction::group())
+      return aFeature->firstResult();
   }
   return aResult;
 }
@@ -472,10 +525,10 @@ FeaturePtr Model_AttributeSelection::contextFeature() {
   return std::dynamic_pointer_cast<ModelAPI_Feature>(myRef.value());
 }
 ObjectPtr Model_AttributeSelection::contextObject() {
-  ResultPtr aRes = context();
+  FeaturePtr aRes = contextFeature();
   if (aRes.get())
     return aRes;
-  return contextFeature();
+  return context();
 }
 
 
@@ -587,6 +640,10 @@ void Model_AttributeSelection::split(
 
 bool Model_AttributeSelection::update()
 {
+  FeaturePtr aContextFeature = contextFeature();
+  if (aContextFeature.get()) {
+    return true;
+  }
   TDF_Label aSelLab = selectionLabel();
   ResultPtr aContext = context();
   if (!aContext.get())
@@ -606,6 +663,29 @@ bool Model_AttributeSelection::update()
   }
 
   if (aContext->groupName() == ModelAPI_ResultBody::group()) {
+    if (aSelLab.IsAttribute(kWEAK_NAMING)) { // a weak naming is used
+      Handle(TDataStd_Integer) aWeakId;
+      aSelLab.FindAttribute(kWEAK_NAMING, aWeakId);
+      // get the context shape
+      GeomShapePtr aContextShape;
+      ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aContext);
+      if (aBody.get()) {
+        aContextShape = aBody->shape();
+      } else {
+        ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(myRef.value());
+        if (aResult) {
+          aContextShape = aResult->shape();
+        }
+      }
+      if (!setInvalidIfFalse(aSelLab, aContextShape.get() != NULL)) // context shape not found
+        return false;
+      Handle(TDataStd_Integer) aWeakShapeType;
+      aSelLab.FindAttribute(kWEAK_NAMING_SHAPETYPE, aWeakShapeType);
+      GeomAlgoAPI_NExplode aNExplode(
+        aContextShape, GeomAPI_Shape::ShapeType(aWeakShapeType->Get()));
+      GeomShapePtr aValue = aNExplode.shape(aWeakId->Get());
+      return setInvalidIfFalse(aSelLab, aValue.get() != NULL);
+    }
     // body: just a named shape, use selection mechanism from OCCT
     TNaming_Selector aSelector(aSelLab);
     TopoDS_Shape anOldShape;
@@ -747,7 +827,38 @@ void Model_AttributeSelection::selectBody(
       if (aEraseResults) // erase results without flash deleted and redisplay: do it after Select
         aFeatureOwner->removeResults(0, false, false);
     }
-    aSel.Select(aNewSub, aNewContext);
+    bool aSelectorOk = true;
+    try {
+      aSel.Select(aNewSub, aNewContext);
+    } catch(...) {
+      aSelectorOk = false;
+    }
+    // face may become divided after the model update, so, new labels may be added to the scope
+    myScope.Clear();
+
+    // check that selection is correct, otherwise use weak naming solution
+    TDF_Label aSelLab = selectionLabel();
+    aSelLab.ForgetAttribute(kWEAK_NAMING);
+    Handle(TNaming_NamedShape) aSelectorShape;
+    if (aSelectorOk && aSelLab.FindAttribute(TNaming_NamedShape::GetID(), aSelectorShape))
+    {
+      TopoDS_Shape aShape = aSelectorShape->Get();
+      if (aShape.IsNull() || aShape.ShapeType() != aNewSub.ShapeType())
+        aSelectorOk = false;
+    }
+    if (!aSelectorOk) { // weak naming identifier instead
+      GeomShapePtr aContextShape(new GeomAPI_Shape);
+      aContextShape->setImpl<TopoDS_Shape>(new TopoDS_Shape(aNewContext));
+      GeomShapePtr aValueShape(new GeomAPI_Shape);
+      aValueShape->setImpl<TopoDS_Shape>(new TopoDS_Shape(aNewSub));
+
+      GeomAlgoAPI_NExplode aNExplode(aContextShape, aValueShape->shapeType());
+      int anId = aNExplode.index(aValueShape);
+      if (anId) {
+        TDataStd_Integer::Set(aSelLab, kWEAK_NAMING, anId);
+        TDataStd_Integer::Set(aSelLab, kWEAK_NAMING_SHAPETYPE, int(aValueShape->shapeType()));
+      }
+    }
 
     if (aEraseResults) { // flash after Select : in Groups it makes selection with shift working
       static Events_Loop* aLoop = Events_Loop::loop();
@@ -824,7 +935,8 @@ std::string Model_AttributeSelection::namingName(const std::string& theDefaultNa
   std::shared_ptr<GeomAPI_Shape> aSubSh = internalValue(aCenterType);
   ResultPtr aCont = context();
 
-  if (!aCont.get()) {
+  if (!aCont.get() ||
+      (aCont->groupName() == ModelAPI_ResultConstruction::group() && contextFeature().get())) {
     // selection of a full feature
     FeaturePtr aFeatureCont = contextFeature();
     if (aFeatureCont.get()) {
@@ -834,7 +946,15 @@ std::string Model_AttributeSelection::namingName(const std::string& theDefaultNa
     return "";
   }
 
-  Model_SelectionNaming aSelNaming(selectionLabel());
+  TDF_Label aSelLab = selectionLabel();
+  Handle(TDataStd_Integer) aWeakId;
+  if (aSelLab.FindAttribute(kWEAK_NAMING, aWeakId)) { // a weak naming is used
+    std::ostringstream aNameStream;
+    aNameStream<<aCont->data()->name()<<"/weak_name_"<<aWeakId->Get();
+    return aNameStream.str();
+  }
+
+  Model_SelectionNaming aSelNaming(aSelLab);
   std::string aResult = aSelNaming.namingName(
     aCont, aSubSh, theDefaultName, owner()->document() != aCont->document());
   if (aCenterType != NOT_CENTER) {
@@ -1040,6 +1160,117 @@ void Model_AttributeSelection::selectSubShape(
   reset();
 }
 
+void Model_AttributeSelection::selectSubShape(const std::string& theType,
+                                              const GeomPointPtr& thePoint)
+{
+  if (theType.empty() || !thePoint)
+    return;
+
+  // list of parent features
+  FeaturePtr anOwner = ModelAPI_Feature::feature(owner());
+  std::set<FeaturePtr> aParents = ModelAPI_Tools::getParents(anOwner);
+
+  int aSelectionIndex = 0;
+  GeomAPI_Shape::ShapeType aType = GeomAPI_Shape::shapeTypeByStr(theType);
+  if (aType == GeomAPI_Shape::SHAPE) {
+    // possibly, the string consists of the type and the index,
+    // thus, try to separate them
+    size_t aUndersporePos = theType.find_first_of('_');
+    if (aUndersporePos != std::string::npos)
+      aType = GeomAPI_Shape::shapeTypeByStr(theType.substr(0, aUndersporePos));
+
+    if (aType != GeomAPI_Shape::SHAPE) {
+      for (std::string::const_iterator aChar = theType.begin() + aUndersporePos + 1;
+           aChar != theType.end(); ++aChar) {
+        if (std::isdigit(*aChar))
+          aSelectionIndex = aSelectionIndex * 10 + (*aChar - '0');
+        else {
+          aSelectionIndex = 1;
+          break;
+        }
+      }
+      aSelectionIndex -= 1;
+    }
+  }
+
+  std::list<ModelGeomAlgo_Shape::SubshapeOfResult> anAppropriate;
+
+  // collect features from PartSet and the current part
+  SessionPtr aSession = ModelAPI_Session::get();
+  std::list<FeaturePtr> aFeatures = aSession->moduleDocument()->allFeatures();
+  if (aSession->moduleDocument() != owner()->document()) {
+    std::list<FeaturePtr> aPartFeatures = owner()->document()->allFeatures();
+    aFeatures.insert(aFeatures.end(), aPartFeatures.begin(), aPartFeatures.end());
+  }
+  // Process results of all features from the last to the first
+  // to find appropriate sub-shape
+  for (std::list<FeaturePtr>::const_reverse_iterator anIt = aFeatures.rbegin();
+       anIt != aFeatures.rend(); ++anIt) {
+    // selection cannot be linked to the parent features
+    if (aParents.find(*anIt) != aParents.end())
+      continue;
+    // check the feature is a part of composite feature (like sketch elements),
+    // then do not process it, it will be processed in scope of composite feature
+    bool isSubOfComposite = false;
+    const std::set<AttributePtr>& aRefs = (*anIt)->data()->refsToMe();
+    for (std::set<AttributePtr>::const_iterator aRefIt = aRefs.begin();
+         aRefIt != aRefs.end() && !isSubOfComposite; ++aRefIt) {
+      FeaturePtr aFeature = ModelAPI_Feature::feature((*aRefIt)->owner());
+      CompositeFeaturePtr aCompFeature =
+          std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeature);
+      isSubOfComposite = aCompFeature && aCompFeature->isSub(*anIt);
+    }
+    if (isSubOfComposite)
+      continue;
+
+    // process results of the current feature to find appropriate sub-shape
+    if (ModelGeomAlgo_Shape::findSubshapeByPoint(*anIt, thePoint, aType, anAppropriate)) {
+      std::list<ModelGeomAlgo_Shape::SubshapeOfResult>::iterator anApIt = anAppropriate.begin();
+      for (; aSelectionIndex > 0 && anApIt != anAppropriate.end(); --aSelectionIndex)
+        ++anApIt; // skip this shape, because one of the previous is selected
+
+      if (anApIt != anAppropriate.end()) {
+        if (anApIt->myCenterType == (int)ModelAPI_AttributeSelection::NOT_CENTER)
+          setValue(anApIt->myResult, anApIt->mySubshape);
+        else
+          setValueCenter(anApIt->myResult, anApIt->mySubshape->edge(),
+                         (ModelAPI_AttributeSelection::CenterType)anApIt->myCenterType);
+        return;
+      }
+    }
+  }
+
+  TDF_Label aSelLab = selectionLabel();
+  setInvalidIfFalse(aSelLab, false);
+  reset();
+}
+
+void Model_AttributeSelection::selectSubShape(const std::string& theType,
+  const std::string& theContextName, const int theIndex)
+{
+  // selection of context by name
+  //std::string aNamingContextName = theContextName + "/";
+  //selectSubShape(theType, aNamingContextName);
+  std::shared_ptr<Model_Document> aDoc =
+    std::dynamic_pointer_cast<Model_Document>(owner()->document());
+  if (aDoc.get()) {
+    bool aUnique = true;
+    std::string aContextName = theContextName;
+    std::string anEmptySub = "";
+    ResultPtr aContext = aDoc->findByName(aContextName, anEmptySub, aUnique);
+    //ResultPtr aContext = context();
+    if (aContext.get()) {
+      GeomShapePtr aContShape = aContext->shape();
+      if (aContShape.get()) {
+        GeomAlgoAPI_NExplode aNExp(aContShape, GeomAPI_Shape::shapeTypeByStr(theType));
+        GeomShapePtr aValue = aNExp.shape(theIndex);
+        if (aValue.get())
+          setValue(aContext, aValue);
+      }
+    }
+  }
+}
+
 int Model_AttributeSelection::Id()
 {
   int anID = 0;
@@ -1456,3 +1687,8 @@ void Model_AttributeSelection::setParent(Model_AttributeSelectionList* theParent
 {
   myParent = theParent;
 }
+
+bool Model_AttributeSelection::isWeakNaming()
+{
+  return selectionLabel().IsAttribute(kWEAK_NAMING);
+}