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     bool& theFullValue, 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   AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiTranslation::VALUE_TYPE());
  32   theFullValue = aMethodTypeAttr->value() != "SingleValue";
  33
  34   getEntitiesAndCopies(theEntities);
  35 }
  36
  37 void SketchSolver_ConstraintMultiTranslation::process()
  38 {
  39   cleanErrorMsg();
  40   if (!myBaseConstraint || !myStorage || myGroupID == GID_UNKNOWN) {
  41     /// TODO: Put error message here
  42     return;
  43   }
  44
  45   EntityWrapperPtr aStartPoint, aEndPoint;
  46   bool aFullValue;
  47   std::list<std::list<EntityWrapperPtr> > anEntitiesAndCopies;
  48   getAttributes(aStartPoint, aEndPoint, aFullValue, anEntitiesAndCopies);
  49   if (!myErrorMsg.empty())
  50     return;
  51
  52   AttributeStringPtr aMethodTypeAttr =
  53       myBaseConstraint->data()->string(SketchPlugin_MultiTranslation::VALUE_TYPE());
  54   myIsFullValue = aMethodTypeAttr->value() != "SingleValue";
  55
  56
  57   BuilderPtr aBuilder = SketchSolver_Manager::instance()->builder();
  58   std::list<ConstraintWrapperPtr> aTransConstraints;
  59
  60   std::list< std::list<EntityWrapperPtr> >::iterator anEntIt = anEntitiesAndCopies.begin();
  61   for (; anEntIt != anEntitiesAndCopies.end(); ++anEntIt) {
  62     std::list<ConstraintWrapperPtr> aNewConstraints =
  63         aBuilder->createConstraint(myBaseConstraint, myGroupID, mySketchID, myType,
  64         0.0, aFullValue, aStartPoint, aEndPoint, *anEntIt);
  65     aTransConstraints.insert(aTransConstraints.end(), aNewConstraints.begin(), aNewConstraints.end());
  66   }
  67   std::list<ConstraintWrapperPtr>::iterator aTCIt = aTransConstraints.begin();
  68   for (; aTCIt != aTransConstraints.end(); ++ aTCIt)
  69     (*aTCIt)->setIsFullValue(myIsFullValue);
  70
  71   myStorage->addConstraint(myBaseConstraint, aTransConstraints);
  72
  73   myAdjusted = false;
  74   adjustConstraint();
  75 }
  76
  77 const std::string& SketchSolver_ConstraintMultiTranslation::nameNbObjects()
  78 {
  79   return SketchPlugin_MultiTranslation::NUMBER_OF_OBJECTS_ID();
  80 }
  81
  82 void SketchSolver_ConstraintMultiTranslation::updateLocal()
  83 {
  84   DataPtr aData = myBaseConstraint->data();
  85   AttributePoint2DPtr aStartPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData,
  86                                       SketchPlugin_MultiTranslation::START_POINT_ID());
  87   AttributePoint2DPtr anEndPointAttribute = GeomDataAPI_Point2D::getPoint2D(aData,
  88                                       SketchPlugin_MultiTranslation::END_POINT_ID());
  89   AttributeStringPtr aMethodTypeAttr = aData->string(SketchPlugin_MultiTranslation::VALUE_TYPE());
  90   bool aFullValue = aMethodTypeAttr->value() != "SingleValue";
  91
  92   bool aStartPointChanged = aStartPointAttribute != myStartPointAttribute;
  93   bool anEndPointChanged = anEndPointAttribute != myEndPointAttribute;
  94   bool isMethodChanged = aFullValue != myIsFullValue;
  95
  96   if (aStartPointChanged)
  97     myStartPointAttribute = aStartPointAttribute;
  98   if (aStartPointChanged)
  99     myEndPointAttribute = anEndPointAttribute;
 100   if (isMethodChanged)
 101     myIsFullValue = aFullValue;
 102
 103   if (aStartPointChanged || anEndPointChanged || isMethodChanged) {
 104     DataPtr aData = myBaseConstraint->data();
 105     std::list<ConstraintWrapperPtr> aConstraints = myStorage->constraint(myBaseConstraint);
 106     std::list<ConstraintWrapperPtr>::const_iterator anIt = aConstraints.begin(),
 107                                                     aLast = aConstraints.end();
 108     std::list<EntityWrapperPtr> anEntities;
 109     for (; anIt != aLast; anIt++) {
 110       ConstraintWrapperPtr aConstraint = *anIt;
 111       aConstraint->setIsFullValue(myIsFullValue);
 112       anEntities.clear();
 113
 114       const std::list<EntityWrapperPtr>& aConstraintEntities = aConstraint->entities();
 115       std::list<EntityWrapperPtr>::const_iterator aSIt = aConstraintEntities.begin(),
 116                                                   aSLast = aConstraintEntities.end();
 117       EntityWrapperPtr aStartEntity = *aSIt++;
 118       if (aStartPointChanged) {
 119         AttributePtr aStartPointAttr = aData->attribute(SketchPlugin_MultiTranslation::START_POINT_ID());
 120         myStorage->update(aStartPointAttr);
 121         aStartEntity = myStorage->entity(aStartPointAttr);
 122       }
 123       anEntities.push_back(aStartEntity);
 124
 125       EntityWrapperPtr anEndEntity = *aSIt++;
 126       if (anEndPointChanged) {
 127         AttributePtr anEndPointAttr = aData->attribute(SketchPlugin_MultiTranslation::END_POINT_ID());
 128         myStorage->update(anEndPointAttr);
 129         anEndEntity = myStorage->entity(anEndPointAttr);
 130       }
 131       anEntities.push_back(anEndEntity);
 132
 133       for (; aSIt != aSLast; ++aSIt)
 134         anEntities.push_back(*aSIt);
 135
 136       aConstraint->setEntities(anEntities);
 137     }
 138     myStorage->addConstraint(myBaseConstraint, aConstraints);
 139
 140     myAdjusted = false;
 141   }
 142 }
 143