#include "Model_Events.h"
#include "Model_Data.h"
#include "Model_Document.h"
-#include "Model_SelectionNaming.h"
#include <Model_Objects.h>
#include <Model_AttributeSelectionList.h>
#include <Model_ResultConstruction.h>
#include <GeomAPI_Edge.h>
#include <GeomAPI_Pnt.h>
#include <GeomAPI_Vertex.h>
+#include <GeomAPI_ShapeExplorer.h>
#include <GeomAlgoAPI_CompoundBuilder.h>
#include <GeomAlgoAPI_NExplode.h>
#include <Selector_Selector.h>
-#include <TNaming_Selector.hxx>
#include <TNaming_NamedShape.hxx>
#include <TNaming_Tool.hxx>
#include <TNaming_Builder.hxx>
#include <TopExp_Explorer.hxx>
#include <BRep_Tool.hxx>
#include <TopoDS.hxx>
+#include <TopoDS_Edge.hxx>
#include <TopExp.hxx>
#include <TDF_ChildIterator.hxx>
#include <TDF_ChildIDIterator.hxx>
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");
+// reference to the external sketch face
+Standard_GUID kEXT_SKETCH_FACE("ba32aa31-bde7-422f-80b4-79c757c77b49");
+// reference to the external sketch edge
+Standard_GUID kEXT_SKETCH_EDGE("ba32aa31-bde7-422f-80b4-79c757c77b48");
+// reference to the external sketch vertex
+Standard_GUID kEXT_SKETCH_VERT("ba32aa31-bde7-422f-80b4-79c757c77b47");
// prefix for the whole feature context identification
const static std::string kWHOLE_FEATURE = "all-in-";
aSelLab.ForgetAttribute(kCIRCLE_CENTER);
aSelLab.ForgetAttribute(kELLIPSE_CENTER1);
aSelLab.ForgetAttribute(kELLIPSE_CENTER2);
- aSelLab.ForgetAttribute(kWEAK_NAMING);
- aSelLab.ForgetAttribute(kWEAK_NAMING_SHAPETYPE);
+ aSelLab.ForgetAttribute(kEXT_SKETCH_FACE);
+ aSelLab.ForgetAttribute(kEXT_SKETCH_EDGE);
+ aSelLab.ForgetAttribute(kEXT_SKETCH_VERT);
bool isDegeneratedEdge = false;
// do not use the degenerated edge as a shape, a null context and shape is used in the case
if (myRef.isInitialized()) {
if (aSelLab.IsAttribute(kSIMPLE_REF_ID)) { // it is just reference to shape, not sub-shape
ResultPtr aContext = context();
- if (!aContext.get())
- return aResult; // empty result
+ if (!aContext.get() || aContext->groupName() == ModelAPI_ResultConstruction::group())
+ return aResult; // empty result, for whole construction selection also
return aContext->shape();
}
if (aSelLab.IsAttribute(kPART_REF_ID)) {
if (aConstr) {
if (aConstr->isInfinite())
return aResult; // empty result
+ // external sketch face
+ Handle(TDataStd_Integer) anIndex;
+ if (aSelLab.FindAttribute(kEXT_SKETCH_FACE, anIndex)) {
+ return aConstr->face(anIndex->Get());
+ }
+ if (aSelLab.FindAttribute(kEXT_SKETCH_EDGE, anIndex) ||
+ aSelLab.FindAttribute(kEXT_SKETCH_VERT, anIndex)) {
+ bool isVert = anIndex->ID() == kEXT_SKETCH_VERT; // vertex is selected
+ CompositeFeaturePtr aComposite = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(
+ aConstr->document()->feature(aConstr));
+ if (aComposite.get()) {
+ int aSubNum = anIndex->Get() % 1000000;
+ int aVertShape = (anIndex->Get() - aSubNum) / 1000000;
+ FeaturePtr aSubFeat = aComposite->subFeature(aSubNum);
+ if (aSubFeat.get()) {
+ const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aSubFeat->results();
+ std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResults.cbegin();
+ for (; aRes != aResults.cend(); aRes++) {
+ ResultConstructionPtr aConstr =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aRes);
+ if (aConstr->shape()) {
+ if (!isVert && aConstr->shape()->isEdge())
+ return aConstr->shape();
+ else if (isVert && aVertShape == 0 && aConstr->shape()->isVertex())
+ return aConstr->shape();
+ else if (isVert && aVertShape > 1 && aConstr->shape()->isEdge()) {
+ GeomAPI_ShapeExplorer anExp(aConstr->shape(), GeomAPI_Shape::VERTEX);
+ for(; anExp.more(); anExp.next()) {
+ if (aVertShape == 1)
+ return anExp.current();
+ aVertShape--;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
}
if (!aConstr.get()) { // for construction context, return empty result as usual even
// the whole feature is selected
}
}
- 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;
if (aSelLab.FindAttribute(TNaming_NamedShape::GetID(), aSelection)) {
TopoDS_Shape aSelShape = aSelection->Get();
myRef.setObject(theObject);
}
-TDF_LabelMap& Model_AttributeSelection::scope()
-{
- if (myScope.IsEmpty()) { // create a new scope if not yet done
- // gets all features with named shapes that are before this feature label (before in history)
- DocumentPtr aMyDoc = owner()->document();
- std::list<std::shared_ptr<ModelAPI_Feature> > allFeatures = aMyDoc->allFeatures();
- std::list<std::shared_ptr<ModelAPI_Feature> >::iterator aFIter = allFeatures.begin();
- bool aMePassed = false;
- CompositeFeaturePtr aComposite =
- std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(owner());
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
- CompositeFeaturePtr aCompositeOwner, aCompositeOwnerOwner;
- if (aFeature.get()) {
- aCompositeOwner = ModelAPI_Tools::compositeOwner(aFeature);
- if (aCompositeOwner.get()) {
- aCompositeOwnerOwner = ModelAPI_Tools::compositeOwner(aCompositeOwner);
- }
- }
- // for group Scope is not limitet: this is always up to date objects
- // this causes problem in galeries.py
- //bool isGroup = aFeature.get() && aFeature->getKind() == "Group";
- for(; aFIter != allFeatures.end(); aFIter++) {
- if (*aFIter == owner()) { // the left features are created later (except subs of composite)
- aMePassed = true;
- continue;
- }
- //if (isGroup) aMePassed = false;
- bool isInScope = !aMePassed;
- if (!isInScope && aComposite.get()) {
- // try to add sub-elements of composite if this is composite
- if (aComposite->isSub(*aFIter))
- isInScope = true;
- }
- // remove the composite-owner of this feature (sketch in extrusion-cut)
- if (isInScope && (aCompositeOwner == *aFIter || aCompositeOwnerOwner == *aFIter))
- isInScope = false;
-
- if (isInScope && aFIter->get() && (*aFIter)->data()->isValid()) {
- TDF_Label aFeatureLab = std::dynamic_pointer_cast<Model_Data>(
- (*aFIter)->data())->label().Father();
- TDF_ChildIDIterator aNSIter(aFeatureLab, TNaming_NamedShape::GetID(), true);
- for(; aNSIter.More(); aNSIter.Next()) {
- Handle(TNaming_NamedShape) aNS = Handle(TNaming_NamedShape)::DownCast(aNSIter.Value());
- if (!aNS.IsNull() && aNS->Evolution() != TNaming_SELECTED) {
- myScope.Add(aNS->Label());
- }
- }
- }
- }
- // also add all naming labels created for external constructions
- std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(aMyDoc);
- TDF_Label anExtDocLab = aDoc->extConstructionsLabel();
- TDF_ChildIDIterator aNSIter(anExtDocLab, TNaming_NamedShape::GetID(), true);
- for(; aNSIter.More(); aNSIter.Next()) {
- Handle(TNaming_NamedShape) aNS = Handle(TNaming_NamedShape)::DownCast(aNSIter.Value());
- if (!aNS.IsNull() && aNS->Evolution() != TNaming_SELECTED) {
- myScope.Add(aNS->Label());
- }
- }
- }
- return myScope;
-}
-
/// Sets the invalid flag if flag is false, or removes it if "true"
/// Returns theFlag
static bool setInvalidIfFalse(TDF_Label& theLab, const bool theFlag) {
{
FeaturePtr aContextFeature = contextFeature();
if (aContextFeature.get()) {
+ owner()->data()->sendAttributeUpdated(this); // send updated if "update" called in any way
return true;
}
TDF_Label aSelLab = selectionLabel();
}
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 topological selection mechanism
bool aResult = false;
TopoDS_Shape anOldShape;
anOldShape = aNS->Get();
Selector_Selector aSelector(aSelLab);
- if (!aSelector.restore()) { // it is stored in old OCCT format, use TNaming_Selector
- TNaming_Selector aSelector(aSelLab);
- if (!aSelector.NamedShape().IsNull()) {
- anOldShape = aSelector.NamedShape()->Get();
- }
- aResult = aSelector.Solve(scope()) == Standard_True;
- } else {
+ if (aSelector.restore()) { // it is stored in old OCCT format, use TNaming_Selector
TopoDS_Shape aContextShape = aContext->shape()->impl<TopoDS_Shape>();
aResult = aSelector.solve(aContextShape);
}
std::shared_ptr<Model_ResultConstruction> aConstructionContext =
std::dynamic_pointer_cast<Model_ResultConstruction>(aContext);
if (!aConstructionContext->isInfinite()) {
+ // external sketch face
+ Handle(TDataStd_Integer) anIndex;
+ if (aSelLab.FindAttribute(kEXT_SKETCH_FACE, anIndex)) {
+ return setInvalidIfFalse(aSelLab, anIndex->Get() < aConstructionContext->facesNum());
+ }
+ if (aSelLab.FindAttribute(kEXT_SKETCH_EDGE, anIndex) ||
+ aSelLab.FindAttribute(kEXT_SKETCH_VERT, anIndex)) {
+ CompositeFeaturePtr aComposite = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(
+ aConstructionContext->document()->feature(aConstructionContext));
+ if (aComposite.get()) {
+ FeaturePtr aSubFeat = aComposite->subFeature(anIndex->Get() % 1000000);
+ return setInvalidIfFalse(aSelLab, aSubFeat.get() != NULL);
+ }
+ return setInvalidIfFalse(aSelLab, false); // composite sub-feature is not found
+ }
Selector_Selector aSelector(aSelLab);
aResult = aSelector.restore();
+ TopoDS_Shape anOldShape = aSelector.value();
if (aResult) {
TopoDS_Shape aContextShape = aContext->shape()->impl<TopoDS_Shape>();
aResult = aSelector.solve(aContextShape);
}
aResult = setInvalidIfFalse(aSelLab, aResult);
+ if (aResult && !anOldShape.IsEqual(aSelector.value()))
+ owner()->data()->sendAttributeUpdated(this); // send updated if shape is changed
+ } else {
+ owner()->data()->sendAttributeUpdated(this); // send updated if "update" called in any way
}
return aResult;
}
}
}
- // with "recover" feature the selected context may be not up to date (issue 1710)
- TDF_Label aSelLab = selectionLabel();
- TopoDS_Shape aNewSub = theSubShape ? theSubShape->impl<TopoDS_Shape>() : aContext;
-
- /// fix for issue 411: result modified shapes must not participate in this selection mechanism
if (!aContext.IsNull()) {
+ TDF_Label aSelLab = selectionLabel();
+ TopoDS_Shape aNewSub = theSubShape->impl<TopoDS_Shape>();
FeaturePtr aFeatureOwner = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
- bool aEraseResults = false;
- if (aFeatureOwner.get()) {
- aEraseResults = !aFeatureOwner->results().empty();
- if (aEraseResults) // erase results without flash deleted and redisplay: do it after Select
- aFeatureOwner->removeResults(0, false, false);
+ if (aFeatureOwner->document() != theContext->document()) { // reference to the sketch face
+ if (theSubShape->shapeType() == TopAbs_FACE) { // sketch face
+ ResultConstructionPtr aConstr =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(theContext);
+ int aFaceIndex = -1, aFacesNum = aConstr->facesNum();
+ for(int a = 0; a < aFacesNum; a++) {
+ if (aConstr->face(a)->isEqual(theSubShape)) {
+ aFaceIndex = a;
+ break;
+ }
+ }
+ if (aFaceIndex >= 0) {
+ TDataStd_Integer::Set(aSelLab, kEXT_SKETCH_FACE, aFaceIndex); // store index of the face
+ return;
+ }
+ } else if (theSubShape->shapeType() == TopAbs_EDGE || // sketch result edge (full one)
+ theSubShape->shapeType() == TopAbs_VERTEX) { // or start/end vertex
+ bool isVertex = theSubShape->shapeType() == TopAbs_VERTEX;
+ CompositeFeaturePtr aComposite = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(
+ theContext->document()->feature(theContext));
+ if (aComposite.get()) { // iterate edges of composite to find index of matched with value
+ int aSub, anEdgeIndex = -1, aSubNum = aComposite->numberOfSubs();
+ int aVertIndex = -1, aVertShape = -1; // shape: 0 full, 1 start, 2 end
+ for(aSub = 0; aSub < aSubNum && anEdgeIndex == -1; aSub++) {
+ FeaturePtr aSubFeat = aComposite->subFeature(aSub);
+ const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aSubFeat->results();
+ std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResults.cbegin();
+ for (; aRes != aResults.cend(); aRes++) {
+ ResultConstructionPtr aConstr =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(*aRes);
+ if (aConstr->shape() && aConstr->shape()->isEdge()) {
+ if (isVertex) {
+ GeomAPI_ShapeExplorer aVertExp(aConstr->shape(), GeomAPI_Shape::VERTEX);
+ for(int aNum = 1; aVertExp.more(); aVertExp.next(), aNum++) {
+ if (aVertExp.current()->isSame(theSubShape) && aVertShape != 0) {
+ aVertIndex = aSub;
+ aVertShape = aNum;
+ }
+ }
+ } else {
+ if (aConstr->shape()->isSame(theSubShape)) {
+ anEdgeIndex = aSub;
+ break;
+ }
+ }
+ } else if (isVertex && aConstr->shape() && aConstr->shape()->isVertex()) {
+ if (aConstr->shape()->isSame(theSubShape)) {
+ aVertIndex = aSub;
+ aVertShape = 0;
+ }
+ }
+ }
+ }
+ if (anEdgeIndex >= 0) {
+ TDataStd_Integer::Set(aSelLab, kEXT_SKETCH_EDGE, anEdgeIndex); // store index of edge
+ return;
+ } else if (aVertIndex >= 0) {
+ aVertIndex += aVertShape * 1000000; // to store both integers: index and shape
+ TDataStd_Integer::Set(aSelLab, kEXT_SKETCH_VERT, aVertIndex); // store index of edge
+ return;
+ }
+ }
+ }
}
bool aSelectorOk = true;
- //TNaming_Selector aSel(aSelLab);
Selector_Selector aSel(aSelLab);
try {
- //aSel.Select(aNewSub, aNewContext);
aSelectorOk = aSel.select(aContext, aNewSub);
if (aSelectorOk) {
aSel.store();
} 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))
{
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(aContext));
- 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();
- static const Events_ID kDeletedEvent = aLoop->eventByName(EVENT_OBJECT_DELETED);
- aLoop->flush(kDeletedEvent);
+ if (!aSelectorOk) {
+ setInvalidIfFalse(aSelLab, false);
}
}
}
return contextName(aCont);
}
- Handle(TDataStd_Integer) aWeakId;
- if (aSelLab.FindAttribute(kWEAK_NAMING, aWeakId)) { // a weak naming is used
- std::ostringstream aNameStream;
- aNameStream<<contextName(aCont)<<"/weak_name_"<<aWeakId->Get();
- return aNameStream.str();
- }
-
// whole infinitive construction
if (aCont->groupName() == ModelAPI_ResultConstruction::group()) {
ResultConstructionPtr aConstr = std::dynamic_pointer_cast<Model_ResultConstruction>(aCont);
if (aConstr->isInfinite()) {
return contextName(aCont);
+ } else {
+ // external sketch face
+ Handle(TDataStd_Integer) anIndex;
+ if (aSelLab.FindAttribute(kEXT_SKETCH_FACE, anIndex) ||
+ aSelLab.FindAttribute(kEXT_SKETCH_EDGE, anIndex) ||
+ aSelLab.FindAttribute(kEXT_SKETCH_VERT, anIndex)) {
+ std::shared_ptr<Model_Document> anExtDoc =
+ std::dynamic_pointer_cast<Model_Document>(aCont->document());
+ Selector_Selector aSelector(anExtDoc->extConstructionsLabel());
+ TopoDS_Shape aContShape = aConstr->shape()->impl<TopoDS_Shape>();
+ TopoDS_Shape aValShape = value()->impl<TopoDS_Shape>();
+ aSelector.select(aContShape, aValShape);
+ myRestoreDocument = anExtDoc;
+ std::string aName = anExtDoc->kind() + "/" + aSelector.name(this);
+ myRestoreDocument.reset();
+ return aName;
+ }
}
}
CenterType aCenterType = theType[0] == 'v' || theType[0] == 'V' ? // only for vertex-type
centerTypeByName(aSubShapeName) : NOT_CENTER;
std::string aType = aCenterType == NOT_CENTER ? theType : "EDGE"; // search for edge now
+ TopAbs_ShapeEnum aShapeType = TopAbs_ShapeEnum(GeomAPI_Shape::shapeTypeByStr(theType));
static const GeomShapePtr anEmptyShape;
// first iteration is selection by name without center prefix, second - in case of problem,
Selector_Selector aSelector(aDoc->generalLabel());
myRestoreDocument = aDoc;
- TDF_Label aContextLabel = aSelector.restoreByName(aSubShapeName, this);
+ TDF_Label aContextLabel = aSelector.restoreByName(aSubShapeName, aShapeType, this);
myRestoreDocument.reset();
if (!aContextLabel.IsNull()) {
ResultPtr aContext = aDoc->resultByLab(aContextLabel); // any label for document access
for(; aNewContIter != aNewToIterate.end(); aNewContIter++) {
std::shared_ptr<Model_Data> aNewData =
std::dynamic_pointer_cast<Model_Data>((*aNewContIter)->data());
- TDF_Label aNewLab = aNewData->label();
+ TDF_Label aNewLab = aNewData->shapeLab();
// searching for produced sub-shape fully on some label
TDF_ChildIDIterator aNSIter(aNewLab, TNaming_NamedShape::GetID(), Standard_True);
for(; aNSIter.More(); aNSIter.Next()) {
if (!aModifierFeat.get())
continue;
FeaturePtr aThisFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(owner());
- if (aModifierFeat == aThisFeature || theDoc->objects()->isLater(aModifierFeat, aThisFeature))
+ if (aModifierFeat == aThisFeature || !theDoc->isLaterByDep(aThisFeature, aModifierFeat))
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))
+ !theDoc->isLaterByDep(aModifierFeat, aCurrentModifierFeat))
continue; // the current modifier is later than the found, so, useless
Handle(TNaming_NamedShape) aNewNS;
aModifIter.Label().FindAttribute(TNaming_NamedShape::GetID(), aNewNS);
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
+ } else { // not-processed modification => don't support it
continue;
}
}
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
+ TDF_Label aContLab = aContData->shapeLab(); // named shape where the selected context is located
Handle(TNaming_NamedShape) aContNS;
if (!aContLab.FindAttribute(TNaming_NamedShape::GetID(), aContNS)) {
bool aFoundNewContext = true;
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
+ if (!aDoc->isLaterByDep(aRefFeat, aThisFeature)) { // found better feature
aFoundNewContext = true;
aNewContext = aRefFeat->firstResult();
}
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
myParent = theParent;
}
-bool Model_AttributeSelection::isWeakNaming()
-{
- return selectionLabel().IsAttribute(kWEAK_NAMING);
-}
-
std::string Model_AttributeSelection::contextName(const TDF_Label theSelectionLab)
{
- DocumentPtr aMyDoc = owner()->document();
- std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(aMyDoc);
+ std::shared_ptr<Model_Document> aDoc = myRestoreDocument.get() ? myRestoreDocument :
+ std::dynamic_pointer_cast<Model_Document>(owner()->document());
FeaturePtr aFeatureOwner = aDoc->featureByLab(theSelectionLab);
if (aFeatureOwner.get()) {
// if it is sub-element of the sketch, the context name is the name of the sketch
std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aDoc->feature(aCont));
if (aComposite.get() && aComposite->numberOfSubs()) {
const int aSubNum = aComposite->numberOfSubs();
- for (int a = 0; a < aSubNum; a++) {
+ for (int a = 0; a < aSubNum && theValue.IsNull(); a++) {
FeaturePtr aSub = aComposite->subFeature(a);
const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aSub->results();
std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResults.cbegin();
- for (; aRes != aResults.cend(); aRes++) {
+ for (; aRes != aResults.cend() && theValue.IsNull(); aRes++) {
if ((*aRes)->data()->name() == aCompName) {
theValue = std::dynamic_pointer_cast<Model_Data>((*aRes)->data())->shapeLab();
+ break;
+ } else if (aCompName.find((*aRes)->data()->name()) != std::string::npos) {// sub-vertex
+ TDF_Label aLab = std::dynamic_pointer_cast<Model_Data>((*aRes)->data())->shapeLab();
+ TDF_ChildIDIterator aSubNames(aLab, TDataStd_Name::GetID());
+ for(; aSubNames.More(); aSubNames.Next()) {
+ if (Handle(TDataStd_Name)::DownCast(aSubNames.Value())->Get().
+ IsEqual(aCompName.c_str())) {
+ theValue = aSubNames.Value()->Label();
+ break;
+ }
+ }
}
}
}
}
return true;
}
+
+bool Model_AttributeSelection::isLater(
+ const TDF_Label theResult1, const TDF_Label theResult2) const
+{
+ std::shared_ptr<Model_Document> aDoc = myRestoreDocument.get() ? myRestoreDocument :
+ std::dynamic_pointer_cast<Model_Document>(owner()->document());
+ FeaturePtr aFeat1 = aDoc->featureByLab(theResult1);
+ if (!aFeat1.get())
+ return false;
+ FeaturePtr aFeat2 = aDoc->featureByLab(theResult2);
+ if (!aFeat2.get())
+ return false;
+ return aDoc->isLaterByDep(aFeat1, aFeat2);
+}
