src/SketchSolver/SketchSolver_ConstraintMultiTranslation.cpp

   1 #include <SketchSolver_ConstraintMultiTranslation.h>
   2 #include <SketchSolver_Error.h>
   3 #include <SketchSolver_Manager.h>
   4
   5 #include <SketchPlugin_MultiTranslation.h>
   6
   7 #include <ModelAPI_AttributeString.h>
   8
   9 #include <GeomDataAPI_Point2D.h>
  10
  11 void SketchSolver_ConstraintMultiTranslation::getAttributes(
  12     EntityWrapperPtr& theStartPoint, EntityWrapperPtr& theEndPoint,
  13     std::list< std::list<EntityWrapperPtr> >& theEntities)
  14 {
  15   DataPtr aData = myBaseConstraint->data();
  16   AttributePtr aStartPointAttr = aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID());
  17   AttributePtr aEndPointAttr = aData->attribute(SketchPlugin_MultiTranslation::END_POINT_ID());
  18   if (!aStartPointAttr || !aStartPointAttr->isInitialized() ||
  19       !aEndPointAttr || !aEndPointAttr->isInitialized()) {
  20     myErrorMsg = SketchSolver_Error::NOT_INITIALIZED();
  21     return;
  22   }
  23
  24   myType = CONSTRAINT_MULTI_TRANSLATION;
  25
  26   myStorage->update(aStartPointAttr);
  27   theStartPoint = myStorage->entity(aStartPointAttr);
  28   myStorage->update(aEndPointAttr);
  29   theEndPoint = myStorage->entity(aEndPointAttr);
  30
  31   getEntitiesAndCopies(theEntities);
  32
  33 }
  34
  35 void SketchSolver_ConstraintMultiTranslation::process()
  36 {
  37   cleanErrorMsg();
  38   if (!myBaseConstraint || !myStorage || myGroupID == GID_UNKNOWN) {
  39     /// TODO: Put error message here
  40     return;
  41   }
  42
  43   EntityWrapperPtr aStartPoint, aEndPoint;
  44   std::list<std::list<EntityWrapperPtr> > anEntitiesAndCopies;
  45   getAttributes(aStartPoint, aEndPoint, anEntitiesAndCopies);
  46   if (!myErrorMsg.empty())
  47     return;
  48
  49   BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
  50   std::list<ConstraintWrapperPtr> aTransConstraints;
  51
  52   std::list< std::list<EntityWrapperPtr> >::iterator anEntIt = anEntitiesAndCopies.begin();
  53   for (; anEntIt != anEntitiesAndCopies.end(); ++anEntIt) {
  54     std::list<ConstraintWrapperPtr> aNewConstraints =
  55         aBuilder->createConstraint(myBaseConstraint, myGroupID, mySketchID, myType,
  56         0.0, aStartPoint, aEndPoint, *anEntIt);
  57     aTransConstraints.insert(aTransConstraints.end(), aNewConstraints.begin(), aNewConstraints.end());
  58   }
  59   myStorage->addConstraint(myBaseConstraint, aTransConstraints);
  60
  61   myAdjusted = false;
  62   adjustConstraint();
  63 }
  64
  65 const std::string& SketchSolver_ConstraintMultiTranslation::nameNbObjects()
  66 {
  67   return SketchPlugin_MultiTranslation::NUMBER_OF_OBJECTS_ID();
  68 }
  69
  70 void SketchSolver_ConstraintMultiTranslation::updateLocal()
  71 {
  72   DataPtr aData = myBaseConstraint->data();
  73   AttributePoint2DPtr aStartPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData,
  74                                       SketchPlugin_MultiTranslation::START_POINT_ID());
  75   AttributePoint2DPtr anEndPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData,
  76                                       SketchPlugin_MultiTranslation::END_POINT_ID());
  77   AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiTranslation::VALUE_TYPE());
  78   bool aFullValue = aMethodTypeAttr->value() != "SingleValue";
  79
  80   bool aStartPointChanged = aStartPointAttribute != myStartPointAttribute;
  81   bool anEndPointChanged = anEndPointAttribute != myEndPointAttribute;
  82   bool isMethodChanged = aFullValue != myIsFullValue;
  83
  84   if (aStartPointChanged)
  85     myStartPointAttribute = aStartPointAttribute;
  86   if (aStartPointChanged)
  87     myEndPointAttribute = anEndPointAttribute;
  88   if (isMethodChanged)
  89     myIsFullValue = aFullValue;
  90
  91   if (aStartPointChanged || anEndPointChanged || isMethodChanged) {
  92     DataPtr aData = myBaseConstraint->data();
  93     std::list<ConstraintWrapperPtr> aConstraints = myStorage->constraint(myBaseConstraint);
  94     std::list<ConstraintWrapperPtr>::const_iterator anIt = aConstraints.begin(),
  95                                                     aLast = aConstraints.end();
  96     std::list<EntityWrapperPtr> anEntities;
  97     for (; anIt != aLast; anIt++) {
  98       ConstraintWrapperPtr aConstraint = *anIt;
  99       aConstraint->setIsFullValue(myIsFullValue);
 100       anEntities.clear();
 101
 102       const std::list<EntityWrapperPtr>& aConstraintEntities = aConstraint->entities();
 103       std::list<EntityWrapperPtr>::const_iterator aSIt = aConstraintEntities.begin(),
 104                                                   aSLast = aConstraintEntities.end();
 105       EntityWrapperPtr aStartEntity = *aSIt++;
 106       if (aStartPointChanged) {
 107         AttributePtr aStartPointAttr = aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID());
 108         myStorage->update(aStartPointAttr);
 109         aStartEntity = myStorage->entity(aStartPointAttr);
 110       }
 111       anEntities.push_back(aStartEntity);
 112
 113       EntityWrapperPtr anEndEntity = *aSIt++;
 114       if (anEndPointChanged) {
 115         AttributePtr anEndPointAttr = aData->attribute(SketchPlugin_MultiTranslation::END_POINT_ID());
 116         myStorage->update(anEndPointAttr);
 117         anEndEntity = myStorage->entity(anEndPointAttr);
 118       }
 119       anEntities.push_back(anEndEntity);
 120
 121       for (; aSIt != aSLast; ++aSIt)
 122         anEntities.push_back(*aSIt);
 123
 124       aConstraint->setEntities(anEntities);
 125     }
 126     myStorage->addConstraint(myBaseConstraint, aConstraints);
 127
 128     myAdjusted = false;
 129   }
 130 }
 131