#include <ModelAPI_AttributeRefList.h>
#include <SketchPlugin_Arc.h>
#include <SketchPlugin_Circle.h>
+#include <SketchPlugin_Line.h>
+#include <SketchPlugin_Point.h>
+#include <SketchPlugin_IntersectionPoint.h>
+#include <SketchPlugin_ConstraintRigid.h>
/// \brief Verify two vectors of constraints are equal.
for (; aCIt != theSolverConstraints.end(); ++aCIt)
update(*aCIt);
}
- myConstraintMap[theConstraint] = theSolverConstraints;
+
+ if (!theSolverConstraints.empty() || aFound == myConstraintMap.end())
+ myConstraintMap[theConstraint] = theSolverConstraints;
// block events if necessary
- if (myEventsBlocked && theConstraint->data() && theConstraint->data()->isValid())
+ if (myEventsBlocked && theConstraint && theConstraint->data() && theConstraint->data()->isValid())
theConstraint->data()->blockSendAttributeUpdated(myEventsBlocked);
}
+static std::list<AttributePtr> pointAttributes(FeaturePtr theFeature)
+{
+ std::list<AttributePtr> aPoints;
+ if (theFeature->getKind() == SketchPlugin_Arc::ID()) {
+ aPoints.push_back(theFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
+ aPoints.push_back(theFeature->attribute(SketchPlugin_Arc::START_ID()));
+ aPoints.push_back(theFeature->attribute(SketchPlugin_Arc::END_ID()));
+ }
+ else if (theFeature->getKind() == SketchPlugin_Circle::ID())
+ aPoints.push_back(theFeature->attribute(SketchPlugin_Circle::CENTER_ID()));
+ else if (theFeature->getKind() == SketchPlugin_Line::ID()) {
+ aPoints.push_back(theFeature->attribute(SketchPlugin_Line::START_ID()));
+ aPoints.push_back(theFeature->attribute(SketchPlugin_Line::END_ID()));
+ }
+ else if (theFeature->getKind() == SketchPlugin_Point::ID() ||
+ theFeature->getKind() == SketchPlugin_IntersectionPoint::ID())
+ aPoints.push_back(theFeature->attribute(SketchPlugin_Point::COORD_ID()));
+ return aPoints;
+}
+
void SketchSolver_Storage::addEntity(FeaturePtr theFeature,
EntityWrapperPtr theSolverEntity)
{
if (!theSolverEntity) {
// feature links to the empty entity, add its attributes
- std::list<AttributePtr> aPntAttrs =
- theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+ std::list<AttributePtr> aPntAttrs = pointAttributes(theFeature);
std::list<AttributePtr>::const_iterator anAttrIt = aPntAttrs.begin();
for (; anAttrIt != aPntAttrs.end(); ++anAttrIt)
- addEntity(*anAttrIt, EntityWrapperPtr());
+ addEntity(*anAttrIt, EntityWrapperPtr());
if (aFound == myFeatureMap.end())
myFeatureMap[theFeature] = theSolverEntity;
} else
// Reserve the feature in the map of features (do not want to add several copies of it)
myFeatureMap[theFeature] = aRelated;
// Firstly, create/update its attributes
- std::list<AttributePtr> anAttrs =
- theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+ std::list<AttributePtr> anAttrs = pointAttributes(theFeature);
std::list<AttributePtr>::const_iterator anIt = anAttrs.begin();
for (; anIt != anAttrs.end(); ++anIt) {
isUpdated = update(*anIt, theGroup) || isUpdated;
// Secondly, convert feature
BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
GroupID aGroup = theGroup != GID_UNKNOWN ? theGroup : myGroupID;
+ // Check external feature
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::dynamic_pointer_cast<SketchPlugin_Feature>(theFeature);
+ if (aSketchFeature && aSketchFeature->isExternal())
+ aGroup = GID_OUTOFGROUP;
aRelated = aBuilder->createFeature(theFeature, aSubs, aGroup);
if (!aRelated)
return false;
if (aFeature->attribute(SketchPlugin_Arc::CENTER_ID())->isInitialized() &&
aFeature->attribute(SketchPlugin_Arc::START_ID())->isInitialized() &&
aFeature->attribute(SketchPlugin_Arc::END_ID())->isInitialized()) {
-//// myFeatureMap[aFeature] = EntityWrapperPtr();
return SketchSolver_Storage::update(aFeature);
+ } else {
+ myFeatureMap[aFeature] = EntityWrapperPtr();
+ myExistArc = true;
}
}
}
BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
GroupID aGroup = theGroup != GID_UNKNOWN ? theGroup : myGroupID;
+ // Check attribute of external features
+ std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
+ std::dynamic_pointer_cast<SketchPlugin_Feature>(theAttribute->owner());
+ if (aSketchFeature && aSketchFeature->isExternal())
+ aGroup = GID_OUTOFGROUP;
aRelated = aBuilder->createAttribute(anAttribute, aGroup);
if (!aRelated)
return false;
template <class ENT_TYPE>
static bool isUsed(ConstraintWrapperPtr theConstraint, ENT_TYPE theEntity)
{
+ if (!theConstraint || !theEntity)
+ return false;
std::list<EntityWrapperPtr>::const_iterator anEntIt = theConstraint->entities().begin();
for (; anEntIt != theConstraint->entities().end(); ++anEntIt)
if ((*anEntIt)->isBase(theEntity))
static bool isUsed(EntityWrapperPtr theFeature, AttributePtr theSubEntity)
{
+ if (!theFeature || !theSubEntity)
+ return false;
std::list<EntityWrapperPtr>::const_iterator aSubIt = theFeature->subEntities().begin();
for (; aSubIt != theFeature->subEntities().end(); ++aSubIt)
if ((*aSubIt)->isBase(theSubEntity))
return false;
}
+static bool isUsed(ConstraintPtr theConstraint, AttributePtr theAttribute)
+{
+ if (!theConstraint || !theAttribute)
+ return false;
+ std::list<AttributePtr> anAttrList = theConstraint->data()->attributes(std::string());
+ std::list<AttributePtr>::const_iterator anIt = anAttrList.begin();
+ for (; anIt != anAttrList.end(); ++anIt) {
+ if (*anIt == theAttribute)
+ return true;
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(*anIt);
+ if (aRefAttr && !aRefAttr->isObject() && aRefAttr->attr() == theAttribute)
+ return true;
+ }
+ return false;
+}
+
bool SketchSolver_Storage::isUsed(FeaturePtr theFeature) const
{
if (myFeatureMap.find(theFeature) != myFeatureMap.end())
if (::isUsed(*aCWIt, theFeature))
return true;
// check attributes
- std::list<AttributePtr> anAttrList = theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+ std::list<AttributePtr> anAttrList = pointAttributes(theFeature);
std::list<AttributePtr>::const_iterator anIt = anAttrList.begin();
for (; anIt != anAttrList.end(); ++anIt)
if (isUsed(*anIt))
std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
aCIt = myConstraintMap.begin();
std::list<ConstraintWrapperPtr>::const_iterator aCWIt;
- for (; aCIt != myConstraintMap.end(); ++aCIt)
+ for (; aCIt != myConstraintMap.end(); ++aCIt) {
for (aCWIt = aCIt->second.begin(); aCWIt != aCIt->second.end(); ++aCWIt)
if (::isUsed(*aCWIt, anAttribute))
return true;
+ // Additional check for the Fixed constraints, which have no wrapper associated.
+ if (aCIt->first->getKind() == SketchPlugin_ConstraintRigid::ID() &&
+ ::isUsed(aCIt->first, anAttribute))
+ return true;
+ }
// check in features
std::map<FeaturePtr, EntityWrapperPtr>::const_iterator aFIt = myFeatureMap.begin();
for (; aFIt != myFeatureMap.end(); ++aFIt)
{
std::map<FeaturePtr, EntityWrapperPtr>::iterator aFound = myFeatureMap.find(theFeature);
if (aFound == myFeatureMap.end())
- return false; // feature not found, nothing to delete
+ return true; // feature not found, nothing to delete
EntityWrapperPtr anEntity = aFound->second;
myFeatureMap.erase(aFound);
// Check if the feature is not used by constraints, remove it
- if (!isUsed(theFeature) && remove(anEntity))
+ if (!anEntity || (!isUsed(theFeature) && remove(anEntity)))
return true;
// feature is not removed, revert operation
{
std::map<AttributePtr, EntityWrapperPtr>::iterator aFound = myAttributeMap.find(theAttribute);
if (aFound == myAttributeMap.end())
- return false; // attribute not found, nothing to delete
+ return true; // attribute not found, nothing to delete
EntityWrapperPtr anEntity = aFound->second;
myAttributeMap.erase(aFound);
// Check if the attribute is not used by constraints and features, remove it
- if (!isUsed(theAttribute) && remove(anEntity))
+ if (!anEntity || (!isUsed(theAttribute) && remove(anEntity)))
return true;
// attribute is not removed, revert operation
addEntity(FeaturePtr(), theSketch);
}
+void SketchSolver_Storage::processArcs()
+{
+ myExistArc = false;
+ std::map<FeaturePtr, EntityWrapperPtr>::iterator aFIt = myFeatureMap.begin();
+ for (; aFIt != myFeatureMap.end(); ++aFIt)
+ if (!aFIt->second && aFIt->first->getKind() == SketchPlugin_Arc::ID()) {
+ // Additional checking the attributes are initialized
+ if (aFIt->first->attribute(SketchPlugin_Arc::CENTER_ID())->isInitialized() &&
+ aFIt->first->attribute(SketchPlugin_Arc::START_ID())->isInitialized() &&
+ aFIt->first->attribute(SketchPlugin_Arc::END_ID())->isInitialized())
+ update(aFIt->first);
+ else
+ myExistArc = true;
+ }
+}
+
void SketchSolver_Storage::blockEvents(bool isBlocked)
{
if (isBlocked == myEventsBlocked)
myEventsBlocked = isBlocked;
}
+std::set<ObjectPtr> SketchSolver_Storage::getConflictingConstraints(SolverPtr theSolver) const
+{
+ std::set<ObjectPtr> aConflicting;
+ std::map<ConstraintPtr, std::list<ConstraintWrapperPtr> >::const_iterator
+ aConstrIt = myConstraintMap.begin();
+ for (; aConstrIt != myConstraintMap.end(); ++aConstrIt) {
+ std::list<ConstraintWrapperPtr>::const_iterator anIt = aConstrIt->second.begin();
+ for (; anIt != aConstrIt->second.end(); ++anIt)
+ if (theSolver->isConflicting((*anIt)->id())) {
+ aConflicting.insert(aConstrIt->first);
+ break;
+ }
+ }
+ return aConflicting;
+}
