#include <GeomAPI_Pnt.h>
#include <GeomAPI_Dir.h>
#include <GeomAPI_ShapeExplorer.h>
+#include <GeomAPI_ShapeIterator.h>
+#include <GeomAlgoAPI_NExplode.h>
#include <GeomDataAPI_Dir.h>
#include <GeomDataAPI_Point.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_ResultPart.h>
+#include <ModelAPI_Session.h>
#include <ModelAPI_Tools.h>
#include <ModelGeomAlgo_Shape.h>
if (aNbFeatures.first == anId && aNbFeatures.second < anId) {
// name is not user-defined
isDefaultName = true;
+
+ // check there are postponed features of this kind,
+ // dump their names, because the sequence of features may be changed
+ for (std::list<EntityPtr>::const_iterator aPpIt = myPostponed.begin();
+ aPpIt != myPostponed.end(); ++aPpIt) {
+ FeaturePtr aCurFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*aPpIt);
+ if (aCurFeature && aCurFeature->getKind() == aKind) {
+ myNames[*aPpIt].myIsDefault = false;
+ isDefaultName = false;
+ }
+ }
}
if (anId > aNbFeatures.second)
return true;
}
+static bool isSketchSub(const FeaturePtr& theFeature)
+{
+ static const std::string SKETCH("Sketch");
+ CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(theFeature);
+ return anOwner && anOwner->getKind() == SKETCH;
+}
+
bool ModelHighAPI_Dumper::isDefaultColor(const ResultPtr& theResult) const
{
AttributeIntArrayPtr aColor = theResult->data()->intArray(ModelAPI_Result::COLOR_ID());
if (!aColor || !aColor->isInitialized())
return true;
+ // check the result belongs to sketch entity, do not dump color in this way
+ ResultConstructionPtr aResConstr =
+ std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(theResult);
+ if (aResConstr) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theResult->data()->owner());
+ if (isSketchSub(aFeature))
+ return true;
+ }
+
std::string aSection, aName, aDefault;
theResult->colorConfigInfo(aSection, aName, aDefault);
}
static int possibleSelectionsByPoint(const GeomPointPtr& thePoint,
- const GeomAPI_Shape::ShapeType& theType,
+ const ResultPtr& theResult,
+ const GeomShapePtr& theShape,
const FeaturePtr& theStartFeature,
const FeaturePtr& theEndFeature)
{
++aFIt;
}
- ResultPtr aResult;
- GeomShapePtr aSubshape;
+ // collect the list of composite features, containing the last feature;
+ // these features should be excluded from searching,
+ // because the feature cannot select sub-shapes from its parent
+ std::set<FeaturePtr> aEndFeatureParents = ModelAPI_Tools::getParents(theEndFeature);
+
int aNbPossibleSelections = 0;
for (; aFIt != aFeatures.end() && *aFIt != theEndFeature; ++aFIt) {
+ bool isSkipFeature = false;
if (aLastCompositeFeature && aLastCompositeFeature->isSub(*aFIt))
- continue;
+ isSkipFeature = true;
CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aFIt);
- if (aCompFeat)
- aLastCompositeFeature = aCompFeat;
+ if (aCompFeat) {
+ ResultPartPtr aPartRes =
+ std::dynamic_pointer_cast<ModelAPI_ResultPart>(aCompFeat->firstResult());
+ if (!aPartRes)
+ aLastCompositeFeature = aCompFeat;
+ if (aEndFeatureParents.find(aCompFeat) != aEndFeatureParents.end()) {
+ // do not process the parent for the last feature,
+ // because it cannot select objects from its parent
+ isSkipFeature = true;
+ }
+ }
+ if (isSkipFeature)
+ continue;
+
+ std::list<ModelGeomAlgo_Shape::SubshapeOfResult> anApproproate;
+ if (ModelGeomAlgo_Shape::findSubshapeByPoint(*aFIt, thePoint, theShape->shapeType(),
+ anApproproate)) {
+ std::list<ModelGeomAlgo_Shape::SubshapeOfResult>::iterator anApIt = anApproproate.begin();
+ for (; anApIt != anApproproate.end(); ++anApIt) {
+ ++aNbPossibleSelections;
- if (ModelGeomAlgo_Shape::findSubshapeByPoint(*aFIt, thePoint, theType, aResult, aSubshape))
- ++aNbPossibleSelections;
+ // stop if the target shape and result are found
+ GeomShapePtr aCurShape = anApIt->mySubshape;
+ if (!aCurShape)
+ aCurShape = anApIt->myResult->shape();
+
+ if (anApIt->myResult->isSame(theResult) && aCurShape->isSame(theShape))
+ break;
+ }
+ }
}
return aNbPossibleSelections;
}
FeaturePtr aSelectedFeature;
if (isDumpByGeom) {
ResultPtr aRes = theAttrSelect->context();
- if (aRes) {
+ FeaturePtr aFeature = theAttrSelect->contextFeature();
+ if (aRes && !aFeature)
aSelectedFeature = ModelAPI_Feature::feature(aRes->data()->owner());
- if (aSelectedFeature)
- isDumpByGeom = aSelectedFeature->isInHistory();
- }
+ isDumpByGeom = aSelectedFeature && aSelectedFeature->isInHistory();
+ }
+
+ if (theAttrSelect->isGeometricalSelection() && aShape->shapeType() == GeomAPI_Shape::COMPOUND) {
+ GeomAPI_ShapeIterator anIt(aShape);
+ aShape = anIt.current();
}
myDumpBuffer << "\"" << aShape->shapeTypeStr();
+ bool aStandardDump = true;
if (isDumpByGeom) {
+ // check the selected item is a ResultPart;
+ // in this case it is necessary to get shape with full transformation
+ // for correct calculation of the middle point
+ ResultPartPtr aResPart =
+ std::dynamic_pointer_cast<ModelAPI_ResultPart>(theAttrSelect->context());
+ if (aResPart && aShape->shapeType() == GeomAPI_Shape::COMPOUND)
+ aShape = aResPart->shape();
GeomPointPtr aMiddlePoint = aShape->middlePoint();
// calculate number of features, which could be selected by the same point
FeaturePtr anOwner = ModelAPI_Feature::feature(theAttrSelect->owner());
- int aNbPossibleSelections =
- possibleSelectionsByPoint(aMiddlePoint, aShape->shapeType(), aSelectedFeature, anOwner);
+ int aNbPossibleSelections = possibleSelectionsByPoint(aMiddlePoint,
+ theAttrSelect->context(), aShape, aSelectedFeature, anOwner);
// produce the index if the number of applicable features is greater than 1
std::string anIndex;
myDumpBuffer << anIndex << "\", ";
*this << aMiddlePoint;
+ aStandardDump = false;
+ } if (myWeakNamingSelection && aShape.get() && theAttrSelect->context().get() &&
+ aShape != theAttrSelect->context()->shape()) { // weak naming for local selection only
+ GeomAlgoAPI_NExplode aNExplode(theAttrSelect->context()->shape(), aShape->shapeType());
+ int anIndex = aNExplode.index(aShape);
+ if (anIndex != 0) { // found a week-naming index, so, export it
+ myDumpBuffer<<"\", \""<<theAttrSelect->context()->data()->name()<<"\", "<<anIndex;
+ aStandardDump = false;
+ }
}
- else
+ if (aStandardDump)
myDumpBuffer << "\", \"" << theAttrSelect->namingName() << "\"";
myDumpBuffer << ")";
return *this;
